FileSync/fileutil.c

#include <stdio.h>
#include <dirent.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <utime.h>
#include <time.h>
#ifdef WIN32
#define _WIN32_WINNT 0x0501
#include <signal.h>
#include <windows.h>
#include <fcntl.h>
#include <io.h>
#else
#include <unistd.h>
#endif

#include "fileutil.h"

#ifdef WIN32
long long FileTime_to_POSIX(FILETIME ft) {
	LARGE_INTEGER date, adjust;

	// takes the last modified date
	date.HighPart = ft.dwHighDateTime;
	date.LowPart = ft.dwLowDateTime;

	// 100-nanoseconds = milliseconds * 10000
	adjust.QuadPart = 11644473600000ll * 10000;

	// removes the diff between 1970 and 1601
	date.QuadPart -= adjust.QuadPart;

	// converts back from 100-nanoseconds to seconds
	return date.QuadPart / 10000000ll;
}

FILETIME POSIX_to_FileTime(FileTime ft) {
	LARGE_INTEGER date, adjust;
	FILETIME filetime;

	// converts to 100-nanoseconds from seconds
	date.QuadPart=ft*10000000ll;

	// 100-nanoseconds = milliseconds * 10000
	adjust.QuadPart = 11644473600000ll * 10000ll;

	// removes the diff between 1970 and 1601
	date.QuadPart += adjust.QuadPart;

	// asigns to filetime
	filetime.dwHighDateTime=date.HighPart;
	filetime.dwLowDateTime=date.LowPart;
	return filetime;
}

FileTime FileTime_Get(char *filename) {
	HANDLE hFile;
	FILETIME ftCreate, ftAccess, ftWrite;
	hFile = CreateFile(filename, GENERIC_READ, FILE_SHARE_READ, NULL,
			OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
	GetFileTime(hFile, &ftCreate, &ftAccess, &ftWrite);
	CloseHandle(hFile);
	return(FileTime_to_POSIX(ftWrite));
}

void FileTime_Set(char *filename,FileTime t) {
	HANDLE hFile;
	FILETIME ftWrite;
	hFile = CreateFile(filename, GENERIC_WRITE, FILE_SHARE_WRITE,
			NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
	ftWrite=POSIX_to_FileTime(t);
	SetFileTime(hFile, NULL, NULL, &ftWrite);
	CloseHandle(hFile);
}

#else

FileTime FileTime_Get(char *filename) {
	struct stat fs;
	lstat(filename, &fs);
	return (fs.st_mtime);
}

void FileTime_Set(char *filename, FileTime t) {
	struct utimbuf utb;

	utb.actime = t;
	utb.modtime = t;
	utime(filename, &utb);
}

#endif

void FileTime_Print(FileTime t) {
	struct tm *tms;

	tms = localtime((time_t *) &t);
	printf("%04d-%02d-%02d %02d:%02d:%02d", tms->tm_year + 1900,
			tms->tm_mon + 1, tms->tm_mday, tms->tm_hour, tms->tm_min,
			tms->tm_sec);
}

void File_GetName(char *path, char *name) {
	int i, j;

	i = strlen(path) - 1;
	while (i >= 0) {
		if (path[i] == '/' || path[i] == '\\') {
			i++;
			break;
		} else {
			i--;
		}
	}
	if (i < 0)
		i++;

	j = 0;
	while (path[i]) {
		name[j] = path[i];
		i++;
		j++;
	}
	name[j] = 0;
}

#ifdef WIN32

int File_ExistePath(char *path) {
	unsigned rc;
	rc=GetFileAttributes(path);

	if(rc==INVALID_FILE_ATTRIBUTES) {
		return(0);
	}
	return(1);
}
int File_EsDirectorio(char *dir) {
	unsigned rc;
	rc=GetFileAttributes(dir);

	if(rc==INVALID_FILE_ATTRIBUTES) {
		return(0);
	}
	if(rc&FILE_ATTRIBUTE_DIRECTORY) {
		return(1);
	}
	return(0);
}
int File_EsFichero(char *fichero) {
	unsigned rc;
	rc=GetFileAttributes(fichero);

	if(rc==INVALID_FILE_ATTRIBUTES) {
		return(0);
	}
	if(rc&FILE_ATTRIBUTE_DIRECTORY) {
		return(0);
	}
	return(1);
}

#else
int File_ExistePath(char *path) {
	struct stat info;

	if (lstat(path, &info) == -1) {
		return (0);
	}
	return (1);
}
int File_EsDirectorio(char *dir) {
	struct stat info;

	if (lstat(dir, &info) == -1) {
		return (0);
	}
	if (S_ISDIR(info.st_mode)) {
		return (1);
	}
	return (0);
}
int File_EsFichero(char *fichero) {
	struct stat info;

	if (lstat(fichero, &info) == -1) {
		return (0);
	}
	if (S_ISDIR(info.st_mode)) {
		return (0);
	}
	return (1);
}
#endif

long long File_TamanhoFichero(char *fichero) {
	FILE *f;
	long long tamanho;

	f = fopen(fichero, "rb");
	if (!f)
		return (-1);

	fseek(f, 0, SEEK_END);
	tamanho = ftell(f);
	fclose(f);
	return (tamanho);
}

#ifdef WIN32
int File_CrearDir(char *path) {
	return(_mkdir(path));
}
#else
int File_CrearDir(char *path) {
	return (mkdir(path, 0777));
}
#endif

#ifdef WIN32

void File_IterateDir(char *path,
		int (*func)(char *path,char *name,void *data),void *data)
{
	int handle;
	struct _finddata_t fileinfo;
	char f_path[MaxPath];
	int fin=0;
	int findnext_rc;
	char path_aux[MaxPath];
	char *ptr;

	snprintf(path_aux,MaxPath,
			"%s/*",path);
	handle=_findfirst(path_aux,&fileinfo);
	if(handle==-1)
	return;

	// Recorrer el directorio
	do {
		if(strcmp(fileinfo.name,".") &&
				strcmp(fileinfo.name,".."))
		{
			// A partir de aqui hay un fichero
			// (o directorio)
			snprintf(f_path,512,
					"%s/%s",path,fileinfo.name);
			fin=func(f_path,fileinfo.name,data);
		}
		findnext_rc=_findnext(handle,&fileinfo);
	}while(findnext_rc!=-1 && !fin);
	_findclose(handle);
}

#else

void File_IterateDir(char *path,
		int (*func)(char *path, char *name, void *data), void *data) {
	DIR *directorio;
	struct dirent *entidad_dir;
	char f_path[MaxPath];
	int fin = 0;
	char *ptr;

	directorio = opendir(path);
	if (directorio == NULL )
		return;

	// Recorrer el directorio
	do {
		entidad_dir = readdir(directorio);
		if (entidad_dir != NULL ) {
			if (strcmp(entidad_dir->d_name, ".")
					&& strcmp(entidad_dir->d_name, "..")) {
				// A partir de aqui hay un fichero
				// (o directorio)
				snprintf(f_path, MaxPath, "%s/%s", path, entidad_dir->d_name);
				fin = func(f_path, entidad_dir->d_name, data);
			}
		}
	} while (entidad_dir != NULL && !fin);
	closedir(directorio);
}
#endif

void File_Borrar(char *path) {
	unlink(path);
}

void File_BorrarDirectorio(char *path) {
	rmdir(path);
}

#define MaxBuffer 16384
int File_Copiar(const char *pathOrig, const char *pathDest) {
	FILE *fOrig, *fDest;
	char buffer[MaxBuffer];
	int readLen = 0;
	int writeLen = 0;
	int ok = 0;

	if ((fOrig = fopen(pathOrig, "rb")) == NULL ) {
		return 0;
	}
	if ((fDest = fopen(pathDest, "wb")) == NULL ) {
		return 0;
	}

	do {
		readLen = fread(&buffer, 1, MaxBuffer, fOrig);
		if (readLen > 0) {
			writeLen = fwrite(&buffer, 1, readLen, fDest);
			if (writeLen != readLen) {
				// Error
				fclose(fOrig);
				fclose(fDest);
				return 0;
			}
		}
	} while (readLen == MaxBuffer);

	if (feof(fOrig)) {
		ok = 1;
	}

	fclose(fOrig);
	fclose(fDest);
	return ok;
}