~drizzle-trunk/drizzle/development : contents of plugin/pbms/src/cslib/CSFile.cc at revision 1841

~drizzle-trunk/drizzle/development : (revision 1841)

/* Copyright (c) 2008 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
 *
 * Original author: Paul McCullagh (H&G2JCtL)
 * Continued development: Barry Leslie
 *
 * 2007-06-07
 *
 * CORE SYSTEM:
 * Basic file I/O.
 *
 */

#include "CSConfig.h"

#ifndef XT_WIN
#include <unistd.h>
#include <dirent.h>
#endif
#include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>

#include "CSFile.h"
#include "CSStream.h"
#include "CSGlobal.h"


static int unix_file_open(const char *path, int flags, mode_t mode)
{
	return open(path, flags, mode);
}

int unix_file_close(int fh)
{
	return close(fh);
}

/*
 * ---------------------------------------------------------------
 * CORE SYSTEM FILES
 */

CSFile::~CSFile()
{
	close();
	if (myFilePath)
		myFilePath->release();
}

CSOutputStream *CSFile::getOutputStream()
{
	return CSFileOutputStream::newStream(RETAIN(this));
}

CSOutputStream *CSFile::getOutputStream(off64_t offset)
{
	return CSFileOutputStream::newStream(RETAIN(this), offset);
}

CSInputStream *CSFile::getInputStream()
{
	return CSFileInputStream::newStream(RETAIN(this));
}

CSInputStream *CSFile::getInputStream(off64_t offset)
{
	return CSFileInputStream::newStream(RETAIN(this), offset);
}

void CSFile::open(int mode)
{
	CSPath	*dir;
	bool	retry = false;

	CLOBBER_PROTECT(retry);

	enter_();
	if (mode & CREATE) {
		/* Create and open the file: */
		do {
			try_(a) {
				openFile(mode);
				retry = false;
			}
			catch_(a) {
				if (retry || !isDirNotFound(&self->myException))
					throw_();

				/* Make sure the parent directory exists: */
				dir = CSPath::newPath(RETAIN(myFilePath), "..");
				push_(dir);
				try_(b) {
					dir->makePath();
				}
				catch_(b) { /* Two threads may try to create the directory at the same time. */
					if (!isDirExists(&self->myException))
						throw_();
				}
				cont_(b);

				release_(dir);
				retry = true;
			}
			cont_(a);
		}
		while (retry);
	}
	else
		openFile(mode);
	exit_();
}

bool CSFile::transfer(CSFile *dst_file, off64_t dst_offset, CSFile *src_file, off64_t src_offset, off64_t size, char *buffer, size_t buffer_size)
{
	size_t tfer;

	while (size > 0) {
		if (size > (off64_t) buffer_size)
			tfer = buffer_size;
		else
			tfer = (size_t) size;
		if (!(tfer = src_file->read(buffer, src_offset, tfer, 0)))
			return false;
		dst_file->write(buffer, dst_offset, tfer);
		dst_offset += tfer;
		src_offset += tfer;
		size -= tfer;
	}
	return true;
}

void CSFile::streamOut(CSOutputStream *dst_stream, off64_t src_offset, off64_t size, char *buffer, size_t buffer_size)
{
	size_t tfer;

	while (size > 0) {
		if (size > (off64_t) buffer_size)
			tfer = buffer_size;
		else
			tfer = (size_t) size;
      
		read(buffer, src_offset, tfer, tfer);
		dst_stream->write(buffer, tfer);
    
		src_offset += tfer;
		size -= tfer;
	}
}

#define CS_MASK				((S_IRUSR | S_IWUSR) | (S_IRGRP | S_IWGRP) | (S_IROTH))

void CSFile::close()
{
	if (iFH != -1) {
		unix_file_close(iFH);
		iFH = -1;
	}
}

off64_t CSFile::getEOF()
{
	off64_t eof;

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

     return eof;
}

void CSFile::setEOF(off64_t offset)
{
	if (ftruncate(iFH, offset) == -1)
		CSException::throwFileError(CS_CONTEXT, myFilePath->getCString(), errno);
}

size_t CSFile::read(void *data, off64_t offset, size_t size, size_t min_size)
{
	ssize_t read_size;
	
	enter_();
	read_size = pread(iFH, data, size, offset);
	self->interrupted();
	if (read_size ==  -1)
		CSException::throwFileError(CS_CONTEXT, myFilePath->getCString(), errno);
	if ((size_t) read_size < min_size)
		CSException::throwEOFError(CS_CONTEXT, myFilePath->getCString());
	return_(read_size);
}

void CSFile::write(const void *data, off64_t offset, size_t size)
{
	size_t write_size;

	enter_();
    write_size = pwrite(iFH, (void *) data, size, offset);
	self->interrupted();
	if (write_size != size)
		CSException::throwFileError(CS_CONTEXT, myFilePath->getCString(), errno);
	exit_();
}

void CSFile::flush()
{
}

void CSFile::sync()
{
	fsync(iFH);
}

CSFile *CSFile::newFile(CSPath *path)
{
	CSFile *f;

	if (!(f = new CSFile())) {
		path->release();
		CSException::throwOSError(CS_CONTEXT, ENOMEM);
	}
	f->myFilePath = path;
	return f;
}

CSFile *CSFile::newFile(const char *path_str)
{
	CSPath *path;

	path = CSPath::newPath(path_str);
	return newFile(path);
}

void CSFile::openFile(int mode)
{
	int flags = 0;

	if (mode & READONLY)
		flags = O_RDONLY;
	else
		flags = O_RDWR;

	if (mode & CREATE)
		flags |= O_CREAT;
	
	if ((iFH = unix_file_open(myFilePath->getCString(), flags, CS_MASK)) ==  -1)
		CSException::throwFileError(CS_CONTEXT, myFilePath->getCString(), errno);

	/* Does not make sense to truncate, and have READONLY! */
	if ((mode & TRUNCATE) && !(mode & READONLY))
		setEOF((off64_t) 0);
}

/*
 * ---------------------------------------------------------------
 * A READ BUFFERED FILE
 */

CSReadBufferedFile::CSReadBufferedFile():
myFile(NULL),
iFileBufferOffset(0),
iBufferDataLen(0)
{
}

CSReadBufferedFile::~CSReadBufferedFile()
{
	if (myFile) {
		close();
		myFile->release();
		myFile = NULL;
	}
}

void CSReadBufferedFile::close()
{
	flush();
	myFile->close();
	iFileBufferOffset = 0;
	iBufferDataLen = 0;
}

off64_t CSReadBufferedFile::getEOF()
{
	off64_t eof = myFile->getEOF();

	if (eof < iFileBufferOffset + iBufferDataLen)
		return iFileBufferOffset + iBufferDataLen;
	return eof;
}

void CSReadBufferedFile::setEOF(off64_t offset)
{
	myFile->setEOF(offset);
	if (offset < iFileBufferOffset) {
		iFileBufferOffset = 0;
		iBufferDataLen = 0;
	}
	else if (offset < iFileBufferOffset + iBufferDataLen)
		iBufferDataLen = offset - iFileBufferOffset;
}

size_t CSReadBufferedFile::read(void *data, off64_t offset, size_t size, size_t min_size)
{
	size_t result;
	size_t tfer = 0;

	if (iBufferDataLen > 0) {
		if (offset < iFileBufferOffset) {
			//  case 1, 2, 6
			if (offset + size > iFileBufferOffset + iBufferDataLen) {
				// 6 (would have to do 2 reads and a memcpy (better is just one read)
				flush();
				goto readit;
			}
			if (offset + size > iFileBufferOffset) {
				// 2
				tfer = offset + size - iFileBufferOffset;
				memcpy((char *) data + (iFileBufferOffset - offset), iFileBuffer, tfer);
				size -= tfer;
			}
			// We assume we are reading back to front: 
			if (size < SC_DEFAULT_FILE_BUFFER_SIZE) {
				size_t mins;

				if (offset + size >= SC_DEFAULT_FILE_BUFFER_SIZE) {
					iFileBufferOffset = offset + size - SC_DEFAULT_FILE_BUFFER_SIZE;
					mins = SC_DEFAULT_FILE_BUFFER_SIZE;
				}
				else {
					iFileBufferOffset = 0;
					mins = (size_t) offset + size;
				}
				result = myFile->read(iFileBuffer, iFileBufferOffset, SC_DEFAULT_FILE_BUFFER_SIZE, mins);
				iBufferDataLen = result;
				memcpy(data, iFileBuffer + (offset - iFileBufferOffset), size);
			}
			else
				result = myFile->read(data, offset, size, size);
			return size + tfer;
		}
		if (offset + size <= iFileBufferOffset + iBufferDataLen) {
			// 3
			memcpy(data, iFileBuffer + (offset - iFileBufferOffset), size);
			return size;
		}
		if (offset < iFileBufferOffset + iBufferDataLen) {
			// 4 We assume we are reading front to back
			tfer = iFileBufferOffset + iBufferDataLen - offset;
			memcpy(data, iFileBuffer + (offset - iFileBufferOffset), tfer);
			data = (char *) data + tfer;
			size -= tfer;
			offset += tfer;
			if (min_size >= tfer)
				min_size -= tfer;
			else
				min_size = 0;
		}
		// else 5
	}

	readit:
	if (size < SC_DEFAULT_FILE_BUFFER_SIZE) {
		result = myFile->read(iFileBuffer, offset, SC_DEFAULT_FILE_BUFFER_SIZE, min_size);
		iFileBufferOffset = offset;
		iBufferDataLen = result;
		if (result > size)
			result = size;
		memcpy(data, iFileBuffer, result);
	}
	else
		result = myFile->read(data, offset, size, min_size);
	return result + tfer;
}

void CSReadBufferedFile::write(const void *data, off64_t offset, size_t size)
{
	if (iBufferDataLen > 0) {
		size_t tfer;

		if (offset < iFileBufferOffset) {
			//  case 1, 2, 6
			if (offset + size > iFileBufferOffset + iBufferDataLen) {
				// 6 (would have to do 2 reads and a memcpy (better is just one read)
				memcpy((char *) data + (iFileBufferOffset - offset), iFileBuffer, iBufferDataLen);
			}
			else if (offset + size > iFileBufferOffset) {
				// 2
				tfer = offset + size - iFileBufferOffset;
				memcpy(iFileBuffer, (char *) data + (iFileBufferOffset - offset), tfer);
			}
		}
		else if (offset + size <= iFileBufferOffset + iBufferDataLen) {
			// 3
			memcpy(iFileBuffer + (offset - iFileBufferOffset), data, size);
		}
		else if (offset < iFileBufferOffset + iBufferDataLen) {
			// 4 We assume we are reading front to back
			tfer = iFileBufferOffset + iBufferDataLen - offset;
			memcpy(iFileBuffer + (offset - iFileBufferOffset), data, tfer);
		}
		// else 5
	}

	myFile->write(data, offset, size);
}

void CSReadBufferedFile::flush()
{
	myFile->flush();
}

void CSReadBufferedFile::sync()
{
	flush();
	myFile->sync();
}

const char *CSReadBufferedFile::getEOL()
{
	return myFile->getEOL();
}

void CSReadBufferedFile::openFile(int mode)
{
	myFile->openFile(mode);
}

CSFile *CSReadBufferedFile::newFile(CSFile *file)
{
	CSReadBufferedFile *f;

	if (!(f = new CSReadBufferedFile())) {
		file->release();
		CSException::throwOSError(CS_CONTEXT, ENOMEM);
	}
	f->myFile = file;
	f->myFilePath = file->myFilePath;
	f->myFilePath->retain();
	return (CSFile *) f;
}

/*
 * ---------------------------------------------------------------
 * A BUFFERED FILE
 */

void CSBufferedFile::write(const void *data, off64_t offset, size_t size)
{
	if (iBufferDataLen > 0) {
		if (offset < iFileBufferOffset && offset <= iFileBufferOffset + iBufferDataLen) {
			size_t tfer;

			tfer = iFileBufferOffset + SC_DEFAULT_FILE_BUFFER_SIZE - offset;
			if (tfer >= size) {
				memcpy(iFileBuffer + (offset - iFileBufferOffset), data, size);
			}
			size -= tfer;
			data = (char *) data + tfer;
		}
		flush();
	}

	if (size < SC_DEFAULT_FILE_BUFFER_SIZE) {
		iFileBufferOffset = offset;
		iBufferDataLen = size;
		memcpy(iFileBuffer, data, size);
		iBufferDirty = true;
	}
	else
		myFile->write(data, offset, size);
}

void CSBufferedFile::flush()
{
	if (iBufferDirty && iBufferDataLen) {
		myFile->write(iFileBuffer, iFileBufferOffset, iBufferDataLen);
		iBufferDirty = false;
		
	}
	myFile->flush();
}

/*
 * ---------------------------------------------------------------
 * FILE BASED ON THE STANDARD C FILE
 */

1548.2.1 by Barry.Leslie at PrimeBase Added the PBMS daemon plugin.	1	/* Copyright (c) 2008 PrimeBase Technologies GmbH, Germany
	2	*
	3	* PrimeBase Media Stream for MySQL
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation; either version 2 of the License, or
	8	* (at your option) any later version.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program; if not, write to the Free Software
1802.10.2 by Monty Taylor Update all of the copyright headers to include the correct address.	17	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
1548.2.1 by Barry.Leslie at PrimeBase Added the PBMS daemon plugin.	18	*
	19	* Original author: Paul McCullagh (H&G2JCtL)
	20	* Continued development: Barry Leslie
	21	*
	22	* 2007-06-07
	23	*
	24	* CORE SYSTEM:
	25	* Basic file I/O.
	26	*
	27	*/
	28
	29	#include "CSConfig.h"
	30
	31	#ifndef XT_WIN
	32	#include <unistd.h>
	33	#include <dirent.h>
	34	#endif
	35	#include <stdio.h>
	36	#include <sys/stat.h>
	37	#include <fcntl.h>
	38	#include <errno.h>
	39	#include <string.h>
	40
1548.2.23 by Barry.Leslie at PrimeBase And more cleanup.	41	#include "CSFile.h"
	42	#include "CSStream.h"
	43	#include "CSGlobal.h"
	44
	45
1548.2.1 by Barry.Leslie at PrimeBase Added the PBMS daemon plugin.	46	static int unix_file_open(const char *path, int flags, mode_t mode)
	47	{
	48	return open(path, flags, mode);
	49	}
	50
	51	int unix_file_close(int fh)
	52	{
	53	return close(fh);
	54	}
	55
	56	/*
	57	* ---------------------------------------------------------------
	58	* CORE SYSTEM FILES
	59	*/
	60
	61	CSFile::~CSFile()
	62	{
	63	close();
	64	if (myFilePath)
	65	myFilePath->release();
	66	}
	67
	68	CSOutputStream *CSFile::getOutputStream()
	69	{
	70	return CSFileOutputStream::newStream(RETAIN(this));
	71	}
	72
1548.2.2 by Barry.Leslie at PrimeBase A lot of minor changes to clean up the code and to get it to build with Drizzle.	73	CSOutputStream *CSFile::getOutputStream(off64_t offset)
1548.2.1 by Barry.Leslie at PrimeBase Added the PBMS daemon plugin.	74	{
	75	return CSFileOutputStream::newStream(RETAIN(this), offset);
	76	}
	77
	78	CSInputStream *CSFile::getInputStream()
	79	{
	80	return CSFileInputStream::newStream(RETAIN(this));
	81	}
	82
1548.2.2 by Barry.Leslie at PrimeBase A lot of minor changes to clean up the code and to get it to build with Drizzle.	83	CSInputStream *CSFile::getInputStream(off64_t offset)
1548.2.1 by Barry.Leslie at PrimeBase Added the PBMS daemon plugin.	84	{
	85	return CSFileInputStream::newStream(RETAIN(this), offset);
	86	}
	87
	88	void CSFile::open(int mode)
	89	{
	90	CSPath *dir;
	91	bool retry = false;
	92
1548.2.20 by Barry.Leslie at PrimeBase Code cleanup.	93	CLOBBER_PROTECT(retry);
1548.2.20 by Barry.Leslie at PrimeBase Code cleanup.	94
1548.2.1 by Barry.Leslie at PrimeBase Added the PBMS daemon plugin.	95	enter_();
	96	if (mode & CREATE) {
	97	/* Create and open the file: */
	98	do {
	99	try_(a) {
	100	openFile(mode);
	101	retry = false;
	102	}
	103	catch_(a) {
	104	if (retry \|\| !isDirNotFound(&self->myException))
	105	throw_();
	106
	107	/* Make sure the parent directory exists: */
	108	dir = CSPath::newPath(RETAIN(myFilePath), "..");
	109	push_(dir);
	110	try_(b) {
	111	dir->makePath();
	112	}
	113	catch_(b) { /* Two threads may try to create the directory at the same time. */
	114	if (!isDirExists(&self->myException))
	115	throw_();
	116	}
	117	cont_(b);
	118
	119	release_(dir);
	120	retry = true;
	121	}
	122	cont_(a);
	123	}
	124	while (retry);
	125	}
	126	else
	127	openFile(mode);
	128	exit_();
	129	}
	130
1548.2.2 by Barry.Leslie at PrimeBase A lot of minor changes to clean up the code and to get it to build with Drizzle.	131	bool CSFile::transfer(CSFile dst_file, off64_t dst_offset, CSFile src_file, off64_t src_offset, off64_t size, char *buffer, size_t buffer_size)
1548.2.1 by Barry.Leslie at PrimeBase Added the PBMS daemon plugin.	132	{
	133	size_t tfer;
	134
	135	while (size > 0) {
1548.2.2 by Barry.Leslie at PrimeBase A lot of minor changes to clean up the code and to get it to build with Drizzle.	136	if (size > (off64_t) buffer_size)
1548.2.1 by Barry.Leslie at PrimeBase Added the PBMS daemon plugin.	137	tfer = buffer_size;
	138	else
	139	tfer = (size_t) size;
	140	if (!(tfer = src_file->read(buffer, src_offset, tfer, 0)))
	141	return false;
	142	dst_file->write(buffer, dst_offset, tfer);
	143	dst_offset += tfer;
	144	src_offset += tfer;
	145	size -= tfer;
	146	}
	147	return true;
	148	}
	149
1548.2.11 by Barry.Leslie at PrimeBase Removed libxml reqirement by using a home grown xml parser.	150	void CSFile::streamOut(CSOutputStream dst_stream, off64_t src_offset, off64_t size, char buffer, size_t buffer_size)
	151	{
	152	size_t tfer;
	153
	154	while (size > 0) {
	155	if (size > (off64_t) buffer_size)
	156	tfer = buffer_size;
	157	else
	158	tfer = (size_t) size;
	159
	160	read(buffer, src_offset, tfer, tfer);
	161	dst_stream->write(buffer, tfer);
	162
	163	src_offset += tfer;
	164	size -= tfer;
	165	}
	166	}
1548.2.1 by Barry.Leslie at PrimeBase Added the PBMS daemon plugin.	167
	168	#define CS_MASK ((S_IRUSR \| S_IWUSR) \| (S_IRGRP \| S_IWGRP) \| (S_IROTH))
	169
	170	void CSFile::close()
	171	{
	172	if (iFH != -1) {
	173	unix_file_close(iFH);
	174	iFH = -1;
	175	}
	176	}
	177
1548.2.2 by Barry.Leslie at PrimeBase A lot of minor changes to clean up the code and to get it to build with Drizzle.	178	off64_t CSFile::getEOF()
1548.2.1 by Barry.Leslie at PrimeBase Added the PBMS daemon plugin.	179	{
1548.2.11 by Barry.Leslie at PrimeBase Removed libxml reqirement by using a home grown xml parser.	180	off64_t eof;
1548.2.1 by Barry.Leslie at PrimeBase Added the PBMS daemon plugin.	181
1548.2.11 by Barry.Leslie at PrimeBase Removed libxml reqirement by using a home grown xml parser.	182	if ((eof = lseek(iFH, 0, SEEK_END)) == (off64_t) -1)
1548.2.1 by Barry.Leslie at PrimeBase Added the PBMS daemon plugin.	183	CSException::throwFileError(CS_CONTEXT, myFilePath->getCString(), errno);
	184
	185	return eof;
	186	}
	187
1548.2.2 by Barry.Leslie at PrimeBase A lot of minor changes to clean up the code and to get it to build with Drizzle.	188	void CSFile::setEOF(off64_t offset)
1548.2.1 by Barry.Leslie at PrimeBase Added the PBMS daemon plugin.	189	{
	190	if (ftruncate(iFH, offset) == -1)
	191	CSException::throwFileError(CS_CONTEXT, myFilePath->getCString(), errno);
	192	}
	193
1548.2.2 by Barry.Leslie at PrimeBase A lot of minor changes to clean up the code and to get it to build with Drizzle.	194	size_t CSFile::read(void *data, off64_t offset, size_t size, size_t min_size)
1548.2.1 by Barry.Leslie at PrimeBase Added the PBMS daemon plugin.	195	{
	196	ssize_t read_size;
	197
	198	enter_();
	199	read_size = pread(iFH, data, size, offset);
	200	self->interrupted();
	201	if (read_size == -1)
	202	CSException::throwFileError(CS_CONTEXT, myFilePath->getCString(), errno);
	203	if ((size_t) read_size < min_size)
	204	CSException::throwEOFError(CS_CONTEXT, myFilePath->getCString());
	205	return_(read_size);
	206	}
	207
1548.2.2 by Barry.Leslie at PrimeBase A lot of minor changes to clean up the code and to get it to build with Drizzle.	208	void CSFile::write(const void *data, off64_t offset, size_t size)
1548.2.1 by Barry.Leslie at PrimeBase Added the PBMS daemon plugin.	209	{
	210	size_t write_size;
	211
	212	enter_();
	213	write_size = pwrite(iFH, (void *) data, size, offset);
	214	self->interrupted();
	215	if (write_size != size)
	216	CSException::throwFileError(CS_CONTEXT, myFilePath->getCString(), errno);
	217	exit_();
	218	}
	219
	220	void CSFile::flush()
	221	{
	222	}
	223
	224	void CSFile::sync()
	225	{
	226	fsync(iFH);
	227	}
	228
	229	CSFile CSFile::newFile(CSPath path)
	230	{
	231	CSFile *f;
	232
	233	if (!(f = new CSFile())) {
	234	path->release();
	235	CSException::throwOSError(CS_CONTEXT, ENOMEM);
	236	}
	237	f->myFilePath = path;
	238	return f;
	239	}
	240
	241	CSFile CSFile::newFile(const char path_str)
	242	{
	243	CSPath *path;
	244
	245	path = CSPath::newPath(path_str);
	246	return newFile(path);
	247	}
	248
	249	void CSFile::openFile(int mode)
	250	{
	251	int flags = 0;
	252
	253	if (mode & READONLY)
	254	flags = O_RDONLY;
	255	else
	256	flags = O_RDWR;
	257
	258	if (mode & CREATE)
	259	flags \|= O_CREAT;
	260
	261	if ((iFH = unix_file_open(myFilePath->getCString(), flags, CS_MASK)) == -1)
	262	CSException::throwFileError(CS_CONTEXT, myFilePath->getCString(), errno);
	263
	264	/* Does not make sense to truncate, and have READONLY! */
	265	if ((mode & TRUNCATE) && !(mode & READONLY))
1548.2.2 by Barry.Leslie at PrimeBase A lot of minor changes to clean up the code and to get it to build with Drizzle.	266	setEOF((off64_t) 0);
1548.2.1 by Barry.Leslie at PrimeBase Added the PBMS daemon plugin.	267	}
	268
	269	/*
	270	* ---------------------------------------------------------------
	271	* A READ BUFFERED FILE
	272	*/
	273
	274	CSReadBufferedFile::CSReadBufferedFile():
	275	myFile(NULL),
	276	iFileBufferOffset(0),
	277	iBufferDataLen(0)
	278	{
	279	}
	280
	281	CSReadBufferedFile::~CSReadBufferedFile()
	282	{
	283	if (myFile) {
	284	close();
	285	myFile->release();
	286	myFile = NULL;
	287	}
	288	}
	289
	290	void CSReadBufferedFile::close()
	291	{
	292	flush();
	293	myFile->close();
	294	iFileBufferOffset = 0;
	295	iBufferDataLen = 0;
	296	}
	297
1548.2.2 by Barry.Leslie at PrimeBase A lot of minor changes to clean up the code and to get it to build with Drizzle.	298	off64_t CSReadBufferedFile::getEOF()
1548.2.1 by Barry.Leslie at PrimeBase Added the PBMS daemon plugin.	299	{
1548.2.2 by Barry.Leslie at PrimeBase A lot of minor changes to clean up the code and to get it to build with Drizzle.	300	off64_t eof = myFile->getEOF();
1548.2.1 by Barry.Leslie at PrimeBase Added the PBMS daemon plugin.	301
	302	if (eof < iFileBufferOffset + iBufferDataLen)
	303	return iFileBufferOffset + iBufferDataLen;
	304	return eof;
	305	}
	306
1548.2.2 by Barry.Leslie at PrimeBase A lot of minor changes to clean up the code and to get it to build with Drizzle.	307	void CSReadBufferedFile::setEOF(off64_t offset)
1548.2.1 by Barry.Leslie at PrimeBase Added the PBMS daemon plugin.	308	{
	309	myFile->setEOF(offset);
	310	if (offset < iFileBufferOffset) {
	311	iFileBufferOffset = 0;
	312	iBufferDataLen = 0;
	313	}
	314	else if (offset < iFileBufferOffset + iBufferDataLen)
	315	iBufferDataLen = offset - iFileBufferOffset;
	316	}
	317
1548.2.2 by Barry.Leslie at PrimeBase A lot of minor changes to clean up the code and to get it to build with Drizzle.	318	size_t CSReadBufferedFile::read(void *data, off64_t offset, size_t size, size_t min_size)
1548.2.1 by Barry.Leslie at PrimeBase Added the PBMS daemon plugin.	319	{
	320	size_t result;
	321	size_t tfer = 0;
	322
	323	if (iBufferDataLen > 0) {
	324	if (offset < iFileBufferOffset) {
	325	// case 1, 2, 6
	326	if (offset + size > iFileBufferOffset + iBufferDataLen) {
	327	// 6 (would have to do 2 reads and a memcpy (better is just one read)
	328	flush();
	329	goto readit;
	330	}
	331	if (offset + size > iFileBufferOffset) {
	332	// 2
	333	tfer = offset + size - iFileBufferOffset;
	334	memcpy((char *) data + (iFileBufferOffset - offset), iFileBuffer, tfer);
	335	size -= tfer;
	336	}
	337	// We assume we are reading back to front:
	338	if (size < SC_DEFAULT_FILE_BUFFER_SIZE) {
	339	size_t mins;
	340
	341	if (offset + size >= SC_DEFAULT_FILE_BUFFER_SIZE) {
	342	iFileBufferOffset = offset + size - SC_DEFAULT_FILE_BUFFER_SIZE;
	343	mins = SC_DEFAULT_FILE_BUFFER_SIZE;
	344	}
	345	else {
	346	iFileBufferOffset = 0;
	347	mins = (size_t) offset + size;
	348	}
	349	result = myFile->read(iFileBuffer, iFileBufferOffset, SC_DEFAULT_FILE_BUFFER_SIZE, mins);
	350	iBufferDataLen = result;
	351	memcpy(data, iFileBuffer + (offset - iFileBufferOffset), size);
	352	}
	353	else
	354	result = myFile->read(data, offset, size, size);
	355	return size + tfer;
	356	}
	357	if (offset + size <= iFileBufferOffset + iBufferDataLen) {
	358	// 3
	359	memcpy(data, iFileBuffer + (offset - iFileBufferOffset), size);
	360	return size;
	361	}
	362	if (offset < iFileBufferOffset + iBufferDataLen) {
	363	// 4 We assume we are reading front to back
	364	tfer = iFileBufferOffset + iBufferDataLen - offset;
	365	memcpy(data, iFileBuffer + (offset - iFileBufferOffset), tfer);
	366	data = (char *) data + tfer;
	367	size -= tfer;
	368	offset += tfer;
	369	if (min_size >= tfer)
	370	min_size -= tfer;
	371	else
	372	min_size = 0;
	373	}
	374	// else 5
	375	}
	376
	377	readit:
	378	if (size < SC_DEFAULT_FILE_BUFFER_SIZE) {
	379	result = myFile->read(iFileBuffer, offset, SC_DEFAULT_FILE_BUFFER_SIZE, min_size);
	380	iFileBufferOffset = offset;
	381	iBufferDataLen = result;
	382	if (result > size)
383	result = size;
384	memcpy(data, iFileBuffer, result);
385	}
386	else
387	result = myFile->read(data, offset, size, min_size);
388	return result + tfer;
389	}
390
1548.2.2 by Barry.Leslie at PrimeBase A lot of minor changes to clean up the code and to get it to build with Drizzle.	391	void CSReadBufferedFile::write(const void *data, off64_t offset, size_t size)
1548.2.1 by Barry.Leslie at PrimeBase Added the PBMS daemon plugin.	392	{
	393	if (iBufferDataLen > 0) {
	394	size_t tfer;
	395
	396	if (offset < iFileBufferOffset) {
	397	// case 1, 2, 6
	398	if (offset + size > iFileBufferOffset + iBufferDataLen) {
	399	// 6 (would have to do 2 reads and a memcpy (better is just one read)
	400	memcpy((char *) data + (iFileBufferOffset - offset), iFileBuffer, iBufferDataLen);
	401	}
	402	else if (offset + size > iFileBufferOffset) {
	403	// 2
	404	tfer = offset + size - iFileBufferOffset;
	405	memcpy(iFileBuffer, (char *) data + (iFileBufferOffset - offset), tfer);
	406	}
	407	}
	408	else if (offset + size <= iFileBufferOffset + iBufferDataLen) {
	409	// 3
	410	memcpy(iFileBuffer + (offset - iFileBufferOffset), data, size);
	411	}
	412	else if (offset < iFileBufferOffset + iBufferDataLen) {
	413	// 4 We assume we are reading front to back
	414	tfer = iFileBufferOffset + iBufferDataLen - offset;
	415	memcpy(iFileBuffer + (offset - iFileBufferOffset), data, tfer);
	416	}
	417	// else 5
	418	}
	419
	420	myFile->write(data, offset, size);
	421	}
	422
	423	void CSReadBufferedFile::flush()
	424	{
	425	myFile->flush();
	426	}
	427
	428	void CSReadBufferedFile::sync()
	429	{
	430	flush();
	431	myFile->sync();
	432	}
	433
	434	const char *CSReadBufferedFile::getEOL()
	435	{
	436	return myFile->getEOL();
	437	}
	438
	439	void CSReadBufferedFile::openFile(int mode)
	440	{
	441	myFile->openFile(mode);
	442	}
	443
	444	CSFile CSReadBufferedFile::newFile(CSFile file)
	445	{
	446	CSReadBufferedFile *f;
	447
	448	if (!(f = new CSReadBufferedFile())) {
	449	file->release();
	450	CSException::throwOSError(CS_CONTEXT, ENOMEM);
	451	}
	452	f->myFile = file;
	453	f->myFilePath = file->myFilePath;
	454	f->myFilePath->retain();
	455	return (CSFile *) f;
456	}
457
458	/*
459	* ---------------------------------------------------------------
460	* A BUFFERED FILE
461	*/
462
1548.2.2 by Barry.Leslie at PrimeBase A lot of minor changes to clean up the code and to get it to build with Drizzle.	463	void CSBufferedFile::write(const void *data, off64_t offset, size_t size)
1548.2.1 by Barry.Leslie at PrimeBase Added the PBMS daemon plugin.	464	{
	465	if (iBufferDataLen > 0) {
	466	if (offset < iFileBufferOffset && offset <= iFileBufferOffset + iBufferDataLen) {
	467	size_t tfer;
	468
	469	tfer = iFileBufferOffset + SC_DEFAULT_FILE_BUFFER_SIZE - offset;
	470	if (tfer >= size) {
	471	memcpy(iFileBuffer + (offset - iFileBufferOffset), data, size);
	472	}
	473	size -= tfer;
	474	data = (char *) data + tfer;
	475	}
	476	flush();
	477	}
	478
	479	if (size < SC_DEFAULT_FILE_BUFFER_SIZE) {
	480	iFileBufferOffset = offset;
	481	iBufferDataLen = size;
	482	memcpy(iFileBuffer, data, size);
	483	iBufferDirty = true;
	484	}
	485	else
	486	myFile->write(data, offset, size);
	487	}
	488
	489	void CSBufferedFile::flush()
	490	{
	491	if (iBufferDirty && iBufferDataLen) {
	492	myFile->write(iFileBuffer, iFileBufferOffset, iBufferDataLen);
	493	iBufferDirty = false;
	494
	495	}
	496	myFile->flush();
	497	}
	498
	499	/*
	500	* ---------------------------------------------------------------
	501	* FILE BASED ON THE STANDARD C FILE
	502	*/