diff options
Diffstat (limited to 'Modules/_pickle.c')
| -rw-r--r-- | Modules/_pickle.c | 4546 |
1 files changed, 0 insertions, 4546 deletions
diff --git a/Modules/_pickle.c b/Modules/_pickle.c deleted file mode 100644 index 730c073..0000000 --- a/Modules/_pickle.c +++ /dev/null @@ -1,4546 +0,0 @@ -#include "Python.h" -#include "structmember.h" - -PyDoc_STRVAR(pickle_module_doc, -"Optimized C implementation for the Python pickle module."); - -/* Bump this when new opcodes are added to the pickle protocol. */ -enum { - HIGHEST_PROTOCOL = 3, - DEFAULT_PROTOCOL = 3 -}; - - -/* Pickle opcodes. These must be kept updated with pickle.py. - Extensive docs are in pickletools.py. */ -enum opcode { - MARK = '(', - STOP = '.', - POP = '0', - POP_MARK = '1', - DUP = '2', - FLOAT = 'F', - INT = 'I', - BININT = 'J', - BININT1 = 'K', - LONG = 'L', - BININT2 = 'M', - NONE = 'N', - PERSID = 'P', - BINPERSID = 'Q', - REDUCE = 'R', - STRING = 'S', - BINSTRING = 'T', - SHORT_BINSTRING = 'U', - UNICODE = 'V', - BINUNICODE = 'X', - APPEND = 'a', - BUILD = 'b', - GLOBAL = 'c', - DICT = 'd', - EMPTY_DICT = '}', - APPENDS = 'e', - GET = 'g', - BINGET = 'h', - INST = 'i', - LONG_BINGET = 'j', - LIST = 'l', - EMPTY_LIST = ']', - OBJ = 'o', - PUT = 'p', - BINPUT = 'q', - LONG_BINPUT = 'r', - SETITEM = 's', - TUPLE = 't', - EMPTY_TUPLE = ')', - SETITEMS = 'u', - BINFLOAT = 'G', - - /* Protocol 2. */ - PROTO = '\x80', - NEWOBJ = '\x81', - EXT1 = '\x82', - EXT2 = '\x83', - EXT4 = '\x84', - TUPLE1 = '\x85', - TUPLE2 = '\x86', - TUPLE3 = '\x87', - NEWTRUE = '\x88', - NEWFALSE = '\x89', - LONG1 = '\x8a', - LONG4 = '\x8b', - - /* Protocol 3 (Python 3.x) */ - BINBYTES = 'B', - SHORT_BINBYTES = 'C', -}; - -/* These aren't opcodes -- they're ways to pickle bools before protocol 2 - * so that unpicklers written before bools were introduced unpickle them - * as ints, but unpicklers after can recognize that bools were intended. - * Note that protocol 2 added direct ways to pickle bools. - */ -#undef TRUE -#define TRUE "I01\n" -#undef FALSE -#define FALSE "I00\n" - -enum { - /* Keep in synch with pickle.Pickler._BATCHSIZE. This is how many elements - batch_list/dict() pumps out before doing APPENDS/SETITEMS. Nothing will - break if this gets out of synch with pickle.py, but it's unclear that would - help anything either. */ - BATCHSIZE = 1000, - - /* Nesting limit until Pickler, when running in "fast mode", starts - checking for self-referential data-structures. */ - FAST_NESTING_LIMIT = 50, - - /* Size of the write buffer of Pickler. Higher values will reduce the - number of calls to the write() method of the output stream. */ - WRITE_BUF_SIZE = 256, -}; - -/* Exception classes for pickle. These should override the ones defined in - pickle.py, when the C-optimized Pickler and Unpickler are used. */ -static PyObject *PickleError; -static PyObject *PicklingError; -static PyObject *UnpicklingError; - -/* copyreg.dispatch_table, {type_object: pickling_function} */ -static PyObject *dispatch_table; -/* For EXT[124] opcodes. */ -/* copyreg._extension_registry, {(module_name, function_name): code} */ -static PyObject *extension_registry; -/* copyreg._inverted_registry, {code: (module_name, function_name)} */ -static PyObject *inverted_registry; -/* copyreg._extension_cache, {code: object} */ -static PyObject *extension_cache; - -/* XXX: Are these really nescessary? */ -/* As the name says, an empty tuple. */ -static PyObject *empty_tuple; -/* For looking up name pairs in copyreg._extension_registry. */ -static PyObject *two_tuple; - -static int -stack_underflow(void) -{ - PyErr_SetString(UnpicklingError, "unpickling stack underflow"); - return -1; -} - -/* Internal data type used as the unpickling stack. */ -typedef struct { - PyObject_HEAD - int length; /* number of initial slots in data currently used */ - int size; /* number of slots in data allocated */ - PyObject **data; -} Pdata; - -static void -Pdata_dealloc(Pdata *self) -{ - int i; - PyObject **p; - - for (i = self->length, p = self->data; --i >= 0; p++) { - Py_DECREF(*p); - } - if (self->data) - PyMem_Free(self->data); - PyObject_Del(self); -} - -static PyTypeObject Pdata_Type = { - PyVarObject_HEAD_INIT(NULL, 0) - "_pickle.Pdata", /*tp_name*/ - sizeof(Pdata), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - (destructor)Pdata_dealloc, /*tp_dealloc*/ -}; - -static PyObject * -Pdata_New(void) -{ - Pdata *self; - - if (!(self = PyObject_New(Pdata, &Pdata_Type))) - return NULL; - self->size = 8; - self->length = 0; - self->data = PyMem_Malloc(self->size * sizeof(PyObject *)); - if (self->data) - return (PyObject *)self; - Py_DECREF(self); - return PyErr_NoMemory(); -} - - -/* Retain only the initial clearto items. If clearto >= the current - * number of items, this is a (non-erroneous) NOP. - */ -static int -Pdata_clear(Pdata *self, int clearto) -{ - int i; - PyObject **p; - - if (clearto < 0) - return stack_underflow(); - if (clearto >= self->length) - return 0; - - for (i = self->length, p = self->data + clearto; --i >= clearto; p++) { - Py_CLEAR(*p); - } - self->length = clearto; - - return 0; -} - -static int -Pdata_grow(Pdata *self) -{ - int bigger; - size_t nbytes; - PyObject **tmp; - - bigger = (self->size << 1) + 1; - if (bigger <= 0) /* was 0, or new value overflows */ - goto nomemory; - if ((int)(size_t)bigger != bigger) - goto nomemory; - nbytes = (size_t)bigger * sizeof(PyObject *); - if (nbytes / sizeof(PyObject *) != (size_t)bigger) - goto nomemory; - tmp = PyMem_Realloc(self->data, nbytes); - if (tmp == NULL) - goto nomemory; - self->data = tmp; - self->size = bigger; - return 0; - - nomemory: - PyErr_NoMemory(); - return -1; -} - -/* D is a Pdata*. Pop the topmost element and store it into V, which - * must be an lvalue holding PyObject*. On stack underflow, UnpicklingError - * is raised and V is set to NULL. - */ -static PyObject * -Pdata_pop(Pdata *self) -{ - if (self->length == 0) { - PyErr_SetString(UnpicklingError, "bad pickle data"); - return NULL; - } - return self->data[--(self->length)]; -} -#define PDATA_POP(D, V) do { (V) = Pdata_pop((D)); } while (0) - -static int -Pdata_push(Pdata *self, PyObject *obj) -{ - if (self->length == self->size && Pdata_grow(self) < 0) { - return -1; - } - self->data[self->length++] = obj; - return 0; -} - -/* Push an object on stack, transferring its ownership to the stack. */ -#define PDATA_PUSH(D, O, ER) do { \ - if (Pdata_push((D), (O)) < 0) return (ER); } while(0) - -/* Push an object on stack, adding a new reference to the object. */ -#define PDATA_APPEND(D, O, ER) do { \ - Py_INCREF((O)); \ - if (Pdata_push((D), (O)) < 0) return (ER); } while(0) - -static PyObject * -Pdata_poptuple(Pdata *self, Py_ssize_t start) -{ - PyObject *tuple; - Py_ssize_t len, i, j; - - len = self->length - start; - tuple = PyTuple_New(len); - if (tuple == NULL) - return NULL; - for (i = start, j = 0; j < len; i++, j++) - PyTuple_SET_ITEM(tuple, j, self->data[i]); - - self->length = start; - return tuple; -} - -static PyObject * -Pdata_poplist(Pdata *self, Py_ssize_t start) -{ - PyObject *list; - Py_ssize_t len, i, j; - - len = self->length - start; - list = PyList_New(len); - if (list == NULL) - return NULL; - for (i = start, j = 0; j < len; i++, j++) - PyList_SET_ITEM(list, j, self->data[i]); - - self->length = start; - return list; -} - -typedef struct PicklerObject { - PyObject_HEAD - PyObject *write; /* write() method of the output stream */ - PyObject *memo; /* Memo dictionary, keep track of the seen - objects to support self-referential objects - pickling. */ - PyObject *pers_func; /* persistent_id() method, can be NULL */ - PyObject *arg; - int proto; /* Pickle protocol number, >= 0 */ - int bin; /* Boolean, true if proto > 0 */ - int nesting; /* Current nesting level, this is to guard - save() from going into infinite recursion - and segfaulting. */ - int buf_size; /* Size of the current buffered pickle data */ - char *write_buf; /* Write buffer, this is to avoid calling the - write() method of the output stream too - often. */ - int fast; /* Enable fast mode if set to a true value. - The fast mode disable the usage of memo, - therefore speeding the pickling process by - not generating superfluous PUT opcodes. It - should not be used if with self-referential - objects. */ - int fast_nesting; - PyObject *fast_memo; -} PicklerObject; - -typedef struct UnpicklerObject { - PyObject_HEAD - Pdata *stack; /* Pickle data stack, store unpickled objects. */ - PyObject *readline; /* readline() method of the output stream */ - PyObject *read; /* read() method of the output stream */ - PyObject *memo; /* Memo dictionary, provide the objects stored - using the PUT opcodes. */ - PyObject *arg; - PyObject *pers_func; /* persistent_load() method, can be NULL. */ - PyObject *last_string; /* Reference to the last string read by the - readline() method. */ - char *buffer; /* Reading buffer. */ - char *encoding; /* Name of the encoding to be used for - decoding strings pickled using Python - 2.x. The default value is "ASCII" */ - char *errors; /* Name of errors handling scheme to used when - decoding strings. The default value is - "strict". */ - int *marks; /* Mark stack, used for unpickling container - objects. */ - Py_ssize_t num_marks; /* Number of marks in the mark stack. */ - Py_ssize_t marks_size; /* Current allocated size of the mark stack. */ -} UnpicklerObject; - -/* Forward declarations */ -static int save(PicklerObject *, PyObject *, int); -static int save_reduce(PicklerObject *, PyObject *, PyObject *); -static PyTypeObject Pickler_Type; -static PyTypeObject Unpickler_Type; - - -/* Helpers for creating the argument tuple passed to functions. This has the - performance advantage of calling PyTuple_New() only once. */ - -#define ARG_TUP(self, obj) do { \ - if ((self)->arg || ((self)->arg=PyTuple_New(1))) { \ - Py_XDECREF(PyTuple_GET_ITEM((self)->arg, 0)); \ - PyTuple_SET_ITEM((self)->arg, 0, (obj)); \ - } \ - else { \ - Py_DECREF((obj)); \ - } \ - } while (0) - -#define FREE_ARG_TUP(self) do { \ - if ((self)->arg->ob_refcnt > 1) \ - Py_CLEAR((self)->arg); \ - } while (0) - -/* A temporary cleaner API for fast single argument function call. - - XXX: Does caching the argument tuple provides any real performance benefits? - - A quick benchmark, on a 2.0GHz Athlon64 3200+ running Linux 2.6.24 with - glibc 2.7, tells me that it takes roughly 20,000,000 PyTuple_New(1) calls - when the tuple is retrieved from the freelist (i.e, call PyTuple_New() then - immediately DECREF it) and 1,200,000 calls when allocating brand new tuples - (i.e, call PyTuple_New() and store the returned value in an array), to save - one second (wall clock time). Either ways, the loading time a pickle stream - large enough to generate this number of calls would be massively - overwhelmed by other factors, like I/O throughput, the GC traversal and - object allocation overhead. So, I really doubt these functions provide any - real benefits. - - On the other hand, oprofile reports that pickle spends a lot of time in - these functions. But, that is probably more related to the function call - overhead, than the argument tuple allocation. - - XXX: And, what is the reference behavior of these? Steal, borrow? At first - glance, it seems to steal the reference of 'arg' and borrow the reference - of 'func'. - */ -static PyObject * -pickler_call(PicklerObject *self, PyObject *func, PyObject *arg) -{ - PyObject *result = NULL; - - ARG_TUP(self, arg); - if (self->arg) { - result = PyObject_Call(func, self->arg, NULL); - FREE_ARG_TUP(self); - } - return result; -} - -static PyObject * -unpickler_call(UnpicklerObject *self, PyObject *func, PyObject *arg) -{ - PyObject *result = NULL; - - ARG_TUP(self, arg); - if (self->arg) { - result = PyObject_Call(func, self->arg, NULL); - FREE_ARG_TUP(self); - } - return result; -} - -static Py_ssize_t -pickler_write(PicklerObject *self, const char *s, Py_ssize_t n) -{ - PyObject *data, *result; - - if (s == NULL) { - if (!(self->buf_size)) - return 0; - data = PyBytes_FromStringAndSize(self->write_buf, self->buf_size); - if (data == NULL) - return -1; - } - else { - if (self->buf_size && (n + self->buf_size) > WRITE_BUF_SIZE) { - if (pickler_write(self, NULL, 0) < 0) - return -1; - } - - if (n > WRITE_BUF_SIZE) { - if (!(data = PyBytes_FromStringAndSize(s, n))) - return -1; - } - else { - memcpy(self->write_buf + self->buf_size, s, n); - self->buf_size += n; - return n; - } - } - - /* object with write method */ - result = pickler_call(self, self->write, data); - if (result == NULL) - return -1; - - Py_DECREF(result); - self->buf_size = 0; - return n; -} - -/* XXX: These read/readline functions ought to be optimized. Buffered I/O - might help a lot, especially with the new (but much slower) io library. - On the other hand, the added complexity might not worth it. - */ - -/* Read at least n characters from the input stream and set s to the current - reading position. */ -static Py_ssize_t -unpickler_read(UnpicklerObject *self, char **s, Py_ssize_t n) -{ - PyObject *len; - PyObject *data; - - len = PyLong_FromSsize_t(n); - if (len == NULL) - return -1; - - data = unpickler_call(self, self->read, len); - if (data == NULL) - return -1; - - /* XXX: Should bytearray be supported too? */ - if (!PyBytes_Check(data)) { - PyErr_SetString(PyExc_ValueError, - "read() from the underlying stream did not" - "return bytes"); - return -1; - } - - Py_XDECREF(self->last_string); - self->last_string = data; - - if (!(*s = PyBytes_AS_STRING(data))) - return -1; - - return n; -} - -static Py_ssize_t -unpickler_readline(UnpicklerObject *self, char **s) -{ - PyObject *data; - - data = PyObject_CallObject(self->readline, empty_tuple); - if (data == NULL) - return -1; - - /* XXX: Should bytearray be supported too? */ - if (!PyBytes_Check(data)) { - PyErr_SetString(PyExc_ValueError, - "readline() from the underlying stream did not" - "return bytes"); - return -1; - } - - Py_XDECREF(self->last_string); - self->last_string = data; - - if (!(*s = PyBytes_AS_STRING(data))) - return -1; - - return PyBytes_GET_SIZE(data); -} - -/* Generate a GET opcode for an object stored in the memo. The 'key' argument - should be the address of the object as returned by PyLong_FromVoidPtr(). */ -static int -memo_get(PicklerObject *self, PyObject *key) -{ - PyObject *value; - PyObject *memo_id; - long x; - char pdata[30]; - int len; - - value = PyDict_GetItemWithError(self->memo, key); - if (value == NULL) { - if (!PyErr_Occurred()) - PyErr_SetObject(PyExc_KeyError, key); - return -1; - } - - memo_id = PyTuple_GetItem(value, 0); - if (memo_id == NULL) - return -1; - - if (!PyLong_Check(memo_id)) { - PyErr_SetString(PicklingError, "memo id must be an integer"); - return -1; - } - x = PyLong_AsLong(memo_id); - if (x == -1 && PyErr_Occurred()) - return -1; - - if (!self->bin) { - pdata[0] = GET; - PyOS_snprintf(pdata + 1, sizeof(pdata) - 1, "%ld\n", x); - len = (int)strlen(pdata); - } - else { - if (x < 256) { - pdata[0] = BINGET; - pdata[1] = (unsigned char)(x & 0xff); - len = 2; - } - else if (x <= 0xffffffffL) { - pdata[0] = LONG_BINGET; - pdata[1] = (unsigned char)(x & 0xff); - pdata[2] = (unsigned char)((x >> 8) & 0xff); - pdata[3] = (unsigned char)((x >> 16) & 0xff); - pdata[4] = (unsigned char)((x >> 24) & 0xff); - len = 5; - } - else { /* unlikely */ - PyErr_SetString(PicklingError, - "memo id too large for LONG_BINGET"); - return -1; - } - } - - if (pickler_write(self, pdata, len) < 0) - return -1; - - return 0; -} - -/* Store an object in the memo, assign it a new unique ID based on the number - of objects currently stored in the memo and generate a PUT opcode. */ -static int -memo_put(PicklerObject *self, PyObject *obj) -{ - PyObject *key = NULL; - PyObject *memo_id = NULL; - PyObject *tuple = NULL; - long x; - char pdata[30]; - int len; - int status = 0; - - if (self->fast) - return 0; - - key = PyLong_FromVoidPtr(obj); - if (key == NULL) - goto error; - if ((x = PyDict_Size(self->memo)) < 0) - goto error; - memo_id = PyLong_FromLong(x); - if (memo_id == NULL) - goto error; - tuple = PyTuple_New(2); - if (tuple == NULL) - goto error; - - Py_INCREF(memo_id); - PyTuple_SET_ITEM(tuple, 0, memo_id); - Py_INCREF(obj); - PyTuple_SET_ITEM(tuple, 1, obj); - if (PyDict_SetItem(self->memo, key, tuple) < 0) - goto error; - - if (!self->bin) { - pdata[0] = PUT; - PyOS_snprintf(pdata + 1, sizeof(pdata) - 1, "%ld\n", x); - len = strlen(pdata); - } - else { - if (x < 256) { - pdata[0] = BINPUT; - pdata[1] = x; - len = 2; - } - else if (x <= 0xffffffffL) { - pdata[0] = LONG_BINPUT; - pdata[1] = (unsigned char)(x & 0xff); - pdata[2] = (unsigned char)((x >> 8) & 0xff); - pdata[3] = (unsigned char)((x >> 16) & 0xff); - pdata[4] = (unsigned char)((x >> 24) & 0xff); - len = 5; - } - else { /* unlikely */ - PyErr_SetString(PicklingError, - "memo id too large for LONG_BINPUT"); - return -1; - } - } - - if (pickler_write(self, pdata, len) < 0) - goto error; - - if (0) { - error: - status = -1; - } - - Py_XDECREF(key); - Py_XDECREF(memo_id); - Py_XDECREF(tuple); - - return status; -} - -static PyObject * -whichmodule(PyObject *global, PyObject *global_name) -{ - Py_ssize_t i, j; - static PyObject *module_str = NULL; - static PyObject *main_str = NULL; - PyObject *module_name; - PyObject *modules_dict; - PyObject *module; - PyObject *obj; - - if (module_str == NULL) { - module_str = PyUnicode_InternFromString("__module__"); - if (module_str == NULL) - return NULL; - main_str = PyUnicode_InternFromString("__main__"); - if (main_str == NULL) - return NULL; - } - - module_name = PyObject_GetAttr(global, module_str); - - /* In some rare cases (e.g., random.getrandbits), __module__ can be - None. If it is so, then search sys.modules for the module of - global. */ - if (module_name == Py_None) { - Py_DECREF(module_name); - goto search; - } - - if (module_name) { - return module_name; - } - if (PyErr_ExceptionMatches(PyExc_AttributeError)) - PyErr_Clear(); - else - return NULL; - - search: - modules_dict = PySys_GetObject("modules"); - if (modules_dict == NULL) - return NULL; - - i = 0; - module_name = NULL; - while ((j = PyDict_Next(modules_dict, &i, &module_name, &module))) { - if (PyObject_Compare(module_name, main_str) == 0) - continue; - - obj = PyObject_GetAttr(module, global_name); - if (obj == NULL) { - if (PyErr_ExceptionMatches(PyExc_AttributeError)) - PyErr_Clear(); - else - return NULL; - continue; - } - - if (obj != global) { - Py_DECREF(obj); - continue; - } - - Py_DECREF(obj); - break; - } - - /* If no module is found, use __main__. */ - if (!j) { - module_name = main_str; - } - - Py_INCREF(module_name); - return module_name; -} - -/* fast_save_enter() and fast_save_leave() are guards against recursive - objects when Pickler is used with the "fast mode" (i.e., with object - memoization disabled). If the nesting of a list or dict object exceed - FAST_NESTING_LIMIT, these guards will start keeping an internal - reference to the seen list or dict objects and check whether these objects - are recursive. These are not strictly necessary, since save() has a - hard-coded recursion limit, but they give a nicer error message than the - typical RuntimeError. */ -static int -fast_save_enter(PicklerObject *self, PyObject *obj) -{ - /* if fast_nesting < 0, we're doing an error exit. */ - if (++self->fast_nesting >= FAST_NESTING_LIMIT) { - PyObject *key = NULL; - if (self->fast_memo == NULL) { - self->fast_memo = PyDict_New(); - if (self->fast_memo == NULL) { - self->fast_nesting = -1; - return 0; - } - } - key = PyLong_FromVoidPtr(obj); - if (key == NULL) - return 0; - if (PyDict_GetItem(self->fast_memo, key)) { - Py_DECREF(key); - PyErr_Format(PyExc_ValueError, - "fast mode: can't pickle cyclic objects " - "including object type %.200s at %p", - obj->ob_type->tp_name, obj); - self->fast_nesting = -1; - return 0; - } - if (PyDict_SetItem(self->fast_memo, key, Py_None) < 0) { - Py_DECREF(key); - self->fast_nesting = -1; - return 0; - } - Py_DECREF(key); - } - return 1; -} - -static int -fast_save_leave(PicklerObject *self, PyObject *obj) -{ - if (self->fast_nesting-- >= FAST_NESTING_LIMIT) { - PyObject *key = PyLong_FromVoidPtr(obj); - if (key == NULL) - return 0; - if (PyDict_DelItem(self->fast_memo, key) < 0) { - Py_DECREF(key); - return 0; - } - Py_DECREF(key); - } - return 1; -} - -static int -save_none(PicklerObject *self, PyObject *obj) -{ - const char none_op = NONE; - if (pickler_write(self, &none_op, 1) < 0) - return -1; - - return 0; -} - -static int -save_bool(PicklerObject *self, PyObject *obj) -{ - static const char *buf[2] = { FALSE, TRUE }; - const char len[2] = {sizeof(FALSE) - 1, sizeof(TRUE) - 1}; - int p = (obj == Py_True); - - if (self->proto >= 2) { - const char bool_op = p ? NEWTRUE : NEWFALSE; - if (pickler_write(self, &bool_op, 1) < 0) - return -1; - } - else if (pickler_write(self, buf[p], len[p]) < 0) - return -1; - - return 0; -} - -static int -save_int(PicklerObject *self, long x) -{ - char pdata[32]; - int len = 0; - - if (!self->bin -#if SIZEOF_LONG > 4 - || x > 0x7fffffffL || x < -0x80000000L -#endif - ) { - /* Text-mode pickle, or long too big to fit in the 4-byte - * signed BININT format: store as a string. - */ - pdata[0] = LONG; /* use LONG for consistence with pickle.py */ - PyOS_snprintf(pdata + 1, sizeof(pdata) - 1, "%ld\n", x); - if (pickler_write(self, pdata, strlen(pdata)) < 0) - return -1; - } - else { - /* Binary pickle and x fits in a signed 4-byte int. */ - pdata[1] = (unsigned char)(x & 0xff); - pdata[2] = (unsigned char)((x >> 8) & 0xff); - pdata[3] = (unsigned char)((x >> 16) & 0xff); - pdata[4] = (unsigned char)((x >> 24) & 0xff); - - if ((pdata[4] == 0) && (pdata[3] == 0)) { - if (pdata[2] == 0) { - pdata[0] = BININT1; - len = 2; - } - else { - pdata[0] = BININT2; - len = 3; - } - } - else { - pdata[0] = BININT; - len = 5; - } - - if (pickler_write(self, pdata, len) < 0) - return -1; - } - - return 0; -} - -static int -save_long(PicklerObject *self, PyObject *obj) -{ - PyObject *repr = NULL; - Py_ssize_t size; - long val = PyLong_AsLong(obj); - int status = 0; - - const char long_op = LONG; - - if (val == -1 && PyErr_Occurred()) { - /* out of range for int pickling */ - PyErr_Clear(); - } - else - return save_int(self, val); - - if (self->proto >= 2) { - /* Linear-time pickling. */ - size_t nbits; - size_t nbytes; - unsigned char *pdata; - char header[5]; - int i; - int sign = _PyLong_Sign(obj); - - if (sign == 0) { - header[0] = LONG1; - header[1] = 0; /* It's 0 -- an empty bytestring. */ - if (pickler_write(self, header, 2) < 0) - goto error; - return 0; - } - nbits = _PyLong_NumBits(obj); - if (nbits == (size_t)-1 && PyErr_Occurred()) - goto error; - /* How many bytes do we need? There are nbits >> 3 full - * bytes of data, and nbits & 7 leftover bits. If there - * are any leftover bits, then we clearly need another - * byte. Wnat's not so obvious is that we *probably* - * need another byte even if there aren't any leftovers: - * the most-significant bit of the most-significant byte - * acts like a sign bit, and it's usually got a sense - * opposite of the one we need. The exception is longs - * of the form -(2**(8*j-1)) for j > 0. Such a long is - * its own 256's-complement, so has the right sign bit - * even without the extra byte. That's a pain to check - * for in advance, though, so we always grab an extra - * byte at the start, and cut it back later if possible. - */ - nbytes = (nbits >> 3) + 1; - if (nbytes > INT_MAX) { - PyErr_SetString(PyExc_OverflowError, - "long too large to pickle"); - goto error; - } - repr = PyUnicode_FromStringAndSize(NULL, (int)nbytes); - if (repr == NULL) - goto error; - pdata = (unsigned char *)PyUnicode_AsString(repr); - i = _PyLong_AsByteArray((PyLongObject *)obj, - pdata, nbytes, - 1 /* little endian */ , 1 /* signed */ ); - if (i < 0) - goto error; - /* If the long is negative, this may be a byte more than - * needed. This is so iff the MSB is all redundant sign - * bits. - */ - if (sign < 0 && - nbytes > 1 && - pdata[nbytes - 1] == 0xff && - (pdata[nbytes - 2] & 0x80) != 0) { - nbytes--; - } - - if (nbytes < 256) { - header[0] = LONG1; - header[1] = (unsigned char)nbytes; - size = 2; - } - else { - header[0] = LONG4; - size = (int)nbytes; - for (i = 1; i < 5; i++) { - header[i] = (unsigned char)(size & 0xff); - size >>= 8; - } - size = 5; - } - if (pickler_write(self, header, size) < 0 || - pickler_write(self, (char *)pdata, (int)nbytes) < 0) - goto error; - } - else { - char *string; - - /* proto < 2: write the repr and newline. This is quadratic-time - (in the number of digits), in both directions. */ - - repr = PyObject_Repr(obj); - if (repr == NULL) - goto error; - - string = PyUnicode_AsStringAndSize(repr, &size); - if (string == NULL) - goto error; - - if (pickler_write(self, &long_op, 1) < 0 || - pickler_write(self, string, size) < 0 || - pickler_write(self, "\n", 1) < 0) - goto error; - } - - if (0) { - error: - status = -1; - } - Py_XDECREF(repr); - - return status; -} - -static int -save_float(PicklerObject *self, PyObject *obj) -{ - double x = PyFloat_AS_DOUBLE((PyFloatObject *)obj); - - if (self->bin) { - char pdata[9]; - pdata[0] = BINFLOAT; - if (_PyFloat_Pack8(x, (unsigned char *)&pdata[1], 0) < 0) - return -1; - if (pickler_write(self, pdata, 9) < 0) - return -1; - } - else { - char pdata[250]; - pdata[0] = FLOAT; - PyOS_ascii_formatd(pdata + 1, sizeof(pdata) - 2, "%.17g", x); - /* Extend the formatted string with a newline character */ - strcat(pdata, "\n"); - - if (pickler_write(self, pdata, strlen(pdata)) < 0) - return -1; - } - - return 0; -} - -static int -save_bytes(PicklerObject *self, PyObject *obj) -{ - if (self->proto < 3) { - /* Older pickle protocols do not have an opcode for pickling bytes - objects. Therefore, we need to fake the copy protocol (i.e., - the __reduce__ method) to permit bytes object unpickling. */ - PyObject *reduce_value = NULL; - PyObject *bytelist = NULL; - int status; - - bytelist = PySequence_List(obj); - if (bytelist == NULL) - return -1; - - reduce_value = Py_BuildValue("(O(O))", (PyObject *)&PyBytes_Type, - bytelist); - if (reduce_value == NULL) { - Py_DECREF(bytelist); - return -1; - } - - /* save_reduce() will memoize the object automatically. */ - status = save_reduce(self, reduce_value, obj); - Py_DECREF(reduce_value); - Py_DECREF(bytelist); - return status; - } - else { - Py_ssize_t size; - char header[5]; - int len; - - size = PyBytes_Size(obj); - if (size < 0) - return -1; - - if (size < 256) { - header[0] = SHORT_BINBYTES; - header[1] = (unsigned char)size; - len = 2; - } - else if (size <= 0xffffffffL) { - header[0] = BINBYTES; - header[1] = (unsigned char)(size & 0xff); - header[2] = (unsigned char)((size >> 8) & 0xff); - header[3] = (unsigned char)((size >> 16) & 0xff); - header[4] = (unsigned char)((size >> 24) & 0xff); - len = 5; - } - else { - return -1; /* string too large */ - } - - if (pickler_write(self, header, len) < 0) - return -1; - - if (pickler_write(self, PyBytes_AS_STRING(obj), size) < 0) - return -1; - - if (memo_put(self, obj) < 0) - return -1; - - return 0; - } -} - -/* A copy of PyUnicode_EncodeRawUnicodeEscape() that also translates - backslash and newline characters to \uXXXX escapes. */ -static PyObject * -raw_unicode_escape(const Py_UNICODE *s, Py_ssize_t size) -{ - PyObject *repr, *result; - char *p; - char *q; - - static const char *hexdigits = "0123456789abcdef"; - -#ifdef Py_UNICODE_WIDE - repr = PyBytes_FromStringAndSize(NULL, 10 * size); -#else - repr = PyBytes_FromStringAndSize(NULL, 6 * size); -#endif - if (repr == NULL) - return NULL; - if (size == 0) - goto done; - - p = q = PyBytes_AS_STRING(repr); - while (size-- > 0) { - Py_UNICODE ch = *s++; -#ifdef Py_UNICODE_WIDE - /* Map 32-bit characters to '\Uxxxxxxxx' */ - if (ch >= 0x10000) { - *p++ = '\\'; - *p++ = 'U'; - *p++ = hexdigits[(ch >> 28) & 0xf]; - *p++ = hexdigits[(ch >> 24) & 0xf]; - *p++ = hexdigits[(ch >> 20) & 0xf]; - *p++ = hexdigits[(ch >> 16) & 0xf]; - *p++ = hexdigits[(ch >> 12) & 0xf]; - *p++ = hexdigits[(ch >> 8) & 0xf]; - *p++ = hexdigits[(ch >> 4) & 0xf]; - *p++ = hexdigits[ch & 15]; - } - else -#endif - /* Map 16-bit characters to '\uxxxx' */ - if (ch >= 256 || ch == '\\' || ch == '\n') { - *p++ = '\\'; - *p++ = 'u'; - *p++ = hexdigits[(ch >> 12) & 0xf]; - *p++ = hexdigits[(ch >> 8) & 0xf]; - *p++ = hexdigits[(ch >> 4) & 0xf]; - *p++ = hexdigits[ch & 15]; - } - /* Copy everything else as-is */ - else - *p++ = (char) ch; - } - size = p - q; - - done: - result = PyBytes_FromStringAndSize(PyBytes_AS_STRING(repr), size); - Py_DECREF(repr); - return result; -} - -static int -save_unicode(PicklerObject *self, PyObject *obj) -{ - Py_ssize_t size; - PyObject *encoded = NULL; - - if (self->bin) { - char pdata[5]; - - encoded = PyUnicode_AsUTF8String(obj); - if (encoded == NULL) - goto error; - - size = PyBytes_GET_SIZE(encoded); - if (size < 0 || size > 0xffffffffL) - goto error; /* string too large */ - - pdata[0] = BINUNICODE; - pdata[1] = (unsigned char)(size & 0xff); - pdata[2] = (unsigned char)((size >> 8) & 0xff); - pdata[3] = (unsigned char)((size >> 16) & 0xff); - pdata[4] = (unsigned char)((size >> 24) & 0xff); - - if (pickler_write(self, pdata, 5) < 0) - goto error; - - if (pickler_write(self, PyBytes_AS_STRING(encoded), size) < 0) - goto error; - } - else { - const char unicode_op = UNICODE; - - encoded = raw_unicode_escape(PyUnicode_AS_UNICODE(obj), - PyUnicode_GET_SIZE(obj)); - if (encoded == NULL) - goto error; - - if (pickler_write(self, &unicode_op, 1) < 0) - goto error; - - size = PyBytes_GET_SIZE(encoded); - if (pickler_write(self, PyBytes_AS_STRING(encoded), size) < 0) - goto error; - - if (pickler_write(self, "\n", 1) < 0) - goto error; - } - if (memo_put(self, obj) < 0) - goto error; - - Py_DECREF(encoded); - return 0; - - error: - Py_XDECREF(encoded); - return -1; -} - -/* A helper for save_tuple. Push the len elements in tuple t on the stack. */ -static int -store_tuple_elements(PicklerObject *self, PyObject *t, int len) -{ - int i; - - assert(PyTuple_Size(t) == len); - - for (i = 0; i < len; i++) { - PyObject *element = PyTuple_GET_ITEM(t, i); - - if (element == NULL) - return -1; - if (save(self, element, 0) < 0) - return -1; - } - - return 0; -} - -/* Tuples are ubiquitous in the pickle protocols, so many techniques are - * used across protocols to minimize the space needed to pickle them. - * Tuples are also the only builtin immutable type that can be recursive - * (a tuple can be reached from itself), and that requires some subtle - * magic so that it works in all cases. IOW, this is a long routine. - */ -static int -save_tuple(PicklerObject *self, PyObject *obj) -{ - PyObject *memo_key = NULL; - int len, i; - int status = 0; - - const char mark_op = MARK; - const char tuple_op = TUPLE; - const char pop_op = POP; - const char pop_mark_op = POP_MARK; - const char len2opcode[] = {EMPTY_TUPLE, TUPLE1, TUPLE2, TUPLE3}; - - if ((len = PyTuple_Size(obj)) < 0) - return -1; - - if (len == 0) { - char pdata[2]; - - if (self->proto) { - pdata[0] = EMPTY_TUPLE; - len = 1; - } - else { - pdata[0] = MARK; - pdata[1] = TUPLE; - len = 2; - } - if (pickler_write(self, pdata, len) < 0) - return -1; - return 0; - } - - /* id(tuple) isn't in the memo now. If it shows up there after - * saving the tuple elements, the tuple must be recursive, in - * which case we'll pop everything we put on the stack, and fetch - * its value from the memo. - */ - memo_key = PyLong_FromVoidPtr(obj); - if (memo_key == NULL) - return -1; - - if (len <= 3 && self->proto >= 2) { - /* Use TUPLE{1,2,3} opcodes. */ - if (store_tuple_elements(self, obj, len) < 0) - goto error; - - if (PyDict_GetItem(self->memo, memo_key)) { - /* pop the len elements */ - for (i = 0; i < len; i++) - if (pickler_write(self, &pop_op, 1) < 0) - goto error; - /* fetch from memo */ - if (memo_get(self, memo_key) < 0) - goto error; - - Py_DECREF(memo_key); - return 0; - } - else { /* Not recursive. */ - if (pickler_write(self, len2opcode + len, 1) < 0) - goto error; - } - goto memoize; - } - - /* proto < 2 and len > 0, or proto >= 2 and len > 3. - * Generate MARK e1 e2 ... TUPLE - */ - if (pickler_write(self, &mark_op, 1) < 0) - goto error; - - if (store_tuple_elements(self, obj, len) < 0) - goto error; - - if (PyDict_GetItem(self->memo, memo_key)) { - /* pop the stack stuff we pushed */ - if (self->bin) { - if (pickler_write(self, &pop_mark_op, 1) < 0) - goto error; - } - else { - /* Note that we pop one more than len, to remove - * the MARK too. - */ - for (i = 0; i <= len; i++) - if (pickler_write(self, &pop_op, 1) < 0) - goto error; - } - /* fetch from memo */ - if (memo_get(self, memo_key) < 0) - goto error; - - Py_DECREF(memo_key); - return 0; - } - else { /* Not recursive. */ - if (pickler_write(self, &tuple_op, 1) < 0) - goto error; - } - - memoize: - if (memo_put(self, obj) < 0) - goto error; - - if (0) { - error: - status = -1; - } - - Py_DECREF(memo_key); - return status; -} - -/* iter is an iterator giving items, and we batch up chunks of - * MARK item item ... item APPENDS - * opcode sequences. Calling code should have arranged to first create an - * empty list, or list-like object, for the APPENDS to operate on. - * Returns 0 on success, <0 on error. - */ -static int -batch_list(PicklerObject *self, PyObject *iter) -{ - PyObject *obj; - PyObject *slice[BATCHSIZE]; - int i, n; - - const char mark_op = MARK; - const char append_op = APPEND; - const char appends_op = APPENDS; - - assert(iter != NULL); - - /* XXX: I think this function could be made faster by avoiding the - iterator interface and fetching objects directly from list using - PyList_GET_ITEM. - */ - - if (self->proto == 0) { - /* APPENDS isn't available; do one at a time. */ - for (;;) { - obj = PyIter_Next(iter); - if (obj == NULL) { - if (PyErr_Occurred()) - return -1; - break; - } - i = save(self, obj, 0); - Py_DECREF(obj); - if (i < 0) - return -1; - if (pickler_write(self, &append_op, 1) < 0) - return -1; - } - return 0; - } - - /* proto > 0: write in batches of BATCHSIZE. */ - do { - /* Get next group of (no more than) BATCHSIZE elements. */ - for (n = 0; n < BATCHSIZE; n++) { - obj = PyIter_Next(iter); - if (obj == NULL) { - if (PyErr_Occurred()) - goto error; - break; - } - slice[n] = obj; - } - - if (n > 1) { - /* Pump out MARK, slice[0:n], APPENDS. */ - if (pickler_write(self, &mark_op, 1) < 0) - goto error; - for (i = 0; i < n; i++) { - if (save(self, slice[i], 0) < 0) - goto error; - } - if (pickler_write(self, &appends_op, 1) < 0) - goto error; - } - else if (n == 1) { - if (save(self, slice[0], 0) < 0 || - pickler_write(self, &append_op, 1) < 0) - goto error; - } - - for (i = 0; i < n; i++) { - Py_DECREF(slice[i]); - } - } while (n == BATCHSIZE); - return 0; - - error: - while (--n >= 0) { - Py_DECREF(slice[n]); - } - return -1; -} - -static int -save_list(PicklerObject *self, PyObject *obj) -{ - PyObject *iter; - char header[3]; - int len; - int status = 0; - - if (self->fast && !fast_save_enter(self, obj)) - goto error; - - /* Create an empty list. */ - if (self->bin) { - header[0] = EMPTY_LIST; - len = 1; - } - else { - header[0] = MARK; - header[1] = LIST; - len = 2; - } - - if (pickler_write(self, header, len) < 0) - goto error; - - /* Get list length, and bow out early if empty. */ - if ((len = PyList_Size(obj)) < 0) - goto error; - - if (memo_put(self, obj) < 0) - goto error; - - if (len != 0) { - /* Save the list elements. */ - iter = PyObject_GetIter(obj); - if (iter == NULL) - goto error; - status = batch_list(self, iter); - Py_DECREF(iter); - } - - if (0) { - error: - status = -1; - } - - if (self->fast && !fast_save_leave(self, obj)) - status = -1; - - return status; -} - -/* iter is an iterator giving (key, value) pairs, and we batch up chunks of - * MARK key value ... key value SETITEMS - * opcode sequences. Calling code should have arranged to first create an - * empty dict, or dict-like object, for the SETITEMS to operate on. - * Returns 0 on success, <0 on error. - * - * This is very much like batch_list(). The difference between saving - * elements directly, and picking apart two-tuples, is so long-winded at - * the C level, though, that attempts to combine these routines were too - * ugly to bear. - */ -static int -batch_dict(PicklerObject *self, PyObject *iter) -{ - PyObject *obj; - PyObject *slice[BATCHSIZE]; - int i, n; - - const char mark_op = MARK; - const char setitem_op = SETITEM; - const char setitems_op = SETITEMS; - - assert(iter != NULL); - - if (self->proto == 0) { - /* SETITEMS isn't available; do one at a time. */ - for (;;) { - obj = PyIter_Next(iter); - if (obj == NULL) { - if (PyErr_Occurred()) - return -1; - break; - } - if (!PyTuple_Check(obj) || PyTuple_Size(obj) != 2) { - PyErr_SetString(PyExc_TypeError, "dict items " - "iterator must return 2-tuples"); - return -1; - } - i = save(self, PyTuple_GET_ITEM(obj, 0), 0); - if (i >= 0) - i = save(self, PyTuple_GET_ITEM(obj, 1), 0); - Py_DECREF(obj); - if (i < 0) - return -1; - if (pickler_write(self, &setitem_op, 1) < 0) - return -1; - } - return 0; - } - - /* proto > 0: write in batches of BATCHSIZE. */ - do { - /* Get next group of (no more than) BATCHSIZE elements. */ - for (n = 0; n < BATCHSIZE; n++) { - obj = PyIter_Next(iter); - if (obj == NULL) { - if (PyErr_Occurred()) - goto error; - break; - } - if (!PyTuple_Check(obj) || PyTuple_Size(obj) != 2) { - PyErr_SetString(PyExc_TypeError, "dict items " - "iterator must return 2-tuples"); - goto error; - } - slice[n] = obj; - } - - if (n > 1) { - /* Pump out MARK, slice[0:n], SETITEMS. */ - if (pickler_write(self, &mark_op, 1) < 0) - goto error; - for (i = 0; i < n; i++) { - obj = slice[i]; - if (save(self, PyTuple_GET_ITEM(obj, 0), 0) < 0 || - save(self, PyTuple_GET_ITEM(obj, 1), 0) < 0) - goto error; - } - if (pickler_write(self, &setitems_op, 1) < 0) - goto error; - } - else if (n == 1) { - obj = slice[0]; - if (save(self, PyTuple_GET_ITEM(obj, 0), 0) < 0 || - save(self, PyTuple_GET_ITEM(obj, 1), 0) < 0 || - pickler_write(self, &setitem_op, 1) < 0) - goto error; - } - - for (i = 0; i < n; i++) { - Py_DECREF(slice[i]); - } - } while (n == BATCHSIZE); - return 0; - - error: - while (--n >= 0) { - Py_DECREF(slice[n]); - } - return -1; -} - -static int -save_dict(PicklerObject *self, PyObject *obj) -{ - PyObject *items, *iter; - char header[3]; - int len; - int status = 0; - - if (self->fast && !fast_save_enter(self, obj)) - goto error; - - /* Create an empty dict. */ - if (self->bin) { - header[0] = EMPTY_DICT; - len = 1; - } - else { - header[0] = MARK; - header[1] = DICT; - len = 2; - } - - if (pickler_write(self, header, len) < 0) - goto error; - - /* Get dict size, and bow out early if empty. */ - if ((len = PyDict_Size(obj)) < 0) - goto error; - - if (memo_put(self, obj) < 0) - goto error; - - if (len != 0) { - /* Save the dict items. */ - items = PyObject_CallMethod(obj, "items", "()"); - if (items == NULL) - goto error; - iter = PyObject_GetIter(items); - Py_DECREF(items); - if (iter == NULL) - goto error; - status = batch_dict(self, iter); - Py_DECREF(iter); - } - - if (0) { - error: - status = -1; - } - - if (self->fast && !fast_save_leave(self, obj)) - status = -1; - - return status; -} - -static int -save_global(PicklerObject *self, PyObject *obj, PyObject *name) -{ - static PyObject *name_str = NULL; - PyObject *global_name = NULL; - PyObject *module_name = NULL; - PyObject *module = NULL; - PyObject *cls; - int status = 0; - - const char global_op = GLOBAL; - - if (name_str == NULL) { - name_str = PyUnicode_InternFromString("__name__"); - if (name_str == NULL) - goto error; - } - - if (name) { - global_name = name; - Py_INCREF(global_name); - } - else { - global_name = PyObject_GetAttr(obj, name_str); - if (global_name == NULL) - goto error; - } - - module_name = whichmodule(obj, global_name); - if (module_name == NULL) - goto error; - - /* XXX: Change to use the import C API directly with level=0 to disallow - relative imports. - - XXX: PyImport_ImportModuleLevel could be used. However, this bypasses - builtins.__import__. Therefore, _pickle, unlike pickle.py, will ignore - custom import functions (IMHO, this would be a nice security - feature). The import C API would need to be extended to support the - extra parameters of __import__ to fix that. */ - module = PyImport_Import(module_name); - if (module == NULL) { - PyErr_Format(PicklingError, - "Can't pickle %R: import of module %R failed", - obj, module_name); - goto error; - } - cls = PyObject_GetAttr(module, global_name); - if (cls == NULL) { - PyErr_Format(PicklingError, - "Can't pickle %R: attribute lookup %S.%S failed", - obj, module_name, global_name); - goto error; - } - if (cls != obj) { - Py_DECREF(cls); - PyErr_Format(PicklingError, - "Can't pickle %R: it's not the same object as %S.%S", - obj, module_name, global_name); - goto error; - } - Py_DECREF(cls); - - if (self->proto >= 2) { - /* See whether this is in the extension registry, and if - * so generate an EXT opcode. - */ - PyObject *code_obj; /* extension code as Python object */ - long code; /* extension code as C value */ - char pdata[5]; - int n; - - PyTuple_SET_ITEM(two_tuple, 0, module_name); - PyTuple_SET_ITEM(two_tuple, 1, global_name); - code_obj = PyDict_GetItem(extension_registry, two_tuple); - /* The object is not registered in the extension registry. - This is the most likely code path. */ - if (code_obj == NULL) - goto gen_global; - - /* XXX: pickle.py doesn't check neither the type, nor the range - of the value returned by the extension_registry. It should for - consistency. */ - - /* Verify code_obj has the right type and value. */ - if (!PyLong_Check(code_obj)) { - PyErr_Format(PicklingError, - "Can't pickle %R: extension code %R isn't an integer", - obj, code_obj); - goto error; - } - code = PyLong_AS_LONG(code_obj); - if (code <= 0 || code > 0x7fffffffL) { - PyErr_Format(PicklingError, - "Can't pickle %R: extension code %ld is out of range", - obj, code); - goto error; - } - - /* Generate an EXT opcode. */ - if (code <= 0xff) { - pdata[0] = EXT1; - pdata[1] = (unsigned char)code; - n = 2; - } - else if (code <= 0xffff) { - pdata[0] = EXT2; - pdata[1] = (unsigned char)(code & 0xff); - pdata[2] = (unsigned char)((code >> 8) & 0xff); - n = 3; - } - else { - pdata[0] = EXT4; - pdata[1] = (unsigned char)(code & 0xff); - pdata[2] = (unsigned char)((code >> 8) & 0xff); - pdata[3] = (unsigned char)((code >> 16) & 0xff); - pdata[4] = (unsigned char)((code >> 24) & 0xff); - n = 5; - } - - if (pickler_write(self, pdata, n) < 0) - goto error; - } - else { - /* Generate a normal global opcode if we are using a pickle - protocol <= 2, or if the object is not registered in the - extension registry. */ - PyObject *encoded; - PyObject *(*unicode_encoder)(PyObject *); - - gen_global: - if (pickler_write(self, &global_op, 1) < 0) - goto error; - - /* Since Python 3.0 now supports non-ASCII identifiers, we encode both - the module name and the global name using UTF-8. We do so only when - we are using the pickle protocol newer than version 3. This is to - ensure compatibility with older Unpickler running on Python 2.x. */ - if (self->proto >= 3) { - unicode_encoder = PyUnicode_AsUTF8String; - } - else { - unicode_encoder = PyUnicode_AsASCIIString; - } - - /* Save the name of the module. */ - encoded = unicode_encoder(module_name); - if (encoded == NULL) { - if (PyErr_ExceptionMatches(PyExc_UnicodeEncodeError)) - PyErr_Format(PicklingError, - "can't pickle module identifier '%S' using " - "pickle protocol %i", module_name, self->proto); - goto error; - } - if (pickler_write(self, PyBytes_AS_STRING(encoded), - PyBytes_GET_SIZE(encoded)) < 0) { - Py_DECREF(encoded); - goto error; - } - Py_DECREF(encoded); - if(pickler_write(self, "\n", 1) < 0) - goto error; - - /* Save the name of the module. */ - encoded = unicode_encoder(global_name); - if (encoded == NULL) { - if (PyErr_ExceptionMatches(PyExc_UnicodeEncodeError)) - PyErr_Format(PicklingError, - "can't pickle global identifier '%S' using " - "pickle protocol %i", global_name, self->proto); - goto error; - } - if (pickler_write(self, PyBytes_AS_STRING(encoded), - PyBytes_GET_SIZE(encoded)) < 0) { - Py_DECREF(encoded); - goto error; - } - Py_DECREF(encoded); - if(pickler_write(self, "\n", 1) < 0) - goto error; - - /* Memoize the object. */ - if (memo_put(self, obj) < 0) - goto error; - } - - if (0) { - error: - status = -1; - } - Py_XDECREF(module_name); - Py_XDECREF(global_name); - Py_XDECREF(module); - - return status; -} - -static int -save_pers(PicklerObject *self, PyObject *obj, PyObject *func) -{ - PyObject *pid = NULL; - int status = 0; - - const char persid_op = PERSID; - const char binpersid_op = BINPERSID; - - Py_INCREF(obj); - pid = pickler_call(self, func, obj); - if (pid == NULL) - return -1; - - if (pid != Py_None) { - if (self->bin) { - if (save(self, pid, 1) < 0 || - pickler_write(self, &binpersid_op, 1) < 0) - goto error; - } - else { - PyObject *pid_str = NULL; - char *pid_ascii_bytes; - Py_ssize_t size; - - pid_str = PyObject_Str(pid); - if (pid_str == NULL) - goto error; - - /* XXX: Should it check whether the persistent id only contains - ASCII characters? And what if the pid contains embedded - newlines? */ - pid_ascii_bytes = PyUnicode_AsStringAndSize(pid_str, &size); - Py_DECREF(pid_str); - if (pid_ascii_bytes == NULL) - goto error; - - if (pickler_write(self, &persid_op, 1) < 0 || - pickler_write(self, pid_ascii_bytes, size) < 0 || - pickler_write(self, "\n", 1) < 0) - goto error; - } - status = 1; - } - - if (0) { - error: - status = -1; - } - Py_XDECREF(pid); - - return status; -} - -/* We're saving obj, and args is the 2-thru-5 tuple returned by the - * appropriate __reduce__ method for obj. - */ -static int -save_reduce(PicklerObject *self, PyObject *args, PyObject *obj) -{ - PyObject *callable; - PyObject *argtup; - PyObject *state = NULL; - PyObject *listitems = NULL; - PyObject *dictitems = NULL; - - int use_newobj = self->proto >= 2; - - const char reduce_op = REDUCE; - const char build_op = BUILD; - const char newobj_op = NEWOBJ; - - if (!PyArg_UnpackTuple(args, "save_reduce", 2, 5, - &callable, &argtup, &state, &listitems, &dictitems)) - return -1; - - if (!PyCallable_Check(callable)) { - PyErr_SetString(PicklingError, - "first argument of save_reduce() must be callable"); - return -1; - } - if (!PyTuple_Check(argtup)) { - PyErr_SetString(PicklingError, - "second argument of save_reduce() must be a tuple"); - return -1; - } - - if (state == Py_None) - state = NULL; - if (listitems == Py_None) - listitems = NULL; - if (dictitems == Py_None) - dictitems = NULL; - - /* Protocol 2 special case: if callable's name is __newobj__, use - NEWOBJ. */ - if (use_newobj) { - static PyObject *newobj_str = NULL; - PyObject *name_str; - - if (newobj_str == NULL) { - newobj_str = PyUnicode_InternFromString("__newobj__"); - } - - name_str = PyObject_GetAttrString(callable, "__name__"); - if (name_str == NULL) { - if (PyErr_ExceptionMatches(PyExc_AttributeError)) - PyErr_Clear(); - else - return -1; - use_newobj = 0; - } - else { - use_newobj = PyUnicode_Check(name_str) && - PyUnicode_Compare(name_str, newobj_str) == 0; - Py_DECREF(name_str); - } - } - if (use_newobj) { - PyObject *cls; - PyObject *newargtup; - PyObject *obj_class; - int p; - - /* Sanity checks. */ - if (Py_SIZE(argtup) < 1) { - PyErr_SetString(PicklingError, "__newobj__ arglist is empty"); - return -1; - } - - cls = PyTuple_GET_ITEM(argtup, 0); - if (!PyObject_HasAttrString(cls, "__new__")) { - PyErr_SetString(PicklingError, "args[0] from " - "__newobj__ args has no __new__"); - return -1; - } - - if (obj != NULL) { - obj_class = PyObject_GetAttrString(obj, "__class__"); - if (obj_class == NULL) { - if (PyErr_ExceptionMatches(PyExc_AttributeError)) - PyErr_Clear(); - else - return -1; - } - p = obj_class != cls; /* true iff a problem */ - Py_DECREF(obj_class); - if (p) { - PyErr_SetString(PicklingError, "args[0] from " - "__newobj__ args has the wrong class"); - return -1; - } - } - /* XXX: These calls save() are prone to infinite recursion. Imagine - what happen if the value returned by the __reduce__() method of - some extension type contains another object of the same type. Ouch! - - Here is a quick example, that I ran into, to illustrate what I - mean: - - >>> import pickle, copyreg - >>> copyreg.dispatch_table.pop(complex) - >>> pickle.dumps(1+2j) - Traceback (most recent call last): - ... - RuntimeError: maximum recursion depth exceeded - - Removing the complex class from copyreg.dispatch_table made the - __reduce_ex__() method emit another complex object: - - >>> (1+1j).__reduce_ex__(2) - (<function __newobj__ at 0xb7b71c3c>, - (<class 'complex'>, (1+1j)), None, None, None) - - Thus when save() was called on newargstup (the 2nd item) recursion - ensued. Of course, the bug was in the complex class which had a - broken __getnewargs__() that emitted another complex object. But, - the point, here, is it is quite easy to end up with a broken reduce - function. */ - - /* Save the class and its __new__ arguments. */ - if (save(self, cls, 0) < 0) - return -1; - - newargtup = PyTuple_GetSlice(argtup, 1, Py_SIZE(argtup)); - if (newargtup == NULL) - return -1; - - p = save(self, newargtup, 0); - Py_DECREF(newargtup); - if (p < 0) - return -1; - - /* Add NEWOBJ opcode. */ - if (pickler_write(self, &newobj_op, 1) < 0) - return -1; - } - else { /* Not using NEWOBJ. */ - if (save(self, callable, 0) < 0 || - save(self, argtup, 0) < 0 || - pickler_write(self, &reduce_op, 1) < 0) - return -1; - } - - /* obj can be NULL when save_reduce() is used directly. A NULL obj means - the caller do not want to memoize the object. Not particularly useful, - but that is to mimic the behavior save_reduce() in pickle.py when - obj is None. */ - if (obj && memo_put(self, obj) < 0) - return -1; - - if (listitems && batch_list(self, listitems) < 0) - return -1; - - if (dictitems && batch_dict(self, dictitems) < 0) - return -1; - - if (state) { - if (save(self, state, 0) < 0 || - pickler_write(self, &build_op, 1) < 0) - return -1; - } - - return 0; -} - -static int -save(PicklerObject *self, PyObject *obj, int pers_save) -{ - PyTypeObject *type; - PyObject *reduce_func = NULL; - PyObject *reduce_value = NULL; - PyObject *memo_key = NULL; - int status = 0; - - /* XXX: Use Py_EnterRecursiveCall()? */ - if (++self->nesting > Py_GetRecursionLimit()) { - PyErr_SetString(PyExc_RuntimeError, - "maximum recursion depth exceeded"); - goto error; - } - - /* The extra pers_save argument is necessary to avoid calling save_pers() - on its returned object. */ - if (!pers_save && self->pers_func) { - /* save_pers() returns: - -1 to signal an error; - 0 if it did nothing successfully; - 1 if a persistent id was saved. - */ - if ((status = save_pers(self, obj, self->pers_func)) != 0) - goto done; - } - - type = Py_TYPE(obj); - - /* XXX: The old cPickle had an optimization that used switch-case - statement dispatching on the first letter of the type name. It was - probably not a bad idea after all. If benchmarks shows that particular - optimization had some real benefits, it would be nice to add it - back. */ - - /* Atom types; these aren't memoized, so don't check the memo. */ - - if (obj == Py_None) { - status = save_none(self, obj); - goto done; - } - else if (obj == Py_False || obj == Py_True) { - status = save_bool(self, obj); - goto done; - } - else if (type == &PyLong_Type) { - status = save_long(self, obj); - goto done; - } - else if (type == &PyFloat_Type) { - status = save_float(self, obj); - goto done; - } - - /* Check the memo to see if it has the object. If so, generate - a GET (or BINGET) opcode, instead of pickling the object - once again. */ - memo_key = PyLong_FromVoidPtr(obj); - if (memo_key == NULL) - goto error; - if (PyDict_GetItem(self->memo, memo_key)) { - if (memo_get(self, memo_key) < 0) - goto error; - goto done; - } - - if (type == &PyBytes_Type) { - status = save_bytes(self, obj); - goto done; - } - else if (type == &PyUnicode_Type) { - status = save_unicode(self, obj); - goto done; - } - else if (type == &PyDict_Type) { - status = save_dict(self, obj); - goto done; - } - else if (type == &PyList_Type) { - status = save_list(self, obj); - goto done; - } - else if (type == &PyTuple_Type) { - status = save_tuple(self, obj); - goto done; - } - else if (type == &PyType_Type) { - status = save_global(self, obj, NULL); - goto done; - } - else if (type == &PyFunction_Type) { - status = save_global(self, obj, NULL); - if (status < 0 && PyErr_ExceptionMatches(PickleError)) { - /* fall back to reduce */ - PyErr_Clear(); - } - else { - goto done; - } - } - else if (type == &PyCFunction_Type) { - status = save_global(self, obj, NULL); - goto done; - } - else if (PyType_IsSubtype(type, &PyType_Type)) { - status = save_global(self, obj, NULL); - goto done; - } - - /* XXX: This part needs some unit tests. */ - - /* Get a reduction callable, and call it. This may come from - * copyreg.dispatch_table, the object's __reduce_ex__ method, - * or the object's __reduce__ method. - */ - reduce_func = PyDict_GetItem(dispatch_table, (PyObject *)type); - if (reduce_func != NULL) { - /* Here, the reference count of the reduce_func object returned by - PyDict_GetItem needs to be increased to be consistent with the one - returned by PyObject_GetAttr. This is allow us to blindly DECREF - reduce_func at the end of the save() routine. - */ - Py_INCREF(reduce_func); - Py_INCREF(obj); - reduce_value = pickler_call(self, reduce_func, obj); - } - else { - static PyObject *reduce_str = NULL; - static PyObject *reduce_ex_str = NULL; - - /* Cache the name of the reduce methods. */ - if (reduce_str == NULL) { - reduce_str = PyUnicode_InternFromString("__reduce__"); - if (reduce_str == NULL) - goto error; - reduce_ex_str = PyUnicode_InternFromString("__reduce_ex__"); - if (reduce_ex_str == NULL) - goto error; - } - - /* XXX: If the __reduce__ method is defined, __reduce_ex__ is - automatically defined as __reduce__. While this is convenient, this - make it impossible to know which method was actually called. Of - course, this is not a big deal. But still, it would be nice to let - the user know which method was called when something go - wrong. Incidentally, this means if __reduce_ex__ is not defined, we - don't actually have to check for a __reduce__ method. */ - - /* Check for a __reduce_ex__ method. */ - reduce_func = PyObject_GetAttr(obj, reduce_ex_str); - if (reduce_func != NULL) { - PyObject *proto; - proto = PyLong_FromLong(self->proto); - if (proto != NULL) { - reduce_value = pickler_call(self, reduce_func, proto); - } - } - else { - if (PyErr_ExceptionMatches(PyExc_AttributeError)) - PyErr_Clear(); - else - goto error; - /* Check for a __reduce__ method. */ - reduce_func = PyObject_GetAttr(obj, reduce_str); - if (reduce_func != NULL) { - reduce_value = PyObject_Call(reduce_func, empty_tuple, NULL); - } - else { - PyErr_Format(PicklingError, "can't pickle '%.200s' object: %R", - type->tp_name, obj); - goto error; - } - } - } - - if (reduce_value == NULL) - goto error; - - if (PyUnicode_Check(reduce_value)) { - status = save_global(self, obj, reduce_value); - goto done; - } - - if (!PyTuple_Check(reduce_value)) { - PyErr_SetString(PicklingError, - "__reduce__ must return a string or tuple"); - goto error; - } - if (Py_SIZE(reduce_value) < 2 || Py_SIZE(reduce_value) > 5) { - PyErr_SetString(PicklingError, "tuple returned by __reduce__ " - "must contain 2 through 5 elements"); - goto error; - } - if (!PyTuple_Check(PyTuple_GET_ITEM(reduce_value, 1))) { - PyErr_SetString(PicklingError, "second item of the tuple " - "returned by __reduce__ must be a tuple"); - goto error; - } - - status = save_reduce(self, reduce_value, obj); - - if (0) { - error: - status = -1; - } - done: - self->nesting--; - Py_XDECREF(memo_key); - Py_XDECREF(reduce_func); - Py_XDECREF(reduce_value); - - return status; -} - -static int -dump(PicklerObject *self, PyObject *obj) -{ - const char stop_op = STOP; - - if (self->proto >= 2) { - char header[2]; - - header[0] = PROTO; - assert(self->proto >= 0 && self->proto < 256); - header[1] = (unsigned char)self->proto; - if (pickler_write(self, header, 2) < 0) - return -1; - } - - if (save(self, obj, 0) < 0 || - pickler_write(self, &stop_op, 1) < 0 || - pickler_write(self, NULL, 0) < 0) - return -1; - - return 0; -} - -PyDoc_STRVAR(Pickler_clear_memo_doc, -"clear_memo() -> None. Clears the pickler's \"memo\"." -"\n" -"The memo is the data structure that remembers which objects the\n" -"pickler has already seen, so that shared or recursive objects are\n" -"pickled by reference and not by value. This method is useful when\n" -"re-using picklers."); - -static PyObject * -Pickler_clear_memo(PicklerObject *self) -{ - if (self->memo) - PyDict_Clear(self->memo); - - Py_RETURN_NONE; -} - -PyDoc_STRVAR(Pickler_dump_doc, -"dump(obj) -> None. Write a pickled representation of obj to the open file."); - -static PyObject * -Pickler_dump(PicklerObject *self, PyObject *args) -{ - PyObject *obj; - - if (!PyArg_ParseTuple(args, "O:dump", &obj)) - return NULL; - - if (dump(self, obj) < 0) - return NULL; - - Py_RETURN_NONE; -} - -static struct PyMethodDef Pickler_methods[] = { - {"dump", (PyCFunction)Pickler_dump, METH_VARARGS, - Pickler_dump_doc}, - {"clear_memo", (PyCFunction)Pickler_clear_memo, METH_NOARGS, - Pickler_clear_memo_doc}, - {NULL, NULL} /* sentinel */ -}; - -static void -Pickler_dealloc(PicklerObject *self) -{ - PyObject_GC_UnTrack(self); - - Py_XDECREF(self->write); - Py_XDECREF(self->memo); - Py_XDECREF(self->pers_func); - Py_XDECREF(self->arg); - Py_XDECREF(self->fast_memo); - - PyMem_Free(self->write_buf); - - Py_TYPE(self)->tp_free((PyObject *)self); -} - -static int -Pickler_traverse(PicklerObject *self, visitproc visit, void *arg) -{ - Py_VISIT(self->write); - Py_VISIT(self->memo); - Py_VISIT(self->pers_func); - Py_VISIT(self->arg); - Py_VISIT(self->fast_memo); - return 0; -} - -static int -Pickler_clear(PicklerObject *self) -{ - Py_CLEAR(self->write); - Py_CLEAR(self->memo); - Py_CLEAR(self->pers_func); - Py_CLEAR(self->arg); - Py_CLEAR(self->fast_memo); - - PyMem_Free(self->write_buf); - self->write_buf = NULL; - - return 0; -} - -PyDoc_STRVAR(Pickler_doc, -"Pickler(file, protocol=None)" -"\n" -"This takes a binary file for writing a pickle data stream.\n" -"\n" -"The optional protocol argument tells the pickler to use the\n" -"given protocol; supported protocols are 0, 1, 2, 3. The default\n" -"protocol is 3; a backward-incompatible protocol designed for\n" -"Python 3.0.\n" -"\n" -"Specifying a negative protocol version selects the highest\n" -"protocol version supported. The higher the protocol used, the\n" -"more recent the version of Python needed to read the pickle\n" -"produced.\n" -"\n" -"The file argument must have a write() method that accepts a single\n" -"bytes argument. It can thus be a file object opened for binary\n" -"writing, a io.BytesIO instance, or any other custom object that\n" -"meets this interface.\n"); - -static int -Pickler_init(PicklerObject *self, PyObject *args, PyObject *kwds) -{ - static char *kwlist[] = {"file", "protocol", 0}; - PyObject *file; - PyObject *proto_obj = NULL; - long proto = 0; - - if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:Pickler", - kwlist, &file, &proto_obj)) - return -1; - - /* In case of multiple __init__() calls, clear previous content. */ - if (self->write != NULL) - (void)Pickler_clear(self); - - if (proto_obj == NULL || proto_obj == Py_None) - proto = DEFAULT_PROTOCOL; - else - proto = PyLong_AsLong(proto_obj); - - if (proto < 0) - proto = HIGHEST_PROTOCOL; - if (proto > HIGHEST_PROTOCOL) { - PyErr_Format(PyExc_ValueError, "pickle protocol must be <= %d", - HIGHEST_PROTOCOL); - return -1; - } - - self->proto = proto; - self->bin = proto > 0; - self->arg = NULL; - self->nesting = 0; - self->fast = 0; - self->fast_nesting = 0; - self->fast_memo = NULL; - - if (!PyObject_HasAttrString(file, "write")) { - PyErr_SetString(PyExc_TypeError, - "file must have a 'write' attribute"); - return -1; - } - self->write = PyObject_GetAttrString(file, "write"); - if (self->write == NULL) - return -1; - self->buf_size = 0; - self->write_buf = (char *)PyMem_Malloc(WRITE_BUF_SIZE); - if (self->write_buf == NULL) { - PyErr_NoMemory(); - return -1; - } - self->pers_func = NULL; - if (PyObject_HasAttrString((PyObject *)self, "persistent_id")) { - self->pers_func = PyObject_GetAttrString((PyObject *)self, - "persistent_id"); - if (self->pers_func == NULL) - return -1; - } - self->memo = PyDict_New(); - if (self->memo == NULL) - return -1; - - return 0; -} - -static PyObject * -Pickler_get_memo(PicklerObject *self) -{ - if (self->memo == NULL) - PyErr_SetString(PyExc_AttributeError, "memo"); - else - Py_INCREF(self->memo); - return self->memo; -} - -static int -Pickler_set_memo(PicklerObject *self, PyObject *value) -{ - PyObject *tmp; - - if (value == NULL) { - PyErr_SetString(PyExc_TypeError, - "attribute deletion is not supported"); - return -1; - } - if (!PyDict_Check(value)) { - PyErr_SetString(PyExc_TypeError, "memo must be a dictionary"); - return -1; - } - - tmp = self->memo; - Py_INCREF(value); - self->memo = value; - Py_XDECREF(tmp); - - return 0; -} - -static PyObject * -Pickler_get_persid(PicklerObject *self) -{ - if (self->pers_func == NULL) - PyErr_SetString(PyExc_AttributeError, "persistent_id"); - else - Py_INCREF(self->pers_func); - return self->pers_func; -} - -static int -Pickler_set_persid(PicklerObject *self, PyObject *value) -{ - PyObject *tmp; - - if (value == NULL) { - PyErr_SetString(PyExc_TypeError, - "attribute deletion is not supported"); - return -1; - } - if (!PyCallable_Check(value)) { - PyErr_SetString(PyExc_TypeError, - "persistent_id must be a callable taking one argument"); - return -1; - } - - tmp = self->pers_func; - Py_INCREF(value); - self->pers_func = value; - Py_XDECREF(tmp); /* self->pers_func can be NULL, so be careful. */ - - return 0; -} - -static PyMemberDef Pickler_members[] = { - {"bin", T_INT, offsetof(PicklerObject, bin)}, - {"fast", T_INT, offsetof(PicklerObject, fast)}, - {NULL} -}; - -static PyGetSetDef Pickler_getsets[] = { - {"memo", (getter)Pickler_get_memo, - (setter)Pickler_set_memo}, - {"persistent_id", (getter)Pickler_get_persid, - (setter)Pickler_set_persid}, - {NULL} -}; - -static PyTypeObject Pickler_Type = { - PyVarObject_HEAD_INIT(NULL, 0) - "_pickle.Pickler" , /*tp_name*/ - sizeof(PicklerObject), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - (destructor)Pickler_dealloc, /*tp_dealloc*/ - 0, /*tp_print*/ - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - 0, /*tp_compare*/ - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash*/ - 0, /*tp_call*/ - 0, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, - Pickler_doc, /*tp_doc*/ - (traverseproc)Pickler_traverse, /*tp_traverse*/ - (inquiry)Pickler_clear, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - Pickler_methods, /*tp_methods*/ - Pickler_members, /*tp_members*/ - Pickler_getsets, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - 0, /*tp_dictoffset*/ - (initproc)Pickler_init, /*tp_init*/ - PyType_GenericAlloc, /*tp_alloc*/ - PyType_GenericNew, /*tp_new*/ - PyObject_GC_Del, /*tp_free*/ - 0, /*tp_is_gc*/ -}; - -/* Temporary helper for calling self.find_class(). - - XXX: It would be nice to able to avoid Python function call overhead, by - using directly the C version of find_class(), when find_class() is not - overridden by a subclass. Although, this could become rather hackish. A - simpler optimization would be to call the C function when self is not a - subclass instance. */ -static PyObject * -find_class(UnpicklerObject *self, PyObject *module_name, PyObject *global_name) -{ - return PyObject_CallMethod((PyObject *)self, "find_class", "OO", - module_name, global_name); -} - -static int -marker(UnpicklerObject *self) -{ - if (self->num_marks < 1) { - PyErr_SetString(UnpicklingError, "could not find MARK"); - return -1; - } - - return self->marks[--self->num_marks]; -} - -static int -load_none(UnpicklerObject *self) -{ - PDATA_APPEND(self->stack, Py_None, -1); - return 0; -} - -static int -bad_readline(void) -{ - PyErr_SetString(UnpicklingError, "pickle data was truncated"); - return -1; -} - -static int -load_int(UnpicklerObject *self) -{ - PyObject *value; - char *endptr, *s; - Py_ssize_t len; - long x; - - if ((len = unpickler_readline(self, &s)) < 0) - return -1; - if (len < 2) - return bad_readline(); - - errno = 0; - /* XXX: Should the base argument of strtol() be explicitly set to 10? */ - x = strtol(s, &endptr, 0); - - if (errno || (*endptr != '\n') || (endptr[1] != '\0')) { - /* Hm, maybe we've got something long. Let's try reading - * it as a Python long object. */ - errno = 0; - /* XXX: Same thing about the base here. */ - value = PyLong_FromString(s, NULL, 0); - if (value == NULL) { - PyErr_SetString(PyExc_ValueError, - "could not convert string to int"); - return -1; - } - } - else { - if (len == 3 && (x == 0 || x == 1)) { - if ((value = PyBool_FromLong(x)) == NULL) - return -1; - } - else { - if ((value = PyLong_FromLong(x)) == NULL) - return -1; - } - } - - PDATA_PUSH(self->stack, value, -1); - return 0; -} - -static int -load_bool(UnpicklerObject *self, PyObject *boolean) -{ - assert(boolean == Py_True || boolean == Py_False); - PDATA_APPEND(self->stack, boolean, -1); - return 0; -} - -/* s contains x bytes of a little-endian integer. Return its value as a - * C int. Obscure: when x is 1 or 2, this is an unsigned little-endian - * int, but when x is 4 it's a signed one. This is an historical source - * of x-platform bugs. - */ -static long -calc_binint(char *s, int size) -{ - unsigned char c; - int i; - long x = 0L; - - for (i = 0; i < size; i++) { - c = (unsigned char)s[i]; - x |= (long)c << (i * 8); - } -#if SIZEOF_LONG > 4 - /* Unlike BININT1 and BININT2, BININT (more accurately BININT4) - * is signed, so on a box with longs bigger than 4 bytes we need - * to extend a BININT's sign bit to the full width. - */ - if (x == 4 && x & (1L << 31)) - x |= (~0L) << 32; -#endif - return x; -} - -static int -load_binintx(UnpicklerObject *self, char *s, int size) -{ - PyObject *value; - long x; - - x = calc_binint(s, size); - - if ((value = PyLong_FromLong(x)) == NULL) - return -1; - - PDATA_PUSH(self->stack, value, -1); - return 0; -} - -static int -load_binint(UnpicklerObject *self) -{ - char *s; - - if (unpickler_read(self, &s, 4) < 0) - return -1; - - return load_binintx(self, s, 4); -} - -static int -load_binint1(UnpicklerObject *self) -{ - char *s; - - if (unpickler_read(self, &s, 1) < 0) - return -1; - - return load_binintx(self, s, 1); -} - -static int -load_binint2(UnpicklerObject *self) -{ - char *s; - - if (unpickler_read(self, &s, 2) < 0) - return -1; - - return load_binintx(self, s, 2); -} - -static int -load_long(UnpicklerObject *self) -{ - PyObject *value; - char *s; - Py_ssize_t len; - - if ((len = unpickler_readline(self, &s)) < 0) - return -1; - if (len < 2) - return bad_readline(); - - /* XXX: Should the base argument explicitly set to 10? */ - if ((value = PyLong_FromString(s, NULL, 0)) == NULL) - return -1; - - PDATA_PUSH(self->stack, value, -1); - return 0; -} - -/* 'size' bytes contain the # of bytes of little-endian 256's-complement - * data following. - */ -static int -load_counted_long(UnpicklerObject *self, int size) -{ - PyObject *value; - char *nbytes; - char *pdata; - - assert(size == 1 || size == 4); - if (unpickler_read(self, &nbytes, size) < 0) - return -1; - - size = calc_binint(nbytes, size); - if (size < 0) { - /* Corrupt or hostile pickle -- we never write one like this */ - PyErr_SetString(UnpicklingError, - "LONG pickle has negative byte count"); - return -1; - } - - if (size == 0) - value = PyLong_FromLong(0L); - else { - /* Read the raw little-endian bytes and convert. */ - if (unpickler_read(self, &pdata, size) < 0) - return -1; - value = _PyLong_FromByteArray((unsigned char *)pdata, (size_t)size, - 1 /* little endian */ , 1 /* signed */ ); - } - if (value == NULL) - return -1; - PDATA_PUSH(self->stack, value, -1); - return 0; -} - -static int -load_float(UnpicklerObject *self) -{ - PyObject *value; - char *endptr, *s; - Py_ssize_t len; - double d; - - if ((len = unpickler_readline(self, &s)) < 0) - return -1; - if (len < 2) - return bad_readline(); - - errno = 0; - d = PyOS_ascii_strtod(s, &endptr); - - if (errno || (endptr[0] != '\n') || (endptr[1] != '\0')) { - PyErr_SetString(PyExc_ValueError, "could not convert string to float"); - return -1; - } - - if ((value = PyFloat_FromDouble(d)) == NULL) - return -1; - - PDATA_PUSH(self->stack, value, -1); - return 0; -} - -static int -load_binfloat(UnpicklerObject *self) -{ - PyObject *value; - double x; - char *s; - - if (unpickler_read(self, &s, 8) < 0) - return -1; - - x = _PyFloat_Unpack8((unsigned char *)s, 0); - if (x == -1.0 && PyErr_Occurred()) - return -1; - - if ((value = PyFloat_FromDouble(x)) == NULL) - return -1; - - PDATA_PUSH(self->stack, value, -1); - return 0; -} - -static int -load_string(UnpicklerObject *self) -{ - PyObject *bytes; - PyObject *str = NULL; - Py_ssize_t len; - char *s, *p; - - if ((len = unpickler_readline(self, &s)) < 0) - return -1; - if (len < 3) - return bad_readline(); - if ((s = strdup(s)) == NULL) { - PyErr_NoMemory(); - return -1; - } - - /* Strip outermost quotes */ - while (s[len - 1] <= ' ') - len--; - if (s[0] == '"' && s[len - 1] == '"') { - s[len - 1] = '\0'; - p = s + 1; - len -= 2; - } - else if (s[0] == '\'' && s[len - 1] == '\'') { - s[len - 1] = '\0'; - p = s + 1; - len -= 2; - } - else { - free(s); - PyErr_SetString(PyExc_ValueError, "insecure string pickle"); - return -1; - } - - /* Use the PyBytes API to decode the string, since that is what is used - to encode, and then coerce the result to Unicode. */ - bytes = PyBytes_DecodeEscape(p, len, NULL, 0, NULL); - free(s); - if (bytes == NULL) - return -1; - str = PyUnicode_FromEncodedObject(bytes, self->encoding, self->errors); - Py_DECREF(bytes); - if (str == NULL) - return -1; - - PDATA_PUSH(self->stack, str, -1); - return 0; -} - -static int -load_binbytes(UnpicklerObject *self) -{ - PyObject *bytes; - long x; - char *s; - - if (unpickler_read(self, &s, 4) < 0) - return -1; - - x = calc_binint(s, 4); - if (x < 0) { - PyErr_SetString(UnpicklingError, - "BINBYTES pickle has negative byte count"); - return -1; - } - - if (unpickler_read(self, &s, x) < 0) - return -1; - bytes = PyBytes_FromStringAndSize(s, x); - if (bytes == NULL) - return -1; - - PDATA_PUSH(self->stack, bytes, -1); - return 0; -} - -static int -load_short_binbytes(UnpicklerObject *self) -{ - PyObject *bytes; - unsigned char x; - char *s; - - if (unpickler_read(self, &s, 1) < 0) - return -1; - - x = (unsigned char)s[0]; - - if (unpickler_read(self, &s, x) < 0) - return -1; - - bytes = PyBytes_FromStringAndSize(s, x); - if (bytes == NULL) - return -1; - - PDATA_PUSH(self->stack, bytes, -1); - return 0; -} - -static int -load_binstring(UnpicklerObject *self) -{ - PyObject *str; - long x; - char *s; - - if (unpickler_read(self, &s, 4) < 0) - return -1; - - x = calc_binint(s, 4); - if (x < 0) { - PyErr_SetString(UnpicklingError, - "BINSTRING pickle has negative byte count"); - return -1; - } - - if (unpickler_read(self, &s, x) < 0) - return -1; - - /* Convert Python 2.x strings to unicode. */ - str = PyUnicode_Decode(s, x, self->encoding, self->errors); - if (str == NULL) - return -1; - - PDATA_PUSH(self->stack, str, -1); - return 0; -} - -static int -load_short_binstring(UnpicklerObject *self) -{ - PyObject *str; - unsigned char x; - char *s; - - if (unpickler_read(self, &s, 1) < 0) - return -1; - - x = (unsigned char)s[0]; - - if (unpickler_read(self, &s, x) < 0) - return -1; - - /* Convert Python 2.x strings to unicode. */ - str = PyUnicode_Decode(s, x, self->encoding, self->errors); - if (str == NULL) - return -1; - - PDATA_PUSH(self->stack, str, -1); - return 0; -} - -static int -load_unicode(UnpicklerObject *self) -{ - PyObject *str; - Py_ssize_t len; - char *s; - - if ((len = unpickler_readline(self, &s)) < 0) - return -1; - if (len < 1) - return bad_readline(); - - str = PyUnicode_DecodeRawUnicodeEscape(s, len - 1, NULL); - if (str == NULL) - return -1; - - PDATA_PUSH(self->stack, str, -1); - return 0; -} - -static int -load_binunicode(UnpicklerObject *self) -{ - PyObject *str; - long size; - char *s; - - if (unpickler_read(self, &s, 4) < 0) - return -1; - - size = calc_binint(s, 4); - if (size < 0) { - PyErr_SetString(UnpicklingError, - "BINUNICODE pickle has negative byte count"); - return -1; - } - - if (unpickler_read(self, &s, size) < 0) - return -1; - - str = PyUnicode_DecodeUTF8(s, size, NULL); - if (str == NULL) - return -1; - - PDATA_PUSH(self->stack, str, -1); - return 0; -} - -static int -load_tuple(UnpicklerObject *self) -{ - PyObject *tuple; - int i; - - if ((i = marker(self)) < 0) - return -1; - - tuple = Pdata_poptuple(self->stack, i); - if (tuple == NULL) - return -1; - PDATA_PUSH(self->stack, tuple, -1); - return 0; -} - -static int -load_counted_tuple(UnpicklerObject *self, int len) -{ - PyObject *tuple; - - tuple = PyTuple_New(len); - if (tuple == NULL) - return -1; - - while (--len >= 0) { - PyObject *item; - - PDATA_POP(self->stack, item); - if (item == NULL) - return -1; - PyTuple_SET_ITEM(tuple, len, item); - } - PDATA_PUSH(self->stack, tuple, -1); - return 0; -} - -static int -load_empty_list(UnpicklerObject *self) -{ - PyObject *list; - - if ((list = PyList_New(0)) == NULL) - return -1; - PDATA_PUSH(self->stack, list, -1); - return 0; -} - -static int -load_empty_dict(UnpicklerObject *self) -{ - PyObject *dict; - - if ((dict = PyDict_New()) == NULL) - return -1; - PDATA_PUSH(self->stack, dict, -1); - return 0; -} - -static int -load_list(UnpicklerObject *self) -{ - PyObject *list; - int i; - - if ((i = marker(self)) < 0) - return -1; - - list = Pdata_poplist(self->stack, i); - if (list == NULL) - return -1; - PDATA_PUSH(self->stack, list, -1); - return 0; -} - -static int -load_dict(UnpicklerObject *self) -{ - PyObject *dict, *key, *value; - int i, j, k; - - if ((i = marker(self)) < 0) - return -1; - j = self->stack->length; - - if ((dict = PyDict_New()) == NULL) - return -1; - - for (k = i + 1; k < j; k += 2) { - key = self->stack->data[k - 1]; - value = self->stack->data[k]; - if (PyDict_SetItem(dict, key, value) < 0) { - Py_DECREF(dict); - return -1; - } - } - Pdata_clear(self->stack, i); - PDATA_PUSH(self->stack, dict, -1); - return 0; -} - -static PyObject * -instantiate(PyObject *cls, PyObject *args) -{ - PyObject *r = NULL; - - /* XXX: The pickle.py module does not create instances this way when the - args tuple is empty. See Unpickler._instantiate(). */ - if ((r = PyObject_CallObject(cls, args))) - return r; - - /* XXX: Is this still nescessary? */ - { - PyObject *tp, *v, *tb, *tmp_value; - - PyErr_Fetch(&tp, &v, &tb); - tmp_value = v; - /* NULL occurs when there was a KeyboardInterrupt */ - if (tmp_value == NULL) - tmp_value = Py_None; - if ((r = PyTuple_Pack(3, tmp_value, cls, args))) { - Py_XDECREF(v); - v = r; - } - PyErr_Restore(tp, v, tb); - } - return NULL; -} - -static int -load_obj(UnpicklerObject *self) -{ - PyObject *cls, *args, *obj = NULL; - int i; - - if ((i = marker(self)) < 0) - return -1; - - args = Pdata_poptuple(self->stack, i + 1); - if (args == NULL) - return -1; - - PDATA_POP(self->stack, cls); - if (cls) { - obj = instantiate(cls, args); - Py_DECREF(cls); - } - Py_DECREF(args); - if (obj == NULL) - return -1; - - PDATA_PUSH(self->stack, obj, -1); - return 0; -} - -static int -load_inst(UnpicklerObject *self) -{ - PyObject *cls = NULL; - PyObject *args = NULL; - PyObject *obj = NULL; - PyObject *module_name; - PyObject *class_name; - Py_ssize_t len; - int i; - char *s; - - if ((i = marker(self)) < 0) - return -1; - if ((len = unpickler_readline(self, &s)) < 0) - return -1; - if (len < 2) - return bad_readline(); - - /* Here it is safe to use PyUnicode_DecodeASCII(), even though non-ASCII - identifiers are permitted in Python 3.0, since the INST opcode is only - supported by older protocols on Python 2.x. */ - module_name = PyUnicode_DecodeASCII(s, len - 1, "strict"); - if (module_name == NULL) - return -1; - - if ((len = unpickler_readline(self, &s)) >= 0) { - if (len < 2) - return bad_readline(); - class_name = PyUnicode_DecodeASCII(s, len - 1, "strict"); - if (class_name == NULL) { - cls = find_class(self, module_name, class_name); - Py_DECREF(class_name); - } - } - Py_DECREF(module_name); - - if (cls == NULL) - return -1; - - if ((args = Pdata_poptuple(self->stack, i)) != NULL) { - obj = instantiate(cls, args); - Py_DECREF(args); - } - Py_DECREF(cls); - - if (obj == NULL) - return -1; - - PDATA_PUSH(self->stack, obj, -1); - return 0; -} - -static int -load_newobj(UnpicklerObject *self) -{ - PyObject *args = NULL; - PyObject *clsraw = NULL; - PyTypeObject *cls; /* clsraw cast to its true type */ - PyObject *obj; - - /* Stack is ... cls argtuple, and we want to call - * cls.__new__(cls, *argtuple). - */ - PDATA_POP(self->stack, args); - if (args == NULL) - goto error; - if (!PyTuple_Check(args)) { - PyErr_SetString(UnpicklingError, "NEWOBJ expected an arg " "tuple."); - goto error; - } - - PDATA_POP(self->stack, clsraw); - cls = (PyTypeObject *)clsraw; - if (cls == NULL) - goto error; - if (!PyType_Check(cls)) { - PyErr_SetString(UnpicklingError, "NEWOBJ class argument " - "isn't a type object"); - goto error; - } - if (cls->tp_new == NULL) { - PyErr_SetString(UnpicklingError, "NEWOBJ class argument " - "has NULL tp_new"); - goto error; - } - - /* Call __new__. */ - obj = cls->tp_new(cls, args, NULL); - if (obj == NULL) - goto error; - - Py_DECREF(args); - Py_DECREF(clsraw); - PDATA_PUSH(self->stack, obj, -1); - return 0; - - error: - Py_XDECREF(args); - Py_XDECREF(clsraw); - return -1; -} - -static int -load_global(UnpicklerObject *self) -{ - PyObject *global = NULL; - PyObject *module_name; - PyObject *global_name; - Py_ssize_t len; - char *s; - - if ((len = unpickler_readline(self, &s)) < 0) - return -1; - if (len < 2) - return bad_readline(); - module_name = PyUnicode_DecodeUTF8(s, len - 1, "strict"); - if (!module_name) - return -1; - - if ((len = unpickler_readline(self, &s)) >= 0) { - if (len < 2) { - Py_DECREF(module_name); - return bad_readline(); - } - global_name = PyUnicode_DecodeUTF8(s, len - 1, "strict"); - if (global_name) { - global = find_class(self, module_name, global_name); - Py_DECREF(global_name); - } - } - Py_DECREF(module_name); - - if (global == NULL) - return -1; - PDATA_PUSH(self->stack, global, -1); - return 0; -} - -static int -load_persid(UnpicklerObject *self) -{ - PyObject *pid; - Py_ssize_t len; - char *s; - - if (self->pers_func) { - if ((len = unpickler_readline(self, &s)) < 0) - return -1; - if (len < 2) - return bad_readline(); - - pid = PyBytes_FromStringAndSize(s, len - 1); - if (pid == NULL) - return -1; - - /* Ugh... this does not leak since unpickler_call() steals the - reference to pid first. */ - pid = unpickler_call(self, self->pers_func, pid); - if (pid == NULL) - return -1; - - PDATA_PUSH(self->stack, pid, -1); - return 0; - } - else { - PyErr_SetString(UnpicklingError, - "A load persistent id instruction was encountered,\n" - "but no persistent_load function was specified."); - return -1; - } -} - -static int -load_binpersid(UnpicklerObject *self) -{ - PyObject *pid; - - if (self->pers_func) { - PDATA_POP(self->stack, pid); - if (pid == NULL) - return -1; - - /* Ugh... this does not leak since unpickler_call() steals the - reference to pid first. */ - pid = unpickler_call(self, self->pers_func, pid); - if (pid == NULL) - return -1; - - PDATA_PUSH(self->stack, pid, -1); - return 0; - } - else { - PyErr_SetString(UnpicklingError, - "A load persistent id instruction was encountered,\n" - "but no persistent_load function was specified."); - return -1; - } -} - -static int -load_pop(UnpicklerObject *self) -{ - int len; - - if ((len = self->stack->length) <= 0) - return stack_underflow(); - - /* Note that we split the (pickle.py) stack into two stacks, - * an object stack and a mark stack. We have to be clever and - * pop the right one. We do this by looking at the top of the - * mark stack. - */ - - if ((self->num_marks > 0) && (self->marks[self->num_marks - 1] == len)) - self->num_marks--; - else { - len--; - Py_DECREF(self->stack->data[len]); - self->stack->length = len; - } - - return 0; -} - -static int -load_pop_mark(UnpicklerObject *self) -{ - int i; - - if ((i = marker(self)) < 0) - return -1; - - Pdata_clear(self->stack, i); - - return 0; -} - -static int -load_dup(UnpicklerObject *self) -{ - PyObject *last; - int len; - - if ((len = self->stack->length) <= 0) - return stack_underflow(); - last = self->stack->data[len - 1]; - PDATA_APPEND(self->stack, last, -1); - return 0; -} - -static int -load_get(UnpicklerObject *self) -{ - PyObject *key, *value; - Py_ssize_t len; - char *s; - - if ((len = unpickler_readline(self, &s)) < 0) - return -1; - if (len < 2) - return bad_readline(); - - key = PyLong_FromString(s, NULL, 10); - if (key == NULL) - return -1; - - value = PyDict_GetItemWithError(self->memo, key); - if (value == NULL) { - if (!PyErr_Occurred()) - PyErr_SetObject(PyExc_KeyError, key); - Py_DECREF(key); - return -1; - } - Py_DECREF(key); - - PDATA_APPEND(self->stack, value, -1); - return 0; -} - -static int -load_binget(UnpicklerObject *self) -{ - PyObject *key, *value; - char *s; - - if (unpickler_read(self, &s, 1) < 0) - return -1; - - /* Here, the unsigned cast is necessary to avoid negative values. */ - key = PyLong_FromLong((long)(unsigned char)s[0]); - if (key == NULL) - return -1; - - value = PyDict_GetItemWithError(self->memo, key); - if (value == NULL) { - if (!PyErr_Occurred()) - PyErr_SetObject(PyExc_KeyError, key); - Py_DECREF(key); - return -1; - } - Py_DECREF(key); - - PDATA_APPEND(self->stack, value, -1); - return 0; -} - -static int -load_long_binget(UnpicklerObject *self) -{ - PyObject *key, *value; - char *s; - long k; - - if (unpickler_read(self, &s, 4) < 0) - return -1; - - k = (long)(unsigned char)s[0]; - k |= (long)(unsigned char)s[1] << 8; - k |= (long)(unsigned char)s[2] << 16; - k |= (long)(unsigned char)s[3] << 24; - - key = PyLong_FromLong(k); - if (key == NULL) - return -1; - - value = PyDict_GetItemWithError(self->memo, key); - if (value == NULL) { - if (!PyErr_Occurred()) - PyErr_SetObject(PyExc_KeyError, key); - Py_DECREF(key); - return -1; - } - Py_DECREF(key); - - PDATA_APPEND(self->stack, value, -1); - return 0; -} - -/* Push an object from the extension registry (EXT[124]). nbytes is - * the number of bytes following the opcode, holding the index (code) value. - */ -static int -load_extension(UnpicklerObject *self, int nbytes) -{ - char *codebytes; /* the nbytes bytes after the opcode */ - long code; /* calc_binint returns long */ - PyObject *py_code; /* code as a Python int */ - PyObject *obj; /* the object to push */ - PyObject *pair; /* (module_name, class_name) */ - PyObject *module_name, *class_name; - - assert(nbytes == 1 || nbytes == 2 || nbytes == 4); - if (unpickler_read(self, &codebytes, nbytes) < 0) - return -1; - code = calc_binint(codebytes, nbytes); - if (code <= 0) { /* note that 0 is forbidden */ - /* Corrupt or hostile pickle. */ - PyErr_SetString(UnpicklingError, "EXT specifies code <= 0"); - return -1; - } - - /* Look for the code in the cache. */ - py_code = PyLong_FromLong(code); - if (py_code == NULL) - return -1; - obj = PyDict_GetItem(extension_cache, py_code); - if (obj != NULL) { - /* Bingo. */ - Py_DECREF(py_code); - PDATA_APPEND(self->stack, obj, -1); - return 0; - } - - /* Look up the (module_name, class_name) pair. */ - pair = PyDict_GetItem(inverted_registry, py_code); - if (pair == NULL) { - Py_DECREF(py_code); - PyErr_Format(PyExc_ValueError, "unregistered extension " - "code %ld", code); - return -1; - } - /* Since the extension registry is manipulable via Python code, - * confirm that pair is really a 2-tuple of strings. - */ - if (!PyTuple_Check(pair) || PyTuple_Size(pair) != 2 || - !PyUnicode_Check(module_name = PyTuple_GET_ITEM(pair, 0)) || - !PyUnicode_Check(class_name = PyTuple_GET_ITEM(pair, 1))) { - Py_DECREF(py_code); - PyErr_Format(PyExc_ValueError, "_inverted_registry[%ld] " - "isn't a 2-tuple of strings", code); - return -1; - } - /* Load the object. */ - obj = find_class(self, module_name, class_name); - if (obj == NULL) { - Py_DECREF(py_code); - return -1; - } - /* Cache code -> obj. */ - code = PyDict_SetItem(extension_cache, py_code, obj); - Py_DECREF(py_code); - if (code < 0) { - Py_DECREF(obj); - return -1; - } - PDATA_PUSH(self->stack, obj, -1); - return 0; -} - -static int -load_put(UnpicklerObject *self) -{ - PyObject *key, *value; - Py_ssize_t len; - char *s; - int x; - - if ((len = unpickler_readline(self, &s)) < 0) - return -1; - if (len < 2) - return bad_readline(); - if ((x = self->stack->length) <= 0) - return stack_underflow(); - - key = PyLong_FromString(s, NULL, 10); - if (key == NULL) - return -1; - value = self->stack->data[x - 1]; - - x = PyDict_SetItem(self->memo, key, value); - Py_DECREF(key); - return x; -} - -static int -load_binput(UnpicklerObject *self) -{ - PyObject *key, *value; - char *s; - int x; - - if (unpickler_read(self, &s, 1) < 0) - return -1; - if ((x = self->stack->length) <= 0) - return stack_underflow(); - - key = PyLong_FromLong((long)(unsigned char)s[0]); - if (key == NULL) - return -1; - value = self->stack->data[x - 1]; - - x = PyDict_SetItem(self->memo, key, value); - Py_DECREF(key); - return x; -} - -static int -load_long_binput(UnpicklerObject *self) -{ - PyObject *key, *value; - long k; - char *s; - int x; - - if (unpickler_read(self, &s, 4) < 0) - return -1; - if ((x = self->stack->length) <= 0) - return stack_underflow(); - - k = (long)(unsigned char)s[0]; - k |= (long)(unsigned char)s[1] << 8; - k |= (long)(unsigned char)s[2] << 16; - k |= (long)(unsigned char)s[3] << 24; - - key = PyLong_FromLong(k); - if (key == NULL) - return -1; - value = self->stack->data[x - 1]; - - x = PyDict_SetItem(self->memo, key, value); - Py_DECREF(key); - return x; -} - -static int -do_append(UnpicklerObject *self, int x) -{ - PyObject *value; - PyObject *list; - int len, i; - - len = self->stack->length; - if (x > len || x <= 0) - return stack_underflow(); - if (len == x) /* nothing to do */ - return 0; - - list = self->stack->data[x - 1]; - - if (PyList_Check(list)) { - PyObject *slice; - Py_ssize_t list_len; - - slice = Pdata_poplist(self->stack, x); - if (!slice) - return -1; - list_len = PyList_GET_SIZE(list); - i = PyList_SetSlice(list, list_len, list_len, slice); - Py_DECREF(slice); - return i; - } - else { - PyObject *append_func; - - append_func = PyObject_GetAttrString(list, "append"); - if (append_func == NULL) - return -1; - for (i = x; i < len; i++) { - PyObject *result; - - value = self->stack->data[i]; - result = unpickler_call(self, append_func, value); - if (result == NULL) { - Pdata_clear(self->stack, i + 1); - self->stack->length = x; - return -1; - } - Py_DECREF(result); - } - self->stack->length = x; - } - - return 0; -} - -static int -load_append(UnpicklerObject *self) -{ - return do_append(self, self->stack->length - 1); -} - -static int -load_appends(UnpicklerObject *self) -{ - return do_append(self, marker(self)); -} - -static int -do_setitems(UnpicklerObject *self, int x) -{ - PyObject *value, *key; - PyObject *dict; - int len, i; - int status = 0; - - len = self->stack->length; - if (x > len || x <= 0) - return stack_underflow(); - if (len == x) /* nothing to do */ - return 0; - if ((len - x) % 2 != 0) { - /* Currupt or hostile pickle -- we never write one like this. */ - PyErr_SetString(UnpicklingError, "odd number of items for SETITEMS"); - return -1; - } - - /* Here, dict does not actually need to be a PyDict; it could be anything - that supports the __setitem__ attribute. */ - dict = self->stack->data[x - 1]; - - for (i = x + 1; i < len; i += 2) { - key = self->stack->data[i - 1]; - value = self->stack->data[i]; - if (PyObject_SetItem(dict, key, value) < 0) { - status = -1; - break; - } - } - - Pdata_clear(self->stack, x); - return status; -} - -static int -load_setitem(UnpicklerObject *self) -{ - return do_setitems(self, self->stack->length - 2); -} - -static int -load_setitems(UnpicklerObject *self) -{ - return do_setitems(self, marker(self)); -} - -static int -load_build(UnpicklerObject *self) -{ - PyObject *state, *inst, *slotstate; - PyObject *setstate; - int status = 0; - - /* Stack is ... instance, state. We want to leave instance at - * the stack top, possibly mutated via instance.__setstate__(state). - */ - if (self->stack->length < 2) - return stack_underflow(); - - PDATA_POP(self->stack, state); - if (state == NULL) - return -1; - - inst = self->stack->data[self->stack->length - 1]; - - setstate = PyObject_GetAttrString(inst, "__setstate__"); - if (setstate == NULL && PyErr_ExceptionMatches(PyExc_AttributeError)) { - PyErr_Clear(); - } - else { - PyObject *result; - - /* The explicit __setstate__ is responsible for everything. */ - result = unpickler_call(self, setstate, state); - Py_DECREF(setstate); - if (result == NULL) - return -1; - Py_DECREF(result); - return 0; - } - - /* A default __setstate__. First see whether state embeds a - * slot state dict too (a proto 2 addition). - */ - if (PyTuple_Check(state) && Py_SIZE(state) == 2) { - PyObject *tmp = state; - - state = PyTuple_GET_ITEM(tmp, 0); - slotstate = PyTuple_GET_ITEM(tmp, 1); - Py_INCREF(state); - Py_INCREF(slotstate); - Py_DECREF(tmp); - } - else - slotstate = NULL; - - /* Set inst.__dict__ from the state dict (if any). */ - if (state != Py_None) { - PyObject *dict; - - if (!PyDict_Check(state)) { - PyErr_SetString(UnpicklingError, "state is not a dictionary"); - goto error; - } - dict = PyObject_GetAttrString(inst, "__dict__"); - if (dict == NULL) - goto error; - - PyDict_Update(dict, state); - Py_DECREF(dict); - } - - /* Also set instance attributes from the slotstate dict (if any). */ - if (slotstate != NULL) { - PyObject *d_key, *d_value; - Py_ssize_t i; - - if (!PyDict_Check(slotstate)) { - PyErr_SetString(UnpicklingError, - "slot state is not a dictionary"); - goto error; - } - i = 0; - while (PyDict_Next(slotstate, &i, &d_key, &d_value)) { - if (PyObject_SetAttr(inst, d_key, d_value) < 0) - goto error; - } - } - - if (0) { - error: - status = -1; - } - - Py_DECREF(state); - Py_XDECREF(slotstate); - return status; -} - -static int -load_mark(UnpicklerObject *self) -{ - - /* Note that we split the (pickle.py) stack into two stacks, an - * object stack and a mark stack. Here we push a mark onto the - * mark stack. - */ - - if ((self->num_marks + 1) >= self->marks_size) { - size_t alloc; - int *marks; - - /* Use the size_t type to check for overflow. */ - alloc = ((size_t)self->num_marks << 1) + 20; - if (alloc > PY_SSIZE_T_MAX || alloc <= (self->num_marks + 1)) { - PyErr_NoMemory(); - return -1; - } - - if (self->marks == NULL) - marks = (int *)PyMem_Malloc(alloc * sizeof(int)); - else - marks = (int *)PyMem_Realloc(self->marks, alloc * sizeof(int)); - if (marks == NULL) { - PyErr_NoMemory(); - return -1; - } - self->marks = marks; - self->marks_size = (Py_ssize_t)alloc; - } - - self->marks[self->num_marks++] = self->stack->length; - - return 0; -} - -static int -load_reduce(UnpicklerObject *self) -{ - PyObject *callable = NULL; - PyObject *argtup = NULL; - PyObject *obj = NULL; - - PDATA_POP(self->stack, argtup); - if (argtup == NULL) - return -1; - PDATA_POP(self->stack, callable); - if (callable) { - obj = instantiate(callable, argtup); - Py_DECREF(callable); - } - Py_DECREF(argtup); - - if (obj == NULL) - return -1; - - PDATA_PUSH(self->stack, obj, -1); - return 0; -} - -/* Just raises an error if we don't know the protocol specified. PROTO - * is the first opcode for protocols >= 2. - */ -static int -load_proto(UnpicklerObject *self) -{ - char *s; - int i; - - if (unpickler_read(self, &s, 1) < 0) - return -1; - - i = (unsigned char)s[0]; - if (i <= HIGHEST_PROTOCOL) - return 0; - - PyErr_Format(PyExc_ValueError, "unsupported pickle protocol: %d", i); - return -1; -} - -static PyObject * -load(UnpicklerObject *self) -{ - PyObject *err; - PyObject *value = NULL; - char *s; - - self->num_marks = 0; - if (self->stack->length) - Pdata_clear(self->stack, 0); - - /* Convenient macros for the dispatch while-switch loop just below. */ -#define OP(opcode, load_func) \ - case opcode: if (load_func(self) < 0) break; continue; - -#define OP_ARG(opcode, load_func, arg) \ - case opcode: if (load_func(self, (arg)) < 0) break; continue; - - while (1) { - if (unpickler_read(self, &s, 1) < 0) - break; - - switch ((enum opcode)s[0]) { - OP(NONE, load_none) - OP(BININT, load_binint) - OP(BININT1, load_binint1) - OP(BININT2, load_binint2) - OP(INT, load_int) - OP(LONG, load_long) - OP_ARG(LONG1, load_counted_long, 1) - OP_ARG(LONG4, load_counted_long, 4) - OP(FLOAT, load_float) - OP(BINFLOAT, load_binfloat) - OP(BINBYTES, load_binbytes) - OP(SHORT_BINBYTES, load_short_binbytes) - OP(BINSTRING, load_binstring) - OP(SHORT_BINSTRING, load_short_binstring) - OP(STRING, load_string) - OP(UNICODE, load_unicode) - OP(BINUNICODE, load_binunicode) - OP_ARG(EMPTY_TUPLE, load_counted_tuple, 0) - OP_ARG(TUPLE1, load_counted_tuple, 1) - OP_ARG(TUPLE2, load_counted_tuple, 2) - OP_ARG(TUPLE3, load_counted_tuple, 3) - OP(TUPLE, load_tuple) - OP(EMPTY_LIST, load_empty_list) - OP(LIST, load_list) - OP(EMPTY_DICT, load_empty_dict) - OP(DICT, load_dict) - OP(OBJ, load_obj) - OP(INST, load_inst) - OP(NEWOBJ, load_newobj) - OP(GLOBAL, load_global) - OP(APPEND, load_append) - OP(APPENDS, load_appends) - OP(BUILD, load_build) - OP(DUP, load_dup) - OP(BINGET, load_binget) - OP(LONG_BINGET, load_long_binget) - OP(GET, load_get) - OP(MARK, load_mark) - OP(BINPUT, load_binput) - OP(LONG_BINPUT, load_long_binput) - OP(PUT, load_put) - OP(POP, load_pop) - OP(POP_MARK, load_pop_mark) - OP(SETITEM, load_setitem) - OP(SETITEMS, load_setitems) - OP(PERSID, load_persid) - OP(BINPERSID, load_binpersid) - OP(REDUCE, load_reduce) - OP(PROTO, load_proto) - OP_ARG(EXT1, load_extension, 1) - OP_ARG(EXT2, load_extension, 2) - OP_ARG(EXT4, load_extension, 4) - OP_ARG(NEWTRUE, load_bool, Py_True) - OP_ARG(NEWFALSE, load_bool, Py_False) - - case STOP: - break; - - case '\0': - PyErr_SetNone(PyExc_EOFError); - return NULL; - - default: - PyErr_Format(UnpicklingError, - "invalid load key, '%c'.", s[0]); - return NULL; - } - - break; /* and we are done! */ - } - - /* XXX: It is not clear what this is actually for. */ - if ((err = PyErr_Occurred())) { - if (err == PyExc_EOFError) { - PyErr_SetNone(PyExc_EOFError); - } - return NULL; - } - - PDATA_POP(self->stack, value); - return value; -} - -PyDoc_STRVAR(Unpickler_load_doc, -"load() -> object. Load a pickle." -"\n" -"Read a pickled object representation from the open file object given in\n" -"the constructor, and return the reconstituted object hierarchy specified\n" -"therein.\n"); - -static PyObject * -Unpickler_load(UnpicklerObject *self) -{ - /* Check whether the Unpickler was initialized correctly. This prevents - segfaulting if a subclass overridden __init__ with a function that does - not call Unpickler.__init__(). Here, we simply ensure that self->read - is not NULL. */ - if (self->read == NULL) { - PyErr_Format(UnpicklingError, - "Unpickler.__init__() was not called by %s.__init__()", - Py_TYPE(self)->tp_name); - return NULL; - } - - return load(self); -} - -/* The name of find_class() is misleading. In newer pickle protocols, this - function is used for loading any global (i.e., functions), not just - classes. The name is kept only for backward compatibility. */ - -PyDoc_STRVAR(Unpickler_find_class_doc, -"find_class(module_name, global_name) -> object.\n" -"\n" -"Return an object from a specified module, importing the module if\n" -"necessary. Subclasses may override this method (e.g. to restrict\n" -"unpickling of arbitrary classes and functions).\n" -"\n" -"This method is called whenever a class or a function object is\n" -"needed. Both arguments passed are str objects.\n"); - -static PyObject * -Unpickler_find_class(UnpicklerObject *self, PyObject *args) -{ - PyObject *global; - PyObject *modules_dict; - PyObject *module; - PyObject *module_name, *global_name; - - if (!PyArg_UnpackTuple(args, "find_class", 2, 2, - &module_name, &global_name)) - return NULL; - - modules_dict = PySys_GetObject("modules"); - if (modules_dict == NULL) - return NULL; - - module = PyDict_GetItem(modules_dict, module_name); - if (module == NULL) { - module = PyImport_Import(module_name); - if (module == NULL) - return NULL; - global = PyObject_GetAttr(module, global_name); - Py_DECREF(module); - } - else { - global = PyObject_GetAttr(module, global_name); - } - return global; -} - -static struct PyMethodDef Unpickler_methods[] = { - {"load", (PyCFunction)Unpickler_load, METH_NOARGS, - Unpickler_load_doc}, - {"find_class", (PyCFunction)Unpickler_find_class, METH_VARARGS, - Unpickler_find_class_doc}, - {NULL, NULL} /* sentinel */ -}; - -static void -Unpickler_dealloc(UnpicklerObject *self) -{ - PyObject_GC_UnTrack((PyObject *)self); - Py_XDECREF(self->readline); - Py_XDECREF(self->read); - Py_XDECREF(self->memo); - Py_XDECREF(self->stack); - Py_XDECREF(self->pers_func); - Py_XDECREF(self->arg); - Py_XDECREF(self->last_string); - - PyMem_Free(self->marks); - free(self->encoding); - free(self->errors); - - Py_TYPE(self)->tp_free((PyObject *)self); -} - -static int -Unpickler_traverse(UnpicklerObject *self, visitproc visit, void *arg) -{ - Py_VISIT(self->readline); - Py_VISIT(self->read); - Py_VISIT(self->memo); - Py_VISIT(self->stack); - Py_VISIT(self->pers_func); - Py_VISIT(self->arg); - Py_VISIT(self->last_string); - return 0; -} - -static int -Unpickler_clear(UnpicklerObject *self) -{ - Py_CLEAR(self->readline); - Py_CLEAR(self->read); - Py_CLEAR(self->memo); - Py_CLEAR(self->stack); - Py_CLEAR(self->pers_func); - Py_CLEAR(self->arg); - Py_CLEAR(self->last_string); - - PyMem_Free(self->marks); - self->marks = NULL; - free(self->encoding); - self->encoding = NULL; - free(self->errors); - self->errors = NULL; - - return 0; -} - -PyDoc_STRVAR(Unpickler_doc, -"Unpickler(file, *, encoding='ASCII', errors='strict')" -"\n" -"This takes a binary file for reading a pickle data stream.\n" -"\n" -"The protocol version of the pickle is detected automatically, so no\n" -"proto argument is needed.\n" -"\n" -"The file-like object must have two methods, a read() method\n" -"that takes an integer argument, and a readline() method that\n" -"requires no arguments. Both methods should return bytes.\n" -"Thus file-like object can be a binary file object opened for\n" -"reading, a BytesIO object, or any other custom object that\n" -"meets this interface.\n" -"\n" -"Optional keyword arguments are encoding and errors, which are\n" -"used to decode 8-bit string instances pickled by Python 2.x.\n" -"These default to 'ASCII' and 'strict', respectively.\n"); - -static int -Unpickler_init(UnpicklerObject *self, PyObject *args, PyObject *kwds) -{ - static char *kwlist[] = {"file", "encoding", "errors", 0}; - PyObject *file; - char *encoding = NULL; - char *errors = NULL; - - /* XXX: That is an horrible error message. But, I don't know how to do - better... */ - if (Py_SIZE(args) != 1) { - PyErr_Format(PyExc_TypeError, - "%s takes exactly one positional argument (%zd given)", - Py_TYPE(self)->tp_name, Py_SIZE(args)); - return -1; - } - - /* Arguments parsing needs to be done in the __init__() method to allow - subclasses to define their own __init__() method, which may (or may - not) support Unpickler arguments. However, this means we need to be - extra careful in the other Unpickler methods, since a subclass could - forget to call Unpickler.__init__() thus breaking our internal - invariants. */ - if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|ss:Unpickler", kwlist, - &file, &encoding, &errors)) - return -1; - - /* In case of multiple __init__() calls, clear previous content. */ - if (self->read != NULL) - (void)Unpickler_clear(self); - - self->read = PyObject_GetAttrString(file, "read"); - self->readline = PyObject_GetAttrString(file, "readline"); - if (self->readline == NULL || self->read == NULL) - return -1; - - if (encoding == NULL) - encoding = "ASCII"; - if (errors == NULL) - errors = "strict"; - - self->encoding = strdup(encoding); - self->errors = strdup(errors); - if (self->encoding == NULL || self->errors == NULL) { - PyErr_NoMemory(); - return -1; - } - - if (PyObject_HasAttrString((PyObject *)self, "persistent_load")) { - self->pers_func = PyObject_GetAttrString((PyObject *)self, - "persistent_load"); - if (self->pers_func == NULL) - return -1; - } - else { - self->pers_func = NULL; - } - - self->stack = (Pdata *)Pdata_New(); - if (self->stack == NULL) - return -1; - - self->memo = PyDict_New(); - if (self->memo == NULL) - return -1; - - return 0; -} - -static PyObject * -Unpickler_get_memo(UnpicklerObject *self) -{ - if (self->memo == NULL) - PyErr_SetString(PyExc_AttributeError, "memo"); - else - Py_INCREF(self->memo); - return self->memo; -} - -static int -Unpickler_set_memo(UnpicklerObject *self, PyObject *value) -{ - PyObject *tmp; - - if (value == NULL) { - PyErr_SetString(PyExc_TypeError, - "attribute deletion is not supported"); - return -1; - } - if (!PyDict_Check(value)) { - PyErr_SetString(PyExc_TypeError, "memo must be a dictionary"); - return -1; - } - - tmp = self->memo; - Py_INCREF(value); - self->memo = value; - Py_XDECREF(tmp); - - return 0; -} - -static PyObject * -Unpickler_get_persload(UnpicklerObject *self) -{ - if (self->pers_func == NULL) - PyErr_SetString(PyExc_AttributeError, "persistent_load"); - else - Py_INCREF(self->pers_func); - return self->pers_func; -} - -static int -Unpickler_set_persload(UnpicklerObject *self, PyObject *value) -{ - PyObject *tmp; - - if (value == NULL) { - PyErr_SetString(PyExc_TypeError, - "attribute deletion is not supported"); - return -1; - } - if (!PyCallable_Check(value)) { - PyErr_SetString(PyExc_TypeError, - "persistent_load must be a callable taking " - "one argument"); - return -1; - } - - tmp = self->pers_func; - Py_INCREF(value); - self->pers_func = value; - Py_XDECREF(tmp); /* self->pers_func can be NULL, so be careful. */ - - return 0; -} - -static PyGetSetDef Unpickler_getsets[] = { - {"memo", (getter)Unpickler_get_memo, (setter)Unpickler_set_memo}, - {"persistent_load", (getter)Unpickler_get_persload, - (setter)Unpickler_set_persload}, - {NULL} -}; - -static PyTypeObject Unpickler_Type = { - PyVarObject_HEAD_INIT(NULL, 0) - "_pickle.Unpickler", /*tp_name*/ - sizeof(UnpicklerObject), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - (destructor)Unpickler_dealloc, /*tp_dealloc*/ - 0, /*tp_print*/ - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - 0, /*tp_compare*/ - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash*/ - 0, /*tp_call*/ - 0, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, - Unpickler_doc, /*tp_doc*/ - (traverseproc)Unpickler_traverse, /*tp_traverse*/ - (inquiry)Unpickler_clear, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - Unpickler_methods, /*tp_methods*/ - 0, /*tp_members*/ - Unpickler_getsets, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - 0, /*tp_dictoffset*/ - (initproc)Unpickler_init, /*tp_init*/ - PyType_GenericAlloc, /*tp_alloc*/ - PyType_GenericNew, /*tp_new*/ - PyObject_GC_Del, /*tp_free*/ - 0, /*tp_is_gc*/ -}; - -static int -init_stuff(void) -{ - PyObject *copyreg; - - copyreg = PyImport_ImportModule("copyreg"); - if (!copyreg) - return -1; - - dispatch_table = PyObject_GetAttrString(copyreg, "dispatch_table"); - if (!dispatch_table) - goto error; - - extension_registry = \ - PyObject_GetAttrString(copyreg, "_extension_registry"); - if (!extension_registry) - goto error; - - inverted_registry = PyObject_GetAttrString(copyreg, "_inverted_registry"); - if (!inverted_registry) - goto error; - - extension_cache = PyObject_GetAttrString(copyreg, "_extension_cache"); - if (!extension_cache) - goto error; - - Py_DECREF(copyreg); - - empty_tuple = PyTuple_New(0); - if (empty_tuple == NULL) - return -1; - - two_tuple = PyTuple_New(2); - if (two_tuple == NULL) - return -1; - /* We use this temp container with no regard to refcounts, or to - * keeping containees alive. Exempt from GC, because we don't - * want anything looking at two_tuple() by magic. - */ - PyObject_GC_UnTrack(two_tuple); - - return 0; - - error: - Py_DECREF(copyreg); - return -1; -} - -static struct PyModuleDef _picklemodule = { - PyModuleDef_HEAD_INIT, - "_pickle", - pickle_module_doc, - -1, - NULL, - NULL, - NULL, - NULL, - NULL -}; - -PyMODINIT_FUNC -PyInit__pickle(void) -{ - PyObject *m; - - if (PyType_Ready(&Unpickler_Type) < 0) - return NULL; - if (PyType_Ready(&Pickler_Type) < 0) - return NULL; - if (PyType_Ready(&Pdata_Type) < 0) - return NULL; - - /* Create the module and add the functions. */ - m = PyModule_Create(&_picklemodule); - if (m == NULL) - return NULL; - - if (PyModule_AddObject(m, "Pickler", (PyObject *)&Pickler_Type) < 0) - return NULL; - if (PyModule_AddObject(m, "Unpickler", (PyObject *)&Unpickler_Type) < 0) - return NULL; - - /* Initialize the exceptions. */ - PickleError = PyErr_NewException("_pickle.PickleError", NULL, NULL); - if (PickleError == NULL) - return NULL; - PicklingError = \ - PyErr_NewException("_pickle.PicklingError", PickleError, NULL); - if (PicklingError == NULL) - return NULL; - UnpicklingError = \ - PyErr_NewException("_pickle.UnpicklingError", PickleError, NULL); - if (UnpicklingError == NULL) - return NULL; - - if (PyModule_AddObject(m, "PickleError", PickleError) < 0) - return NULL; - if (PyModule_AddObject(m, "PicklingError", PicklingError) < 0) - return NULL; - if (PyModule_AddObject(m, "UnpicklingError", UnpicklingError) < 0) - return NULL; - - if (init_stuff() < 0) - return NULL; - - return m; -} |