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         PyVarObject_HEAD_INIT(0, 0) /* patched in module init */
 786         "mmap.mmap",                            /* tp_name */
 787         sizeof(mmap_object),                    /* tp_size */
 788         0,                                      /* tp_itemsize */
 789         /* methods */
 790         (destructor) mmap_object_dealloc,       /* tp_dealloc */
 791         0,                                      /* tp_print */
 792         (getattrfunc) mmap_object_getattr,      /* tp_getattr */
 793         0,                                      /* tp_setattr */
 794         0,                                      /* tp_compare */
 795         0,                                      /* tp_repr */
 796         0,                                      /* tp_as_number */
 797         &mmap_as_sequence,                      /*tp_as_sequence*/
 798         0,                                      /*tp_as_mapping*/
 799         0,                                      /*tp_hash*/
 800         0,                                      /*tp_call*/
 801         0,                                      /*tp_str*/
 802         0,                                      /*tp_getattro*/
 803         0,                                      /*tp_setattro*/
 804         &mmap_as_buffer,                        /*tp_as_buffer*/
 805         Py_TPFLAGS_HAVE_GETCHARBUFFER,          /*tp_flags*/
 806         0,                                      /*tp_doc*/
 807 };
 808
 809
 810 /* extract the map size from the given PyObject
 811
 812    Returns -1 on error, with an appropriate Python exception raised. On
 813    success, the map size is returned. */
 814 static Py_ssize_t
 815 _GetMapSize(PyObject *o)
 816 {
 817         if (PyIndex_Check(o)) {
 818                 Py_ssize_t i = PyNumber_AsSsize_t(o, PyExc_OverflowError);
 819                 if (i==-1 && PyErr_Occurred())
 820                         return -1;
 821                 if (i < 0) {
 822                         PyErr_SetString(PyExc_OverflowError,
 823                                         "memory mapped size must be positive");
 824                         return -1;
 825                 }
 826                 return i;
 827         }
 828
 829         PyErr_SetString(PyExc_TypeError, "map size must be an integral value");
 830         return -1;
 831 }
 832
 833 #ifdef UNIX
 834 static PyObject *
 835 new_mmap_object(PyObject *self, PyObject *args, PyObject *kwdict)
 836 {
 837 #ifdef HAVE_FSTAT
 838         struct stat st;
 839 #endif
 840         mmap_object *m_obj;
 841         PyObject *map_size_obj = NULL;
 842         Py_ssize_t map_size;
 843         int fd, flags = MAP_SHARED, prot = PROT_WRITE | PROT_READ;
 844         int devzero = -1;
 845         int access = (int)ACCESS_DEFAULT;
 846         static char *keywords[] = {"fileno", "length",
 847                                          "flags", "prot",
 848                                          "access", NULL};
 849
 850         if (!PyArg_ParseTupleAndKeywords(args, kwdict, "iO|iii", keywords,
 851                                          &fd, &map_size_obj, &flags, &prot,
 852                                          &access))
 853                 return NULL;
 854         map_size = _GetMapSize(map_size_obj);
 855         if (map_size < 0)
 856                 return NULL;
 857
 858         if ((access != (int)ACCESS_DEFAULT) &&
 859             ((flags != MAP_SHARED) || (prot != (PROT_WRITE | PROT_READ))))
 860                 return PyErr_Format(PyExc_ValueError,
 861                                     "mmap can't specify both access and flags, prot.");
 862         switch ((access_mode)access) {
 863         case ACCESS_READ:
 864                 flags = MAP_SHARED;
 865                 prot = PROT_READ;
 866                 break;
 867         case ACCESS_WRITE:
 868                 flags = MAP_SHARED;
 869                 prot = PROT_READ | PROT_WRITE;
 870                 break;
 871         case ACCESS_COPY:
 872                 flags = MAP_PRIVATE;
 873                 prot = PROT_READ | PROT_WRITE;
 874                 break;
 875         case ACCESS_DEFAULT:
 876                 /* use the specified or default values of flags and prot */
 877                 break;
 878         default:
 879                 return PyErr_Format(PyExc_ValueError,
 880                                     "mmap invalid access parameter.");
 881         }
 882
 883 #ifdef HAVE_FSTAT
 884 #  ifdef __VMS
 885         /* on OpenVMS we must ensure that all bytes are written to the file */
 886         fsync(fd);
 887 #  endif
 888         if (fstat(fd, &st) == 0 && S_ISREG(st.st_mode)) {
 889                 if (map_size == 0) {
 890                         map_size = st.st_size;
 891                 } else if ((size_t)map_size > st.st_size) {
 892                         PyErr_SetString(PyExc_ValueError,
 893                                         "mmap length is greater than file size");
 894                         return NULL;
 895                 }
 896         }
 897 #endif
 898         m_obj = PyObject_New(mmap_object, &mmap_object_type);
 899         if (m_obj == NULL) {return NULL;}
 900         m_obj->data = NULL;
 901         m_obj->size = (size_t) map_size;
 902         m_obj->pos = (size_t) 0;
 903         if (fd == -1) {
 904                 m_obj->fd = -1;
 905                 /* Assume the caller wants to map anonymous memory.
 906                    This is the same behaviour as Windows.  mmap.mmap(-1, size)
 907                    on both Windows and Unix map anonymous memory.
 908                 */
 909 #ifdef MAP_ANONYMOUS
 910                 /* BSD way to map anonymous memory */
 911                 flags |= MAP_ANONYMOUS;
 912 #else
 913                 /* SVR4 method to map anonymous memory is to open /dev/zero */
 914                 fd = devzero = open("/dev/zero", O_RDWR);
 915                 if (devzero == -1) {
 916                         Py_DECREF(m_obj);
 917                         PyErr_SetFromErrno(mmap_module_error);
 918                         return NULL;
 919                 }
 920 #endif
 921         } else {
 922                 m_obj->fd = dup(fd);
 923                 if (m_obj->fd == -1) {
 924                         Py_DECREF(m_obj);
 925                         PyErr_SetFromErrno(mmap_module_error);
 926                         return NULL;
 927                 }
 928         }
 929
 930         m_obj->data = mmap(NULL, map_size,
 931                            prot, flags,
 932                            fd, 0);
 933
 934         if (devzero != -1) {
 935                 close(devzero);
 936         }
 937
 938         if (m_obj->data == (char *)-1) {
 939                 m_obj->data = NULL;
 940                 Py_DECREF(m_obj);
 941                 PyErr_SetFromErrno(mmap_module_error);
 942                 return NULL;
 943         }
 944         m_obj->access = (access_mode)access;
 945         return (PyObject *)m_obj;
 946 }
 947 #endif /* UNIX */
 948
 949 #ifdef MS_WINDOWS
 950 static PyObject *
 951 new_mmap_object(PyObject *self, PyObject *args, PyObject *kwdict)
 952 {
 953         mmap_object *m_obj;
 954         PyObject *map_size_obj = NULL;
 955         Py_ssize_t map_size;
 956         DWORD size_hi;  /* upper 32 bits of m_obj->size */
 957         DWORD size_lo;  /* lower 32 bits of m_obj->size */
 958         char *tagname = "";
 959         DWORD dwErr = 0;
 960         int fileno;
 961         HANDLE fh = 0;
 962         int access = (access_mode)ACCESS_DEFAULT;
 963         DWORD flProtect, dwDesiredAccess;
 964         static char *keywords[] = { "fileno", "length",
 965                                           "tagname",
 966                                           "access", NULL };
 967
 968         if (!PyArg_ParseTupleAndKeywords(args, kwdict, "iO|zi", keywords,
 969                                          &fileno, &map_size_obj,
 970                                          &tagname, &access)) {
 971                 return NULL;
 972         }
 973
 974         switch((access_mode)access) {
 975         case ACCESS_READ:
 976                 flProtect = PAGE_READONLY;
 977                 dwDesiredAccess = FILE_MAP_READ;
 978                 break;
 979         case ACCESS_DEFAULT:  case ACCESS_WRITE:
 980                 flProtect = PAGE_READWRITE;
 981                 dwDesiredAccess = FILE_MAP_WRITE;
 982                 break;
 983         case ACCESS_COPY:
 984                 flProtect = PAGE_WRITECOPY;
 985                 dwDesiredAccess = FILE_MAP_COPY;
 986                 break;
 987         default:
 988                 return PyErr_Format(PyExc_ValueError,
 989                                     "mmap invalid access parameter.");
 990         }
 991
 992         map_size = _GetMapSize(map_size_obj);
 993         if (map_size < 0)
 994                 return NULL;
 995
 996         /* assume -1 and 0 both mean invalid filedescriptor
 997            to 'anonymously' map memory.
 998            XXX: fileno == 0 is a valid fd, but was accepted prior to 2.5.
 999            XXX: Should this code be added?
1000            if (fileno == 0)
1001                 PyErr_Warn(PyExc_DeprecationWarning,
1002                            "don't use 0 for anonymous memory");
1003          */
1004         if (fileno != -1 && fileno != 0) {
1005                 fh = (HANDLE)_get_osfhandle(fileno);
1006                 if (fh==(HANDLE)-1) {
1007                         PyErr_SetFromErrno(mmap_module_error);
1008                         return NULL;
1009                 }
1010                 /* Win9x appears to need us seeked to zero */
1011                 lseek(fileno, 0, SEEK_SET);
1012         }
1013
1014         m_obj = PyObject_New(mmap_object, &mmap_object_type);
1015         if (m_obj == NULL)
1016                 return NULL;
1017         /* Set every field to an invalid marker, so we can safely
1018            destruct the object in the face of failure */
1019         m_obj->data = NULL;
1020         m_obj->file_handle = INVALID_HANDLE_VALUE;
1021         m_obj->map_handle = INVALID_HANDLE_VALUE;
1022         m_obj->tagname = NULL;
1023
1024         if (fh) {
1025                 /* It is necessary to duplicate the handle, so the
1026                    Python code can close it on us */
1027                 if (!DuplicateHandle(
1028                         GetCurrentProcess(), /* source process handle */
1029                         fh, /* handle to be duplicated */
1030                         GetCurrentProcess(), /* target proc handle */
1031                         (LPHANDLE)&m_obj->file_handle, /* result */
1032                         0, /* access - ignored due to options value */
1033                         FALSE, /* inherited by child processes? */
1034                         DUPLICATE_SAME_ACCESS)) { /* options */
1035                         dwErr = GetLastError();
1036                         Py_DECREF(m_obj);
1037                         PyErr_SetFromWindowsErr(dwErr);
1038                         return NULL;
1039                 }
1040                 if (!map_size) {
1041                         DWORD low,high;
1042                         low = GetFileSize(fh, &high);
1043                         /* low might just happen to have the value INVALID_FILE_SIZE;
1044                            so we need to check the last error also. */
1045                         if (low == INVALID_FILE_SIZE &&
1046                             (dwErr = GetLastError()) != NO_ERROR) {
1047                                 Py_DECREF(m_obj);
1048                                 return PyErr_SetFromWindowsErr(dwErr);
1049                         }
1050
1051 #if SIZEOF_SIZE_T > 4
1052                         m_obj->size = (((size_t)high)<<32) + low;
1053 #else
1054                         if (high)
1055                                 /* File is too large to map completely */
1056                                 m_obj->size = (size_t)-1;
1057                         else
1058                                 m_obj->size = low;
1059 #endif
1060                 } else {
1061                         m_obj->size = map_size;
1062                 }
1063         }
1064         else {
1065                 m_obj->size = map_size;
1066         }
1067
1068         /* set the initial position */
1069         m_obj->pos = (size_t) 0;
1070
1071         /* set the tag name */
1072         if (tagname != NULL && *tagname != '\0') {
1073                 m_obj->tagname = PyMem_Malloc(strlen(tagname)+1);
1074                 if (m_obj->tagname == NULL) {
1075                         PyErr_NoMemory();
1076                         Py_DECREF(m_obj);
1077                         return NULL;
1078                 }
1079                 strcpy(m_obj->tagname, tagname);
1080         }
1081         else
1082                 m_obj->tagname = NULL;
1083
1084         m_obj->access = (access_mode)access;
1085         /* DWORD is a 4-byte int.  If we're on a box where size_t consumes
1086          * more than 4 bytes, we need to break it apart.  Else (size_t
1087          * consumes 4 bytes), C doesn't define what happens if we shift
1088          * right by 32, so we need different code.
1089          */
1090 #if SIZEOF_SIZE_T > 4
1091         size_hi = (DWORD)(m_obj->size >> 32);
1092         size_lo = (DWORD)(m_obj->size & 0xFFFFFFFF);
1093 #else
1094         size_hi = 0;
1095         size_lo = (DWORD)m_obj->size;
1096 #endif
1097         m_obj->map_handle = CreateFileMapping(m_obj->file_handle,
1098                                               NULL,
1099                                               flProtect,
1100                                               size_hi,
1101                                               size_lo,
1102                                               m_obj->tagname);
1103         if (m_obj->map_handle != NULL) {
1104                 m_obj->data = (char *) MapViewOfFile(m_obj->map_handle,
1105                                                      dwDesiredAccess,
1106                                                      0,
1107                                                      0,
1108                                                      0);
1109                 if (m_obj->data != NULL)
1110                         return (PyObject *)m_obj;
1111                 else
1112                         dwErr = GetLastError();
1113         } else
1114                 dwErr = GetLastError();
1115         Py_DECREF(m_obj);
1116         PyErr_SetFromWindowsErr(dwErr);
1117         return NULL;
1118 }
1119 #endif /* MS_WINDOWS */
1120
1121 /* List of functions exported by this module */
1122 static struct PyMethodDef mmap_functions[] = {
1123         {"mmap",        (PyCFunction) new_mmap_object,
1124          METH_VARARGS|METH_KEYWORDS},
1125         {NULL,          NULL}        /* Sentinel */
1126 };
1127
1128 static void
1129 setint(PyObject *d, const char *name, long value)
1130 {
1131         PyObject *o = PyInt_FromLong(value);
1132         if (o && PyDict_SetItemString(d, name, o) == 0) {
1133                 Py_DECREF(o);
1134         }
1135 }
1136
1137 PyMODINIT_FUNC
1138         initmmap(void)
1139 {
1140         PyObject *dict, *module;
1141
1142         /* Patch the object type */
1143         Py_Type(&mmap_object_type) = &PyType_Type;
1144
1145         module = Py_InitModule("mmap", mmap_functions);
1146         if (module == NULL)
1147                 return;
1148         dict = PyModule_GetDict(module);
1149         if (!dict)
1150                 return;
1151         mmap_module_error = PyExc_EnvironmentError;
1152         PyDict_SetItemString(dict, "error", mmap_module_error);
1153 #ifdef PROT_EXEC
1154         setint(dict, "PROT_EXEC", PROT_EXEC);
1155 #endif
1156 #ifdef PROT_READ
1157         setint(dict, "PROT_READ", PROT_READ);
1158 #endif
1159 #ifdef PROT_WRITE
1160         setint(dict, "PROT_WRITE", PROT_WRITE);
1161 #endif
1162
1163 #ifdef MAP_SHARED
1164         setint(dict, "MAP_SHARED", MAP_SHARED);
1165 #endif
1166 #ifdef MAP_PRIVATE
1167         setint(dict, "MAP_PRIVATE", MAP_PRIVATE);
1168 #endif
1169 #ifdef MAP_DENYWRITE
1170         setint(dict, "MAP_DENYWRITE", MAP_DENYWRITE);
1171 #endif
1172 #ifdef MAP_EXECUTABLE
1173         setint(dict, "MAP_EXECUTABLE", MAP_EXECUTABLE);
1174 #endif
1175 #ifdef MAP_ANONYMOUS
1176         setint(dict, "MAP_ANON", MAP_ANONYMOUS);
1177         setint(dict, "MAP_ANONYMOUS", MAP_ANONYMOUS);
1178 #endif
1179
1180         setint(dict, "PAGESIZE", (long)my_getpagesize());
1181
1182         setint(dict, "ACCESS_READ", ACCESS_READ);
1183         setint(dict, "ACCESS_WRITE", ACCESS_WRITE);
1184         setint(dict, "ACCESS_COPY", ACCESS_COPY);
1185 }