Modules/mmapmodule.c

   1 /*
   2  /  Author: Sam Rushing <rushing@nightmare.com>
   3  /  Hacked for Unix by AMK
   4  /  $Id$
   5
   6  / mmapmodule.cpp -- map a view of a file into memory
   7  /
   8  / todo: need permission flags, perhaps a 'chsize' analog
   9  /   not all functions check range yet!!!
  10  /
  11  /
  12  / This version of mmapmodule.c has been changed significantly
  13  / from the original mmapfile.c on which it was based.
  14  / The original version of mmapfile is maintained by Sam at
  15  / ftp://squirl.nightmare.com/pub/python/python-ext.
  16 */
  17
  18 #define PY_SSIZE_T_CLEAN
  19 #include <Python.h>
  20
  21 #ifndef MS_WINDOWS
  22 #define UNIX
  23 #endif
  24
  25 #ifdef MS_WINDOWS
  26 #include <windows.h>
  27 static int
  28 my_getpagesize(void)
  29 {
  30         SYSTEM_INFO si;
  31         GetSystemInfo(&si);
  32         return si.dwPageSize;
  33 }
  34 #endif
  35
  36 #ifdef UNIX
  37 #include <sys/mman.h>
  38 #include <sys/stat.h>
  39
  40 #if defined(HAVE_SYSCONF) && defined(_SC_PAGESIZE)
  41 static int
  42 my_getpagesize(void)
  43 {
  44         return sysconf(_SC_PAGESIZE);
  45 }
  46 #else
  47 #define my_getpagesize getpagesize
  48 #endif
  49
  50 #endif /* UNIX */
  51
  52 #include <string.h>
  53
  54 #ifdef HAVE_SYS_TYPES_H
  55 #include <sys/types.h>
  56 #endif /* HAVE_SYS_TYPES_H */
  57
  58 /* Prefer MAP_ANONYMOUS since MAP_ANON is deprecated according to man page. */
  59 #if !defined(MAP_ANONYMOUS) && defined(MAP_ANON)
  60 #  define MAP_ANONYMOUS MAP_ANON
  61 #endif
  62
  63 static PyObject *mmap_module_error;
  64
  65 typedef enum
  66 {
  67         ACCESS_DEFAULT,
  68         ACCESS_READ,
  69         ACCESS_WRITE,
  70         ACCESS_COPY
  71 } access_mode;
  72
  73 typedef struct {
  74         PyObject_HEAD
  75         char *  data;
  76         size_t  size;
  77         size_t  pos;
  78
  79 #ifdef MS_WINDOWS
  80         HANDLE  map_handle;
  81         HANDLE  file_handle;
  82         char *  tagname;
  83 #endif
  84
  85 #ifdef UNIX
  86         int fd;
  87 #endif
  88
  89         access_mode access;
  90 } mmap_object;
  91
  92
  93 static void
  94 mmap_object_dealloc(mmap_object *m_obj)
  95 {
  96 #ifdef MS_WINDOWS
  97         if (m_obj->data != NULL)
  98                 UnmapViewOfFile (m_obj->data);
  99         if (m_obj->map_handle != INVALID_HANDLE_VALUE)
 100                 CloseHandle (m_obj->map_handle);
 101         if (m_obj->file_handle != INVALID_HANDLE_VALUE)
 102                 CloseHandle (m_obj->file_handle);
 103         if (m_obj->tagname)
 104                 PyMem_Free(m_obj->tagname);
 105 #endif /* MS_WINDOWS */
 106
 107 #ifdef UNIX
 108         if (m_obj->fd >= 0)
 109                 (void) close(m_obj->fd);
 110         if (m_obj->data!=NULL) {
 111                 msync(m_obj->data, m_obj->size, MS_SYNC);
 112                 munmap(m_obj->data, m_obj->size);
 113         }
 114 #endif /* UNIX */
 115
 116         PyObject_Del(m_obj);
 117 }
 118
 119 static PyObject *
 120 mmap_close_method(mmap_object *self, PyObject *unused)
 121 {
 122 #ifdef MS_WINDOWS
 123         /* For each resource we maintain, we need to check
 124            the value is valid, and if so, free the resource
 125            and set the member value to an invalid value so
 126            the dealloc does not attempt to resource clearing
 127            again.
 128            TODO - should we check for errors in the close operations???
 129         */
 130         if (self->data != NULL) {
 131                 UnmapViewOfFile(self->data);
 132                 self->data = NULL;
 133         }
 134         if (self->map_handle != INVALID_HANDLE_VALUE) {
 135                 CloseHandle(self->map_handle);
 136                 self->map_handle = INVALID_HANDLE_VALUE;
 137         }
 138         if (self->file_handle != INVALID_HANDLE_VALUE) {
 139                 CloseHandle(self->file_handle);
 140                 self->file_handle = INVALID_HANDLE_VALUE;
 141         }
 142 #endif /* MS_WINDOWS */
 143
 144 #ifdef UNIX
 145         (void) close(self->fd);
 146         self->fd = -1;
 147         if (self->data != NULL) {
 148                 munmap(self->data, self->size);
 149                 self->data = NULL;
 150         }
 151 #endif
 152
 153         Py_INCREF(Py_None);
 154         return Py_None;
 155 }
 156
 157 #ifdef MS_WINDOWS
 158 #define CHECK_VALID(err)                                                \
 159 do {                                                                    \
 160     if (self->map_handle == INVALID_HANDLE_VALUE) {                                             \
 161         PyErr_SetString(PyExc_ValueError, "mmap closed or invalid");    \
 162         return err;                                                     \
 163     }                                                                   \
 164 } while (0)
 165 #endif /* MS_WINDOWS */
 166
 167 #ifdef UNIX
 168 #define CHECK_VALID(err)                                                \
 169 do {                                                                    \
 170     if (self->data == NULL) {                                           \
 171         PyErr_SetString(PyExc_ValueError, "mmap closed or invalid");    \
 172         return err;                                                     \
 173         }                                                               \
 174 } while (0)
 175 #endif /* UNIX */
 176
 177 static PyObject *
 178 mmap_read_byte_method(mmap_object *self,
 179                       PyObject *unused)
 180 {
 181         CHECK_VALID(NULL);
 182         if (self->pos < self->size) {
 183                 char value = self->data[self->pos];
 184                 self->pos += 1;
 185                 return Py_BuildValue("c", value);
 186         } else {
 187                 PyErr_SetString(PyExc_ValueError, "read byte out of range");
 188                 return NULL;
 189         }
 190 }
 191
 192 static PyObject *
 193 mmap_read_line_method(mmap_object *self,
 194                       PyObject *unused)
 195 {
 196         char *start = self->data+self->pos;
 197         char *eof = self->data+self->size;
 198         char *eol;
 199         PyObject *result;
 200
 201         CHECK_VALID(NULL);
 202
 203         eol = memchr(start, '\n', self->size - self->pos);
 204         if (!eol)
 205                 eol = eof;
 206         else
 207                 ++eol;          /* we're interested in the position after the
 208                                    newline. */
 209         result = PyString_FromStringAndSize(start, (eol - start));
 210         self->pos += (eol - start);
 211         return result;
 212 }
 213
 214 static PyObject *
 215 mmap_read_method(mmap_object *self,
 216                  PyObject *args)
 217 {
 218         Py_ssize_t num_bytes;
 219         PyObject *result;
 220
 221         CHECK_VALID(NULL);
 222         if (!PyArg_ParseTuple(args, "n:read", &num_bytes))
 223                 return(NULL);
 224
 225         /* silently 'adjust' out-of-range requests */
 226         if ((self->pos + num_bytes) > self->size) {
 227                 num_bytes -= (self->pos+num_bytes) - self->size;
 228         }
 229         result = Py_BuildValue("s#", self->data+self->pos, num_bytes);
 230         self->pos += num_bytes;
 231         return result;
 232 }
 233
 234 static PyObject *
 235 mmap_find_method(mmap_object *self,
 236                  PyObject *args)
 237 {
 238         Py_ssize_t start = self->pos;
 239         char *needle;
 240         Py_ssize_t len;
 241
 242         CHECK_VALID(NULL);
 243         if (!PyArg_ParseTuple(args, "s#|n:find", &needle, &len, &start)) {
 244                 return NULL;
 245         } else {
 246                 char *p;
 247                 char *e = self->data + self->size;
 248
 249                 if (start < 0)
 250                         start += self->size;
 251                 if (start < 0)
 252                         start = 0;
 253                 else if ((size_t)start > self->size)
 254                         start = self->size;
 255
 256                 for (p = self->data + start; p + len <= e; ++p) {
 257                         Py_ssize_t i;
 258                         for (i = 0; i < len && needle[i] == p[i]; ++i)
 259                                 /* nothing */;
 260                         if (i == len) {
 261                                 return PyInt_FromSsize_t(p - self->data);
 262                         }
 263                 }
 264                 return PyInt_FromLong(-1);
 265         }
 266 }
 267
 268 static int
 269 is_writeable(mmap_object *self)
 270 {
 271         if (self->access != ACCESS_READ)
 272                 return 1;
 273         PyErr_Format(PyExc_TypeError, "mmap can't modify a readonly memory map.");
 274         return 0;
 275 }
 276
 277 static int
 278 is_resizeable(mmap_object *self)
 279 {
 280         if ((self->access == ACCESS_WRITE) || (self->access == ACCESS_DEFAULT))
 281                 return 1;
 282         PyErr_Format(PyExc_TypeError,
 283                      "mmap can't resize a readonly or copy-on-write memory map.");
 284         return 0;
 285 }
 286
 287
 288 static PyObject *
 289 mmap_write_method(mmap_object *self,
 290                   PyObject *args)
 291 {
 292         Py_ssize_t length;
 293         char *data;
 294
 295         CHECK_VALID(NULL);
 296         if (!PyArg_ParseTuple(args, "s#:write", &data, &length))
 297                 return(NULL);
 298
 299         if (!is_writeable(self))
 300                 return NULL;
 301
 302         if ((self->pos + length) > self->size) {
 303                 PyErr_SetString(PyExc_ValueError, "data out of range");
 304                 return NULL;
 305         }
 306         memcpy(self->data+self->pos, data, length);
 307         self->pos = self->pos+length;
 308         Py_INCREF(Py_None);
 309         return Py_None;
 310 }
 311
 312 static PyObject *
 313 mmap_write_byte_method(mmap_object *self,
 314                        PyObject *args)
 315 {
 316         char value;
 317
 318         CHECK_VALID(NULL);
 319         if (!PyArg_ParseTuple(args, "c:write_byte", &value))
 320                 return(NULL);
 321
 322         if (!is_writeable(self))
 323                 return NULL;
 324         *(self->data+self->pos) = value;
 325         self->pos += 1;
 326         Py_INCREF(Py_None);
 327         return Py_None;
 328 }
 329
 330 static PyObject *
 331 mmap_size_method(mmap_object *self,
 332                  PyObject *unused)
 333 {
 334         CHECK_VALID(NULL);
 335
 336 #ifdef MS_WINDOWS
 337         if (self->file_handle != INVALID_HANDLE_VALUE) {
 338                 DWORD low,high;
 339                 PY_LONG_LONG size;
 340                 low = GetFileSize(self->file_handle, &high);
 341                 if (low == INVALID_FILE_SIZE) {
 342                         /* It might be that the function appears to have failed,
 343                            when indeed its size equals INVALID_FILE_SIZE */
 344                         DWORD error = GetLastError();
 345                         if (error != NO_ERROR)
 346                                 return PyErr_SetFromWindowsErr(error);
 347                 }
 348                 if (!high && low < LONG_MAX)
 349                         return PyInt_FromLong((long)low);
 350                 size = (((PY_LONG_LONG)high)<<32) + low;
 351                 return PyLong_FromLongLong(size);
 352         } else {
 353                 return PyInt_FromSsize_t(self->size);
 354         }
 355 #endif /* MS_WINDOWS */
 356
 357 #ifdef UNIX
 358         {
 359                 struct stat buf;
 360                 if (-1 == fstat(self->fd, &buf)) {
 361                         PyErr_SetFromErrno(mmap_module_error);
 362                         return NULL;
 363                 }
 364                 return PyInt_FromSsize_t(buf.st_size);
 365         }
 366 #endif /* UNIX */
 367 }
 368
 369 /* This assumes that you want the entire file mapped,
 370  / and when recreating the map will make the new file
 371  / have the new size
 372  /
 373  / Is this really necessary?  This could easily be done
 374  / from python by just closing and re-opening with the
 375  / new size?
 376  */
 377
 378 static PyObject *
 379 mmap_resize_method(mmap_object *self,
 380                    PyObject *args)
 381 {
 382         Py_ssize_t new_size;
 383         CHECK_VALID(NULL);
 384         if (!PyArg_ParseTuple(args, "n:resize", &new_size) ||
 385             !is_resizeable(self)) {
 386                 return NULL;
 387 #ifdef MS_WINDOWS
 388         } else {
 389                 DWORD dwErrCode = 0;
 390                 DWORD newSizeLow, newSizeHigh;
 391                 /* First, unmap the file view */
 392                 UnmapViewOfFile(self->data);
 393                 /* Close the mapping object */
 394                 CloseHandle(self->map_handle);
 395                 /* Move to the desired EOF position */
 396 #if SIZEOF_SIZE_T > 4
 397                 newSizeHigh = (DWORD)(new_size >> 32);
 398                 newSizeLow = (DWORD)(new_size & 0xFFFFFFFF);
 399 #else
 400                 newSizeHigh = 0;
 401                 newSizeLow = (DWORD)new_size;
 402 #endif
 403                 SetFilePointer(self->file_handle,
 404                                newSizeLow, &newSizeHigh, FILE_BEGIN);
 405                 /* Change the size of the file */
 406                 SetEndOfFile(self->file_handle);
 407                 /* Create another mapping object and remap the file view */
 408                 self->map_handle = CreateFileMapping(
 409                         self->file_handle,
 410                         NULL,
 411                         PAGE_READWRITE,
 412                         newSizeHigh,
 413                         newSizeLow,
 414                         self->tagname);
 415                 if (self->map_handle != NULL) {
 416                         self->data = (char *) MapViewOfFile(self->map_handle,
 417                                                             FILE_MAP_WRITE,
 418                                                             0,
 419                                                             0,
 420                                                             0);
 421                         if (self->data != NULL) {
 422                                 self->size = new_size;
 423                                 Py_INCREF(Py_None);
 424                                 return Py_None;
 425                         } else {
 426                                 dwErrCode = GetLastError();
 427                         }
 428                 } else {
 429                         dwErrCode = GetLastError();
 430                 }
 431                 PyErr_SetFromWindowsErr(dwErrCode);
 432                 return NULL;
 433 #endif /* MS_WINDOWS */
 434
 435 #ifdef UNIX
 436 #ifndef HAVE_MREMAP
 437         } else {
 438                 PyErr_SetString(PyExc_SystemError,
 439                                 "mmap: resizing not available--no mremap()");
 440                 return NULL;
 441 #else
 442         } else {
 443                 void *newmap;
 444
 445                 if (ftruncate(self->fd, new_size) == -1) {
 446                         PyErr_SetFromErrno(mmap_module_error);
 447                         return NULL;
 448                 }
 449
 450 #ifdef MREMAP_MAYMOVE
 451                 newmap = mremap(self->data, self->size, new_size, MREMAP_MAYMOVE);
 452 #else
 453                 newmap = mremap(self->data, self->size, new_size, 0);
 454 #endif
 455                 if (newmap == (void *)-1)
 456                 {
 457                         PyErr_SetFromErrno(mmap_module_error);
 458                         return NULL;
 459                 }
 460                 self->data = newmap;
 461                 self->size = new_size;
 462                 Py_INCREF(Py_None);
 463                 return Py_None;
 464 #endif /* HAVE_MREMAP */
 465 #endif /* UNIX */
 466         }
 467 }
 468
 469 static PyObject *
 470 mmap_tell_method(mmap_object *self, PyObject *unused)
 471 {
 472         CHECK_VALID(NULL);
 473         return PyInt_FromSize_t(self->pos);
 474 }
 475
 476 static PyObject *
 477 mmap_flush_method(mmap_object *self, PyObject *args)
 478 {
 479         Py_ssize_t offset = 0;
 480         Py_ssize_t size = self->size;
 481         CHECK_VALID(NULL);
 482         if (!PyArg_ParseTuple(args, "|nn:flush", &offset, &size))
 483                 return NULL;
 484         if ((size_t)(offset + size) > self->size) {
 485                 PyErr_SetString(PyExc_ValueError, "flush values out of range");
 486                 return NULL;
 487         } else {
 488 #ifdef MS_WINDOWS
 489                 return PyInt_FromLong((long)
 490                                       FlushViewOfFile(self->data+offset, size));
 491 #endif /* MS_WINDOWS */
 492 #ifdef UNIX
 493                 /* XXX semantics of return value? */
 494                 /* XXX flags for msync? */
 495                 if (-1 == msync(self->data + offset, size,
 496                                 MS_SYNC))
 497                 {
 498                         PyErr_SetFromErrno(mmap_module_error);
 499                         return NULL;
 500                 }
 501                 return PyInt_FromLong(0);
 502 #endif /* UNIX */
 503         }
 504 }
 505
 506 static PyObject *
 507 mmap_seek_method(mmap_object *self, PyObject *args)
 508 {
 509         Py_ssize_t dist;
 510         int how=0;
 511         CHECK_VALID(NULL);
 512         if (!PyArg_ParseTuple(args, "n|i:seek", &dist, &how))
 513                 return NULL;
 514         else {
 515                 size_t where;
 516                 switch (how) {
 517                 case 0: /* relative to start */
 518                         if (dist < 0)
 519                                 goto onoutofrange;
 520                         where = dist;
 521                         break;
 522                 case 1: /* relative to current position */
 523                         if ((Py_ssize_t)self->pos + dist < 0)
 524                                 goto onoutofrange;
 525                         where = self->pos + dist;
 526                         break;
 527                 case 2: /* relative to end */
 528                         if ((Py_ssize_t)self->size + dist < 0)
 529                                 goto onoutofrange;
 530                         where = self->size + dist;
 531                         break;
 532                 default:
 533                         PyErr_SetString(PyExc_ValueError, "unknown seek type");
 534                         return NULL;
 535                 }
 536                 if (where > self->size)
 537                         goto onoutofrange;
 538                 self->pos = where;
 539                 Py_INCREF(Py_None);
 540                 return Py_None;
 541         }
 542
 543   onoutofrange:
 544         PyErr_SetString(PyExc_ValueError, "seek out of range");
 545         return NULL;
 546 }
 547
 548 static PyObject *
 549 mmap_move_method(mmap_object *self, PyObject *args)
 550 {
 551         unsigned long dest, src, count;
 552         CHECK_VALID(NULL);
 553         if (!PyArg_ParseTuple(args, "kkk:move", &dest, &src, &count) ||
 554             !is_writeable(self)) {
 555                 return NULL;
 556         } else {
 557                 /* bounds check the values */
 558                 if (/* end of source after end of data?? */
 559                         ((src+count) > self->size)
 560                         /* dest will fit? */
 561                         || (dest+count > self->size)) {
 562                         PyErr_SetString(PyExc_ValueError,
 563                                         "source or destination out of range");
 564                         return NULL;
 565                 } else {
 566                         memmove(self->data+dest, self->data+src, count);
 567                         Py_INCREF(Py_None);
 568                         return Py_None;
 569                 }
 570         }
 571 }
 572
 573 static struct PyMethodDef mmap_object_methods[] = {
 574         {"close",       (PyCFunction) mmap_close_method,        METH_NOARGS},
 575         {"find",        (PyCFunction) mmap_find_method,         METH_VARARGS},
 576         {"flush",       (PyCFunction) mmap_flush_method,        METH_VARARGS},
 577         {"move",        (PyCFunction) mmap_move_method,         METH_VARARGS},
 578         {"read",        (PyCFunction) mmap_read_method,         METH_VARARGS},
 579         {"read_byte",   (PyCFunction) mmap_read_byte_method,    METH_NOARGS},
 580         {"readline",    (PyCFunction) mmap_read_line_method,    METH_NOARGS},
 581         {"resize",      (PyCFunction) mmap_resize_method,       METH_VARARGS},
 582         {"seek",        (PyCFunction) mmap_seek_method,         METH_VARARGS},
 583         {"size",        (PyCFunction) mmap_size_method,         METH_NOARGS},
 584         {"tell",        (PyCFunction) mmap_tell_method,         METH_NOARGS},
 585         {"write",       (PyCFunction) mmap_write_method,        METH_VARARGS},
 586         {"write_byte",  (PyCFunction) mmap_write_byte_method,   METH_VARARGS},
 587         {NULL,     NULL}       /* sentinel */
 588 };
 589
 590 /* Functions for treating an mmap'ed file as a buffer */
 591
 592 static Py_ssize_t
 593 mmap_buffer_getreadbuf(mmap_object *self, Py_ssize_t index, const void **ptr)
 594 {
 595         CHECK_VALID(-1);
 596         if (index != 0) {
 597                 PyErr_SetString(PyExc_SystemError,
 598                                 "Accessing non-existent mmap segment");
 599                 return -1;
 600         }
 601         *ptr = self->data;
 602         return self->size;
 603 }
 604
 605 static Py_ssize_t
 606 mmap_buffer_getwritebuf(mmap_object *self, Py_ssize_t index, const void **ptr)
 607 {
 608         CHECK_VALID(-1);
 609         if (index != 0) {
 610                 PyErr_SetString(PyExc_SystemError,
 611                                 "Accessing non-existent mmap segment");
 612                 return -1;
 613         }
 614         if (!is_writeable(self))
 615                 return -1;
 616         *ptr = self->data;
 617         return self->size;
 618 }
 619
 620 static Py_ssize_t
 621 mmap_buffer_getsegcount(mmap_object *self, Py_ssize_t *lenp)
 622 {
 623         CHECK_VALID(-1);
 624         if (lenp)
 625                 *lenp = self->size;
 626         return 1;
 627 }
 628
 629 static Py_ssize_t
 630 mmap_buffer_getcharbuffer(mmap_object *self, Py_ssize_t index, const void **ptr)
 631 {
 632         if (index != 0) {
 633                 PyErr_SetString(PyExc_SystemError,
 634                                 "accessing non-existent buffer segment");
 635                 return -1;
 636         }
 637         *ptr = (const char *)self->data;
 638         return self->size;
 639 }
 640
 641 static PyObject *
 642 mmap_object_getattr(mmap_object *self, char *name)
 643 {
 644         return Py_FindMethod(mmap_object_methods, (PyObject *)self, name);
 645 }
 646
 647 static Py_ssize_t
 648 mmap_length(mmap_object *self)
 649 {
 650         CHECK_VALID(-1);
 651         return self->size;
 652 }
 653
 654 static PyObject *
 655 mmap_item(mmap_object *self, Py_ssize_t i)
 656 {
 657         CHECK_VALID(NULL);
 658         if (i < 0 || (size_t)i >= self->size) {
 659                 PyErr_SetString(PyExc_IndexError, "mmap index out of range");
 660                 return NULL;
 661         }
 662         return PyString_FromStringAndSize(self->data + i, 1);
 663 }
 664
 665 static PyObject *
 666 mmap_slice(mmap_object *self, Py_ssize_t ilow, Py_ssize_t ihigh)
 667 {
 668         CHECK_VALID(NULL);
 669         if (ilow < 0)
 670                 ilow = 0;
 671         else if ((size_t)ilow > self->size)
 672                 ilow = self->size;
 673         if (ihigh < 0)
 674                 ihigh = 0;
 675         if (ihigh < ilow)
 676                 ihigh = ilow;
 677         else if ((size_t)ihigh > self->size)
 678                 ihigh = self->size;
 679
 680         return PyString_FromStringAndSize(self->data + ilow, ihigh-ilow);
 681 }
 682
 683 static PyObject *
 684 mmap_concat(mmap_object *self, PyObject *bb)
 685 {
 686         CHECK_VALID(NULL);
 687         PyErr_SetString(PyExc_SystemError,
 688                         "mmaps don't support concatenation");
 689         return NULL;
 690 }
 691
 692 static PyObject *
 693 mmap_repeat(mmap_object *self, Py_ssize_t n)
 694 {
 695         CHECK_VALID(NULL);
 696         PyErr_SetString(PyExc_SystemError,
 697                         "mmaps don't support repeat operation");
 698         return NULL;
 699 }
 700
 701 static int
 702 mmap_ass_slice(mmap_object *self, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *v)
 703 {
 704         const char *buf;
 705
 706         CHECK_VALID(-1);
 707         if (ilow < 0)
 708                 ilow = 0;
 709         else if ((size_t)ilow > self->size)
 710                 ilow = self->size;
 711         if (ihigh < 0)
 712                 ihigh = 0;
 713         if (ihigh < ilow)
 714                 ihigh = ilow;
 715         else if ((size_t)ihigh > self->size)
 716                 ihigh = self->size;
 717
 718         if (v == NULL) {
 719                 PyErr_SetString(PyExc_TypeError,
 720                                 "mmap object doesn't support slice deletion");
 721                 return -1;
 722         }
 723         if (! (PyString_Check(v)) ) {
 724                 PyErr_SetString(PyExc_IndexError,
 725                                 "mmap slice assignment must be a string");
 726                 return -1;
 727         }
 728         if (PyString_Size(v) != (ihigh - ilow)) {
 729                 PyErr_SetString(PyExc_IndexError,
 730                                 "mmap slice assignment is wrong size");
 731                 return -1;
 732         }
 733         if (!is_writeable(self))
 734                 return -1;
 735         buf = PyString_AsString(v);
 736         memcpy(self->data + ilow, buf, ihigh-ilow);
 737         return 0;
 738 }
 739
 740 static int
 741 mmap_ass_item(mmap_object *self, Py_ssize_t i, PyObject *v)
 742 {
 743         const char *buf;
 744
 745         CHECK_VALID(-1);
 746         if (i < 0 || (size_t)i >= self->size) {
 747                 PyErr_SetString(PyExc_IndexError, "mmap index out of range");
 748                 return -1;
 749         }
 750         if (v == NULL) {
 751                 PyErr_SetString(PyExc_TypeError,
 752                                 "mmap object doesn't support item deletion");
 753                 return -1;
 754         }
 755         if (! (PyString_Check(v) && PyString_Size(v)==1) ) {
 756                 PyErr_SetString(PyExc_IndexError,
 757                                 "mmap assignment must be single-character string");
 758                 return -1;
 759         }
 760         if (!is_writeable(self))
 761                 return -1;
 762         buf = PyString_AsString(v);
 763         self->data[i] = buf[0];
 764         return 0;
 765 }
 766
 767 static PySequenceMethods mmap_as_sequence = {
 768         (lenfunc)mmap_length,                  /*sq_length*/
 769         (binaryfunc)mmap_concat,               /*sq_concat*/
 770         (ssizeargfunc)mmap_repeat,             /*sq_repeat*/
 771         (ssizeargfunc)mmap_item,                       /*sq_item*/
 772         (ssizessizeargfunc)mmap_slice,         /*sq_slice*/
 773         (ssizeobjargproc)mmap_ass_item,        /*sq_ass_item*/
 774         (ssizessizeobjargproc)mmap_ass_slice,      /*sq_ass_slice*/
 775 };
 776
 777 static PyBufferProcs mmap_as_buffer = {
 778         (readbufferproc)mmap_buffer_getreadbuf,
 779         (writebufferproc)mmap_buffer_getwritebuf,
 780         (segcountproc)mmap_buffer_getsegcount,
 781         (charbufferproc)mmap_buffer_getcharbuffer,
 782 };
 783
 784 static PyTypeObject mmap_object_type = {
 785         PyObject_HEAD_INIT(0) /* patched in module init */
 786         0,                                      /* ob_size */
 787         "mmap.mmap",                            /* tp_name */
 788         sizeof(mmap_object),                    /* tp_size */
 789         0,                                      /* tp_itemsize */
 790         /* methods */
 791         (destructor) mmap_object_dealloc,       /* tp_dealloc */
 792         0,                                      /* tp_print */
 793         (getattrfunc) mmap_object_getattr,      /* tp_getattr */
 794         0,                                      /* tp_setattr */
 795         0,                                      /* tp_compare */
 796         0,                                      /* tp_repr */
 797         0,                                      /* tp_as_number */
 798         &mmap_as_sequence,                      /*tp_as_sequence*/
 799         0,                                      /*tp_as_mapping*/
 800         0,                                      /*tp_hash*/
 801         0,                                      /*tp_call*/
 802         0,                                      /*tp_str*/
 803         0,                                      /*tp_getattro*/
 804         0,                                      /*tp_setattro*/
 805         &mmap_as_buffer,                        /*tp_as_buffer*/
 806         Py_TPFLAGS_HAVE_GETCHARBUFFER,          /*tp_flags*/
 807         0,                                      /*tp_doc*/
 808 };
 809
 810
 811 /* extract the map size from the given PyObject
 812
 813    Returns -1 on error, with an appropriate Python exception raised. On
 814    success, the map size is returned. */
 815 static Py_ssize_t
 816 _GetMapSize(PyObject *o)
 817 {
 818         if (PyIndex_Check(o)) {
 819                 Py_ssize_t i = PyNumber_AsSsize_t(o, PyExc_OverflowError);
 820                 if (i==-1 && PyErr_Occurred())
 821                         return -1;
 822                 if (i < 0) {
 823                         PyErr_SetString(PyExc_OverflowError,
 824                                         "memory mapped size must be positive");
 825                         return -1;
 826                 }
 827                 return i;
 828         }
 829
 830         PyErr_SetString(PyExc_TypeError, "map size must be an integral value");
 831         return -1;
 832 }
 833
 834 #ifdef UNIX
 835 static PyObject *
 836 new_mmap_object(PyObject *self, PyObject *args, PyObject *kwdict)
 837 {
 838 #ifdef HAVE_FSTAT
 839         struct stat st;
 840 #endif
 841         mmap_object *m_obj;
 842         PyObject *map_size_obj = NULL;
 843         Py_ssize_t map_size;
 844         int fd, flags = MAP_SHARED, prot = PROT_WRITE | PROT_READ;
 845         int devzero = -1;
 846         int access = (int)ACCESS_DEFAULT;
 847         static char *keywords[] = {"fileno", "length",
 848                                          "flags", "prot",
 849                                          "access", NULL};
 850
 851         if (!PyArg_ParseTupleAndKeywords(args, kwdict, "iO|iii", keywords,
 852                                          &fd, &map_size_obj, &flags, &prot,
 853                                          &access))
 854                 return NULL;
 855         map_size = _GetMapSize(map_size_obj);
 856         if (map_size < 0)
 857                 return NULL;
 858
 859         if ((access != (int)ACCESS_DEFAULT) &&
 860             ((flags != MAP_SHARED) || (prot != (PROT_WRITE | PROT_READ))))
 861                 return PyErr_Format(PyExc_ValueError,
 862                                     "mmap can't specify both access and flags, prot.");
 863         switch ((access_mode)access) {
 864         case ACCESS_READ:
 865                 flags = MAP_SHARED;
 866                 prot = PROT_READ;
 867                 break;
 868         case ACCESS_WRITE:
 869                 flags = MAP_SHARED;
 870                 prot = PROT_READ | PROT_WRITE;
 871                 break;
 872         case ACCESS_COPY:
 873                 flags = MAP_PRIVATE;
 874                 prot = PROT_READ | PROT_WRITE;
 875                 break;
 876         case ACCESS_DEFAULT:
 877                 /* use the specified or default values of flags and prot */
 878                 break;
 879         default:
 880                 return PyErr_Format(PyExc_ValueError,
 881                                     "mmap invalid access parameter.");
 882         }
 883
 884 #ifdef HAVE_FSTAT
 885 #  ifdef __VMS
 886         /* on OpenVMS we must ensure that all bytes are written to the file */
 887         fsync(fd);
 888 #  endif
 889         if (fstat(fd, &st) == 0 && S_ISREG(st.st_mode)) {
 890                 if (map_size == 0) {
 891                         map_size = st.st_size;
 892                 } else if ((size_t)map_size > st.st_size) {
 893                         PyErr_SetString(PyExc_ValueError,
 894                                         "mmap length is greater than file size");
 895                         return NULL;
 896                 }
 897         }
 898 #endif
 899         m_obj = PyObject_New(mmap_object, &mmap_object_type);
 900         if (m_obj == NULL) {return NULL;}
 901         m_obj->data = NULL;
 902         m_obj->size = (size_t) map_size;
 903         m_obj->pos = (size_t) 0;
 904         if (fd == -1) {
 905                 m_obj->fd = -1;
 906                 /* Assume the caller wants to map anonymous memory.
 907                    This is the same behaviour as Windows.  mmap.mmap(-1, size)
 908                    on both Windows and Unix map anonymous memory.
 909                 */
 910 #ifdef MAP_ANONYMOUS
 911                 /* BSD way to map anonymous memory */
 912                 flags |= MAP_ANONYMOUS;
 913 #else
 914                 /* SVR4 method to map anonymous memory is to open /dev/zero */
 915                 fd = devzero = open("/dev/zero", O_RDWR);
 916                 if (devzero == -1) {
 917                         Py_DECREF(m_obj);
 918                         PyErr_SetFromErrno(mmap_module_error);
 919                         return NULL;
 920                 }
 921 #endif
 922         } else {
 923                 m_obj->fd = dup(fd);
 924                 if (m_obj->fd == -1) {
 925                         Py_DECREF(m_obj);
 926                         PyErr_SetFromErrno(mmap_module_error);
 927                         return NULL;
 928                 }
 929         }
 930
 931         m_obj->data = mmap(NULL, map_size,
 932                            prot, flags,
 933                            fd, 0);
 934
 935         if (devzero != -1) {
 936                 close(devzero);
 937         }
 938
 939         if (m_obj->data == (char *)-1) {
 940                 m_obj->data = NULL;
 941                 Py_DECREF(m_obj);
 942                 PyErr_SetFromErrno(mmap_module_error);
 943                 return NULL;
 944         }
 945         m_obj->access = (access_mode)access;
 946         return (PyObject *)m_obj;
 947 }
 948 #endif /* UNIX */
 949
 950 #ifdef MS_WINDOWS
 951 static PyObject *
 952 new_mmap_object(PyObject *self, PyObject *args, PyObject *kwdict)
 953 {
 954         mmap_object *m_obj;
 955         PyObject *map_size_obj = NULL;
 956         Py_ssize_t map_size;
 957         DWORD size_hi;  /* upper 32 bits of m_obj->size */
 958         DWORD size_lo;  /* lower 32 bits of m_obj->size */
 959         char *tagname = "";
 960         DWORD dwErr = 0;
 961         int fileno;
 962         HANDLE fh = 0;
 963         int access = (access_mode)ACCESS_DEFAULT;
 964         DWORD flProtect, dwDesiredAccess;
 965         static char *keywords[] = { "fileno", "length",
 966                                           "tagname",
 967                                           "access", NULL };
 968
 969         if (!PyArg_ParseTupleAndKeywords(args, kwdict, "iO|zi", keywords,
 970                                          &fileno, &map_size_obj,
 971                                          &tagname, &access)) {
 972                 return NULL;
 973         }
 974
 975         switch((access_mode)access) {
 976         case ACCESS_READ:
 977                 flProtect = PAGE_READONLY;
 978                 dwDesiredAccess = FILE_MAP_READ;
 979                 break;
 980         case ACCESS_DEFAULT:  case ACCESS_WRITE:
 981                 flProtect = PAGE_READWRITE;
 982                 dwDesiredAccess = FILE_MAP_WRITE;
 983                 break;
 984         case ACCESS_COPY:
 985                 flProtect = PAGE_WRITECOPY;
 986                 dwDesiredAccess = FILE_MAP_COPY;
 987                 break;
 988         default:
 989                 return PyErr_Format(PyExc_ValueError,
 990                                     "mmap invalid access parameter.");
 991         }
 992
 993         map_size = _GetMapSize(map_size_obj);
 994         if (map_size < 0)
 995                 return NULL;
 996
 997         /* assume -1 and 0 both mean invalid filedescriptor
 998            to 'anonymously' map memory.
 999            XXX: fileno == 0 is a valid fd, but was accepted prior to 2.5.
1000            XXX: Should this code be added?
1001            if (fileno == 0)
1002                 PyErr_Warn(PyExc_DeprecationWarning,
1003                            "don't use 0 for anonymous memory");
1004          */
1005         if (fileno != -1 && fileno != 0) {
1006                 fh = (HANDLE)_get_osfhandle(fileno);
1007                 if (fh==(HANDLE)-1) {
1008                         PyErr_SetFromErrno(mmap_module_error);
1009                         return NULL;
1010                 }
1011                 /* Win9x appears to need us seeked to zero */
1012                 lseek(fileno, 0, SEEK_SET);
1013         }
1014
1015         m_obj = PyObject_New(mmap_object, &mmap_object_type);
1016         if (m_obj == NULL)
1017                 return NULL;
1018         /* Set every field to an invalid marker, so we can safely
1019            destruct the object in the face of failure */
1020         m_obj->data = NULL;
1021         m_obj->file_handle = INVALID_HANDLE_VALUE;
1022         m_obj->map_handle = INVALID_HANDLE_VALUE;
1023         m_obj->tagname = NULL;
1024
1025         if (fh) {
1026                 /* It is necessary to duplicate the handle, so the
1027                    Python code can close it on us */
1028                 if (!DuplicateHandle(
1029                         GetCurrentProcess(), /* source process handle */
1030                         fh, /* handle to be duplicated */
1031                         GetCurrentProcess(), /* target proc handle */
1032                         (LPHANDLE)&m_obj->file_handle, /* result */
1033                         0, /* access - ignored due to options value */
1034                         FALSE, /* inherited by child processes? */
1035                         DUPLICATE_SAME_ACCESS)) { /* options */
1036                         dwErr = GetLastError();
1037                         Py_DECREF(m_obj);
1038                         PyErr_SetFromWindowsErr(dwErr);
1039                         return NULL;
1040                 }
1041                 if (!map_size) {
1042                         DWORD low,high;
1043                         low = GetFileSize(fh, &high);
1044                         /* low might just happen to have the value INVALID_FILE_SIZE;
1045                            so we need to check the last error also. */
1046                         if (low == INVALID_FILE_SIZE &&
1047                             (dwErr = GetLastError()) != NO_ERROR) {
1048                                 Py_DECREF(m_obj);
1049                                 return PyErr_SetFromWindowsErr(dwErr);
1050                         }
1051
1052 #if SIZEOF_SIZE_T > 4
1053                         m_obj->size = (((size_t)high)<<32) + low;
1054 #else
1055                         if (high)
1056                                 /* File is too large to map completely */
1057                                 m_obj->size = (size_t)-1;
1058                         else
1059                                 m_obj->size = low;
1060 #endif
1061                 } else {
1062                         m_obj->size = map_size;
1063                 }
1064         }
1065         else {
1066                 m_obj->size = map_size;
1067         }
1068
1069         /* set the initial position */
1070         m_obj->pos = (size_t) 0;
1071
1072         /* set the tag name */
1073         if (tagname != NULL && *tagname != '\0') {
1074                 m_obj->tagname = PyMem_Malloc(strlen(tagname)+1);
1075                 if (m_obj->tagname == NULL) {
1076                         PyErr_NoMemory();
1077                         Py_DECREF(m_obj);
1078                         return NULL;
1079                 }
1080                 strcpy(m_obj->tagname, tagname);
1081         }
1082         else
1083                 m_obj->tagname = NULL;
1084
1085         m_obj->access = (access_mode)access;
1086         /* DWORD is a 4-byte int.  If we're on a box where size_t consumes
1087          * more than 4 bytes, we need to break it apart.  Else (size_t
1088          * consumes 4 bytes), C doesn't define what happens if we shift
1089          * right by 32, so we need different code.
1090          */
1091 #if SIZEOF_SIZE_T > 4
1092         size_hi = (DWORD)(m_obj->size >> 32);
1093         size_lo = (DWORD)(m_obj->size & 0xFFFFFFFF);
1094 #else
1095         size_hi = 0;
1096         size_lo = (DWORD)m_obj->size;
1097 #endif
1098         m_obj->map_handle = CreateFileMapping(m_obj->file_handle,
1099                                               NULL,
1100                                               flProtect,
1101                                               size_hi,
1102                                               size_lo,
1103                                               m_obj->tagname);
1104         if (m_obj->map_handle != NULL) {
1105                 m_obj->data = (char *) MapViewOfFile(m_obj->map_handle,
1106                                                      dwDesiredAccess,
1107                                                      0,
1108                                                      0,
1109                                                      0);
1110                 if (m_obj->data != NULL)
1111                         return (PyObject *)m_obj;
1112                 else
1113                         dwErr = GetLastError();
1114         } else
1115                 dwErr = GetLastError();
1116         Py_DECREF(m_obj);
1117         PyErr_SetFromWindowsErr(dwErr);
1118         return NULL;
1119 }
1120 #endif /* MS_WINDOWS */
1121
1122 /* List of functions exported by this module */
1123 static struct PyMethodDef mmap_functions[] = {
1124         {"mmap",        (PyCFunction) new_mmap_object,
1125          METH_VARARGS|METH_KEYWORDS},
1126         {NULL,          NULL}        /* Sentinel */
1127 };
1128
1129 static void
1130 setint(PyObject *d, const char *name, long value)
1131 {
1132         PyObject *o = PyInt_FromLong(value);
1133         if (o && PyDict_SetItemString(d, name, o) == 0) {
1134                 Py_DECREF(o);
1135         }
1136 }
1137
1138 PyMODINIT_FUNC
1139         initmmap(void)
1140 {
1141         PyObject *dict, *module;
1142
1143         /* Patch the object type */
1144         mmap_object_type.ob_type = &PyType_Type;
1145
1146         module = Py_InitModule("mmap", mmap_functions);
1147         if (module == NULL)
1148                 return;
1149         dict = PyModule_GetDict(module);
1150         if (!dict)
1151                 return;
1152         mmap_module_error = PyExc_EnvironmentError;
1153         PyDict_SetItemString(dict, "error", mmap_module_error);
1154 #ifdef PROT_EXEC
1155         setint(dict, "PROT_EXEC", PROT_EXEC);
1156 #endif
1157 #ifdef PROT_READ
1158         setint(dict, "PROT_READ", PROT_READ);
1159 #endif
1160 #ifdef PROT_WRITE
1161         setint(dict, "PROT_WRITE", PROT_WRITE);
1162 #endif
1163
1164 #ifdef MAP_SHARED
1165         setint(dict, "MAP_SHARED", MAP_SHARED);
1166 #endif
1167 #ifdef MAP_PRIVATE
1168         setint(dict, "MAP_PRIVATE", MAP_PRIVATE);
1169 #endif
1170 #ifdef MAP_DENYWRITE
1171         setint(dict, "MAP_DENYWRITE", MAP_DENYWRITE);
1172 #endif
1173 #ifdef MAP_EXECUTABLE
1174         setint(dict, "MAP_EXECUTABLE", MAP_EXECUTABLE);
1175 #endif
1176 #ifdef MAP_ANONYMOUS
1177         setint(dict, "MAP_ANON", MAP_ANONYMOUS);
1178         setint(dict, "MAP_ANONYMOUS", MAP_ANONYMOUS);
1179 #endif
1180
1181         setint(dict, "PAGESIZE", (long)my_getpagesize());
1182
1183         setint(dict, "ACCESS_READ", ACCESS_READ);
1184         setint(dict, "ACCESS_WRITE", ACCESS_WRITE);
1185         setint(dict, "ACCESS_COPY", ACCESS_COPY);
1186 }