diff --git a/src/crc.c b/src/crc.c
index b314cef..6ea6bf1 100644
--- a/src/crc.c
+++ b/src/crc.c
@@ -28,14 +28,14 @@ void CRCTable_Init() {
 }
 
 unsigned long CRC_BufferInternal(unsigned char *buffer, int len,
-		unsigned long crc) {
+	unsigned long crc) {
 	unsigned char *p;
 
-	// Calcular CRC del buffer
-	p = (unsigned char*) buffer;
+	// Calculate CRC from buffer
+	p = (unsigned char*)buffer;
 	while (len-- != 0) {
 		unsigned long termA = (crc >> 8) & 0x00FFFFFFL;
-		unsigned long termB = _crcTable[((int) crc ^ *p++) & 0xff];
+		unsigned long termB = _crcTable[((int)crc ^ *p++) & 0xff];
 		crc = termA ^ termB;
 	}
 
@@ -55,12 +55,11 @@ unsigned long CRC_File(FILE *file) {
 
 	crc = 0xFFFFFFFFL;
 	for (;;) {
-		// Llenar el buffer
+		// Fill buffer
 		int count = fread(buffer, 1, 512, file);
 		if (count == 0)
 			break;
 
-		// Calcular CRC del buffer
 		crc = CRC_BufferInternal(buffer, count, crc);
 	}
 	return (crc ^= 0xFFFFFFFFL);
diff --git a/src/filenode.c b/src/filenode.c
index 2f233f1..967c575 100644
--- a/src/filenode.c
+++ b/src/filenode.c
@@ -13,11 +13,14 @@ int _n_filenode = 0;
 FileNode *FileNode_Create() {
 	FileNode *fileNode;
 
-	if (_free_filenode == NULL ) {
+	if (_free_filenode == NULL) {
 		FileNode *nodos;
 		int i;
-		// Reservar un tocho
+		// Allocate a block
 		nodos = malloc(sizeof(FileNode) * FileNode_Block);
+		if (nodos == NULL) {
+			return NULL;
+		}
 		for (i = 0; i < FileNode_Block - 1; i++) {
 			nodos[i].next = &nodos[i + 1];
 		}
@@ -25,15 +28,16 @@ FileNode *FileNode_Create() {
 		_free_filenode = &nodos[0];
 	}
 
-	// Obtener el primero libre
+	// Get first free
 	fileNode = _free_filenode;
 	_free_filenode = fileNode->next;
+	fileNode->next = NULL;
 	_n_filenode++;
 
-	// Iniciar
+	// Initialize
 	fileNode->name[0] = 0;
 	fileNode->flags = 0;
-	fileNode->estado = FileStatus_None;
+	fileNode->status = FileStatus_None;
 	fileNode->size = 0;
 	fileNode->crc = 0;
 	fileNode->fileTime = 0;
@@ -49,6 +53,7 @@ void FileNode_Delete(FileNode *fn) {
 	fn->next = _free_filenode;
 	_free_filenode = fn;
 	_n_filenode--;
+	// FIXME: delete childs
 }
 
 void FileNode_AddChild(FileNode *fileNode, FileNode *file2) {
@@ -60,12 +65,12 @@ void FileNode_AddChild(FileNode *fileNode, FileNode *file2) {
 	file2->parent = fileNode;
 }
 
-void FileNode_SetEstadoRec(FileNode *fileNode, FileStatus estado) {
+void FileNode_SetStatusRec(FileNode *fileNode, FileStatus status) {
 	FileNode *fn_child;
-	fileNode->estado = estado;
+	fileNode->status = status;
 	fn_child = fileNode->child;
-	while (fn_child != NULL ) {
-		FileNode_SetEstadoRec(fn_child, estado);
+	while (fn_child != NULL) {
+		FileNode_SetStatusRec(fn_child, status);
 		fn_child = fn_child->next;
 	}
 }
@@ -74,7 +79,8 @@ void FileNode_GetPath_Rec(FileNode *fileNode, char **pathnode) {
 	if (fileNode->parent) {
 		pathnode[0] = fileNode->parent->name;
 		FileNode_GetPath_Rec(fileNode->parent, pathnode + 1);
-	} else {
+	}
+	else {
 		pathnode[0] = NULL;
 	}
 }
@@ -83,8 +89,7 @@ char *FileNode_GetPath(FileNode *fileNode, char *path) {
 	char *pathnodes[128];
 	int levels, i;
 	char *pathptr = temppath;
-	if (path)
-		pathptr = path;
+	if (path) { pathptr = path; }
 
 	FileNode_GetPath_Rec(fileNode, pathnodes);
 	levels = 0;
@@ -99,6 +104,7 @@ char *FileNode_GetPath(FileNode *fileNode, char *path) {
 	strcat(pathptr, fileNode->name);
 	return temppath;
 }
+
 char *FileNode_GetFullPath(FileNode *fileNode, char *basePath, char *path) {
 	char *pathnodes[128];
 	int levels, i;
@@ -127,12 +133,12 @@ void FileNode_GetSize(FileNode *fileNode, char *file) {
 }
 
 void FileNode_GetTime(FileNode *fileNode, char *file) {
-	fileNode->flags |= FileFlag_HastTime;
+	fileNode->flags |= FileFlag_HasTime;
 	fileNode->fileTime = FileTime_Get(file);
 }
 
 void FileNode_GetSizeAndTime(FileNode *fileNode, char *file) {
-	fileNode->flags |= FileFlag_HasSize | FileFlag_HastTime;
+	fileNode->flags |= FileFlag_HasSize | FileFlag_HasTime;
 	File_GetSizeAndTime(file, &fileNode->size, &fileNode->fileTime);
 }
 
@@ -148,49 +154,58 @@ void FileNode_GetCRC(FileNode *fileNode, char *filePath) {
 }
 
 void FileNode_SaveNode(FileNode *fileNode, FILE *file) {
-	int name_len;
+	short nameLen;
 
-	// Escribir nombre
-	name_len = strlen(fileNode->name);
-	fwrite((void *) &name_len, sizeof(name_len), 1, file);
-	fputs(fileNode->name, file);
+	// Write name
+	nameLen = strlen(fileNode->name);
+	fwrite((void *)&nameLen, sizeof(nameLen), 1, file);
+	if (nameLen>0 && nameLen<MaxFilename) {
+		fputs(fileNode->name, file);
+	} else {
+		return;
+	}
 
-	// Escribir flags
-	fwrite((void *) &fileNode->flags, sizeof(fileNode->flags), 1, file);
+	// Write flags
+	fwrite((void *)&fileNode->flags, sizeof(fileNode->flags), 1, file);
 
-	// Escribir estado
-	fputc((char) fileNode->estado, file);
+	// Write status
+	fputc((char)fileNode->status, file);
 
-	// Escribir tamanho
+	// Write size
 	if (fileNode->flags & FileFlag_HasSize) {
-		fwrite((void *) &fileNode->size, sizeof(fileNode->size), 1, file);
+		fwrite((void *)&fileNode->size, sizeof(fileNode->size), 1, file);
 	}
 
-	// Escribir fecha
-	if (fileNode->flags & FileFlag_HastTime) {
-		fwrite((void *) &fileNode->fileTime, sizeof(fileNode->fileTime), 1, file);
+	// Write date
+	if (fileNode->flags & FileFlag_HasTime) {
+		fwrite((void *)&fileNode->fileTime, sizeof(fileNode->fileTime), 1, file);
 	}
 
-	// Escribir CRC
+	// Write CRC
 	if (fileNode->flags & FileFlag_HasCRC) {
-		fwrite((void *) &fileNode->crc, sizeof(fileNode->crc), 1, file);
+		fwrite((void *)&fileNode->crc, sizeof(fileNode->crc), 1, file);
 	}
 
-	// Escribir ficheros del directorio
+	// Write files of directory
 	if (fileNode->flags & FileFlag_Directory) {
 		FileNode *fileNodeChild;
-		fwrite((void *) &fileNode->childCount, sizeof(fileNode->childCount), 1, file);
+		fwrite((void *)&fileNode->childCount, sizeof(fileNode->childCount), 1, file);
 		fileNodeChild = fileNode->child;
+		int cnt = 0;
 		while (fileNodeChild) {
 			FileNode_SaveNode(fileNodeChild, file);
 			fileNodeChild = fileNodeChild->next;
+			cnt++;
+		}
+		if (fileNode->childCount != cnt) {
+			return;
 		}
 	}
 }
 
 void FileNode_Save(FileNode *fileNode, char *filePath) {
 	FILE *file;
-	char marca[5];
+	char mark[5];
 	int version;
 
 	if (!fileNode)
@@ -199,11 +214,11 @@ void FileNode_Save(FileNode *fileNode, char *filePath) {
 	if (!file)
 		return;
 
-	// Escribir marca y version
-	strcpy(marca, "sYnC");
-	fwrite((void *) marca, sizeof(char), 4, file);
+	// Write mark and version
+	strcpy(mark, "sYnC");
+	fwrite((void *)mark, sizeof(char), 4, file);
 	version = FileNode_Version;
-	fwrite((void *) &version, sizeof(int), 1, file);
+	fwrite((void *)&version, sizeof(int), 1, file);
 
 	FileNode_SaveNode(fileNode, file);
 	fclose(file);
@@ -216,42 +231,54 @@ FileNode *FileNode_LoadNode(FILE *file) {
 
 	fileNode = FileNode_Create();
 
-	// Leer el nombre
-	fread((void *) &nameLen, sizeof(nameLen), 1, file);
-	fread((void *) fileNode->name, sizeof(char), nameLen, file);
-	fileNode->name[nameLen] = 0;
+	// Read name
+	fread((void *)&nameLen, sizeof(nameLen), 1, file);
+	fileNode->name[0] = 0;
+	if (nameLen<0 || nameLen>MaxFilename) {
+		FileNode_Delete(fileNode);
+		return NULL;
+	}
+	if (nameLen > 0) {
+		fread((void *)fileNode->name, sizeof(char), nameLen, file);
+		fileNode->name[nameLen] = 0;
+	}
 
-	// Leer vanderas
-	fread((void *) &fileNode->flags, sizeof(fileNode->flags), 1, file);
+	// Read flags
+	fread((void *)&fileNode->flags, sizeof(fileNode->flags), 1, file);
 
 	// Leer estado
-	fileNode->estado = fgetc(file);
+	fileNode->status = fgetc(file);
 
-	// Leer tamanho
+	// Read status
 	if (fileNode->flags & FileFlag_HasSize) {
-		fread((void *) &fileNode->size, sizeof(fileNode->size), 1, file);
+		fread((void *)&fileNode->size, sizeof(fileNode->size), 1, file);
 	}
 
-	// Leer fecha
-	if (fileNode->flags & FileFlag_HastTime) {
-		fread((void *) &fileNode->fileTime, sizeof(fileNode->fileTime), 1, file);
+	// Read date
+	if (fileNode->flags & FileFlag_HasTime) {
+		fread((void *)&fileNode->fileTime, sizeof(fileNode->fileTime), 1, file);
 	}
 
-	// Leer CRC
+	// Read CRC
 	if (fileNode->flags & FileFlag_HasCRC) {
-		fread((void *) &fileNode->crc, sizeof(fileNode->crc), 1, file);
+		fread((void *)&fileNode->crc, sizeof(fileNode->crc), 1, file);
 	}
 
-	// Leer ficheros del directorio
+	// Read files on directory
 	if (fileNode->flags & FileFlag_Directory) {
 		FileNode *fileNodeChildAux = NULL, *fileNodeChild;
-		fread((void *) &fileNode->childCount, sizeof(fileNode->childCount), 1, file);
+		fread((void *)&fileNode->childCount, sizeof(fileNode->childCount), 1, file);
 		for (i = 0; i < fileNode->childCount; i++) {
 			fileNodeChild = FileNode_LoadNode(file);
+			if (fileNodeChild == NULL) {
+				// FIXME: Clean memory (fileNode, fileNodeChild etc)
+				return NULL;
+			}
 			fileNodeChild->parent = fileNode;
 			if (!fileNodeChildAux) {
 				fileNode->child = fileNodeChild;
-			} else {
+			}
+			else {
 				fileNodeChildAux->next = fileNodeChild;
 			}
 			fileNodeChildAux = fileNodeChild;
@@ -269,21 +296,21 @@ FileNode *FileNode_Load(char *filePath) {
 
 	file = fopen(filePath, "rb");
 	if (!file)
-		return (NULL );
+		return (NULL);
 
-	// Leer marca y version
-	fread((void *) mark, sizeof(char), 4, file);
+	// Read mark and version
+	fread((void *)mark, sizeof(char), 4, file);
 	mark[4] = 0;
 	if (strcmp(mark, "sYnC")) {
-		// Marca incorrecta
+		// Incorrect mark
 		fclose(file);
-		return (NULL );
+		return (NULL);
 	}
-	fread((void *) &version, sizeof(int), 1, file);
+	fread((void *)&version, sizeof(int), 1, file);
 	if (version != FileNode_Version) {
-		// Version incorrecta
+		// Incorrect version
 		fclose(file);
-		return (NULL );
+		return (NULL);
 	}
 
 	fileNode = FileNode_LoadNode(file);
@@ -293,32 +320,33 @@ FileNode *FileNode_Load(char *filePath) {
 }
 
 void FileNode_PrintNode(FileNode *fileNode) {
-	printff(FileNode_GetPath(fileNode, NULL ));
+	printff(FileNode_GetPath(fileNode, NULL));
 	if (fileNode->flags & FileFlag_Normal) {
 		printff(" File");
-	} else {
+	}
+	else {
 		printff(" Dir");
 	}
-	printff(" %d", fileNode->estado);
-	if (fileNode->estado == FileStatus_New) {
-		printff(" Nuevo");
+	printff(" %d", fileNode->status);
+	if (fileNode->status == FileStatus_New) {
+		printff(" New");
 	}
-	if (fileNode->estado == FileStatus_Modified) {
-		printff(" Modificado");
+	if (fileNode->status == FileStatus_Modified) {
+		printff(" Modified");
 	}
-	if (fileNode->estado == FileStatus_Deleted) {
-		printff(" Borrado!!!");
+	if (fileNode->status == FileStatus_Deleted) {
+		printff(" Deleted!!!");
 	}
 	printff("\n");
 
-	if(fileNode->flags&FileFlag_HasSize){
-		printff("\\-Tamanho: %lld\n",fileNode->size);
+	if (fileNode->flags&FileFlag_HasSize) {
+		printff("\\-Size : %lld\n", fileNode->size);
 	}
-	if(fileNode->flags&FileFlag_HastTime){
-		printff("\\-Fecha  : ");FileTime_Print(fileNode->fileTime);printff("\n");
+	if (fileNode->flags&FileFlag_HasTime) {
+		printff("\\-Date : "); FileTime_Print(fileNode->fileTime); printff("\n");
 	}
-	if(fileNode->flags&FileFlag_HasCRC){
-		printff("\\-CRC    : [%08X]\n",fileNode->crc);
+	if (fileNode->flags&FileFlag_HasCRC) {
+		printff("\\-CRC  : [%08X]\n", fileNode->crc);
 	}
 
 }
@@ -329,16 +357,17 @@ void FileNode_Print(FileNode *fileNode) {
 
 	while (fileNodeAux != NULL && !end) {
 
-		if (fileNodeAux->parent != NULL ) {
+		if (fileNodeAux->parent != NULL) {
 			FileNode_PrintNode(fileNodeAux);
 		}
 
 		if (fileNodeAux->child) {
 			fileNodeAux = fileNodeAux->child;
-		} else {
-			while (fileNodeAux->next == NULL ) {
+		}
+		else {
+			while (fileNodeAux->next == NULL) {
 				fileNodeAux = fileNodeAux->parent;
-				if (fileNodeAux == fileNode || fileNodeAux == NULL ) {
+				if (fileNodeAux == fileNode || fileNodeAux == NULL) {
 					printff("End\n");
 					end = 1;
 					break;
@@ -357,20 +386,20 @@ FileNode *FileNode_Build(char *path) {
 	FileNode *fileNode;
 
 	if (!File_ExistsPath(path))
-		return (NULL );
+		return (NULL);
 
-	// Crear el nodo
+	// Create node
 	fileNode = FileNode_Create();
 	File_GetName(path, fileNode->name);
 
-	// Determinar si es un fichero o directorio
 	if (File_IsDirectory(path)) {
-		// Obtener datos para los directorios
+		// Get information data from directories, and child files
 		fileNode->flags |= FileFlag_Directory;
 		FileNode_GetTime(fileNode, path);
 		File_IterateDir(path, FileNode_Build_Iterate, fileNode);
-	} else {
-		// Obtener datos para los ficheros
+	}
+	else {
+		// Get information data from files
 		fileNode->flags |= FileFlag_Normal;
 		FileNode_GetSizeAndTime(fileNode, path);
 	}
@@ -380,7 +409,6 @@ FileNode *FileNode_Build(char *path) {
 
 int FileNode_Build_Iterate(char *path, char *name, void *d) {
 	FileNode *fileNode, *fileNodeParent = d;
-	;
 
 	if (!strcmp(name, FileNode_Filename)) {
 		return (0);
@@ -401,20 +429,21 @@ FileNode *FileNode_Refresh(FileNode *fileNode, char *filePath) {
 			fileNode = FileNode_Create();
 			File_GetName(filePath, fileNode->name);
 		}
-		FileNode_SetEstadoRec(fileNode, FileStatus_Deleted);
+		FileNode_SetStatusRec(fileNode, FileStatus_Deleted);
 		return (fileNode);
 	}
 	if (!fileNode) {
 		// El fichero ha sido creado
 		fileNode = FileNode_Build(filePath);
-		FileNode_SetEstadoRec(fileNode, FileStatus_New);
-	} else {
+		FileNode_SetStatusRec(fileNode, FileStatus_New);
+	}
+	else {
 		// Comprobar si ha sido modificado
 		FileTime fileTime;
 		long long size;
 
 		// Marcar normal
-		fileNode->estado = FileStatus_None;
+		fileNode->status = FileStatus_None;
 		fileNode->flags &= ~FileFlag_MarkerForReview;
 
 		// Determinar si es un fichero o directorio
@@ -423,13 +452,13 @@ FileNode *FileNode_Refresh(FileNode *fileNode, char *filePath) {
 
 			// Comparar datos de los directorios
 			if (!(fileNode->flags & FileFlag_Directory)) {
-				fileNode->estado = FileStatus_Modified;
+				fileNode->status = FileStatus_Modified;
 				fileNode->flags |= FileFlag_Directory;
 				fileNode->flags &= ~FileFlag_Normal;
 			}
 			fileTime = FileTime_Get(filePath);
 			if (fileTime != fileNode->fileTime) {
-				fileNode->estado = FileStatus_Modified;
+				fileNode->status = FileStatus_Modified;
 				fileNode->fileTime = fileTime;
 			}
 
@@ -448,27 +477,28 @@ FileNode *FileNode_Refresh(FileNode *fileNode, char *filePath) {
 			while (fileNodeChild) {
 				if (fileNodeChild->flags & FileFlag_MarkerForReview) {
 					fileNodeChild->flags &= ~FileFlag_MarkerForReview;
-					FileNode_SetEstadoRec(fileNodeChild, FileStatus_Deleted);
+					FileNode_SetStatusRec(fileNodeChild, FileStatus_Deleted);
 				}
 				fileNodeChild = fileNodeChild->next;
 			}
-		} else {
+		}
+		else {
 			// Comprar datos de los ficheros
 			if (!(fileNode->flags & FileFlag_Normal)) {
-				fileNode->estado = FileStatus_Modified;
+				fileNode->status = FileStatus_Modified;
 				fileNode->flags |= FileFlag_Normal;
 				fileNode->flags &= ~FileFlag_Directory;
 			}
 			File_GetSizeAndTime(filePath, &size, &fileTime);
 			if (size != fileNode->size) {
-				fileNode->estado = FileStatus_Modified;
+				fileNode->status = FileStatus_Modified;
 				fileNode->size = size;
 			}
 			if (fileTime != fileNode->fileTime) {
-				fileNode->estado = FileStatus_Modified;
+				fileNode->status = FileStatus_Modified;
 				fileNode->fileTime = fileTime;
 			}
-			if (fileNode->estado == FileStatus_Modified) {
+			if (fileNode->status == FileStatus_Modified) {
 				fileNode->flags &= ~FileFlag_HasCRC;
 			}
 		}
@@ -495,7 +525,8 @@ int FileNode_Refresh_Iterate(char *path, char *name, void *d) {
 	if (fileNodeChild) {
 		// Existe, refrescar
 		FileNode_Refresh(fileNodeChild, path);
-	} else {
+	}
+	else {
 		// Nuevo, construir
 		fileNodeChild = FileNode_Refresh(NULL, path);
 		FileNode_AddChild(fileNode, fileNodeChild);
diff --git a/src/filenode.h b/src/filenode.h
index b2023b9..68acdba 100644
--- a/src/filenode.h
+++ b/src/filenode.h
@@ -9,7 +9,7 @@
 #define FileFlag_Normal 2
 #define FileFlag_Directory 4
 #define FileFlag_HasSize 8
-#define FileFlag_HastTime 16
+#define FileFlag_HasTime 16
 #define FileFlag_HasCRC 32
 #define FileFlag_MarkerForReview 1024
 
@@ -23,7 +23,7 @@ typedef enum {
 typedef struct SFileNode {
 	char name[MaxFilename];
 	int flags;
-	FileStatus estado;
+	FileStatus status;
 
 	long long size;
 	unsigned long crc;
diff --git a/src/filenodecmp.c b/src/filenodecmp.c
index ab4f9f4..41a8a57 100644
--- a/src/filenodecmp.c
+++ b/src/filenodecmp.c
@@ -12,17 +12,20 @@ int maxDeltaTime = 4000;
 
 #define QueueNode(queue,node) (queue)->next = node; (queue) = node;
 
-AccionFileNode *_actionFileNodeFree = NULL;
+ActionFileNode *_actionFileNodeFree = NULL;
 #define AccionFileNode_Tocho 1024
-AccionFileNode *AccionFileNode_Create() {
-	AccionFileNode *actionFileNode;
+ActionFileNode *ActionFileNode_Create() {
+	ActionFileNode *actionFileNode;
 
-	if (_actionFileNodeFree == NULL ) {
-		AccionFileNode *actionFileNodeFreeAux;
+	if (_actionFileNodeFree == NULL) {
+		ActionFileNode *actionFileNodeFreeAux;
 		int i;
 		// Reservar un tocho
 		actionFileNodeFreeAux = malloc(
-				sizeof(AccionFileNode) * AccionFileNode_Tocho);
+			sizeof(ActionFileNode) * AccionFileNode_Tocho);
+		if (actionFileNodeFreeAux == NULL) {
+			return NULL;
+		}
 		for (i = 0; i < AccionFileNode_Tocho - 1; i++) {
 			actionFileNodeFreeAux[i].next = &actionFileNodeFreeAux[i + 1];
 		}
@@ -35,7 +38,7 @@ AccionFileNode *AccionFileNode_Create() {
 	_actionFileNodeFree = actionFileNode->next;
 
 	// Iniciar
-	actionFileNode->action = AccionFileCmp_Nothing;
+	actionFileNode->action = ActionFileCmp_Nothing;
 	actionFileNode->left = NULL;
 	actionFileNode->right = NULL;
 	actionFileNode->next = NULL;
@@ -43,26 +46,26 @@ AccionFileNode *AccionFileNode_Create() {
 	return (actionFileNode);
 }
 
-void AccionFileNode_Destroy(AccionFileNode *actionFileNode) {
+void AccionFileNode_Destroy(ActionFileNode *actionFileNode) {
 	actionFileNode->next = _actionFileNodeFree;
 	_actionFileNodeFree = actionFileNode;
 }
 
-AccionFileNode *AccionFileNode_CreateNormal(FileNode *fileNodeLeft,
-		FileNode *fileNodeRight) {
-	AccionFileNode *actionFileNode;
-	actionFileNode = AccionFileNode_Create();
-	actionFileNode->action = AccionFileCmp_Nothing;
+ActionFileNode *ActionFileNode_CreateNormal(FileNode *fileNodeLeft,
+	FileNode *fileNodeRight) {
+	ActionFileNode *actionFileNode;
+	actionFileNode = ActionFileNode_Create();
+	actionFileNode->action = ActionFileCmp_Nothing;
 	actionFileNode->left = fileNodeLeft;
 	actionFileNode->right = fileNodeRight;
 	return actionFileNode;
 }
 
 
-void AccionFileNode_CompareChilds(AccionFileNode *actionFileNodeRoot,
-		AccionFileNode **actionFileNodeQueue,
-		void (*CheckPair)(FileNode *fileNodeLeft, FileNode *fileNodeRight,
-				AccionFileNode **actionFileNodeQueue)) {
+void AccionFileNode_CompareChilds(ActionFileNode *actionFileNodeRoot,
+	ActionFileNode **actionFileNodeQueue,
+	void(*CheckPair)(FileNode *fileNodeLeft, FileNode *fileNodeRight,
+		ActionFileNode **actionFileNodeQueue)) {
 	FileNode *fileNodeLeft;
 	FileNode *fileNodeRight;
 	FileNode *fileNodeRightQueue;
@@ -108,11 +111,12 @@ void AccionFileNode_CompareChilds(AccionFileNode *actionFileNodeRoot,
 		fileNodeRightPrevious = NULL;
 		fileNodeRight = fileNodeRightQueue;
 		while (fileNodeRight) {
-			if(!strcmp(fileNodeLeft->name, fileNodeRight->name)){
+			if (!strcmp(fileNodeLeft->name, fileNodeRight->name)) {
 				// Match, extract right child FileNode to the processed chain
-				if(fileNodeRightPrevious) {
+				if (fileNodeRightPrevious) {
 					fileNodeRightPrevious->next = fileNodeRight->next;
-				}else{
+				}
+				else {
 					fileNodeRightQueue = fileNodeRight->next;
 				}
 				fileNodeRight->next = fileNodeRightProcessed;
@@ -120,13 +124,14 @@ void AccionFileNode_CompareChilds(AccionFileNode *actionFileNodeRoot,
 
 				CheckPair(fileNodeLeft, fileNodeRight, actionFileNodeQueue);
 				break;
-			}else{
+			}
+			else {
 				// Next right child
 				fileNodeRightPrevious = fileNodeRight;
 				fileNodeRight = fileNodeRight->next;
 			}
 		}
-		if(!fileNodeRight){
+		if (!fileNodeRight) {
 			CheckPair(fileNodeLeft, NULL, actionFileNodeQueue);
 		}
 		fileNodeLeft = fileNodeLeft->next;
@@ -146,9 +151,9 @@ void AccionFileNode_CompareChilds(AccionFileNode *actionFileNodeRoot,
 }
 
 void AccionFileNode_DeletePair(FileNode *fileNodeLeft, FileNode *fileNodeRight,
-		AccionFileNode **actionFileNodeQueue) {
-	AccionFileNode *actionFileNodeNew = AccionFileNode_CreateNormal(
-			fileNodeLeft, fileNodeRight);
+	ActionFileNode **actionFileNodeQueue) {
+	ActionFileNode *actionFileNodeNew = ActionFileNode_CreateNormal(
+		fileNodeLeft, fileNodeRight);
 
 	if (!fileNodeLeft && !fileNodeRight) {
 		AccionFileNode_Destroy(actionFileNodeNew);
@@ -158,14 +163,15 @@ void AccionFileNode_DeletePair(FileNode *fileNodeLeft, FileNode *fileNodeRight,
 		if (fileNodeRight->flags & FileFlag_Directory) {
 			// Iterar hijos para borrarlos
 			AccionFileNode_CompareChilds(actionFileNodeNew, actionFileNodeQueue,
-					AccionFileNode_DeletePair);
+				AccionFileNode_DeletePair);
 		}
 
-		if (fileNodeRight->estado != FileStatus_Deleted) {
+		if (fileNodeRight->status != FileStatus_Deleted) {
 			// Accion de borrado para el nodo
-			actionFileNodeNew->action = AccionFileCmp_DeleteRight;
+			actionFileNodeNew->action = ActionFileCmp_DeleteRight;
 			QueueNode(*actionFileNodeQueue, actionFileNodeNew);
-		} else {
+		}
+		else {
 			AccionFileNode_Destroy(actionFileNodeNew);
 		}
 	}
@@ -173,40 +179,41 @@ void AccionFileNode_DeletePair(FileNode *fileNodeLeft, FileNode *fileNodeRight,
 		if (fileNodeLeft->flags & FileFlag_Directory) {
 			// Iterar hijos para borrarlos
 			AccionFileNode_CompareChilds(actionFileNodeNew, actionFileNodeQueue,
-					AccionFileNode_DeletePair);
+				AccionFileNode_DeletePair);
 		}
 
-		if (fileNodeLeft->estado != FileStatus_Deleted) {
+		if (fileNodeLeft->status != FileStatus_Deleted) {
 			// Accion de borrado para el nodo
-			actionFileNodeNew->action = AccionFileCmp_DeleteLeft;
+			actionFileNodeNew->action = ActionFileCmp_DeleteLeft;
 			QueueNode(*actionFileNodeQueue, actionFileNodeNew);
-		} else {
+		}
+		else {
 			AccionFileNode_Destroy(actionFileNodeNew);
 		}
 	}
 	if (fileNodeLeft && fileNodeRight) {
 		if ((fileNodeLeft->flags & FileFlag_Directory)
-				|| (fileNodeRight->flags & FileFlag_Directory)) {
+			|| (fileNodeRight->flags & FileFlag_Directory)) {
 			// Alguno es directorio
 
 			// Iterar hijos para borrarlos
 			AccionFileNode_CompareChilds(actionFileNodeNew, actionFileNodeQueue,
-					AccionFileNode_DeletePair);
+				AccionFileNode_DeletePair);
 		}
 
-		if (fileNodeLeft->estado != FileStatus_Deleted) {
+		if (fileNodeLeft->status != FileStatus_Deleted) {
 			// Accion de borrado para el nodo izquierdo
-			actionFileNodeNew->action = AccionFileCmp_DeleteLeft;
+			actionFileNodeNew->action = ActionFileCmp_DeleteLeft;
 			QueueNode(*actionFileNodeQueue, actionFileNodeNew);
 			actionFileNodeNew = NULL;
 		}
-		if (fileNodeRight->estado != FileStatus_Deleted) {
+		if (fileNodeRight->status != FileStatus_Deleted) {
 			if (!actionFileNodeNew) {
-				actionFileNodeNew = AccionFileNode_CreateNormal(fileNodeLeft,
-						fileNodeRight);
+				actionFileNodeNew = ActionFileNode_CreateNormal(fileNodeLeft,
+					fileNodeRight);
 			}
 			// Accion de borrado para el nodo derecho
-			actionFileNodeNew->action = AccionFileCmp_DeleteRight;
+			actionFileNodeNew->action = ActionFileCmp_DeleteRight;
 			QueueNode(*actionFileNodeQueue, actionFileNodeNew);
 			actionFileNodeNew = NULL;
 		}
@@ -217,9 +224,9 @@ void AccionFileNode_DeletePair(FileNode *fileNodeLeft, FileNode *fileNodeRight,
 }
 
 void AccionFileNode_CheckPair(FileNode *fileNodeLeft, FileNode *fileNodeRight,
-		AccionFileNode **actionFileNodeQueue) {
-	AccionFileNode *actionFileNodeNew = AccionFileNode_CreateNormal(
-			fileNodeLeft, fileNodeRight);
+	ActionFileNode **actionFileNodeQueue) {
+	ActionFileNode *actionFileNodeNew = ActionFileNode_CreateNormal(
+		fileNodeLeft, fileNodeRight);
 
 	if (!fileNodeLeft && !fileNodeRight) {
 		AccionFileNode_Destroy(actionFileNodeNew);
@@ -228,29 +235,32 @@ void AccionFileNode_CheckPair(FileNode *fileNodeLeft, FileNode *fileNodeRight,
 	if (!fileNodeLeft && fileNodeRight) {
 		if (fileNodeRight->flags & FileFlag_Directory) {
 			// Directory
-			if (fileNodeRight->estado == FileStatus_Deleted) {
-				actionFileNodeNew->action = AccionFileCmp_Nothing;
+			if (fileNodeRight->status == FileStatus_Deleted) {
+				actionFileNodeNew->action = ActionFileCmp_Nothing;
 				QueueNode(*actionFileNodeQueue, actionFileNodeNew);
-			} else {
-				actionFileNodeNew->action = AccionFileCmp_MakeLeftDirectory;
+			}
+			else {
+				actionFileNodeNew->action = ActionFileCmp_MakeLeftDirectory;
 				QueueNode(*actionFileNodeQueue, actionFileNodeNew);
 
 				// Iterar hijos
 				AccionFileNode_CompareChilds(actionFileNodeNew,
-						actionFileNodeQueue, AccionFileNode_CheckPair);
+					actionFileNodeQueue, AccionFileNode_CheckPair);
 
 				// Crear nueva accion para copiar la fecha
-				actionFileNodeNew = AccionFileNode_CreateNormal(fileNodeLeft,
-						fileNodeRight);
-				actionFileNodeNew->action = AccionFileCmp_DateRightToLeft;
+				actionFileNodeNew = ActionFileNode_CreateNormal(fileNodeLeft,
+					fileNodeRight);
+				actionFileNodeNew->action = ActionFileCmp_DateRightToLeft;
 				QueueNode(*actionFileNodeQueue, actionFileNodeNew);
 			}
-		} else {
+		}
+		else {
 			// File
-			if (fileNodeRight->estado == FileStatus_Deleted) {
-				actionFileNodeNew->action = AccionFileCmp_Nothing;
-			} else {
-				actionFileNodeNew->action = AccionFileCmp_RightToLeft;
+			if (fileNodeRight->status == FileStatus_Deleted) {
+				actionFileNodeNew->action = ActionFileCmp_Nothing;
+			}
+			else {
+				actionFileNodeNew->action = ActionFileCmp_RightToLeft;
 			}
 			QueueNode(*actionFileNodeQueue, actionFileNodeNew);
 		}
@@ -258,130 +268,146 @@ void AccionFileNode_CheckPair(FileNode *fileNodeLeft, FileNode *fileNodeRight,
 	if (fileNodeLeft && !fileNodeRight) {
 		if (fileNodeLeft->flags & FileFlag_Directory) {
 			// Directory
-			if (fileNodeLeft->estado == FileStatus_Deleted) {
-				actionFileNodeNew->action = AccionFileCmp_Nothing;
+			if (fileNodeLeft->status == FileStatus_Deleted) {
+				actionFileNodeNew->action = ActionFileCmp_Nothing;
 				QueueNode(*actionFileNodeQueue, actionFileNodeNew);
-			} else {
-				actionFileNodeNew->action = AccionFileCmp_MakeRightDirectory;
+			}
+			else {
+				actionFileNodeNew->action = ActionFileCmp_MakeRightDirectory;
 				QueueNode(*actionFileNodeQueue, actionFileNodeNew);
 
 				// Iterar hijos
 				AccionFileNode_CompareChilds(actionFileNodeNew,
-						actionFileNodeQueue, AccionFileNode_CheckPair);
+					actionFileNodeQueue, AccionFileNode_CheckPair);
 
 				// Crear nueva accion para copiar la fecha
-				actionFileNodeNew = AccionFileNode_CreateNormal(fileNodeLeft,
-						fileNodeRight);
-				actionFileNodeNew->action = AccionFileCmp_DateLeftToRight;
+				actionFileNodeNew = ActionFileNode_CreateNormal(fileNodeLeft,
+					fileNodeRight);
+				actionFileNodeNew->action = ActionFileCmp_DateLeftToRight;
 				QueueNode(*actionFileNodeQueue, actionFileNodeNew);
 			}
-		} else {
+		}
+		else {
 			// File
-			if (fileNodeLeft->estado == FileStatus_Deleted) {
-				actionFileNodeNew->action = AccionFileCmp_Nothing;
-			} else {
-				actionFileNodeNew->action = AccionFileCmp_LeftToRight;
+			if (fileNodeLeft->status == FileStatus_Deleted) {
+				actionFileNodeNew->action = ActionFileCmp_Nothing;
+			}
+			else {
+				actionFileNodeNew->action = ActionFileCmp_LeftToRight;
 			}
 			QueueNode(*actionFileNodeQueue, actionFileNodeNew);
 		}
 	}
 	if (fileNodeLeft && fileNodeRight) {
 		if ((fileNodeLeft->flags & FileFlag_Directory)
-				&& (fileNodeRight->flags & FileFlag_Directory)) {
+			&& (fileNodeRight->flags & FileFlag_Directory)) {
 			// Directorios
 
 			// Preparar accion para el par de directorios
 			if (abs((int)(fileNodeLeft->fileTime - fileNodeRight->fileTime)) <= maxDeltaTime) { // appoximadamente iguales
-				if (fileNodeRight->estado == FileStatus_Deleted
-						&& fileNodeLeft->estado == FileStatus_Deleted) {
-					actionFileNodeNew->action = AccionFileCmp_Nothing;
-				} else if (fileNodeRight->estado == FileStatus_Deleted) {
-					actionFileNodeNew->action = AccionFileCmp_DeleteLeft;
-					if (fileNodeLeft->estado == FileStatus_Deleted) {
-						actionFileNodeNew->action = AccionFileCmp_Nothing;
-					}
-				} else if (fileNodeLeft->estado == FileStatus_Deleted) {
-					actionFileNodeNew->action = AccionFileCmp_DeleteRight;
-					if (fileNodeRight->estado == FileStatus_Deleted) {
-						actionFileNodeNew->action = AccionFileCmp_Nothing;
-					}
-				} else {
-					actionFileNodeNew->action = AccionFileCmp_Nothing;
+				if (fileNodeRight->status == FileStatus_Deleted
+					&& fileNodeLeft->status == FileStatus_Deleted) {
+					actionFileNodeNew->action = ActionFileCmp_Nothing;
 				}
-			} else if (fileNodeLeft->fileTime < fileNodeRight->fileTime) {
-				actionFileNodeNew->action = AccionFileCmp_DateRightToLeft;
-				if (fileNodeRight->estado == FileStatus_Deleted) {
-					actionFileNodeNew->action = AccionFileCmp_DeleteLeft;
-					if (fileNodeLeft->estado == FileStatus_Deleted) {
-						actionFileNodeNew->action = AccionFileCmp_Nothing;
+				else if (fileNodeRight->status == FileStatus_Deleted) {
+					actionFileNodeNew->action = ActionFileCmp_DeleteLeft;
+					if (fileNodeLeft->status == FileStatus_Deleted) {
+						actionFileNodeNew->action = ActionFileCmp_Nothing;
 					}
 				}
-			} else if (fileNodeLeft->fileTime > fileNodeRight->fileTime) {
-				actionFileNodeNew->action = AccionFileCmp_DateLeftToRight;
-				if (fileNodeLeft->estado == FileStatus_Deleted) {
-					actionFileNodeNew->action = AccionFileCmp_DeleteRight;
-					if (fileNodeRight->estado == FileStatus_Deleted) {
-						actionFileNodeNew->action = AccionFileCmp_Nothing;
+				else if (fileNodeLeft->status == FileStatus_Deleted) {
+					actionFileNodeNew->action = ActionFileCmp_DeleteRight;
+					if (fileNodeRight->status == FileStatus_Deleted) {
+						actionFileNodeNew->action = ActionFileCmp_Nothing;
+					}
+				}
+				else {
+					actionFileNodeNew->action = ActionFileCmp_Nothing;
+				}
+			}
+			else if (fileNodeLeft->fileTime < fileNodeRight->fileTime) {
+				actionFileNodeNew->action = ActionFileCmp_DateRightToLeft;
+				if (fileNodeRight->status == FileStatus_Deleted) {
+					actionFileNodeNew->action = ActionFileCmp_DeleteLeft;
+					if (fileNodeLeft->status == FileStatus_Deleted) {
+						actionFileNodeNew->action = ActionFileCmp_Nothing;
+					}
+				}
+			}
+			else if (fileNodeLeft->fileTime > fileNodeRight->fileTime) {
+				actionFileNodeNew->action = ActionFileCmp_DateLeftToRight;
+				if (fileNodeLeft->status == FileStatus_Deleted) {
+					actionFileNodeNew->action = ActionFileCmp_DeleteRight;
+					if (fileNodeRight->status == FileStatus_Deleted) {
+						actionFileNodeNew->action = ActionFileCmp_Nothing;
 					}
 				}
 			}
 
 			// Procesar nodos hijos
-			if (actionFileNodeNew->action == AccionFileCmp_DeleteRight
-					|| actionFileNodeNew->action == AccionFileCmp_DeleteLeft
-					|| (fileNodeLeft->estado == FileStatus_Deleted
-							&& fileNodeRight->estado == FileStatus_Deleted)) {
+			if (actionFileNodeNew->action == ActionFileCmp_DeleteRight
+				|| actionFileNodeNew->action == ActionFileCmp_DeleteLeft
+				|| (fileNodeLeft->status == FileStatus_Deleted
+					&& fileNodeRight->status == FileStatus_Deleted)) {
 				// Iterar nodos hijos para borrarlos
 				AccionFileNode_CompareChilds(actionFileNodeNew,
-						actionFileNodeQueue, AccionFileNode_DeletePair);
-			} else {
+					actionFileNodeQueue, AccionFileNode_DeletePair);
+			}
+			else {
 				AccionFileNode_CompareChilds(actionFileNodeNew,
-						actionFileNodeQueue, AccionFileNode_CheckPair);
+					actionFileNodeQueue, AccionFileNode_CheckPair);
 			}
 			QueueNode(*actionFileNodeQueue, actionFileNodeNew);
-		} else if ((fileNodeLeft->flags & FileFlag_Normal)
-				&& (fileNodeRight->flags & FileFlag_Normal)) {
+		}
+		else if ((fileNodeLeft->flags & FileFlag_Normal)
+			&& (fileNodeRight->flags & FileFlag_Normal)) {
 			// Ficheros
 
 			// Preparar accion para el par de ficheros
 			if (abs((int)(fileNodeLeft->fileTime - fileNodeRight->fileTime)) <= maxDeltaTime) { // appoximadamente iguales
-				if (fileNodeRight->estado == FileStatus_Deleted
-						&& fileNodeLeft->estado == FileStatus_Deleted) {
-					actionFileNodeNew->action = AccionFileCmp_Nothing;
-				} else if (fileNodeRight->estado == FileStatus_Deleted) {
-					actionFileNodeNew->action = AccionFileCmp_DeleteLeft;
-					if (fileNodeLeft->estado == FileStatus_Deleted) {
-						actionFileNodeNew->action = AccionFileCmp_Nothing;
-					}
-				} else if (fileNodeLeft->estado == FileStatus_Deleted) {
-					actionFileNodeNew->action = AccionFileCmp_DeleteRight;
-					if (fileNodeRight->estado == FileStatus_Deleted) {
-						actionFileNodeNew->action = AccionFileCmp_Nothing;
-					}
-				} else {
-					actionFileNodeNew->action = AccionFileCmp_Nothing;
+				if (fileNodeRight->status == FileStatus_Deleted
+					&& fileNodeLeft->status == FileStatus_Deleted) {
+					actionFileNodeNew->action = ActionFileCmp_Nothing;
 				}
-			} else if (fileNodeLeft->fileTime < fileNodeRight->fileTime) {
-				// FIXME: Check size to determine y further checks are necessary
-				actionFileNodeNew->action = AccionFileCmp_RightToLeft;
-				if (fileNodeRight->estado == FileStatus_Deleted) {
-					actionFileNodeNew->action = AccionFileCmp_DeleteLeft;
-					if (fileNodeLeft->estado == FileStatus_Deleted) {
-						actionFileNodeNew->action = AccionFileCmp_Nothing;
+				else if (fileNodeRight->status == FileStatus_Deleted) {
+					actionFileNodeNew->action = ActionFileCmp_DeleteLeft;
+					if (fileNodeLeft->status == FileStatus_Deleted) {
+						actionFileNodeNew->action = ActionFileCmp_Nothing;
 					}
 				}
-			} else if (fileNodeLeft->fileTime > fileNodeRight->fileTime) {
+				else if (fileNodeLeft->status == FileStatus_Deleted) {
+					actionFileNodeNew->action = ActionFileCmp_DeleteRight;
+					if (fileNodeRight->status == FileStatus_Deleted) {
+						actionFileNodeNew->action = ActionFileCmp_Nothing;
+					}
+				}
+				else {
+					actionFileNodeNew->action = ActionFileCmp_Nothing;
+				}
+			}
+			else if (fileNodeLeft->fileTime < fileNodeRight->fileTime) {
 				// FIXME: Check size to determine y further checks are necessary
-				actionFileNodeNew->action = AccionFileCmp_LeftToRight;
-				if (fileNodeLeft->estado == FileStatus_Deleted) {
-					actionFileNodeNew->action = AccionFileCmp_DeleteRight;
-					if (fileNodeRight->estado == FileStatus_Deleted) {
-						actionFileNodeNew->action = AccionFileCmp_Nothing;
+				actionFileNodeNew->action = ActionFileCmp_RightToLeft;
+				if (fileNodeRight->status == FileStatus_Deleted) {
+					actionFileNodeNew->action = ActionFileCmp_DeleteLeft;
+					if (fileNodeLeft->status == FileStatus_Deleted) {
+						actionFileNodeNew->action = ActionFileCmp_Nothing;
+					}
+				}
+			}
+			else if (fileNodeLeft->fileTime > fileNodeRight->fileTime) {
+				// FIXME: Check size to determine y further checks are necessary
+				actionFileNodeNew->action = ActionFileCmp_LeftToRight;
+				if (fileNodeLeft->status == FileStatus_Deleted) {
+					actionFileNodeNew->action = ActionFileCmp_DeleteRight;
+					if (fileNodeRight->status == FileStatus_Deleted) {
+						actionFileNodeNew->action = ActionFileCmp_Nothing;
 					}
 				}
 			}
 			QueueNode(*actionFileNodeQueue, actionFileNodeNew);
-		} else {
+		}
+		else {
 			// FIXME: !!!!!
 			// Directory vs File
 
@@ -389,19 +415,19 @@ void AccionFileNode_CheckPair(FileNode *fileNodeLeft, FileNode *fileNodeRight,
 	}
 }
 
-AccionFileNode *AccionFileNode_BuildSync(FileNode *izquierda, FileNode *derecha) {
-	AccionFileNode *actionFileNodeRoot = AccionFileNode_CreateNormal(izquierda,
-			derecha);
-	AccionFileNode *actionFileNodeQueue = actionFileNodeRoot;
+ActionFileNode *ActionFileNode_BuildSync(FileNode *izquierda, FileNode *derecha) {
+	ActionFileNode *actionFileNodeRoot = ActionFileNode_CreateNormal(izquierda,
+		derecha);
+	ActionFileNode *actionFileNodeQueue = actionFileNodeRoot;
 	AccionFileNode_CompareChilds(actionFileNodeRoot, &actionFileNodeQueue,
-			AccionFileNode_CheckPair);
+		AccionFileNode_CheckPair);
 	return actionFileNodeRoot;
 }
 
 void AccionFileNode_Copy(FileNode *fileNodeLeft, FileNode *fileNodeRight,
-		AccionFileNode **actionFileNodeQueue) {
-	AccionFileNode *actionFileNodeNew = AccionFileNode_CreateNormal(
-			fileNodeLeft, fileNodeRight);
+	ActionFileNode **actionFileNodeQueue) {
+	ActionFileNode *actionFileNodeNew = ActionFileNode_CreateNormal(
+		fileNodeLeft, fileNodeRight);
 
 	if (!fileNodeLeft && !fileNodeRight) {
 		AccionFileNode_Destroy(actionFileNodeNew);
@@ -410,65 +436,73 @@ void AccionFileNode_Copy(FileNode *fileNodeLeft, FileNode *fileNodeRight,
 	if (!fileNodeLeft && fileNodeRight) {
 		if (fileNodeRight->flags & FileFlag_Directory) {
 			AccionFileNode_CompareChilds(actionFileNodeNew, actionFileNodeQueue,
-					AccionFileNode_DeletePair);
+				AccionFileNode_DeletePair);
 		}
 
-		if (fileNodeRight->estado != FileStatus_Deleted) {
-			actionFileNodeNew->action = AccionFileCmp_DeleteRight;
-		} else {
-			actionFileNodeNew->action = AccionFileCmp_Nothing;
+		if (fileNodeRight->status != FileStatus_Deleted) {
+			actionFileNodeNew->action = ActionFileCmp_DeleteRight;
+		}
+		else {
+			actionFileNodeNew->action = ActionFileCmp_Nothing;
 		}
 		QueueNode(*actionFileNodeQueue, actionFileNodeNew);
 	}
 	if (fileNodeLeft && !fileNodeRight) {
-		if (fileNodeLeft->estado != FileStatus_Deleted) {
+		if (fileNodeLeft->status != FileStatus_Deleted) {
 			if (fileNodeLeft->flags & FileFlag_Directory) {
-				actionFileNodeNew->action = AccionFileCmp_MakeRightDirectory;
+				actionFileNodeNew->action = ActionFileCmp_MakeRightDirectory;
 				(*actionFileNodeQueue)->next = actionFileNodeNew;
 				(*actionFileNodeQueue) = actionFileNodeNew;
 				AccionFileNode_CompareChilds(actionFileNodeNew,
-						actionFileNodeQueue, AccionFileNode_Copy);
-				actionFileNodeNew = AccionFileNode_CreateNormal(fileNodeLeft,
-						fileNodeRight);
-				actionFileNodeNew->action = AccionFileCmp_DateLeftToRight;
-			} else {
-				actionFileNodeNew->action = AccionFileCmp_LeftToRight;
+					actionFileNodeQueue, AccionFileNode_Copy);
+				actionFileNodeNew = ActionFileNode_CreateNormal(fileNodeLeft,
+					fileNodeRight);
+				actionFileNodeNew->action = ActionFileCmp_DateLeftToRight;
 			}
-		} else {
-			actionFileNodeNew->action = AccionFileCmp_Nothing;
+			else {
+				actionFileNodeNew->action = ActionFileCmp_LeftToRight;
+			}
+		}
+		else {
+			actionFileNodeNew->action = ActionFileCmp_Nothing;
 		}
 		QueueNode(*actionFileNodeQueue, actionFileNodeNew);
 	}
 	if (fileNodeLeft && fileNodeRight) {
 		if ((fileNodeLeft->flags & FileFlag_Directory)
-				|| (fileNodeRight->flags & FileFlag_Directory)) {
-			if (fileNodeLeft->estado != FileStatus_Deleted) {
+			|| (fileNodeRight->flags & FileFlag_Directory)) {
+			if (fileNodeLeft->status != FileStatus_Deleted) {
 				AccionFileNode_CompareChilds(actionFileNodeNew,
-						actionFileNodeQueue, AccionFileNode_Copy);
+					actionFileNodeQueue, AccionFileNode_Copy);
 				if (abs((int)(fileNodeLeft->fileTime - fileNodeRight->fileTime))
-						<= maxDeltaTime) { // appox. equal
-					actionFileNodeNew->action = AccionFileCmp_Nothing;
-				} else {
-					actionFileNodeNew->action = AccionFileCmp_DateLeftToRight;
+					<= maxDeltaTime) { // appox. equal
+					actionFileNodeNew->action = ActionFileCmp_Nothing;
 				}
-			} else {
-				AccionFileNode_CompareChilds(actionFileNodeNew,
-						actionFileNodeQueue, AccionFileNode_DeletePair);
-				if (fileNodeRight->estado != FileStatus_Deleted) {
-					actionFileNodeNew->action = AccionFileCmp_DeleteRight;
+				else {
+					actionFileNodeNew->action = ActionFileCmp_DateLeftToRight;
 				}
 			}
-		} else {
-			if (fileNodeLeft->estado != FileStatus_Deleted) {
-				if (abs((int)(fileNodeLeft->fileTime - fileNodeRight->fileTime))
-						<= maxDeltaTime) { // appox. equal
-					actionFileNodeNew->action = AccionFileCmp_Nothing;
-				} else {
-					actionFileNodeNew->action = AccionFileCmp_LeftToRight;
+			else {
+				AccionFileNode_CompareChilds(actionFileNodeNew,
+					actionFileNodeQueue, AccionFileNode_DeletePair);
+				if (fileNodeRight->status != FileStatus_Deleted) {
+					actionFileNodeNew->action = ActionFileCmp_DeleteRight;
 				}
-			} else {
-				if (fileNodeRight->estado != FileStatus_Deleted) {
-					actionFileNodeNew->action = AccionFileCmp_DeleteRight;
+			}
+		}
+		else {
+			if (fileNodeLeft->status != FileStatus_Deleted) {
+				if (abs((int)(fileNodeLeft->fileTime - fileNodeRight->fileTime))
+					<= maxDeltaTime) { // appox. equal
+					actionFileNodeNew->action = ActionFileCmp_Nothing;
+				}
+				else {
+					actionFileNodeNew->action = ActionFileCmp_LeftToRight;
+				}
+			}
+			else {
+				if (fileNodeRight->status != FileStatus_Deleted) {
+					actionFileNodeNew->action = ActionFileCmp_DeleteRight;
 				}
 			}
 		}
@@ -476,18 +510,18 @@ void AccionFileNode_Copy(FileNode *fileNodeLeft, FileNode *fileNodeRight,
 	}
 }
 
-AccionFileNode *AccionFileNode_BuildCopy(FileNode *fileNodeLeft,
-		FileNode *fileNodeRight) {
-	AccionFileNode *actionFileNodeRoot = AccionFileNode_CreateNormal(
-			fileNodeLeft, fileNodeRight);
-	AccionFileNode *actionFileNodeQueue = actionFileNodeRoot;
+ActionFileNode *ActionFileNode_BuildCopy(FileNode *fileNodeLeft,
+	FileNode *fileNodeRight) {
+	ActionFileNode *actionFileNodeRoot = ActionFileNode_CreateNormal(
+		fileNodeLeft, fileNodeRight);
+	ActionFileNode *actionFileNodeQueue = actionFileNodeRoot;
 	AccionFileNode_CompareChilds(actionFileNodeRoot, &actionFileNodeQueue,
-			AccionFileNode_Copy);
+		AccionFileNode_Copy);
 	return actionFileNodeRoot;
 }
 
-void AccionFileNode_Statistics(AccionFileNode *actionFileNode,
-		ActionQueueStatistics *statistics) {
+void ActionFileNode_Statistics(ActionFileNode *actionFileNode,
+	ActionQueueStatistics *statistics) {
 	statistics->readLeft = 0;
 	statistics->writeLeft = 0;
 	statistics->readRight = 0;
@@ -499,39 +533,39 @@ void AccionFileNode_Statistics(AccionFileNode *actionFileNode,
 	statistics->deleteLeft = 0;
 	statistics->deleteRight = 0;
 
-	while (actionFileNode != NULL ) {
+	while (actionFileNode != NULL) {
 
 		switch (actionFileNode->action) {
-		case AccionFileCmp_Nothing:
+		case ActionFileCmp_Nothing:
 			break;
-		case AccionFileCmp_LeftToRight:
+		case ActionFileCmp_LeftToRight:
 			statistics->fullCopyCount++;
 			statistics->readLeft += actionFileNode->left->size;
 			statistics->writeRight += actionFileNode->left->size;
 			break;
-		case AccionFileCmp_RightToLeft:
+		case ActionFileCmp_RightToLeft:
 			statistics->fullCopyCount++;
 			statistics->writeLeft += actionFileNode->right->size;
 			statistics->readRight += actionFileNode->right->size;
 			break;
-		case AccionFileCmp_DeleteLeft:
+		case ActionFileCmp_DeleteLeft:
 			statistics->deleteCount++;
 			statistics->deleteLeft += actionFileNode->left->size;
 			break;
-		case AccionFileCmp_DeleteRight:
+		case ActionFileCmp_DeleteRight:
 			statistics->deleteCount++;
 			statistics->deleteRight += actionFileNode->right->size;
 			break;
-		case AccionFileCmp_DateLeftToRight:
+		case ActionFileCmp_DateLeftToRight:
 			statistics->dateCopyCount++;
 			break;
-		case AccionFileCmp_DateRightToLeft:
+		case ActionFileCmp_DateRightToLeft:
 			statistics->dateCopyCount++;
 			break;
-		case AccionFileCmp_MakeRightDirectory:
+		case ActionFileCmp_MakeRightDirectory:
 			statistics->directoryCount++;
 			break;
-		case AccionFileCmp_MakeLeftDirectory:
+		case ActionFileCmp_MakeLeftDirectory:
 			statistics->directoryCount++;
 			break;
 		}
@@ -540,41 +574,42 @@ void AccionFileNode_Statistics(AccionFileNode *actionFileNode,
 	}
 }
 
-void AccionFileNode_Print(AccionFileNode *actionFileNode) {
+void ActionFileNode_Print(ActionFileNode *actionFileNode) {
 	char showPath[MaxPath];
-	while (actionFileNode != NULL ) {
+	while (actionFileNode != NULL) {
 		if (actionFileNode->left) {
 			FileNode_GetFullPath(actionFileNode->left, "", showPath);
-		} else {
+		}
+		else {
 			FileNode_GetFullPath(actionFileNode->right, "", showPath);
 		}
 
 		switch (actionFileNode->action) {
-		case AccionFileCmp_Nothing:
+		case ActionFileCmp_Nothing:
 			//printff("%s == %s\n",pathIzq,pathDer);
 			break;
-		case AccionFileCmp_LeftToRight:
+		case ActionFileCmp_LeftToRight:
 			printff(" => %s\n", showPath);
 			break;
-		case AccionFileCmp_RightToLeft:
+		case ActionFileCmp_RightToLeft:
 			printff(" <= %s\n", showPath);
 			break;
-		case AccionFileCmp_DeleteLeft:
+		case ActionFileCmp_DeleteLeft:
 			printff(" *- %s\n", showPath);
 			break;
-		case AccionFileCmp_DeleteRight:
+		case ActionFileCmp_DeleteRight:
 			printff(" -* %s\n", showPath);
 			break;
-		case AccionFileCmp_DateLeftToRight:
+		case ActionFileCmp_DateLeftToRight:
 			printff(" -> %s\n", showPath);
 			break;
-		case AccionFileCmp_DateRightToLeft:
+		case ActionFileCmp_DateRightToLeft:
 			printff(" <- %s\n", showPath);
 			break;
-		case AccionFileCmp_MakeRightDirectory:
+		case ActionFileCmp_MakeRightDirectory:
 			printff(" -D %s\n", showPath);
 			break;
-		case AccionFileCmp_MakeLeftDirectory:
+		case ActionFileCmp_MakeLeftDirectory:
 			printff(" D- %s\n", showPath);
 			break;
 		}
@@ -592,14 +627,16 @@ void AccionFileNodeAux_CopyDate(char *pathOrig, char *pathDest) {
 void AccionFileNodeAux_Copy(char *pathOrig, char *pathDest) {
 	if (File_Copy(pathOrig, pathDest)) {
 		AccionFileNodeAux_CopyDate(pathOrig, pathDest);
-	} else {
+	}
+	else {
 		File_Delete(pathDest);
 	}
 }
 void AccionFileNodeAux_Delete(char *pathOrig, char *pathDest) {
 	if (File_IsDirectory(pathDest)) {
 		File_DeleteDirectory(pathDest);
-	} else {
+	}
+	else {
 		File_Delete(pathDest);
 	}
 }
@@ -607,61 +644,64 @@ void AccionFileNodeAux_MakeDir(char *pathOrig, char *pathDest) {
 	File_MakeDirectory(pathDest);
 }
 
-void AccionFileNode_RunList(AccionFileNode *actionFileNode, char *pathLeft,
-		char *pathRight) {
+void ActionFileNode_RunList(ActionFileNode *actionFileNode, char *pathLeft,
+	char *pathRight) {
 	char fullPathLeft[MaxPath], fullPathRight[MaxPath], showPath[MaxPath];
-	while (actionFileNode != NULL ) {
+	while (actionFileNode != NULL) {
 		if (actionFileNode->left) {
 			FileNode_GetFullPath(actionFileNode->left, pathLeft, fullPathLeft);
-		} else {
+		}
+		else {
 			FileNode_GetFullPath(actionFileNode->right, pathLeft, fullPathLeft);
 		}
 		if (actionFileNode->right) {
 			FileNode_GetFullPath(actionFileNode->right, pathRight,
-					fullPathRight);
-		} else {
+				fullPathRight);
+		}
+		else {
 			FileNode_GetFullPath(actionFileNode->left, pathRight,
-					fullPathRight);
+				fullPathRight);
 		}
 		if (actionFileNode->left) {
 			FileNode_GetFullPath(actionFileNode->left, "", showPath);
-		} else {
+		}
+		else {
 			FileNode_GetFullPath(actionFileNode->right, "", showPath);
 		}
 
 		switch (actionFileNode->action) {
-		case AccionFileCmp_Nothing:
+		case ActionFileCmp_Nothing:
 			//printff("%s == %s\n",pathIzq,pathDer);
 			break;
-		case AccionFileCmp_LeftToRight:
+		case ActionFileCmp_LeftToRight:
 			printff(" => %s\n", showPath);
 			AccionFileNodeAux_Copy(fullPathLeft, fullPathRight);
 			break;
-		case AccionFileCmp_RightToLeft:
+		case ActionFileCmp_RightToLeft:
 			printff(" <= %s\n", showPath);
 			AccionFileNodeAux_Copy(fullPathRight, fullPathLeft);
 			break;
-		case AccionFileCmp_DeleteLeft:
+		case ActionFileCmp_DeleteLeft:
 			printff(" *- %s\n", showPath);
 			AccionFileNodeAux_Delete(fullPathRight, fullPathLeft);
 			break;
-		case AccionFileCmp_DeleteRight:
+		case ActionFileCmp_DeleteRight:
 			printff(" -* %s\n", showPath);
 			AccionFileNodeAux_Delete(fullPathLeft, fullPathRight);
 			break;
-		case AccionFileCmp_DateLeftToRight:
+		case ActionFileCmp_DateLeftToRight:
 			printff(" -> %s\n", showPath);
 			AccionFileNodeAux_CopyDate(fullPathLeft, fullPathRight);
 			break;
-		case AccionFileCmp_DateRightToLeft:
+		case ActionFileCmp_DateRightToLeft:
 			printff(" <- %s\n", showPath);
 			AccionFileNodeAux_CopyDate(fullPathRight, fullPathLeft);
 			break;
-		case AccionFileCmp_MakeRightDirectory:
+		case ActionFileCmp_MakeRightDirectory:
 			printff(" -D %s\n", showPath);
 			AccionFileNodeAux_MakeDir(fullPathLeft, fullPathRight);
 			break;
-		case AccionFileCmp_MakeLeftDirectory:
+		case ActionFileCmp_MakeLeftDirectory:
 			printff(" D- %s\n", showPath);
 			AccionFileNodeAux_MakeDir(fullPathRight, fullPathLeft);
 			break;
diff --git a/src/filenodecmp.h b/src/filenodecmp.h
index aa8b16a..465fe4f 100644
--- a/src/filenodecmp.h
+++ b/src/filenodecmp.h
@@ -4,33 +4,33 @@
 #include "filenode.h"
 
 typedef enum {
-	AccionFileCmp_Nothing,
-	AccionFileCmp_LeftToRight,
-	AccionFileCmp_RightToLeft,
-	AccionFileCmp_DeleteLeft,
-	AccionFileCmp_DeleteRight,
-	AccionFileCmp_DateLeftToRight,
-	AccionFileCmp_DateRightToLeft,
-	AccionFileCmp_MakeRightDirectory,
-	AccionFileCmp_MakeLeftDirectory
-} AccionFileCmp;
+	ActionFileCmp_Nothing,
+	ActionFileCmp_LeftToRight,
+	ActionFileCmp_RightToLeft,
+	ActionFileCmp_DeleteLeft,
+	ActionFileCmp_DeleteRight,
+	ActionFileCmp_DateLeftToRight,
+	ActionFileCmp_DateRightToLeft,
+	ActionFileCmp_MakeRightDirectory,
+	ActionFileCmp_MakeLeftDirectory
+} ActionFileCmp;
 
-typedef struct SAccionFileNode {
-	AccionFileCmp action;
+typedef struct SActionFileNode {
+	ActionFileCmp action;
 	FileNode *left;
 	FileNode *right;
-	struct SAccionFileNode *next;
-} AccionFileNode;
+	struct SActionFileNode *next;
+} ActionFileNode;
 
-AccionFileNode *AccionFileNode_Create();
-void AccionFileNode_Destroy(AccionFileNode *actionFileNode);
-AccionFileNode *AccionFileNode_CreateNormal(FileNode *fileNodeLeft,
-		FileNode *fileNodeRight);
+ActionFileNode *ActionFileNode_Create();
+void AccionFileNode_Destroy(ActionFileNode *actionFileNode);
+ActionFileNode *ActionFileNode_CreateNormal(FileNode *fileNodeLeft,
+	FileNode *fileNodeRight);
 
-AccionFileNode *AccionFileNode_BuildSync(FileNode *fileNodeLeft,
-		FileNode *fileNodeRight);
-AccionFileNode *AccionFileNode_BuildCopy(FileNode *fileNodeLeft,
-		FileNode *fileNodeRight);
+ActionFileNode *ActionFileNode_BuildSync(FileNode *fileNodeLeft,
+	FileNode *fileNodeRight);
+ActionFileNode *ActionFileNode_BuildCopy(FileNode *fileNodeLeft,
+	FileNode *fileNodeRight);
 
 typedef struct SActionQueueStatistics {
 	long long readLeft;
@@ -45,12 +45,12 @@ typedef struct SActionQueueStatistics {
 	long long deleteRight;
 } ActionQueueStatistics;
 
-void AccionFileNode_Statistics(AccionFileNode *actionFileNode,
-		ActionQueueStatistics *statistics);
+void ActionFileNode_Statistics(ActionFileNode *actionFileNode,
+	ActionQueueStatistics *statistics);
 
-void AccionFileNode_Print(AccionFileNode *actionFileNode);
+void ActionFileNode_Print(ActionFileNode *actionFileNode);
 
-void AccionFileNode_RunList(AccionFileNode *actionFileNode, char *pathLeft,
-		char *pathRight);
+void ActionFileNode_RunList(ActionFileNode *actionFileNode, char *pathLeft,
+	char *pathRight);
 
 #endif
diff --git a/src/fileutil.c b/src/fileutil.c
index a1a0540..b537770 100644
--- a/src/fileutil.c
+++ b/src/fileutil.c
@@ -59,7 +59,7 @@ 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 );
+		OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
 	GetFileTime(hFile, &ftCreate, &ftAccess, &ftWrite);
 	CloseHandle(hFile);
 	return (FileTime_to_POSIX(ftWrite));
@@ -69,7 +69,7 @@ void FileTime_Set(char *fileName, FileTime fileTime) {
 	HANDLE hFile;
 	FILETIME ftWrite;
 	hFile = CreateFile(fileName, GENERIC_WRITE, FILE_SHARE_WRITE, NULL,
-			OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL );
+		OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
 	ftWrite = POSIX_to_FileTime(fileTime);
 	SetFileTime(hFile, NULL, NULL, &ftWrite);
 	CloseHandle(hFile);
@@ -96,10 +96,10 @@ void FileTime_Set(char *fileName, FileTime t) {
 void FileTime_Print(FileTime fileTime) {
 	struct tm *tms;
 
-	tms = localtime((time_t *) &fileTime);
+	tms = localtime((time_t *)&fileTime);
 	printff("%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);
+		tms->tm_mon + 1, tms->tm_mday, tms->tm_hour, tms->tm_min,
+		tms->tm_sec);
 }
 
 void File_GetName(char *path, char *name) {
@@ -110,7 +110,8 @@ void File_GetName(char *path, char *name) {
 		if (path[i] == '/' || path[i] == '\\') {
 			i++;
 			break;
-		} else {
+		}
+		else {
 			i--;
 		}
 	}
@@ -132,7 +133,7 @@ int File_ExistsPath(char *path) {
 	unsigned rc;
 	rc = GetFileAttributes(path);
 
-	if (rc == INVALID_FILE_ATTRIBUTES ) {
+	if (rc == INVALID_FILE_ATTRIBUTES) {
 		return (0);
 	}
 	return (1);
@@ -141,7 +142,7 @@ int File_IsDirectory(char *fileName) {
 	unsigned rc;
 	rc = GetFileAttributes(fileName);
 
-	if (rc == INVALID_FILE_ATTRIBUTES ) {
+	if (rc == INVALID_FILE_ATTRIBUTES) {
 		return (0);
 	}
 	if (rc & FILE_ATTRIBUTE_DIRECTORY) {
@@ -153,7 +154,7 @@ int File_IsFile(char *fileName) {
 	unsigned rc;
 	rc = GetFileAttributes(fileName);
 
-	if (rc == INVALID_FILE_ATTRIBUTES ) {
+	if (rc == INVALID_FILE_ATTRIBUTES) {
 		return (0);
 	}
 	if (rc & FILE_ATTRIBUTE_DIRECTORY) {
@@ -201,7 +202,7 @@ long long File_GetSize(char *fileName) {
 	HANDLE hFile;
 	DWORD fSize;
 	hFile = CreateFile(fileName, GENERIC_READ, FILE_SHARE_READ, NULL,
-			OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL );
+		OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
 	GetFileSize(hFile, &fSize);
 	CloseHandle(hFile);
 	return (fSize);
@@ -221,7 +222,7 @@ void File_GetSizeAndTime(char *fileName, long long *size, FileTime *time) {
 	DWORD fSize;
 	FILETIME ftCreate, ftAccess, ftWrite;
 	hFile = CreateFile(fileName, GENERIC_READ, FILE_SHARE_READ, NULL,
-			OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL );
+		OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
 	GetFileSize(hFile, &fSize);
 	GetFileTime(hFile, &ftCreate, &ftAccess, &ftWrite);
 	CloseHandle(hFile);
@@ -253,7 +254,7 @@ int File_MakeDirectory(char *path) {
 #ifdef WIN32
 
 void File_IterateDir(char *path,
-		int (*func)(char *path, char *name, void *data), void *data) {
+	int(*func)(char *path, char *name, void *data), void *data) {
 	int handle;
 	struct _finddata_t fileinfo;
 	char f_path[MaxPath];
@@ -266,11 +267,10 @@ void File_IterateDir(char *path,
 	if (handle == -1)
 		return;
 
-	// Recorrer el directorio
+	// Iterate directory
 	do {
 		if (strcmp(fileinfo.name, ".") && strcmp(fileinfo.name, "..")) {
-			// A partir de aqui hay un fichero
-			// (o directorio)
+			// Each item
 			snprintf(f_path, 512, "%s/%s", path, fileinfo.name);
 			fin = func(f_path, fileinfo.name, data);
 		}
@@ -282,7 +282,7 @@ void File_IterateDir(char *path,
 #else
 
 void File_IterateDir(char *path,
-		int (*func)(char *path, char *name, void *data), void *data) {
+	int(*func)(char *path, char *name, void *data), void *data) {
 	DIR *directorio;
 	struct dirent *entidad_dir;
 	char f_path[MaxPath];
@@ -290,22 +290,21 @@ void File_IterateDir(char *path,
 	char *ptr;
 
 	directorio = opendir(path);
-	if (directorio == NULL )
-	return;
+	if (directorio == NULL)
+		return;
 
-	// Recorrer el directorio
+	// Iterate directory
 	do {
 		entidad_dir = readdir(directorio);
-		if (entidad_dir != NULL ) {
+		if (entidad_dir != NULL) {
 			if (strcmp(entidad_dir->d_name, ".")
-					&& strcmp(entidad_dir->d_name, "..")) {
-				// A partir de aqui hay un fichero
-				// (o directorio)
+				&& strcmp(entidad_dir->d_name, "..")) {
+				// Each item
 				snprintff(f_path, MaxPath, "%s/%s", path, entidad_dir->d_name);
 				fin = func(f_path, entidad_dir->d_name, data);
 			}
 		}
-	}while (entidad_dir != NULL && !fin);
+	} while (entidad_dir != NULL && !fin);
 	closedir(directorio);
 }
 #endif
@@ -329,26 +328,32 @@ void File_DeleteDirectory(char *path) {
 #define MaxBuffer 16384
 int File_Copy(const char *pathOrig, const char *pathDest) {
 	FILE *fOrig, *fDest;
-	char buffer[MaxBuffer];
+	char *buffer = NULL;
 	int readLen = 0;
 	int writeLen = 0;
 	int ok = 0;
 
-	if ((fOrig = fopen(pathOrig, "rb")) == NULL ) {
+	if ((fOrig = fopen(pathOrig, "rb")) == NULL) {
 		return 0;
 	}
-	if ((fDest = fopen(pathDest, "wb")) == NULL ) {
+	if ((fDest = fopen(pathDest, "wb")) == NULL) {
+		return 0;
+	}
+
+	buffer = malloc(sizeof(char)*MaxBuffer);
+	if (buffer == NULL) {
 		return 0;
 	}
 
 	do {
-		readLen = fread(&buffer, 1, MaxBuffer, fOrig);
+		readLen = fread(buffer, 1, MaxBuffer, fOrig);
 		if (readLen > 0) {
 			writeLen = fwrite(&buffer, 1, readLen, fDest);
 			if (writeLen != readLen) {
 				// Error
 				fclose(fOrig);
 				fclose(fDest);
+				free(buffer);
 				return 0;
 			}
 		}
@@ -360,5 +365,6 @@ int File_Copy(const char *pathOrig, const char *pathDest) {
 
 	fclose(fOrig);
 	fclose(fDest);
+	free(buffer);
 	return ok;
 }
diff --git a/src/fileutil.h b/src/fileutil.h
index 47077d8..80177b3 100644
--- a/src/fileutil.h
+++ b/src/fileutil.h
@@ -13,7 +13,7 @@ void FileTime_Print(FileTime t);
 ///////////////////////////////////////////////
 // File
 #define MaxPath 4096
-#define MaxFilename 512
+#define MaxFilename 2048
 
 void File_GetName(char *path, char *name);
 
@@ -23,14 +23,14 @@ int File_IsDirectory(char *path);
 
 int File_IsFile(char *path);
 
-long long File_GetSize(char *ficheros);
+long long File_GetSize(char *fileName);
 
-void File_GetSizeAndTime(char *ficheros, long long *size, FileTime *time);
+void File_GetSizeAndTime(char *fileName, long long *size, FileTime *time);
 
 int File_MakeDirectory(char *path);
 
 void File_IterateDir(char *path,
-		int (*func)(char *path, char *name, void *data), void *data);
+	int(*func)(char *path, char *name, void *data), void *data);
 
 void File_Delete(char *path);
 void File_DeleteDirectory(char *path);
diff --git a/src/main.c b/src/main.c
index 544d70d..37202c7 100644
--- a/src/main.c
+++ b/src/main.c
@@ -49,43 +49,48 @@ int main(int argc, char *argv[]) {
 				FileNode_PrintNode(fileNode);
 			}
 		}
-	} else if (!strcmp(argv[1], "scan") && argc == 4) {
-		// Scanear informacion de directorio y guardar arbol
-		long long tScan=Time_GetTime();
+	}
+	else if (!strcmp(argv[1], "scan") && argc == 4) {
+		// Scan directory information tree and save
+		long long tScan = Time_GetTime();
 		FileNode *fileNode;
 		printff("Building FileNode..\n");
 		fileNode = FileNode_Build(argv[2]);
-		tScan=Time_GetTime()-tScan;
-		printff("tScan: %9lldus\n",tScan);
+		tScan = Time_GetTime() - tScan;
+		printff("tScan: %9lldus\n", tScan);
 		FileNode_Save(fileNode, argv[3]);
-	} else if (!strcmp(argv[1], "rescan") && argc == 4) {
-		// Scanear informacion de directorio y guardar arbol
+	}
+	else if (!strcmp(argv[1], "rescan") && argc == 4) {
+		// Scan directory information and save tree
 		FileNode *fileNode;
 		printff("Loading FileNode..\n");
 		fileNode = FileNode_Load(argv[3]);
 		if (fileNode) {
 			printff("Rebuilding FileNode..\n");
-			long long tScan=Time_GetTime();
+			long long tScan = Time_GetTime();
 			fileNode = FileNode_Refresh(fileNode, argv[2]);
-			tScan=Time_GetTime()-tScan;
-			printff("tScan: %9lldus\n",tScan);
-			FileNode_Save(fileNode, argv[3]);
-		}else{
-			printff("Building FileNode..\n");
-			long long tScan=Time_GetTime();
-			fileNode = FileNode_Build(argv[2]);
-			tScan=Time_GetTime()-tScan;
-			printff("tScan: %9lldus\n",tScan);
+			tScan = Time_GetTime() - tScan;
+			printff("tScan: %9lldus\n", tScan);
 			FileNode_Save(fileNode, argv[3]);
 		}
-	} else if (!strcmp(argv[1], "read") && argc == 3) {
-		// Leer informacion de arbol
+		else {
+			printff("Building FileNode..\n");
+			long long tScan = Time_GetTime();
+			fileNode = FileNode_Build(argv[2]);
+			tScan = Time_GetTime() - tScan;
+			printff("tScan: %9lldus\n", tScan);
+			FileNode_Save(fileNode, argv[3]);
+		}
+	}
+	else if (!strcmp(argv[1], "read") && argc == 3) {
+		// Read information tree from file
 		FileNode *fileNode;
 		fileNode = FileNode_Load(argv[2]);
 		if (fileNode)
 			FileNode_Print(fileNode);
-	} else if (!strcmp(argv[1], "dir") && argc == 3) {
-		// Leer informacion de dir
+	}
+	else if (!strcmp(argv[1], "dir") && argc == 3) {
+		// Read directory information tree
 		char *path = argv[2];
 		FileNode *fileNode;
 
@@ -93,28 +98,37 @@ int main(int argc, char *argv[]) {
 		if (fileNode) {
 			FileNode_Print(fileNode);
 		}
-	} else if (argc == 4) {
+	}
+	else if (argc == 4) {
 		char *cmd = argv[1];
 		char *pathLeft = argv[2];
 		char *pathRight = argv[3];
 		if (!strcmp(cmd, "sync")) {
 			Sync(pathLeft, pathRight, 1, 0);
-		} else if (!strcmp(cmd, "resync")) {
+		}
+		else if (!strcmp(cmd, "resync")) {
 			Sync(pathLeft, pathRight, 0, 0);
-		} else if (!strcmp(cmd, "synctest")) {
+		}
+		else if (!strcmp(cmd, "synctest")) {
 			Sync(pathLeft, pathRight, 1, 1);
-		} else if (!strcmp(cmd, "resynctest")) {
+		}
+		else if (!strcmp(cmd, "resynctest")) {
 			Sync(pathLeft, pathRight, 0, 1);
-		} else if (!strcmp(cmd, "copy")) {
+		}
+		else if (!strcmp(cmd, "copy")) {
 			Copy(pathLeft, pathRight, 1, 0);
-		} else if (!strcmp(cmd, "recopy")) {
+		}
+		else if (!strcmp(cmd, "recopy")) {
 			Copy(pathLeft, pathRight, 0, 0);
-		} else if (!strcmp(cmd, "copytest")) {
+		}
+		else if (!strcmp(cmd, "copytest")) {
 			Copy(pathLeft, pathRight, 1, 1);
-		} else if (!strcmp(cmd, "recopytest")) {
+		}
+		else if (!strcmp(cmd, "recopytest")) {
 			Copy(pathLeft, pathRight, 0, 1);
 		}
-	} else {
+	}
+	else {
 		Help(argv[0]);
 	}
 
@@ -125,40 +139,42 @@ FileNode *CheckDir(char *path, int recheck) {
 	char dirNodesFile[MaxPath];
 	FileNode *fileNode;
 
-	// Comprobar directorio
+	// Check directory
 	snprintf(dirNodesFile, MaxPath, "%s/"FileNode_Filename, path);
 	if (recheck) {
 		printff("Checking Directory.. %s\n", path);
-		long long tScan=Time_GetTime();
+		long long tScan = Time_GetTime();
 		fileNode = FileNode_Load(dirNodesFile);
 		if (fileNode) {
 			fileNode = FileNode_Refresh(fileNode, path);
-		} else {
+		}
+		else {
 			fileNode = FileNode_Build(path);
 		}
-		tScan=Time_GetTime()-tScan;
-		printff("tScan: %9lldus\n",tScan);
+		tScan = Time_GetTime() - tScan;
+		printff("tScan: %9lldus\n", tScan);
 		FileNode_Save(fileNode, dirNodesFile);
-	} else {
+	}
+	else {
 		printff("Loading Directory.. %s\n", path);
 		fileNode = FileNode_Load(dirNodesFile);
 		if (!fileNode) {
 			printff("Error, no nodesFile.fs\n");
-			return NULL ;
+			return NULL;
 		}
 	}
 	return fileNode;
 }
 
-void PrintStatistics(AccionFileNode *actionFileNode) {
+void PrintStatistics(ActionFileNode *actionFileNode) {
 	ActionQueueStatistics statistics;
-	AccionFileNode_Statistics(actionFileNode, &statistics);
+	ActionFileNode_Statistics(actionFileNode, &statistics);
 	printff("Statistics\n");
 	printff("       % 12s % 12s % 12s\n", "Read", "Write", "Delete");
 	printff("Left : % 12lld % 12lld % 12lld\n", statistics.readLeft,
-			statistics.writeLeft, statistics.deleteLeft);
+		statistics.writeLeft, statistics.deleteLeft);
 	printff("Right: % 12lld % 12lld % 12lld\n", statistics.readRight,
-			statistics.writeRight, statistics.deleteRight);
+		statistics.writeRight, statistics.deleteRight);
 	printff("\n");
 	printff("Copy count     : % 10d\n", statistics.fullCopyCount);
 	printff("Date copy count: % 10d\n", statistics.dateCopyCount);
@@ -169,7 +185,7 @@ void PrintStatistics(AccionFileNode *actionFileNode) {
 int Sync(char *pathLeft, char *pathRight, int recheck, int dryRun) {
 	FileNode *fileNodeLeft, *fileNodeRight;
 
-	// Comprobar y cargar directorios
+	// Check and load directories
 	if (!File_ExistsPath(pathLeft) || !File_IsDirectory(pathLeft)) {
 		printff("Error, directory does not exist: %s\n", pathLeft);
 		return 0;
@@ -187,21 +203,22 @@ int Sync(char *pathLeft, char *pathRight, int recheck, int dryRun) {
 		return 0;
 	}
 
-	// Construir acciones
-	long long tBuild=Time_GetTime();
+	// Build actions
+	long long tBuild = Time_GetTime();
 	printff("Building action list.. \n");
-	AccionFileNode *actionFileNode = NULL;
-	actionFileNode = AccionFileNode_BuildSync(fileNodeLeft, fileNodeRight);
-	tBuild=Time_GetTime()-tBuild;
-	printff("tBuild: %9lldus\n",tBuild);
+	ActionFileNode *actionFileNode = NULL;
+	actionFileNode = ActionFileNode_BuildSync(fileNodeLeft, fileNodeRight);
+	tBuild = Time_GetTime() - tBuild;
+	printff("tBuild: %9lldus\n", tBuild);
 
 	if (dryRun) {
-		// Mostrar lista de acciones
-		AccionFileNode_Print(actionFileNode);
+		// Show action list
+		ActionFileNode_Print(actionFileNode);
 		PrintStatistics(actionFileNode);
-	} else {
-		// Ejecutar lista de acciones
-		AccionFileNode_RunList(actionFileNode, pathLeft, pathRight);
+	}
+	else {
+		// Run action list
+		ActionFileNode_RunList(actionFileNode, pathLeft, pathRight);
 	}
 
 	return (1);
@@ -210,7 +227,7 @@ int Sync(char *pathLeft, char *pathRight, int recheck, int dryRun) {
 int Copy(char *pathLeft, char *pathRight, int reCheck, int dryRun) {
 	FileNode *fileNodeLeft, *fileNodeRight;
 
-	// Comprobar y cargar directorios
+	// Check and load directories
 	if (!File_ExistsPath(pathLeft) || !File_IsDirectory(pathLeft)) {
 		printff("Error, directory does not exist: %s\n", pathLeft);
 		return 0;
@@ -228,21 +245,22 @@ int Copy(char *pathLeft, char *pathRight, int reCheck, int dryRun) {
 		return 0;
 	}
 
-	// Construir acciones
-	long long tBuild=Time_GetTime();
+	// Build actions
+	long long tBuild = Time_GetTime();
 	printff("Building action list.. \n");
-	AccionFileNode *actionFileNode = NULL;
-	actionFileNode = AccionFileNode_BuildCopy(fileNodeLeft, fileNodeRight);
-	tBuild=Time_GetTime()-tBuild;
-	printff("tBuild: %9lldus\n",tBuild);
+	ActionFileNode *actionFileNode = NULL;
+	actionFileNode = ActionFileNode_BuildCopy(fileNodeLeft, fileNodeRight);
+	tBuild = Time_GetTime() - tBuild;
+	printff("tBuild: %9lldus\n", tBuild);
 
 	if (dryRun) {
-		// Mostrar lista de acciones
-		AccionFileNode_Print(actionFileNode);
+		// Show action list
+		ActionFileNode_Print(actionFileNode);
 		PrintStatistics(actionFileNode);
-	} else {
-		// Ejecutar lista de acciones
-		AccionFileNode_RunList(actionFileNode, pathLeft, pathRight);
+	}
+	else {
+		// Run action list
+		ActionFileNode_RunList(actionFileNode, pathLeft, pathRight);
 	}
 
 	return (1);
diff --git a/src/util.c b/src/util.c
index 8b70c7c..0586dcd 100644
--- a/src/util.c
+++ b/src/util.c
@@ -9,22 +9,20 @@ char *String_Copy(char *str) {
 	int len;
 	len = strlen(str);
 	strnew = malloc(len + 1);
-	strcpy(strnew, str);
+	if (strnew != NULL) {
+		strcpy(strnew, str);
+	}
 	return (strnew);
 }
 
 
-/////////////////////////////
-// Time_GetTime
-//
-// Gets the current time in usecs.
-/////////////////////////////
-// Time_Pause
-//
-// Pauses the execution for t usecs.
 #if WIN32
 #include <windows.h>
 // WIN32
+/////////////////////////////
+// Time_GetTime
+//
+// Gets the current time in usecs. WIN32 version.
 long long Time_GetTime(){
 	LARGE_INTEGER freq;
 	LARGE_INTEGER tim;
@@ -35,6 +33,11 @@ long long Time_GetTime(){
 	microt=(tim.QuadPart*1000000)/freq.QuadPart;
 	return(microt);
 }
+
+/////////////////////////////
+// Time_Pause
+//
+// Pauses the execution for t usecs. WIN32 version.
 void Time_Pause(int pausa){
 	long long tend,t,diff;
 
@@ -51,7 +54,10 @@ void Time_Pause(int pausa){
 	}while(tend>=t);
 }
 #else
-// UNIX
+/////////////////////////////
+// Time_GetTime
+//
+// Gets the current time in usecs. UNIX version.
 long long Time_GetTime(){
 	struct timeval t;
 	long long usecs;
@@ -59,6 +65,11 @@ long long Time_GetTime(){
 	usecs=(t.tv_sec*1000000ll)+(t.tv_usec);
 	return(usecs);
 }
+
+/////////////////////////////
+// Time_Pause
+//
+// Pauses the execution for t usecs. UNIX version.
 void Time_Pause(int pausa){
 	struct timeval tv;
 	tv.tv_sec=(long long)pausa/1000000;