ladish/daemon/file.c

/*
 *   LASH
 *
 *   Copyright (C) 2008 Juuso Alasuutari <juuso.alasuutari@gmail.com>
 *   Copyright (C) 2002 Robert Ham <rah@bash.sh>
 *
 *   This program 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 of the License, or
 *   (at your option) any later version.
 *
 *   This program 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 this program; if not, write to the Free Software
 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <dirent.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>

#include "file.h"
#include "../common/safety.h"
#include "../common/debug.h"

bool
lash_file_exists(const char *file)
{
	struct stat filestat;

	if (stat(file, &filestat) != -1)
		return true;

	return false;
}

bool
lash_dir_exists(const char *dir)
{
	if (dir) {
		DIR *dirstream = opendir(dir);
		if (dirstream) {
			closedir(dirstream);
			return true;
		}
	}

	return false;
}

const char *
lash_get_fqn(const char *param_dir,
             const char *param_file)
{
	static char *fqn = NULL;
	static size_t fqn_size = 48;
	size_t str_size;
	char *dir, *file;

	dir = lash_strdup(param_dir);
	file = lash_strdup(param_file);

	if (!fqn)
		fqn = lash_malloc(1, fqn_size);

	str_size = strlen(dir) + 1 + strlen(file) + 1;

	if (str_size > fqn_size) {
		fqn_size = str_size;
		fqn = lash_realloc(fqn, 1, fqn_size);
	}

	sprintf(fqn, "%s/%s", dir, file);

	free(dir);
	free(file);

	return fqn;
}

char *
lash_dup_fqn(
	const char * dir,
	const char * append)
{
	char * fqn;
	size_t size_dir;
	size_t size_append;

	size_dir = strlen(dir);
	size_append = strlen(append);
 
	fqn = lash_malloc(1, size_dir + 1 + size_append + 1);
 
	memcpy(fqn, dir, size_dir);
	fqn[size_dir] = '/';
	memcpy(fqn + size_dir + 1, append, size_append);
	fqn[size_dir + 1 + size_append] = 0;
 
	return fqn;
}

void
lash_create_dir(const char *dir)
{
	char *parent, *ptr;
	DIR *dirstream;
	struct stat parentstat;

	dirstream = opendir(dir);
	if (dirstream) {
		closedir(dirstream);
		return;
	}

	if (errno == EACCES) {
		lash_error("Cannot read directory %s: Permission denied", dir);
		return;
	}

	/* Try and create the parent */
	parent = lash_strdup(dir);
	ptr = strrchr(parent, '/');
	if (ptr) {
		*ptr = '\0';

		if (parent[0])
			lash_create_dir(parent);
		else {
			ptr[0] = '/';
			ptr[1] = '\0';
		}
	}

	/* Try and create the directory */
	if (stat(parent, &parentstat) == -1) {
		lash_error("Cannot stat parent %s to create directory %s: %s",
		           parent, dir, strerror(errno));
	} else if (mkdir(dir, parentstat.st_mode) == -1) {
		lash_error("Cannot create directory %s: %s",
		           dir, strerror(errno));
	}

	free(parent);
}

bool
lash_dir_empty(const char *dir)
{
	DIR *dirstream;
	struct dirent *entry;
	bool empty = true;

	dirstream = opendir(dir);
	if (!dirstream) {
		lash_error("Cannot open directory %s to check emptiness: %s",
		           dir, strerror(errno));
		return false;
	}

	while ((entry = readdir(dirstream))) {
		if (entry->d_name[0] == '.'
		    && (entry->d_name[1] == '\0'
		        || (entry->d_name[1] == '.'
		            && entry->d_name[2] == '\0')))
			continue;

		empty = false;
		break;
	}

	closedir(dirstream);

	return empty;
}

void
lash_remove_dir(const char *dirarg)
{
	DIR *dirstream;
	struct dirent *entry;
	const char *fqn;
	struct stat stat_info;
	char *dir;

	dir = lash_strdup(dirarg);

	dirstream = opendir(dir);
	if (!dirstream) {
		lash_error("Cannot open directory %s to remove it: %s",
		           dir, strerror(errno));
		free(dir);
		return;
	}

	while ((entry = readdir(dirstream))) {
		if (entry->d_name[0] == '.'
		    && (entry->d_name[1] == '\0'
		        || (entry->d_name[1] == '.'
		            && entry->d_name[2] == '\0')))
			continue;

		fqn = lash_get_fqn(dir, entry->d_name);

		if (stat(fqn, &stat_info) == -1) {
			lash_error("Cannot stat file %s: %s",
			           fqn, strerror(errno));
		} else {
			if (S_ISDIR(stat_info.st_mode)) {
				lash_remove_dir(fqn);
				continue;
			}
		}

		if (unlink(fqn) == -1) {
			lash_error("Cannot unlink file %s: %s",
			           fqn, strerror(errno));
			closedir(dirstream);
			free(dir);
			return;
		}
	}

	closedir(dirstream);

	if (rmdir(dir) == -1) {
		lash_error("Cannot remove directory %s: %s",
		           dir, strerror(errno));
	}

	free(dir);
}

bool
lash_read_text_file(const char  *file_path,
                    char       **ptr)
{
	FILE *file;
	long size;
	char *data;
	bool ret = false;

	file = fopen(file_path, "r");
	if (!file) {
		lash_error("Failed to open '%s' for reading: %s",
		           file_path, strerror(errno));
		return false;
	}

	if (fseek(file, 0, SEEK_END) == -1) {
		lash_error("Failed to set file offset for '%s': %s",
		           file_path, strerror(errno));
		goto exit_close;
	}

	size = ftell(file);
	if (size == -1) {
		lash_error("Failed to obtain file offset for '%s': %s",
		           file_path, strerror(errno));
		goto exit_close;
	}

	if (size == 0) {
		*ptr = NULL;
		ret = true;
		goto exit_close;
	}

	if (fseek(file, 0, SEEK_SET) == -1) {
		lash_error("Failed to set file offset for '%s': %s",
		           file_path, strerror(errno));
		goto exit_close;
	}

	data = lash_malloc(1, size + 1);

	if (fread(data, size, 1, file) != 1) {
		lash_error("Failed to read %ld bytes of data from file '%s'",
		           size, file_path);
		free(data);
		goto exit_close;
	}

	data[size] = 0;
	*ptr = data;

	ret = true;

exit_close:
	if (fclose(file) == EOF)
		lash_error("Failed to close file '%s': %s",
		           file_path, strerror(errno));

	return ret;
}


/* EOF */