// Recursive Directory Deletion Implementation ===============

#ifdef _WIN32

	typedef struct {

		HANDLE hFind;

		WIN32_FIND_DATA findData;

	} fileDirectoryPos;

#else

	#include <sys/types.h>

	#include <dirent.h>

	typedef struct {

		DIR * dirPointer;

		char * currEntry;

	} fileDirectoryPos;

#endif

/** Returns 1 if is a directory, 0 if not, -1 if file does not exist or there is some other error*/

int isDirectory(char * path);

fileDirectoryPos * fileOpenDir(char *fileName);

char * getPathFromDirPos(fileDirectoryPos * dirPos);

int advanceToNextDirPos(fileDirectoryPos * dirPos);

int rmdirDirectory(char * path);

void closeDirPos(fileDirectoryPos *dirPos);

int fileExists(char * path);

	#include <errno.h>	

/** Returns 1 if file (or directory) exists, 0 if not, -1 if there is some other error*/

int fileExists(char * path) {

	#ifdef _WIN32

		struct _stat statbuf;

		int result = 0;

		result = _stat(path, &statbuf);

		if(result != 0) {

			if(errno == ENOENT) {

				return 0;

			} else {

				return -1;

			}

		}

		return 1;

	#else

		struct stat statbuf;

		int result = 0;

		result = stat(path, &statbuf);

		if(result != 0) {

			if(errno == ENOENT) {

				return 0;

			} else {

				return -1;

			}

		}

		return 1;

	#endif

}

/** Returns 1 if is a directory, 0 if not, -1 if file does not exist or there is some other error*/

int isDirectory(char * path) {

	#ifdef _WIN32

		if(path == 0) return -1;

		DWORD attrs;

		attrs = GetFileAttributes(path);

		if (attrs == INVALID_FILE_ATTRIBUTES) return -1;

		return (attrs & FILE_ATTRIBUTE_DIRECTORY) > 0;

	#else

		struct stat statbuf;

		int result = 0;

		result = stat(path, &statbuf);

		if(result != 0) {

			return -1;

		}

		return S_ISDIR(statbuf.st_mode);

	#endif

}

/** Returns 0 if successful, -1 otherwise*/

int rmdirDirectory(char * path) {

	int r = 0;

	#ifdef _WIN32

		r = RemoveDirectory(path);

		// If the operation reports to have succeeded, or the directory no longer exists, then return

		if(r != 0 || fileExists(path) == 0) {

			return 0;

		} else {

			return -1;

		}

	#else

		// Attempt to remove directory first -- this will succeed on either empty directories, or sym links

		// Do not remove this -- this is to prevent recursion into the contents of symlinked dirs which shouldn't be deleted

		r = remove(path);

		if(r == 0 || fileExists(path) == 0) {

			return 0;

		} else {

			return -1;

		}

	#endif

}

fileDirectoryPos * fileOpenDir(char *fileName) {

	fileDirectoryPos * result;

	#ifdef _WIN32

		char *updatedPath;

		// the FindFirstFile API requires a wildcard at the end of the path, so we append one

		// length is = strlen(fileName) + 2 (\*) + 1 (\0) + 1 (buffer)

		updatedPath = (char *)malloc(strlen(fileName) + 2 + 1 + 1 );

		sprintf(updatedPath, "%s\\*", fileName);

		result = (fileDirectoryPos *)malloc(sizeof(fileDirectoryPos));

		result->hFind = FindFirstFile(updatedPath, &(result->findData));

		free(updatedPath);

		if (result->hFind == INVALID_HANDLE_VALUE)  {

			free(result);

			return 0;

		}  else {

			return result;

		}

	#else

		DIR *dir;

		struct dirent *ep;

		dir = opendir (fileName);

		if(dir == 0) return 0;

		ep = readdir (dir);

		if(ep == 0) return 0;

		result = (fileDirectoryPos *) malloc(sizeof(fileDirectoryPos));

		result->dirPointer = dir;

		result->currEntry = ep->d_name;

		return result;

	#endif

}

char * getPathFromDirPos(fileDirectoryPos * dirPos) {

	if(dirPos == 0) return 0;

	#ifdef _WIN32

		return dirPos->findData.cFileName;

	#else

		return dirPos->currEntry;

	#endif

}

int advanceToNextDirPos(fileDirectoryPos * dirPos) {

	#ifdef _WIN32

		int result;

		result = FindNextFile(dirPos->hFind, &(dirPos->findData));

		if(result == 0) {

			return -1;

		}

		return 0;

	#else

		struct dirent *ep;

		ep = readdir (dirPos->dirPointer);

		if(ep == 0) return -1;

		dirPos->currEntry = ep->d_name;

		return 0;

	#endif

}

void closeDirPos(fileDirectoryPos *dirPos) {

	#ifdef _WIN32

		FindClose(dirPos->hFind);

	#else

		closedir (dirPos->dirPointer);

	#endif

	free(dirPos);

}

#include <stdio.h>

#include <stdlib.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <errno.h>

#ifdef _WIN32

	#define WIN32_LEAN_AND_MEAN

	#include <windows.h>

#else

	#include <unistd.h>

	#include <dirent.h>

#endif

int deleteDirectory(char * path);

int processDeleteDirCmd(fs_connection_block_t* con) {

	int i, numFiles, num;

	char* name;

	readInt(con->socket, &numFiles);

	readInt(con->socket, &num);

	if (num <= 0) return -1;

	for (i=0; i<num; i++) {

		name = readStringIntoBuffer(con);

		if (name == NULL) return -1;

		deleteDirectory(name);

		remove(name);

	}

	return 0;

}

	case DELETE_DIR_COMMAND:

		return processDeleteDirCmd(con);

static int isSymLink(char *path) {

	#ifndef _WIN32

		struct stat statbuf;

		int result = 0;

		result = lstat(path, &statbuf);

		if(result != 0) {

			return -1;

		}

		return S_ISLNK(statbuf.st_mode);

	#else

		// No sym links in Windows :)

		return 0;

	#endif

}

#ifdef _WIN32

	#define PATH_SEPARATOR_STR "\\"

	#define PATH_SEPARATOR_CHAR '\\'

#else

	#define PATH_SEPARATOR_STR "/"

	#define PATH_SEPARATOR_CHAR '/'

#endif

static int stripTrailingSlashIfExists(char * str) {

	int r = 0;

	if(str == 0) return -1;

	r = strlen(str);

	if(str[r-1] == PATH_SEPARATOR_CHAR) {

		str[r-1] = 0;

		return 1;

	}

	return 0;

}

static int deleteFile(char * path ) {

	int r = 0;

	if(path == 0) { return -1; }

	r = remove(path);

	if(r != 0) {

		return -1;

	}

	return 0;

}

static int recurseDeleteFilesInPath(char * path) {

	char * localPath;

	fileDirectoryPos *dp;

	char *currName;

	char *newPath;

	int r = 0;

	int skipFile = 0;

	if(fileExists(path) != 1 || isDirectory(path) != 1) {

		return -1;

	}

	localPath = (char *) malloc(strlen(path)+1);

	strcpy(localPath, path);

	stripTrailingSlashIfExists(localPath);

	dp = fileOpenDir(localPath);

	if(dp != 0) {

		currName = getPathFromDirPos(dp);

		while (currName != 0) {

			// Skip the . and .. values

			if(!strcmp(currName, ".")) { skipFile = 1; }

			if(!strcmp(currName, "..")) { skipFile = 1; }

			if(!skipFile) {

				// len(localPath) + 1 (for path separator) + length of file name + 1 (for \0 string terminator) + 1 (for buffer)

				newPath = (char *)malloc(  strlen(localPath) + 1 + strlen(currName) + 1 + 1  );

				sprintf(newPath, "%s%s%s", localPath, PATH_SEPARATOR_STR, currName);

				if(isDirectory(newPath) == 1) {

					deleteDirectory(newPath);

				} else {

					deleteFile(newPath);

				}

				free(newPath);

			}

			if(advanceToNextDirPos(dp) != 0) {

				currName = 0;

			} else {

				currName = getPathFromDirPos(dp);

			}

			skipFile = 0;

		}

		closeDirPos(dp);

	}

	free(localPath);

	return 0;

}

/** Note: This function will be passed to both regular directory paths, and symlinked directory paths */

int deleteDirectory(char * path) {

	int pathLength = 0;

	int r = 0;

	if(path == 0) {

		return -1;

	}

	// If the path is not a directory, or there was an error, return -1

	if(isDirectory(path) != 1) {

		return -1;

	}

	pathLength = strlen(path);

	// Safety check to ensure we are not being asked to delete the root of the file system

	#ifdef _WIN32

		// This matches any incidence of (drive-letter):(\), so, c:, d:, c:\, d:\, etc.

		if( (pathLength == 2 || pathLength == 3) && ((path[0] >= 'a' && path[0] <= 'z') || (path[0] >= 'A' && path[0] <= 'Z')  ) ) {

			if(path[1] == ':') {

				return  -1;

			}

		}

	#endif

	// This matches either \ or / or . or .. or empty string

	if(!strcmp(path, "/") || !strcmp(path, "\\") || !strcmp(path, ".") || !strcmp(path, "..") || !strcmp(path, "~") || !strcmp(path, "") ) {

		return -1;

	}

	// Attempt to remove directory first -- this will succeed on either empty directories, or sym links

	// Do not remove this -- this is to prevent recursion into the contents of symlinked dirs which shouldn't be deleted

	r = rmdirDirectory(path);

	if(r == 0) {

		return 0;

	}

	#ifndef _WIN32

		// The symlink should have been removed by the above; we don't want to recurse it if it hasn't, so just return here.

		if(isSymLink(path) == 1) {

			return -1;

		}

	#endif

	// We are assured at this point that path is a directory by the isDirectory check above

	recurseDeleteFilesInPath(path);

	r = rmdirDirectory(path);

	// If the operation reports to have succeeded, or the directory no longer exists, then return

	if(r == 0) {

		return 0;

	}

	return r;

}

#ifdef _WIN32

	#define WIN32_LEAN_AND_MEAN

	#include <windows.h>

#endif