/*

 /  Author: Sam Rushing <rushing@nightmare.com>

 /  Hacked for Unix by AMK

 /  $Id: mmapmodule.c 65859 2008-08-19 17:47:13Z thomas.heller $

 / Modified to support mmap with offset - to map a 'window' of a file

 /   Author:  Yotam Medini  yotamm@mellanox.co.il

 /

 / mmapmodule.cpp -- map a view of a file into memory

 /

 / todo: need permission flags, perhaps a 'chsize' analog

 /   not all functions check range yet!!!

 /

 /

 / This version of mmapmodule.c has been changed significantly

 / from the original mmapfile.c on which it was based.

 / The original version of mmapfile is maintained by Sam at

 / ftp://squirl.nightmare.com/pub/python/python-ext.

*/

#define PY_SSIZE_T_CLEAN

#include <Python.h>

#ifndef MS_WINDOWS

#define UNIX

#endif

#ifdef MS_WINDOWS

#include <windows.h>

static int

my_getpagesize(void)

{

	SYSTEM_INFO si;

	GetSystemInfo(&si);

	return si.dwPageSize;

}

static int

my_getallocationgranularity (void)

{

	SYSTEM_INFO si;

	GetSystemInfo(&si);

	return si.dwAllocationGranularity;

}

#endif

#ifdef UNIX

#include <sys/mman.h>

#include <sys/stat.h>

#if defined(HAVE_SYSCONF) && defined(_SC_PAGESIZE)

static int

my_getpagesize(void)

{

	return sysconf(_SC_PAGESIZE);

}

#define my_getallocationgranularity my_getpagesize

#else

#define my_getpagesize getpagesize

#endif

#endif /* UNIX */

#include <string.h>

#ifdef HAVE_SYS_TYPES_H

#include <sys/types.h>

#endif /* HAVE_SYS_TYPES_H */

/* Prefer MAP_ANONYMOUS since MAP_ANON is deprecated according to man page. */

#if !defined(MAP_ANONYMOUS) && defined(MAP_ANON)

#  define MAP_ANONYMOUS MAP_ANON

#endif

static PyObject *mmap_module_error;

typedef enum

{

	ACCESS_DEFAULT,

	ACCESS_READ,

	ACCESS_WRITE,

	ACCESS_COPY

} access_mode;

typedef struct {

	PyObject_HEAD

	char *	data;

	size_t	size;

	size_t	pos;    /* relative to offset */

	size_t	offset; 

#ifdef MS_WINDOWS

	HANDLE	map_handle;

	HANDLE	file_handle;

	char *	tagname;

#endif

#ifdef UNIX

        int fd;

#endif

        access_mode access;

} mmap_object;

static void

mmap_object_dealloc(mmap_object *m_obj)

{

#ifdef MS_WINDOWS

	if (m_obj->data != NULL)

		UnmapViewOfFile (m_obj->data);

	if (m_obj->map_handle != INVALID_HANDLE_VALUE)

		CloseHandle (m_obj->map_handle);

	if (m_obj->file_handle != INVALID_HANDLE_VALUE)

		CloseHandle (m_obj->file_handle);

	if (m_obj->tagname)

		PyMem_Free(m_obj->tagname);

#endif /* MS_WINDOWS */

#ifdef UNIX

	if (m_obj->fd >= 0)

		(void) close(m_obj->fd);

	if (m_obj->data!=NULL) {

		msync(m_obj->data, m_obj->size, MS_SYNC);

		munmap(m_obj->data, m_obj->size);

	}

#endif /* UNIX */

	Py_TYPE(m_obj)->tp_free((PyObject*)m_obj);

}

static PyObject *

mmap_close_method(mmap_object *self, PyObject *unused)

{

#ifdef MS_WINDOWS

	/* For each resource we maintain, we need to check

	   the value is valid, and if so, free the resource

	   and set the member value to an invalid value so

	   the dealloc does not attempt to resource clearing

	   again.

	   TODO - should we check for errors in the close operations???

	*/

	if (self->data != NULL) {

		UnmapViewOfFile(self->data);

		self->data = NULL;

	}

	if (self->map_handle != INVALID_HANDLE_VALUE) {

		CloseHandle(self->map_handle);

		self->map_handle = INVALID_HANDLE_VALUE;

	}

	if (self->file_handle != INVALID_HANDLE_VALUE) {

		CloseHandle(self->file_handle);

		self->file_handle = INVALID_HANDLE_VALUE;

	}

#endif /* MS_WINDOWS */

#ifdef UNIX

	(void) close(self->fd);

	self->fd = -1;

	if (self->data != NULL) {

		munmap(self->data, self->size);

		self->data = NULL;

	}

#endif

	Py_INCREF(Py_None);

	return Py_None;

}

#ifdef MS_WINDOWS

#define CHECK_VALID(err)						\

do {									\

    if (self->map_handle == INVALID_HANDLE_VALUE) {						\

	PyErr_SetString(PyExc_ValueError, "mmap closed or invalid");	\

	return err;							\

    }									\

} while (0)

#endif /* MS_WINDOWS */

#ifdef UNIX

#define CHECK_VALID(err)						\

do {									\

    if (self->data == NULL) {						\

	PyErr_SetString(PyExc_ValueError, "mmap closed or invalid");	\

	return err;							\

	}								\

} while (0)

#endif /* UNIX */

static PyObject *

mmap_read_byte_method(mmap_object *self,

		      PyObject *unused)

{

	CHECK_VALID(NULL);

	if (self->pos < self->size) {

	        char value = self->data[self->pos];

		self->pos += 1;

		return Py_BuildValue("c", value);

	} else {

		PyErr_SetString(PyExc_ValueError, "read byte out of range");

		return NULL;

	}

}

static PyObject *

mmap_read_line_method(mmap_object *self,

		      PyObject *unused)

{

	char *start = self->data+self->pos;

	char *eof = self->data+self->size;

	char *eol;

	PyObject *result;

	CHECK_VALID(NULL);

	eol = memchr(start, '\n', self->size - self->pos);

	if (!eol)

		eol = eof;

	else

		++eol;		/* we're interested in the position after the

				   newline. */

	result = PyString_FromStringAndSize(start, (eol - start));

	self->pos += (eol - start);

	return result;

}

static PyObject *

mmap_read_method(mmap_object *self,

		 PyObject *args)

{

	Py_ssize_t num_bytes;

	PyObject *result;

	CHECK_VALID(NULL);

	if (!PyArg_ParseTuple(args, "n:read", &num_bytes))

		return(NULL);

	/* silently 'adjust' out-of-range requests */

	if (num_bytes > self->size - self->pos) {

		num_bytes -= (self->pos+num_bytes) - self->size;

	}

	result = Py_BuildValue("s#", self->data+self->pos, num_bytes);

	self->pos += num_bytes;

	return result;

}

static PyObject *

mmap_gfind(mmap_object *self,

	   PyObject *args,

	   int reverse)

{

	Py_ssize_t start = self->pos;

	Py_ssize_t end = self->size;

	const char *needle;

	Py_ssize_t len;

	CHECK_VALID(NULL);

	if (!PyArg_ParseTuple(args, reverse ? "s#|nn:rfind" : "s#|nn:find",

			      &needle, &len, &start, &end)) {

		return NULL;

	} else {

		const char *p, *start_p, *end_p;

		int sign = reverse ? -1 : 1;

                if (start < 0)

			start += self->size;

                if (start < 0)

			start = 0;

                else if ((size_t)start > self->size)

			start = self->size;

                if (end < 0)

			end += self->size;

		if (end < 0)

			end = 0;

		else if ((size_t)end > self->size)

			end = self->size;

		start_p = self->data + start;

		end_p = self->data + end;

		for (p = (reverse ? end_p - len : start_p);

		     (p >= start_p) && (p + len <= end_p); p += sign) {

			Py_ssize_t i;

			for (i = 0; i < len && needle[i] == p[i]; ++i)

				/* nothing */;

			if (i == len) {

				return PyInt_FromSsize_t(p - self->data);

			}

		}

		return PyInt_FromLong(-1);

	}

}

static PyObject *

mmap_find_method(mmap_object *self,

		 PyObject *args)

{

	return mmap_gfind(self, args, 0);

}

static PyObject *

mmap_rfind_method(mmap_object *self,

		 PyObject *args)

{

	return mmap_gfind(self, args, 1);

}

static int

is_writeable(mmap_object *self)

{

	if (self->access != ACCESS_READ)

		return 1;

	PyErr_Format(PyExc_TypeError, "mmap can't modify a readonly memory map.");

	return 0;

}

static int

is_resizeable(mmap_object *self)

{

	if ((self->access == ACCESS_WRITE) || (self->access == ACCESS_DEFAULT))

		return 1;

	PyErr_Format(PyExc_TypeError,

		     "mmap can't resize a readonly or copy-on-write memory map.");

	return 0;

}

static PyObject *

mmap_write_method(mmap_object *self,

		  PyObject *args)

{

	Py_ssize_t length;

	char *data;

	CHECK_VALID(NULL);

	if (!PyArg_ParseTuple(args, "s#:write", &data, &length))

		return(NULL);

	if (!is_writeable(self))

		return NULL;

	if ((self->pos + length) > self->size) {

		PyErr_SetString(PyExc_ValueError, "data out of range");

		return NULL;

	}

	memcpy(self->data+self->pos, data, length);

	self->pos = self->pos+length;

	Py_INCREF(Py_None);

	return Py_None;

}

static PyObject *

mmap_write_byte_method(mmap_object *self,

		       PyObject *args)

{

	char value;

	CHECK_VALID(NULL);

	if (!PyArg_ParseTuple(args, "c:write_byte", &value))

		return(NULL);

	if (!is_writeable(self))

		return NULL;

	*(self->data+self->pos) = value;

	self->pos += 1;

	Py_INCREF(Py_None);

	return Py_None;

}

static PyObject *

mmap_size_method(mmap_object *self,

		 PyObject *unused)

{

	CHECK_VALID(NULL);

#ifdef MS_WINDOWS

	if (self->file_handle != INVALID_HANDLE_VALUE) {

		DWORD low,high;

		PY_LONG_LONG size;

		low = GetFileSize(self->file_handle, &high);

		if (low == INVALID_FILE_SIZE) {

			/* It might be that the function appears to have failed,

			   when indeed its size equals INVALID_FILE_SIZE */

			DWORD error = GetLastError();

			if (error != NO_ERROR)

				return PyErr_SetFromWindowsErr(error);

		}

		if (!high && low < LONG_MAX)

			return PyInt_FromLong((long)low);

		size = (((PY_LONG_LONG)high)<<32) + low;

		return PyLong_FromLongLong(size);

	} else {

		return PyInt_FromSsize_t(self->size);

	}

#endif /* MS_WINDOWS */

#ifdef UNIX

	{

		struct stat buf;

		if (-1 == fstat(self->fd, &buf)) {

			PyErr_SetFromErrno(mmap_module_error);

			return NULL;

		}

		return PyInt_FromSsize_t(buf.st_size);

	}

#endif /* UNIX */

}

/* This assumes that you want the entire file mapped,

 / and when recreating the map will make the new file

 / have the new size

 /

 / Is this really necessary?  This could easily be done

 / from python by just closing and re-opening with the

 / new size?

 */

static PyObject *

mmap_resize_method(mmap_object *self,

		   PyObject *args)

{

	Py_ssize_t new_size;

	CHECK_VALID(NULL);

	if (!PyArg_ParseTuple(args, "n:resize", &new_size) ||

	    !is_resizeable(self)) {

		return NULL;

#ifdef MS_WINDOWS

	} else {

		DWORD dwErrCode = 0;

		DWORD off_hi, off_lo, newSizeLow, newSizeHigh;

		/* First, unmap the file view */

		UnmapViewOfFile(self->data);

		/* Close the mapping object */

		CloseHandle(self->map_handle);

		/* Move to the desired EOF position */

#if SIZEOF_SIZE_T > 4

		newSizeHigh = (DWORD)((self->offset + new_size) >> 32);

		newSizeLow = (DWORD)((self->offset + new_size) & 0xFFFFFFFF);

		off_hi = (DWORD)(self->offset >> 32);

		off_lo = (DWORD)(self->offset & 0xFFFFFFFF);

#else

		newSizeHigh = 0;

		newSizeLow = (DWORD)new_size;

		off_hi = 0;

		off_lo = (DWORD)self->offset;

#endif

		SetFilePointer(self->file_handle,

			       newSizeLow, &newSizeHigh, FILE_BEGIN);

		/* Change the size of the file */

		SetEndOfFile(self->file_handle);

		/* Create another mapping object and remap the file view */

		self->map_handle = CreateFileMapping(

			self->file_handle,

			NULL,

			PAGE_READWRITE,

			0,

			0,

			self->tagname);

		if (self->map_handle != NULL) {

			self->data = (char *) MapViewOfFile(self->map_handle,

							    FILE_MAP_WRITE,

							    off_hi,

							    off_lo,

							    new_size);

			if (self->data != NULL) {

				self->size = new_size;

				Py_INCREF(Py_None);

				return Py_None;

			} else {

				dwErrCode = GetLastError();

			}

		} else {

			dwErrCode = GetLastError();

		}

		PyErr_SetFromWindowsErr(dwErrCode);

		return NULL;

#endif /* MS_WINDOWS */

#ifdef UNIX

#ifndef HAVE_MREMAP

	} else {

		PyErr_SetString(PyExc_SystemError,

				"mmap: resizing not available--no mremap()");

		return NULL;

#else

	} else {

		void *newmap;

		if (ftruncate(self->fd, new_size) == -1) {

			PyErr_SetFromErrno(mmap_module_error);

			return NULL;

		}

#ifdef MREMAP_MAYMOVE

		newmap = mremap(self->data, self->size, new_size, MREMAP_MAYMOVE);

#else

		newmap = mremap(self->data, self->size, new_size, 0);

#endif

		if (newmap == (void *)-1)

		{

			PyErr_SetFromErrno(mmap_module_error);

			return NULL;

		}

		self->data = newmap;

		self->size = new_size;

		Py_INCREF(Py_None);

		return Py_None;

#endif /* HAVE_MREMAP */

#endif /* UNIX */

	}

}

static PyObject *

mmap_tell_method(mmap_object *self, PyObject *unused)

{

	CHECK_VALID(NULL);

	return PyInt_FromSize_t(self->pos);

}

static PyObject *

mmap_flush_method(mmap_object *self, PyObject *args)

{

	Py_ssize_t offset = 0;

	Py_ssize_t size = self->size;

	CHECK_VALID(NULL);