return PyInt_FromLong(0);#endif /* UNIX */ }} 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, count; CHECK_VALID(NULL); if (!PyArg_ParseTuple(args, "kkk:move", &dest, &src, &count) || !is_writeable(self)) { return NULL; } else { /* bounds check the values */ if (/* end of source after end of data?? */ ((src+count) > self->size) /* dest will fit? */ || (dest+count > self->size)) { PyErr_SetString(PyExc_ValueError, "source or destination out of range"); return NULL; } else { memmove(self->data+dest, self->data+src, count); Py_INCREF(Py_None); return Py_None; } }} static struct PyMethodDef mmap_object_methods[] = { {"close", (PyCFunction) mmap_close_method, METH_NOARGS}, {"find", (PyCFunction) mmap_find_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}, {NULL, NULL} /* sentinel */}; /* Functions for treating an mmap'ed file as a buffer */ static Py_ssize_tmmap_buffer_getreadbuf(mmap_object *self, Py_ssize_t index, const void **ptr){ CHECK_VALID(-1); if (index != 0) { PyErr_SetString(PyExc_SystemError, "Accessing non-existent mmap segment"); return -1; } *ptr = self->data; return self->size;} static Py_ssize_tmmap_buffer_getwritebuf(mmap_object *self, Py_ssize_t index, const void **ptr){ CHECK_VALID(-1); if (index != 0) { PyErr_SetString(PyExc_SystemError, "Accessing non-existent mmap segment"); return -1; } if (!is_writeable(self)) return -1; *ptr = self->data; return self->size;} static Py_ssize_tmmap_buffer_getsegcount(mmap_object *self, Py_ssize_t *lenp){ CHECK_VALID(-1); if (lenp) *lenp = self->size; return 1;} static Py_ssize_tmmap_buffer_getcharbuffer(mmap_object *self, Py_ssize_t index, const void **ptr){ if (index != 0) { PyErr_SetString(PyExc_SystemError, "accessing non-existent buffer segment"); return -1; } *ptr = (const char *)self->data; return self->size;} static PyObject *mmap_object_getattr(mmap_object *self, char *name){ return Py_FindMethod(mmap_object_methods, (PyObject *)self, name);} static Py_ssize_tmmap_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 PyString_FromStringAndSize(self->data + i, 1);} static PyObject *mmap_slice(mmap_object *self, Py_ssize_t ilow, Py_ssize_t ihigh){ CHECK_VALID(NULL); if (ilow < 0) ilow = 0; else if ((size_t)ilow > self->size) ilow = self->size; if (ihigh < 0) ihigh = 0; if (ihigh < ilow) ihigh = ilow; else if ((size_t)ihigh > self->size) ihigh = self->size; return PyString_FromStringAndSize(self->data + ilow, ihigh-ilow);} 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 intmmap_ass_slice(mmap_object *self, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *v){ const char *buf; CHECK_VALID(-1); if (ilow < 0) ilow = 0; else if ((size_t)ilow > self->size) ilow = self->size; if (ihigh < 0) ihigh = 0; if (ihigh < ilow) ihigh = ilow; else if ((size_t)ihigh > self->size) ihigh = self->size; if (v == NULL) { PyErr_SetString(PyExc_TypeError, "mmap object doesn't support slice deletion"); return -1; } if (! (PyString_Check(v)) ) { PyErr_SetString(PyExc_IndexError, "mmap slice assignment must be a string"); return -1; } if (PyString_Size(v) != (ihigh - ilow)) { PyErr_SetString(PyExc_IndexError, "mmap slice assignment is wrong size"); return -1; } if (!is_writeable(self)) return -1; buf = PyString_AsString(v); memcpy(self->data + ilow, buf, ihigh-ilow); return 0;} static intmmap_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 (! (PyString_Check(v) && PyString_Size(v)==1) ) { PyErr_SetString(PyExc_IndexError, "mmap assignment must be single-character string"); return -1; } if (!is_writeable(self)) return -1; buf = PyString_AsString(v); self->data[i] = buf[0]; return 0;} 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*/ (ssizessizeargfunc)mmap_slice, /*sq_slice*/ (ssizeobjargproc)mmap_ass_item, /*sq_ass_item*/ (ssizessizeobjargproc)mmap_ass_slice, /*sq_ass_slice*/}; static PyBufferProcs mmap_as_buffer = { (readbufferproc)mmap_buffer_getreadbuf, (writebufferproc)mmap_buffer_getwritebuf, (segcountproc)mmap_buffer_getsegcount, (charbufferproc)mmap_buffer_getcharbuffer,}; static PyTypeObject mmap_object_type = { PyObject_HEAD_INIT(0) /* patched in module init */ 0, /* ob_size */ "mmap.mmap", /* tp_name */ sizeof(mmap_object), /* tp_size */ 0, /* tp_itemsize */ /* methods */ (destructor) mmap_object_dealloc, /* tp_dealloc */ 0, /* tp_print */ (getattrfunc) mmap_object_getattr, /* tp_getattr */ 0, /* tp_setattr */ 0, /* tp_compare */ 0, /* tp_repr */ 0, /* tp_as_number */ &mmap_as_sequence, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ &mmap_as_buffer, /*tp_as_buffer*/ Py_TPFLAGS_HAVE_GETCHARBUFFER, /*tp_flags*/ 0, /*tp_doc*/}; /* 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){ 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_SetString(PyExc_OverflowError, "memory mapped size must be positive"); return -1; } return i; } PyErr_SetString(PyExc_TypeError, "map size must be an integral value"); return -1;} #ifdef UNIXstatic PyObject *new_mmap_object(PyObject *self, 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; 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", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwdict, "iO|iii", keywords, &fd, &map_size_obj, &flags, &prot, &access)) return NULL; map_size = _GetMapSize(map_size_obj); if (map_size < 0) 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: /* use the specified or default values of flags and prot */ break; default: return PyErr_Format(PyExc_ValueError, "mmap invalid access parameter."); } #ifdef HAVE_FSTAT# ifdef __VMS /* on OpenVMS we must ensure that all bytes are written to the file */ fsync(fd);# endif if (fstat(fd, &st) == 0 && S_ISREG(st.st_mode)) { if (map_size == 0) { map_size = st.st_size; } else if ((size_t)map_size > st.st_size) { PyErr_SetString(PyExc_ValueError, "mmap length is greater than file size"); return NULL; } }#endif m_obj = PyObject_New(mmap_object, &mmap_object_type); if (m_obj == NULL) {return NULL;} m_obj->data = NULL; m_obj->size = (size_t) map_size; m_obj->pos = (size_t) 0; 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, 0); 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_WINDOWSstatic PyObject *new_mmap_object(PyObject *self, PyObject *args, PyObject *kwdict){ mmap_object *m_obj; PyObject *map_size_obj = NULL; Py_ssize_t map_size; DWORD size_hi; /* upper 32 bits of m_obj->size */ DWORD size_lo; /* lower 32 bits of m_obj->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", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwdict, "iO|zi", keywords, &fileno, &map_size_obj, &tagname, &access)) { 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); if (map_size < 0) 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?Lines 501–1000 of 1186. Previous lines Load more
return PyInt_FromLong(0); #endif /* UNIX */ } } 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, count; CHECK_VALID(NULL); if (!PyArg_ParseTuple(args, "kkk:move", &dest, &src, &count) || !is_writeable(self)) { return NULL; } else { /* bounds check the values */ if (/* end of source after end of data?? */ ((src+count) > self->size) /* dest will fit? */ || (dest+count > self->size)) { PyErr_SetString(PyExc_ValueError, "source or destination out of range"); return NULL; } else { memmove(self->data+dest, self->data+src, count); Py_INCREF(Py_None); return Py_None; } } } static struct PyMethodDef mmap_object_methods[] = { {"close", (PyCFunction) mmap_close_method, METH_NOARGS}, {"find", (PyCFunction) mmap_find_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}, {NULL, NULL} /* sentinel */ }; /* Functions for treating an mmap'ed file as a buffer */ static Py_ssize_t mmap_buffer_getreadbuf(mmap_object *self, Py_ssize_t index, const void **ptr) { CHECK_VALID(-1); if (index != 0) { PyErr_SetString(PyExc_SystemError, "Accessing non-existent mmap segment"); return -1; } *ptr = self->data; return self->size; } static Py_ssize_t mmap_buffer_getwritebuf(mmap_object *self, Py_ssize_t index, const void **ptr) { CHECK_VALID(-1); if (index != 0) { PyErr_SetString(PyExc_SystemError, "Accessing non-existent mmap segment"); return -1; } if (!is_writeable(self)) return -1; *ptr = self->data; return self->size; } static Py_ssize_t mmap_buffer_getsegcount(mmap_object *self, Py_ssize_t *lenp) { CHECK_VALID(-1); if (lenp) *lenp = self->size; return 1; } static Py_ssize_t mmap_buffer_getcharbuffer(mmap_object *self, Py_ssize_t index, const void **ptr) { if (index != 0) { PyErr_SetString(PyExc_SystemError, "accessing non-existent buffer segment"); return -1; } *ptr = (const char *)self->data; return self->size; } static PyObject * mmap_object_getattr(mmap_object *self, char *name) { return Py_FindMethod(mmap_object_methods, (PyObject *)self, name); } 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 PyString_FromStringAndSize(self->data + i, 1); } static PyObject * mmap_slice(mmap_object *self, Py_ssize_t ilow, Py_ssize_t ihigh) { CHECK_VALID(NULL); if (ilow < 0) ilow = 0; else if ((size_t)ilow > self->size) ilow = self->size; if (ihigh < 0) ihigh = 0; if (ihigh < ilow) ihigh = ilow; else if ((size_t)ihigh > self->size) ihigh = self->size; return PyString_FromStringAndSize(self->data + ilow, ihigh-ilow); } 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_slice(mmap_object *self, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *v) { const char *buf; CHECK_VALID(-1); if (ilow < 0) ilow = 0; else if ((size_t)ilow > self->size) ilow = self->size; if (ihigh < 0) ihigh = 0; if (ihigh < ilow) ihigh = ilow; else if ((size_t)ihigh > self->size) ihigh = self->size; if (v == NULL) { PyErr_SetString(PyExc_TypeError, "mmap object doesn't support slice deletion"); return -1; } if (! (PyString_Check(v)) ) { PyErr_SetString(PyExc_IndexError, "mmap slice assignment must be a string"); return -1; } if (PyString_Size(v) != (ihigh - ilow)) { PyErr_SetString(PyExc_IndexError, "mmap slice assignment is wrong size"); return -1; } if (!is_writeable(self)) return -1; buf = PyString_AsString(v); memcpy(self->data + ilow, buf, ihigh-ilow); return 0; } 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 (! (PyString_Check(v) && PyString_Size(v)==1) ) { PyErr_SetString(PyExc_IndexError, "mmap assignment must be single-character string"); return -1; } if (!is_writeable(self)) return -1; buf = PyString_AsString(v); self->data[i] = buf[0]; return 0; } 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*/ (ssizessizeargfunc)mmap_slice, /*sq_slice*/ (ssizeobjargproc)mmap_ass_item, /*sq_ass_item*/ (ssizessizeobjargproc)mmap_ass_slice, /*sq_ass_slice*/ }; static PyBufferProcs mmap_as_buffer = { (readbufferproc)mmap_buffer_getreadbuf, (writebufferproc)mmap_buffer_getwritebuf, (segcountproc)mmap_buffer_getsegcount, (charbufferproc)mmap_buffer_getcharbuffer, }; static PyTypeObject mmap_object_type = { PyObject_HEAD_INIT(0) /* patched in module init */ 0, /* ob_size */ "mmap.mmap", /* tp_name */ sizeof(mmap_object), /* tp_size */ 0, /* tp_itemsize */ /* methods */ (destructor) mmap_object_dealloc, /* tp_dealloc */ 0, /* tp_print */ (getattrfunc) mmap_object_getattr, /* tp_getattr */ 0, /* tp_setattr */ 0, /* tp_compare */ 0, /* tp_repr */ 0, /* tp_as_number */ &mmap_as_sequence, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ &mmap_as_buffer, /*tp_as_buffer*/ Py_TPFLAGS_HAVE_GETCHARBUFFER, /*tp_flags*/ 0, /*tp_doc*/ }; /* 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) { 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_SetString(PyExc_OverflowError, "memory mapped size must be positive"); return -1; } return i; } PyErr_SetString(PyExc_TypeError, "map size must be an integral value"); return -1; } #ifdef UNIX static PyObject * new_mmap_object(PyObject *self, 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; 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", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwdict, "iO|iii", keywords, &fd, &map_size_obj, &flags, &prot, &access)) return NULL; map_size = _GetMapSize(map_size_obj); if (map_size < 0) 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: /* use the specified or default values of flags and prot */ break; default: return PyErr_Format(PyExc_ValueError, "mmap invalid access parameter."); } #ifdef HAVE_FSTAT # ifdef __VMS /* on OpenVMS we must ensure that all bytes are written to the file */ fsync(fd); # endif if (fstat(fd, &st) == 0 && S_ISREG(st.st_mode)) { if (map_size == 0) { map_size = st.st_size; } else if ((size_t)map_size > st.st_size) { PyErr_SetString(PyExc_ValueError, "mmap length is greater than file size"); return NULL; } } #endif m_obj = PyObject_New(mmap_object, &mmap_object_type); if (m_obj == NULL) {return NULL;} m_obj->data = NULL; m_obj->size = (size_t) map_size; m_obj->pos = (size_t) 0; 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, 0); 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 static PyObject * new_mmap_object(PyObject *self, PyObject *args, PyObject *kwdict) { mmap_object *m_obj; PyObject *map_size_obj = NULL; Py_ssize_t map_size; DWORD size_hi; /* upper 32 bits of m_obj->size */ DWORD size_lo; /* lower 32 bits of m_obj->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", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwdict, "iO|zi", keywords, &fileno, &map_size_obj, &tagname, &access)) { 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); if (map_size < 0) 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?