~drizzle-trunk/drizzle/development

/* Copyright (c) 2010 PrimeBase Technologies GmbH, Germany
 *
 * PrimeBase Media Stream for MySQL
 *
 * 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
 *
 * Author: Barry Leslie
 *
 * 2010-02-05
 *
 * CORE SYSTEM:
 * Basic UNIX specific file I/O classes.
 *
 */

#include "CSConfig.h"
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <sys/file.h>
#include <unistd.h>
#include <signal.h>

#include "CSGlobal.h"
#include "CSDefs.h"
#include "CSStrUtil.h"
#include "CSSys.h"

#define CS_MASK		((S_IRUSR | S_IWUSR) | (S_IRGRP | S_IWGRP) | (S_IROTH))
//=====================
// CSSysFile
//=====================
bool CSSysFile::isDirNotFound(CSException *e) { return e->getErrorCode() == ENOENT; }
bool CSSysFile::isFileNotFound(CSException *e) { return e->getErrorCode() == ENOENT; }
bool CSSysFile::isDirExists(CSException *e) { return e->getErrorCode() == EEXIST; }

//--------------
void CSSysFile::sf_open(const char *path, bool readonly, bool create)
{
	int flags;
	
	flags = (readonly)?O_RDONLY:O_RDWR;
	
	if (create)
		flags |= O_CREAT;
		
	if (sf_fh != -1)
		sf_close();
	
	sf_path = CSString::newString(path);
	
	sf_fh = open(path, flags, CS_MASK);
	if (sf_fh == -1) {
		sf_path->release();
		sf_path = NULL;
		CSException::throwFileError(CS_CONTEXT, path, errno);
	}
}

//--------------
void CSSysFile::sf_close()
{
	if (sf_fh != -1) {
		close(sf_fh);
		sf_fh = -1;
		sf_path->release();
		sf_path = NULL;
	}	
}

//--------------
size_t CSSysFile::sf_pread(void *data, size_t size, off64_t offset)
{
	ssize_t read_size;
	
	read_size = pread(sf_fh, data, size, offset);
	if (read_size ==  -1)
		CSException::throwFileError(CS_CONTEXT, sf_path->getCString(), errno);

	return read_size;
}

//--------------
void CSSysFile::sf_pwrite(const void *data, size_t size, off64_t offset)
{
	size_t write_size;
	
	write_size = pwrite(sf_fh, data, size, offset);
	if (write_size != size)
		CSException::throwFileError(CS_CONTEXT, sf_path->getCString(), errno);

}

//--------------
void CSSysFile::sf_setEOF(off64_t offset)
{
	if (ftruncate(sf_fh, offset) == -1)
		CSException::throwFileError(CS_CONTEXT, sf_path->getCString(), errno);
}

//--------------
off64_t CSSysFile::sf_getEOF()
{
	off64_t eof;

	if ((eof = lseek(sf_fh, 0, SEEK_END)) == ((off64_t)-1))
		CSException::throwFileError(CS_CONTEXT, sf_path->getCString(), errno);

     return eof;
}

//--------------
void CSSysFile::sf_sync()
{
	fsync(sf_fh);
}

//--------------
void CSSysFile::sf_lock(bool shared)
{
	if (flock(sf_fh, (shared)?LOCK_SH:LOCK_EX) == -1)
		CSException::throwOSError(CS_CONTEXT, errno);
}

//--------------
void CSSysFile::sf_unlock()
{
	if (flock(sf_fh, LOCK_UN) == -1)
		CSException::throwOSError(CS_CONTEXT, errno);
}

//=====================
// CSSys
//=====================
//--------------
bool CSSys::sys_exists(const char *path)
{
	 return (access(path, F_OK) != -1);
}

//--------------
void CSSys::sys_makeDir(const char *path)
{
	char		super_path[PATH_MAX];
	struct stat	stats;
	char		*ptr;

	if (mkdir(path, S_IRWXU | S_IRWXG | S_IRWXO) == -1)
		CSException::throwFileError(CS_CONTEXT, path, errno);

	// Set the access privileges.
	ptr = cs_last_name_of_path(path);
	if (ptr == path) 
		strcpy(super_path, ".");
	else {
		cs_strcpy(PATH_MAX, super_path, path);

		if ((ptr = cs_last_name_of_path(super_path)))
			*ptr = 0;
	}
	
	if (stat(super_path, &stats) == -1)
		CSException::throwFileError(CS_CONTEXT, path, errno);

	if (chmod(path, stats.st_mode) == -1)
		CSException::throwFileError(CS_CONTEXT, path, errno);

}

//--------------
void CSSys::sys_removeDir(const char *path)
{
	if (rmdir(path) == -1) {
		int err = errno;

		if (err != ENOENT)
			CSException::throwFileError(CS_CONTEXT, path, err);
	}
}

//--------------
void CSSys::sys_removeFile(const char *path)
{
	if (unlink(path) == -1) {
		int err = errno;

		if (err != ENOENT)
			CSException::throwFileError(CS_CONTEXT, path, err);
	}
}


//--------------

void CSSys::sys_stat(const char *path, bool *is_dir, off64_t *size, CSTime *mod_time)
{
	struct stat sb;

	if (stat(path, &sb) == -1)
		CSException::throwFileError(CS_CONTEXT, path, errno);
	if (is_dir)
		*is_dir = sb.st_mode & S_IFDIR;
	if (size)
		*size = sb.st_size;
	if (mod_time)
#ifdef __USE_MISC
		/* This is the Linux version: */
		mod_time->setUTC1970(sb.st_mtim.tv_sec, sb.st_mtim.tv_nsec);
#else
		/* This is the Mac OS X version: */
		mod_time->setUTC1970(sb.st_mtimespec.tv_sec, sb.st_mtimespec.tv_nsec);
#endif
}

//--------------
bool CSSys::sys_isLink(const char *path)
{
	struct stat sb;

	if (lstat(path, &sb) == -1)
		CSException::throwFileError(CS_CONTEXT, path, errno);
		
	return S_ISLNK(sb.st_mode);
}

//--------------
void CSSys::sys_rename(const char *old_path, const char *new_path)
{
	 if (rename(old_path, new_path) == -1)
		CSException::throwFileError(CS_CONTEXT, old_path, errno);
}

//--------------
void CSSys::sys_getcwd(char *path, size_t size)
{
	if (getcwd(path, size) == NULL)
		CSException::throwOSError(CS_CONTEXT, errno);
}

//--------------
void CSSys::sys_setcwd(const char *path)
{
	if (chdir(path) == -1)
		CSException::throwFileError(CS_CONTEXT, path, errno);
}

//--------------
uint32_t CSSys::sys_getpid()
{
	return getpid();
}

//--------------
bool CSSys::sys_isAlive(uint32_t pid)
{
	return (kill(pid, 0) == 0);
}

//=====================
// CSSysDir
//=====================
CSSysDir::~CSSysDir()
{
	close();
	if (sd_path)
		sd_path->release();
		
	if (sd_filter)
		sd_filter->release();
}

//--------------
void CSSysDir::open()
{
	enter_();
	if (!(sd_dir = opendir(sd_path->getCString())))
		CSException::throwFileError(CS_CONTEXT, sd_path->getCString(), errno);
	exit_();
}

//--------------
void CSSysDir::close()
{
	enter_();
	if (sd_dir) {
		closedir(sd_dir);
		sd_dir = NULL;
	}
	exit_();
}

//--------------
bool CSSysDir::next()
{
	int				err;
	struct dirent	*result;

	enter_();
	for (;;) {
		err = readdir_r(sd_dir, &sd_entry, &result);
		self->interrupted();
		if (err)
			CSException::throwFileError(CS_CONTEXT, sd_path->getCString(), err);
		if (!result)
			break;
		/* Filter out '.' and '..': */
		if (sd_entry.d_name[0] == '.') {
			if (sd_entry.d_name[1] == '.') {
				if (sd_entry.d_name[2] == '\0')
					continue;
			}
			else {
				if (sd_entry.d_name[1] == '\0')
					continue;
			}
		}
		break;
	}
	return_(result ? true : false);
}


//--------------
void CSSysDir::getEntryPath(char *path, size_t size)
{
	cs_strcpy(size, path, sd_path->getCString());
	cs_add_dir_char(size, path);
	cs_strcat(size, path, sd_entry.d_name);
}

//--------------
const char *CSSysDir::entryName()
{
	return sd_entry.d_name;
}

//--------------
bool CSSysDir::entryIsFile()
{
	if (sd_entry.d_type & DT_DIR)
		return false;
	return true;
}

//--------------
extern void unix_close(int h);
void unix_close(int h) {close(h);}