Mercurial > mbsePi-apps / file revision

/*****************************************************************************
 * Copyright (C) 2015
 *   
 * Michiel Broek <mbroek at mbse dot eu>
 *
 * This file is part of the mbsePi-apps
 *
 * This is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2, or (at your option) any
 * later version.
 *
 * mbsePi-apps is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with ThermFerm; see the file COPYING.  If not, write to the Free
 * Software Foundation, 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
 *****************************************************************************/

#include "brewco.h"
#include "util.h"


/*
 * Make directory tree, the name must end with a /
 */
int mkdirs(char *name, mode_t mode)
{
    char	buf[PATH_MAX], *p, *q;
    int		last = 0, oldmask;

    memset(&buf, 0, sizeof(buf));
    strncpy(buf, name, sizeof(buf)-1);
    buf[sizeof(buf)-1] = '\0';

    p = buf+1;

    oldmask = umask(000);
    while ((q = strchr(p, '/'))) {
	*q = '\0';
	mkdir(buf, mode);
	last = errno;
	*q = '/';
	p = q+1;
    }

    umask(oldmask);
											
    if ((last == 0) || (last == EEXIST)) {
	return TRUE;
    } else {
	syslog(LOG_NOTICE, "mkdirs(%s)", name);
	return FALSE;
    }
}



/*
 * Test if the given file exists. The second option is:
 * R_OK - test for Read rights 
 * W_OK - test for Write rights
 * X_OK - test for eXecute rights
 * F_OK - test file presence only
 */ 
int file_exist(char *path, int mode)
{
    if (access(path, mode) != 0)
	return errno;

    return 0;
}



/*
 * Buffered filecopy, filetime is preserved.
 */
int file_cp(char *from, char *to)
{
    char		*line;
    FILE		*stfrom, *stto;
    int			dummy, bread;
    static int		error;
    struct stat 	sb;
    struct utimbuf 	ut;

    stfrom = fopen(from, "r");
    if (stfrom == NULL)
	return errno;

    stto = fopen(to, "w");
    if (stto == NULL) {
	error = errno;
	fclose(stfrom);
	return error;
    }

    line = malloc(16384);
    do {
	bread = fread(line, 1, 16384, stfrom);
	dummy = fwrite(line, 1, bread, stto);
	if (bread != dummy) {
	    error = errno;
	    fclose(stfrom);
	    fclose(stto);
	    unlink(to);
	    free(line);
	    return error;
	}
    } while (bread != 0);
    free(line);
    fclose(stfrom);
    if (fclose(stto) != 0) {
	error = errno;
	unlink(to);
	return error;
    }

    /*
     * copy successfull, now copy file- and modification-time
     */
    if (stat(from, &sb) == 0) {
	ut.actime = mktime(localtime(&sb.st_atime));
	ut.modtime = mktime(localtime(&sb.st_mtime));
	if (utime(to, &ut) != 0) {
	    error = errno;
	    unlink(to);
	    return error;
	}
	chmod(to, sb.st_mode);
    }

    return 0;
}



long millis(void)
{
    struct timespec	now;

    clock_gettime(CLOCK_REALTIME , &now);
    return ((now.tv_sec * 1000000000) + now.tv_nsec) / 1000000;
}



/* From ArdBir */
float Arrotonda025(float Num){
    // Appoggio la parte intera
    int Appoggio= (int)Num;

    // Arrotondo il valore con peso 0.25
    return Appoggio+(int)((Num-Appoggio)*1000/225)*0.25;
}

float ConvertiCtoF(float Num){        
    Num = Num/16;              // Recupero il valore
    Num = (Num*1.8)+32;          // Converto in °F
    Num = Arrotonda025(Num);
    return Num*16;              // Preparo il valore per la registrazione
}
float ConvertiFtoC(float Num){
    Num = Num/16;              // Recupero il valore
    Num = (Num-32)/1.8;            // Converto in °C
    Num = Arrotonda025(Num);
    return Num*16;              // Preparo il valore per la registrazione
}