text: /*
   /  Author: Sam Rushing <rushing@nightmare.com>
   /  Hacked for Unix by AMK
   /  $Id$
  
   / 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
  # ifdef __APPLE__
  #  include <fcntl.h>
  # endif
  #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 */
  #ifdef MS_WINDOWS
      PY_LONG_LONG offset;
  #else
      off_t       offset;
  #endif
      int     exports;
  
  #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 != NULL)
          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) {
          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)
  {
      if (self->exports > 0) {
          PyErr_SetString(PyExc_BufferError, "cannot close "\
                          "exported pointers exist");
          return NULL;
      }
  #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 != NULL) {
          CloseHandle(self->map_handle);
          self->map_handle = NULL;
      }
      if (self->file_handle != INVALID_HANDLE_VALUE) {
          CloseHandle(self->file_handle);
          self->file_handle = INVALID_HANDLE_VALUE;
      }
  #endif /* MS_WINDOWS */
  
  #ifdef UNIX
      if (0 <= self->fd)
          (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 == NULL) {                                     \
      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("B", (unsigned char)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 = PyBytes_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, n;
      PyObject *result;
  
      CHECK_VALID(NULL);
      if (!PyArg_ParseTuple(args, "n:read", &num_bytes))
          return(NULL);
  
      /* silently 'adjust' out-of-range requests */
      assert(self->size >= self->pos);
      n = self->size - self->pos;
      /* The difference can overflow, only if self->size is greater than
       * PY_SSIZE_T_MAX.  But then the operation cannot possibly succeed,
       * because the mapped area and the returned string each need more
       * than half of the addressable memory.  So we clip the size, and let
       * the code below raise MemoryError.
       */
      if (n < 0)
          n = PY_SSIZE_T_MAX;
      if (num_bytes < 0 || num_bytes > n) {
          num_bytes = n;
      }
      result = PyBytes_FromStringAndSize(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 ? "y#|nn:rfind" : "y#|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 PyLong_FromSsize_t(p - self->data);
              }
          }
          return PyLong_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_writable(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->exports > 0) {
          PyErr_SetString(PyExc_BufferError,
                          "mmap can't resize with extant buffers exported.");
          return 0;
      }
      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, "y#:write", &data, &length))
          return(NULL);
  
      if (!is_writable(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, "b:write_byte", &value))
          return(NULL);
  
      if (!is_writable(self))
          return NULL;
  
      if (self->pos < self->size) {
          *(self->data+self->pos) = value;
          self->pos += 1;
          Py_INCREF(Py_None);
          return Py_None;
      }
      else {
          PyErr_SetString(PyExc_ValueError, "write byte out of range");
          return NULL;
      }
  }
  
  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 PyLong_FromLong((long)low);
          size = (((PY_LONG_LONG)high)<<32) + low;
          return PyLong_FromLongLong(size);
      } else {
          return PyLong_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;
          }
  #ifdef HAVE_LARGEFILE_SUPPORT
          return PyLong_FromLongLong(buf.st_size);
  #else
          return PyLong_FromLong(buf.st_size);
  #endif
      }
  #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);
          self->data = NULL;
          /* Close the mapping object */
          CloseHandle(self->map_handle);
          self->map_handle = NULL;
          /* Move to the desired EOF position */
          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);
          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();
                  CloseHandle(self->map_handle);
                  self->map_handle = NULL;
              }
          } 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, self->offset + new_size) == -1) {
              PyErr_SetFromErrno(mmap_module_error);
              return NULL;
          }
  
  #ifdef MREMAP_MAYMOVE
          newmap = mremap(self->data, self->size, new_size, MREMAP_MAYMOVE);
  #else
          #if defined(__NetBSD__)
              newmap = mremap(self->data, self->size, self->data, new_size, 0);
          #else
              newmap = mremap(self->data, self->size, new_size, 0);
          #endif /* __NetBSD__ */
  #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 PyLong_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);
      if (!PyArg_ParseTuple(args, "|nn:flush", &offset, &size))
          return NULL;
      if ((size_t)(offset + size) > self->size) {
          PyErr_SetString(PyExc_ValueError, "flush values out of range");
          return NULL;
      }
  
      if (self->access == ACCESS_READ || self->access == ACCESS_COPY)
          return PyLong_FromLong(0);
  
  #ifdef MS_WINDOWS
      return PyLong_FromLong((long) FlushViewOfFile(self->data+offset, size));
  #elif defined(UNIX)
      /* XXX semantics of return value? */
      /* XXX flags for msync? */
      if (-1 == msync(self->data + offset, size, MS_SYNC)) {
          PyErr_SetFromErrno(mmap_module_error);
          return NULL;
      }
      return PyLong_FromLong(0);
  #else
      PyErr_SetString(PyExc_ValueError, "flush not supported on this system");
      return NULL;
  #endif
  }
  
  static PyObject *
  mmap_seek_method(mmap_object *self, PyObject *args)
  {
      Py_ssize_t dist;
      int how=0;
      CHECK_VALID(NULL);
      if (!PyArg_ParseTuple(args, "n|i:seek", &dist, &how))
          return NULL;
      else {
          size_t where;
          switch (how) {
          case 0: /* relative to start */
              if (dist < 0)
                  goto onoutofrange;
              where = dist;
              break;
          case 1: /* relative to current position */
              if ((Py_ssize_t)self->pos + dist < 0)
                  goto onoutofrange;
              where = self->pos + dist;
              break;
          case 2: /* relative to end */
              if ((Py_ssize_t)self->size + dist < 0)
                  goto onoutofrange;
              where = self->size + dist;
              break;
          default:
              PyErr_SetString(PyExc_ValueError, "unknown seek type");
              return NULL;
          }
          if (where > self->size)
              goto onoutofrange;
          self->pos = where;
          Py_INCREF(Py_None);
          return Py_None;
      }
  
    onoutofrange:
      PyErr_SetString(PyExc_ValueError, "seek out of range");
      return NULL;
  }
  
  static PyObject *
  mmap_move_method(mmap_object *self, PyObject *args)
  {
      unsigned long dest, src, cnt;
      CHECK_VALID(NULL);
      if (!PyArg_ParseTuple(args, "kkk:move", &dest, &src, &cnt) ||
          !is_writable(self)) {
          return NULL;
      } else {
          /* bounds check the values */
          if (cnt < 0 || (cnt + dest) < cnt || (cnt + src) < cnt ||
             src < 0 || src > self->size || (src + cnt) > self->size ||
             dest < 0 || dest > self->size || (dest + cnt) > self->size) {
              PyErr_SetString(PyExc_ValueError,
                  "source, destination, or count out of range");
              return NULL;
          }
          memmove(self->data+dest, self->data+src, cnt);
          Py_INCREF(Py_None);
          return Py_None;
      }
  }
  
  static PyObject *
  mmap_closed_get(mmap_object *self)
  {
  #ifdef MS_WINDOWS
      return PyBool_FromLong(self->map_handle == NULL ? 1 : 0);
  #elif defined(UNIX)
      return PyBool_FromLong(self->data == NULL ? 1 : 0);
  #endif
  }
  
  static PyObject *
  mmap__enter__method(mmap_object *self, PyObject *args)
  {
      CHECK_VALID(NULL);
  
      Py_INCREF(self);
      return (PyObject *)self;
  }
  
  static PyObject *
  mmap__exit__method(PyObject *self, PyObject *args)
  {
      return PyObject_CallMethod(self, "close", NULL);
  }
  
  static struct PyMethodDef mmap_object_methods[] = {
      {"close",           (PyCFunction) mmap_close_method,        METH_NOARGS},
      {"find",            (PyCFunction) mmap_find_method,         METH_VARARGS},
      {"rfind",           (PyCFunction) mmap_rfind_method,        METH_VARARGS},
      {"flush",           (PyCFunction) mmap_flush_method,        METH_VARARGS},
      {"move",            (PyCFunction) mmap_move_method,         METH_VARARGS},
      {"read",            (PyCFunction) mmap_read_method,         METH_VARARGS},
      {"read_byte",       (PyCFunction) mmap_read_byte_method,    METH_NOARGS},
      {"readline",        (PyCFunction) mmap_read_line_method,    METH_NOARGS},
      {"resize",          (PyCFunction) mmap_resize_method,       METH_VARARGS},
      {"seek",            (PyCFunction) mmap_seek_method,         METH_VARARGS},
      {"size",            (PyCFunction) mmap_size_method,         METH_NOARGS},
      {"tell",            (PyCFunction) mmap_tell_method,         METH_NOARGS},
      {"write",           (PyCFunction) mmap_write_method,        METH_VARARGS},
      {"write_byte",      (PyCFunction) mmap_write_byte_method,   METH_VARARGS},
      {"__enter__",       (PyCFunction) mmap__enter__method,      METH_NOARGS},
      {"__exit__",        (PyCFunction) mmap__exit__method,       METH_VARARGS},
      {NULL,         NULL}       /* sentinel */
  };
  
  static PyGetSetDef mmap_object_getset[] = {
      {"closed", (getter) mmap_closed_get, NULL, NULL},
      {NULL}
  };
  
  
  /* Functions for treating an mmap'ed file as a buffer */
  
  static int
  mmap_buffer_getbuf(mmap_object *self, Py_buffer *view, int flags)
  {
      CHECK_VALID(-1);
      if (PyBuffer_FillInfo(view, (PyObject*)self, self->data, self->size,
                            (self->access == ACCESS_READ), flags) < 0)
          return -1;
      self->exports++;
      return 0;
  }
  
  static void
  mmap_buffer_releasebuf(mmap_object *self, Py_buffer *view)
  {
      self->exports--;
  }
  
  static Py_ssize_t
  mmap_length(mmap_object *self)
  {
      CHECK_VALID(-1);
      return self->size;
  }
  
  static PyObject *
  mmap_item(mmap_object *self, Py_ssize_t i)
  {
      CHECK_VALID(NULL);
      if (i < 0 || (size_t)i >= self->size) {
          PyErr_SetString(PyExc_IndexError, "mmap index out of range");
          return NULL;
      }
      return PyBytes_FromStringAndSize(self->data + i, 1);
  }
  
  static PyObject *
  mmap_subscript(mmap_object *self, PyObject *item)
  {
      CHECK_VALID(NULL);
      if (PyIndex_Check(item)) {
          Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
          if (i == -1 && PyErr_Occurred())
              return NULL;
          if (i < 0)
              i += self->size;
          if (i < 0 || (size_t)i >= self->size) {
              PyErr_SetString(PyExc_IndexError,
                  "mmap index out of range");
              return NULL;
          }
          return PyLong_FromLong(Py_CHARMASK(self->data[i]));
      }
      else if (PySlice_Check(item)) {
          Py_ssize_t start, stop, step, slicelen;
  
          if (PySlice_GetIndicesEx(item, self->size,
                           &start, &stop, &step, &slicelen) < 0) {
              return NULL;
          }
  
          if (slicelen <= 0)
              return PyBytes_FromStringAndSize("", 0);
          else if (step == 1)
              return PyBytes_FromStringAndSize(self->data + start,
                                                slicelen);
          else {
              char *result_buf = (char *)PyMem_Malloc(slicelen);
              Py_ssize_t cur, i;
              PyObject *result;
  
              if (result_buf == NULL)
                  return PyErr_NoMemory();
              for (cur = start, i = 0; i < slicelen;
                   cur += step, i++) {
                  result_buf[i] = self->data[cur];
              }
              result = PyBytes_FromStringAndSize(result_buf,
                                                  slicelen);
              PyMem_Free(result_buf);
              return result;
          }
      }
      else {
          PyErr_SetString(PyExc_TypeError,
                          "mmap indices must be integers");
          return NULL;
      }
  }
  
  static PyObject *
  mmap_concat(mmap_object *self, PyObject *bb)
  {
      CHECK_VALID(NULL);
      PyErr_SetString(PyExc_SystemError,
                      "mmaps don't support concatenation");
      return NULL;
  }
  
  static PyObject *
  mmap_repeat(mmap_object *self, Py_ssize_t n)
  {
      CHECK_VALID(NULL);
      PyErr_SetString(PyExc_SystemError,
                      "mmaps don't support repeat operation");
      return NULL;
  }
  
  static int
  mmap_ass_item(mmap_object *self, Py_ssize_t i, PyObject *v)
  {
      const char *buf;
  
      CHECK_VALID(-1);
      if (i < 0 || (size_t)i >= self->size) {
          PyErr_SetString(PyExc_IndexError, "mmap index out of range");
          return -1;
      }
      if (v == NULL) {
          PyErr_SetString(PyExc_TypeError,
                          "mmap object doesn't support item deletion");
          return -1;
      }
      if (! (PyBytes_Check(v) && PyBytes_Size(v)==1) ) {
          PyErr_SetString(PyExc_IndexError,
                          "mmap assignment must be length-1 bytes()");
          return -1;
      }
      if (!is_writable(self))
          return -1;
      buf = PyBytes_AsString(v);
      self->data[i] = buf[0];
      return 0;
  }
  
  static int
  mmap_ass_subscript(mmap_object *self, PyObject *item, PyObject *value)
  {
      CHECK_VALID(-1);
  
      if (!is_writable(self))
          return -1;
  
      if (PyIndex_Check(item)) {
          Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
          Py_ssize_t v;
  
          if (i == -1 && PyErr_Occurred())
              return -1;
          if (i < 0)
              i += self->size;
          if (i < 0 || (size_t)i >= self->size) {
              PyErr_SetString(PyExc_IndexError,
                              "mmap index out of range");
              return -1;
          }
          if (value == NULL) {
              PyErr_SetString(PyExc_TypeError,
                              "mmap doesn't support item deletion");
              return -1;
          }
          if (!PyIndex_Check(value)) {
              PyErr_SetString(PyExc_TypeError,
                              "mmap item value must be an int");
              return -1;
          }
          v = PyNumber_AsSsize_t(value, PyExc_TypeError);
          if (v == -1 && PyErr_Occurred())
              return -1;
          if (v < 0 || v > 255) {
              PyErr_SetString(PyExc_ValueError,
                              "mmap item value must be "
                              "in range(0, 256)");
              return -1;
          }
          self->data[i] = (char) v;
          return 0;
      }
      else if (PySlice_Check(item)) {
          Py_ssize_t start, stop, step, slicelen;
          Py_buffer vbuf;
  
          if (PySlice_GetIndicesEx(item,
                                   self->size, &start, &stop,
                                   &step, &slicelen) < 0) {
              return -1;
          }
          if (value == NULL) {
              PyErr_SetString(PyExc_TypeError,
                  "mmap object doesn't support slice deletion");
              return -1;
          }
          if (PyObject_GetBuffer(value, &vbuf, PyBUF_SIMPLE) < 0)
              return -1;
          if (vbuf.len != slicelen) {
              PyErr_SetString(PyExc_IndexError,
                  "mmap slice assignment is wrong size");
              PyBuffer_Release(&vbuf);
              return -1;
          }
  
          if (slicelen == 0) {
          }
          else if (step == 1) {
              memcpy(self->data + start, vbuf.buf, slicelen);
          }
          else {
              Py_ssize_t cur, i;
  
              for (cur = start, i = 0;
                   i < slicelen;
                   cur += step, i++)
              {
                  self->data[cur] = ((char *)vbuf.buf)[i];
              }
          }
          PyBuffer_Release(&vbuf);
          return 0;
      }
      else {
          PyErr_SetString(PyExc_TypeError,
                          "mmap indices must be integer");
          return -1;
      }
  }
  
  static PySequenceMethods mmap_as_sequence = {
      (lenfunc)mmap_length,                      /*sq_length*/
      (binaryfunc)mmap_concat,                   /*sq_concat*/
      (ssizeargfunc)mmap_repeat,                 /*sq_repeat*/
      (ssizeargfunc)mmap_item,                           /*sq_item*/
      0,                                        /*sq_slice*/
      (ssizeobjargproc)mmap_ass_item,            /*sq_ass_item*/
      0,                                        /*sq_ass_slice*/
  };
  
  static PyMappingMethods mmap_as_mapping = {
      (lenfunc)mmap_length,
      (binaryfunc)mmap_subscript,
      (objobjargproc)mmap_ass_subscript,
  };
  
  static PyBufferProcs mmap_as_buffer = {
      (getbufferproc)mmap_buffer_getbuf,
      (releasebufferproc)mmap_buffer_releasebuf,
  };
  
  static PyObject *
  new_mmap_object(PyTypeObject *type, PyObject *args, PyObject *kwdict);
  
  PyDoc_STRVAR(mmap_doc,
  "Windows: mmap(fileno, length[, tagname[, access[, offset]]])\n\
  \n\
  Maps length bytes from the file specified by the file handle fileno,\n\
  and returns a mmap object.  If length is larger than the current size\n\
  of the file, the file is extended to contain length bytes.  If length\n\
  is 0, the maximum length of the map is the current size of the file,\n\
  except that if the file is empty Windows raises an exception (you cannot\n\
  create an empty mapping on Windows).\n\
  \n\
  Unix: mmap(fileno, length[, flags[, prot[, access[, offset]]]])\n\
  \n\
  Maps length bytes from the file specified by the file descriptor fileno,\n\
  and returns a mmap object.  If length is 0, the maximum length of the map\n\
  will be the current size of the file when mmap is called.\n\
  flags specifies the nature of the mapping. MAP_PRIVATE creates a\n\
  private copy-on-write mapping, so changes to the contents of the mmap\n\
  object will be private to this process, and MAP_SHARED creates a mapping\n\
  that's shared with all other processes mapping the same areas of the file.\n\
  The default value is MAP_SHARED.\n\
  \n\
  To map anonymous memory, pass -1 as the fileno (both versions).");
  
  
  static PyTypeObject mmap_object_type = {
      PyVarObject_HEAD_INIT(NULL, 0)
      "mmap.mmap",                                /* tp_name */
      sizeof(mmap_object),                        /* tp_size */
      0,                                          /* tp_itemsize */
      /* methods */
      (destructor) mmap_object_dealloc,           /* tp_dealloc */
      0,                                          /* tp_print */
      0,                                          /* tp_getattr */
      0,                                          /* tp_setattr */
      0,                                          /* tp_reserved */
      0,                                          /* tp_repr */
      0,                                          /* tp_as_number */
      &mmap_as_sequence,                          /*tp_as_sequence*/
      &mmap_as_mapping,                           /*tp_as_mapping*/
      0,                                          /*tp_hash*/
      0,                                          /*tp_call*/
      0,                                          /*tp_str*/
      PyObject_GenericGetAttr,                    /*tp_getattro*/
      0,                                          /*tp_setattro*/
      &mmap_as_buffer,                            /*tp_as_buffer*/
      Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                   /*tp_flags*/
      mmap_doc,                                   /*tp_doc*/
      0,                                          /* tp_traverse */
      0,                                          /* tp_clear */
      0,                                          /* tp_richcompare */
      0,                                          /* tp_weaklistoffset */
      0,                                          /* tp_iter */
      0,                                          /* tp_iternext */
      mmap_object_methods,                        /* tp_methods */
      0,                                          /* tp_members */
      mmap_object_getset,                         /* tp_getset */
      0,                                          /* tp_base */
      0,                                          /* tp_dict */
      0,                                          /* tp_descr_get */
      0,                                          /* tp_descr_set */
      0,                                          /* tp_dictoffset */
      0,                                      /* tp_init */
      PyType_GenericAlloc,                        /* tp_alloc */
      new_mmap_object,                            /* tp_new */
      PyObject_Del,                           /* tp_free */
  };
  
  
  /* extract the map size from the given PyObject
  
     Returns -1 on error, with an appropriate Python exception raised. On
     success, the map size is returned. */
  static Py_ssize_t
  _GetMapSize(PyObject *o, const char* param)
  {
      if (o == NULL)
          return 0;
      if (PyIndex_Check(o)) {
          Py_ssize_t i = PyNumber_AsSsize_t(o, PyExc_OverflowError);
          if (i==-1 && PyErr_Occurred())
              return -1;
          if (i < 0) {
              PyErr_Format(PyExc_OverflowError,
                              "memory mapped %s must be positive",
                              param);
              return -1;
          }
          return i;
      }
  
      PyErr_SetString(PyExc_TypeError, "map size must be an integral value");
      return -1;
  }
  
  #ifdef UNIX
  #ifdef HAVE_LARGEFILE_SUPPORT
  #define _Py_PARSE_OFF_T "L"
  #else
  #define _Py_PARSE_OFF_T "l"
  #endif
  
  static PyObject *
  new_mmap_object(PyTypeObject *type, PyObject *args, PyObject *kwdict)
  {
  #ifdef HAVE_FSTAT
      struct stat st;
  #endif
      mmap_object *m_obj;
      PyObject *map_size_obj = NULL;
      Py_ssize_t map_size;
      off_t offset = 0;
      int fd, flags = MAP_SHARED, prot = PROT_WRITE | PROT_READ;
      int devzero = -1;
      int access = (int)ACCESS_DEFAULT;
      static char *keywords[] = {"fileno", "length",
                                       "flags", "prot",
                                       "access", "offset", NULL};
  
      if (!PyArg_ParseTupleAndKeywords(args, kwdict, "iO|iii" _Py_PARSE_OFF_T, keywords,
                                       &fd, &map_size_obj, &flags, &prot,
                                       &access, &offset))
          return NULL;
      map_size = _GetMapSize(map_size_obj, "size");
      if (map_size < 0)
          return NULL;
      if (offset < 0) {
          PyErr_SetString(PyExc_OverflowError,
              "memory mapped offset must be positive");
          return NULL;
      }
  
      if ((access != (int)ACCESS_DEFAULT) &&
          ((flags != MAP_SHARED) || (prot != (PROT_WRITE | PROT_READ))))
          return PyErr_Format(PyExc_ValueError,
                              "mmap can't specify both access and flags, prot.");
      switch ((access_mode)access) {
      case ACCESS_READ:
          flags = MAP_SHARED;
          prot = PROT_READ;
          break;
      case ACCESS_WRITE:
          flags = MAP_SHARED;
          prot = PROT_READ | PROT_WRITE;
          break;
      case ACCESS_COPY:
          flags = MAP_PRIVATE;
          prot = PROT_READ | PROT_WRITE;
          break;
      case ACCESS_DEFAULT:
          /* map prot to access type */
          if ((prot & PROT_READ) && (prot & PROT_WRITE)) {
              /* ACCESS_DEFAULT */
          }
          else if (prot & PROT_WRITE) {
              access = ACCESS_WRITE;
          }
          else {
              access = ACCESS_READ;
          }
          break;
      default:
          return PyErr_Format(PyExc_ValueError,
                              "mmap invalid access parameter.");
      }
  
  #ifdef __APPLE__
      /* Issue #11277: fsync(2) is not enough on OS X - a special, OS X specific
         fcntl(2) is necessary to force DISKSYNC and get around mmap(2) bug */
      if (fd != -1)
          (void)fcntl(fd, F_FULLFSYNC);
  #endif
  #ifdef HAVE_FSTAT
  #  ifdef __VMS
      /* on OpenVMS we must ensure that all bytes are written to the file */
      if (fd != -1) {
          fsync(fd);
      }
  #  endif
      if (fd != -1 && fstat(fd, &st) == 0 && S_ISREG(st.st_mode)) {
          if (map_size == 0) {
              if (st.st_size == 0) {
                  PyErr_SetString(PyExc_ValueError,
                                  "cannot mmap an empty file");
                  return NULL;
              }
              if (offset >= st.st_size) {
                  PyErr_SetString(PyExc_ValueError,
                                  "mmap offset is greater than file size");
                  return NULL;
              }
              if (st.st_size - offset > PY_SSIZE_T_MAX) {
                  PyErr_SetString(PyExc_ValueError,
                                   "mmap length is too large");
                  return NULL;
              }
              map_size = (Py_ssize_t) (st.st_size - offset);
          } else if (offset + (size_t)map_size > st.st_size) {
              PyErr_SetString(PyExc_ValueError,
                              "mmap length is greater than file size");
              return NULL;
          }
      }
  #endif
      m_obj = (mmap_object *)type->tp_alloc(type, 0);
      if (m_obj == NULL) {return NULL;}
      m_obj->data = NULL;
      m_obj->size = (size_t) map_size;
      m_obj->pos = (size_t) 0;
      m_obj->exports = 0;
      m_obj->offset = offset;
      if (fd == -1) {
          m_obj->fd = -1;
          /* Assume the caller wants to map anonymous memory.
             This is the same behaviour as Windows.  mmap.mmap(-1, size)
             on both Windows and Unix map anonymous memory.
          */
  #ifdef MAP_ANONYMOUS
          /* BSD way to map anonymous memory */
          flags |= MAP_ANONYMOUS;
  #else
          /* SVR4 method to map anonymous memory is to open /dev/zero */
          fd = devzero = open("/dev/zero", O_RDWR);
          if (devzero == -1) {
              Py_DECREF(m_obj);
              PyErr_SetFromErrno(mmap_module_error);
              return NULL;
          }
  #endif
      } else {
          m_obj->fd = dup(fd);
          if (m_obj->fd == -1) {
              Py_DECREF(m_obj);
              PyErr_SetFromErrno(mmap_module_error);
              return NULL;
          }
      }
  
      m_obj->data = mmap(NULL, map_size,
                         prot, flags,
                         fd, offset);
  
      if (devzero != -1) {
          close(devzero);
      }
  
      if (m_obj->data == (char *)-1) {
          m_obj->data = NULL;
          Py_DECREF(m_obj);
          PyErr_SetFromErrno(mmap_module_error);
          return NULL;
      }
      m_obj->access = (access_mode)access;
      return (PyObject *)m_obj;
  }
  #endif /* UNIX */
  
  #ifdef MS_WINDOWS
  
  /* A note on sizes and offsets: while the actual map size must hold in a
     Py_ssize_t, both the total file size and the start offset can be longer
     than a Py_ssize_t, so we use PY_LONG_LONG which is always 64-bit.
  */
  
  static PyObject *
  new_mmap_object(PyTypeObject *type, PyObject *args, PyObject *kwdict)
  {
      mmap_object *m_obj;
      PyObject *map_size_obj = NULL;
      Py_ssize_t map_size;
      PY_LONG_LONG offset = 0, size;
      DWORD off_hi;       /* upper 32 bits of offset */
      DWORD off_lo;       /* lower 32 bits of offset */
      DWORD size_hi;      /* upper 32 bits of size */
      DWORD size_lo;      /* lower 32 bits of size */
      char *tagname = "";
      DWORD dwErr = 0;
      int fileno;
      HANDLE fh = 0;
      int access = (access_mode)ACCESS_DEFAULT;
      DWORD flProtect, dwDesiredAccess;
      static char *keywords[] = { "fileno", "length",
                                        "tagname",
                                        "access", "offset", NULL };
  
      if (!PyArg_ParseTupleAndKeywords(args, kwdict, "iO|ziL", keywords,
                                       &fileno, &map_size_obj,
                                       &tagname, &access, &offset)) {
          return NULL;
      }
  
      switch((access_mode)access) {
      case ACCESS_READ:
          flProtect = PAGE_READONLY;
          dwDesiredAccess = FILE_MAP_READ;
          break;
      case ACCESS_DEFAULT:  case ACCESS_WRITE:
          flProtect = PAGE_READWRITE;
          dwDesiredAccess = FILE_MAP_WRITE;
          break;
      case ACCESS_COPY:
          flProtect = PAGE_WRITECOPY;
          dwDesiredAccess = FILE_MAP_COPY;
          break;
      default:
          return PyErr_Format(PyExc_ValueError,
                              "mmap invalid access parameter.");
      }
  
      map_size = _GetMapSize(map_size_obj, "size");
      if (map_size < 0)
          return NULL;
      if (offset < 0) {
          PyErr_SetString(PyExc_OverflowError,
              "memory mapped offset must be positive");
          return NULL;
      }
  
      /* assume -1 and 0 both mean invalid filedescriptor
         to 'anonymously' map memory.
         XXX: fileno == 0 is a valid fd, but was accepted prior to 2.5.
         XXX: Should this code be added?
         if (fileno == 0)
          PyErr_WarnEx(PyExc_DeprecationWarning,
                       "don't use 0 for anonymous memory",
                       1);
       */
      if (fileno != -1 && fileno != 0) {
          /* Ensure that fileno is within the CRT's valid range */
          if (_PyVerify_fd(fileno) == 0) {
              PyErr_SetFromErrno(mmap_module_error);
              return NULL;
          }
          fh = (HANDLE)_get_osfhandle(fileno);
          if (fh==(HANDLE)-1) {
              PyErr_SetFromErrno(mmap_module_error);
              return NULL;
          }
          /* Win9x appears to need us seeked to zero */
          lseek(fileno, 0, SEEK_SET);
      }
  
      m_obj = (mmap_object *)type->tp_alloc(type, 0);
      if (m_obj == NULL)
          return NULL;
      /* Set every field to an invalid marker, so we can safely
         destruct the object in the face of failure */
      m_obj->data = NULL;
      m_obj->file_handle = INVALID_HANDLE_VALUE;
      m_obj->map_handle = NULL;
      m_obj->tagname = NULL;
      m_obj->offset = offset;
  
      if (fh) {
          /* It is necessary to duplicate the handle, so the
             Python code can close it on us */
          if (!DuplicateHandle(
              GetCurrentProcess(), /* source process handle */
              fh, /* handle to be duplicated */
              GetCurrentProcess(), /* target proc handle */
              (LPHANDLE)&m_obj->file_handle, /* result */
              0, /* access - ignored due to options value */
              FALSE, /* inherited by child processes? */
              DUPLICATE_SAME_ACCESS)) { /* options */
              dwErr = GetLastError();
              Py_DECREF(m_obj);
              PyErr_SetFromWindowsErr(dwErr);
              return NULL;
          }
          if (!map_size) {
              DWORD low,high;
              low = GetFileSize(fh, &high);
              /* low might just happen to have the value INVALID_FILE_SIZE;
                 so we need to check the last error also. */
              if (low == INVALID_FILE_SIZE &&
                  (dwErr = GetLastError()) != NO_ERROR) {
                  Py_DECREF(m_obj);
                  return PyErr_SetFromWindowsErr(dwErr);
              }
  
              size = (((PY_LONG_LONG) high) << 32) + low;
              if (size == 0) {
                  PyErr_SetString(PyExc_ValueError,
                                  "cannot mmap an empty file");
                  Py_DECREF(m_obj);
                  return NULL;
              }
              if (offset >= size) {
                  PyErr_SetString(PyExc_ValueError,
                                  "mmap offset is greater than file size");
                  Py_DECREF(m_obj);
                  return NULL;
              }
              if (size - offset > PY_SSIZE_T_MAX) {
                  PyErr_SetString(PyExc_ValueError,
                                  "mmap length is too large");
                  Py_DECREF(m_obj);
                  return NULL;
              }
              m_obj->size = (Py_ssize_t) (size - offset);
          } else {
              m_obj->size = map_size;
              size = offset + map_size;
          }
      }
      else {
          m_obj->size = map_size;
          size = offset + map_size;
      }
  
      /* set the initial position */
      m_obj->pos = (size_t) 0;
  
      m_obj->exports = 0;
      /* set the tag name */
      if (tagname != NULL && *tagname != '\0') {
          m_obj->tagname = PyMem_Malloc(strlen(tagname)+1);
          if (m_obj->tagname == NULL) {
              PyErr_NoMemory();
              Py_DECREF(m_obj);
              return NULL;
          }
          strcpy(m_obj->tagname, tagname);
      }
      else
          m_obj->tagname = NULL;
  
      m_obj->access = (access_mode)access;
      size_hi = (DWORD)(size >> 32);
      size_lo = (DWORD)(size & 0xFFFFFFFF);
      off_hi = (DWORD)(offset >> 32);
      off_lo = (DWORD)(offset & 0xFFFFFFFF);
      /* For files, it would be sufficient to pass 0 as size.
         For anonymous maps, we have to pass the size explicitly. */
      m_obj->map_handle = CreateFileMapping(m_obj->file_handle,
                                            NULL,
                                            flProtect,
                                            size_hi,
                                            size_lo,
                                            m_obj->tagname);
      if (m_obj->map_handle != NULL) {
          m_obj->data = (char *) MapViewOfFile(m_obj->map_handle,
                                               dwDesiredAccess,
                                               off_hi,
                                               off_lo,
                                               m_obj->size);
          if (m_obj->data != NULL)
              return (PyObject *)m_obj;
          else {
              dwErr = GetLastError();
              CloseHandle(m_obj->map_handle);
              m_obj->map_handle = NULL;
          }
      } else
          dwErr = GetLastError();
      Py_DECREF(m_obj);
      PyErr_SetFromWindowsErr(dwErr);
      return NULL;
  }
  #endif /* MS_WINDOWS */
  
  static void
  setint(PyObject *d, const char *name, long value)
  {
      PyObject *o = PyLong_FromLong(value);
      if (o && PyDict_SetItemString(d, name, o) == 0) {
          Py_DECREF(o);
      }
  }
  
  
  static struct PyModuleDef mmapmodule = {
      PyModuleDef_HEAD_INIT,
      "mmap",
      NULL,
      -1,
      NULL,
      NULL,
      NULL,
      NULL,
      NULL
  };
  
  PyMODINIT_FUNC
  PyInit_mmap(void)
  {
      PyObject *dict, *module;
  
      if (PyType_Ready(&mmap_object_type) < 0)
          return NULL;
  
      module = PyModule_Create(&mmapmodule);
      if (module == NULL)
          return NULL;
      dict = PyModule_GetDict(module);
      if (!dict)
          return NULL;
      mmap_module_error = PyErr_NewException("mmap.error",
          PyExc_EnvironmentError , NULL);
      if (mmap_module_error == NULL)
          return NULL;
      PyDict_SetItemString(dict, "error", mmap_module_error);
      PyDict_SetItemString(dict, "mmap", (PyObject*) &mmap_object_type);
  #ifdef PROT_EXEC
      setint(dict, "PROT_EXEC", PROT_EXEC);
  #endif
  #ifdef PROT_READ
      setint(dict, "PROT_READ", PROT_READ);
  #endif
  #ifdef PROT_WRITE
      setint(dict, "PROT_WRITE", PROT_WRITE);
  #endif
  
  #ifdef MAP_SHARED
      setint(dict, "MAP_SHARED", MAP_SHARED);
  #endif
  #ifdef MAP_PRIVATE
      setint(dict, "MAP_PRIVATE", MAP_PRIVATE);
  #endif
  #ifdef MAP_DENYWRITE
      setint(dict, "MAP_DENYWRITE", MAP_DENYWRITE);
  #endif
  #ifdef MAP_EXECUTABLE
      setint(dict, "MAP_EXECUTABLE", MAP_EXECUTABLE);
  #endif
  #ifdef MAP_ANONYMOUS
      setint(dict, "MAP_ANON", MAP_ANONYMOUS);
      setint(dict, "MAP_ANONYMOUS", MAP_ANONYMOUS);
  #endif
  
      setint(dict, "PAGESIZE", (long)my_getpagesize());
  
      setint(dict, "ALLOCATIONGRANULARITY", (long)my_getallocationgranularity());
  
      setint(dict, "ACCESS_READ", ACCESS_READ);
      setint(dict, "ACCESS_WRITE", ACCESS_WRITE);
      setint(dict, "ACCESS_COPY", ACCESS_COPY);
      return module;
  }
  