1 #include "Python.h"
2 #include "cStringIO.h"
3 #include "structmember.h"
4
5 PyDoc_STRVAR(cPickle_module_documentation,
6 "C implementation and optimization of the Python pickle module.");
7
8 #ifndef Py_eval_input
9 #include <graminit.h>
10 #define Py_eval_input eval_input
11 #endif /* Py_eval_input */
12
13 #define DEL_LIST_SLICE(list, from, to) (PyList_SetSlice(list, from, to, NULL))
14
15 #define WRITE_BUF_SIZE 256
16
17 /* Bump this when new opcodes are added to the pickle protocol. */
18 #define HIGHEST_PROTOCOL 2
19
20 /*
21 * Note: The UNICODE macro controls the TCHAR meaning of the win32 API. Since
22 * all headers have already been included here, we can safely redefine it.
23 */
24 #ifdef UNICODE
25 # undef UNICODE
26 #endif
27
28 /*
29 * Pickle opcodes. These must be kept in synch with pickle.py. Extensive
30 * docs are in pickletools.py.
31 */
32 #define MARK '('
33 #define STOP '.'
34 #define POP '0'
35 #define POP_MARK '1'
36 #define DUP '2'
37 #define FLOAT 'F'
38 #define BINFLOAT 'G'
39 #define INT 'I'
40 #define BININT 'J'
41 #define BININT1 'K'
42 #define LONG 'L'
43 #define BININT2 'M'
44 #define NONE 'N'
45 #define PERSID 'P'
46 #define BINPERSID 'Q'
47 #define REDUCE 'R'
48 #define STRING 'S'
49 #define BINSTRING 'T'
50 #define SHORT_BINSTRING 'U'
51 #define UNICODE 'V'
52 #define BINUNICODE 'X'
53 #define APPEND 'a'
54 #define BUILD 'b'
55 #define GLOBAL 'c'
56 #define DICT 'd'
57 #define EMPTY_DICT '}'
58 #define APPENDS 'e'
59 #define GET 'g'
60 #define BINGET 'h'
61 #define INST 'i'
62 #define LONG_BINGET 'j'
63 #define LIST 'l'
64 #define EMPTY_LIST ']'
65 #define OBJ 'o'
66 #define PUT 'p'
67 #define BINPUT 'q'
68 #define LONG_BINPUT 'r'
69 #define SETITEM 's'
70 #define TUPLE 't'
71 #define EMPTY_TUPLE ')'
72 #define SETITEMS 'u'
73
74 /* Protocol 2. */
75 #define PROTO '\x80' /* identify pickle protocol */
76 #define NEWOBJ '\x81' /* build object by applying cls.__new__ to argtuple */
77 #define EXT1 '\x82' /* push object from extension registry; 1-byte index */
78 #define EXT2 '\x83' /* ditto, but 2-byte index */
79 #define EXT4 '\x84' /* ditto, but 4-byte index */
80 #define TUPLE1 '\x85' /* build 1-tuple from stack top */
81 #define TUPLE2 '\x86' /* build 2-tuple from two topmost stack items */
82 #define TUPLE3 '\x87' /* build 3-tuple from three topmost stack items */
83 #define NEWTRUE '\x88' /* push True */
84 #define NEWFALSE '\x89' /* push False */
85 #define LONG1 '\x8a' /* push long from < 256 bytes */
86 #define LONG4 '\x8b' /* push really big long */
87
88 /* There aren't opcodes -- they're ways to pickle bools before protocol 2,
89 * so that unpicklers written before bools were introduced unpickle them
90 * as ints, but unpicklers after can recognize that bools were intended.
91 * Note that protocol 2 added direct ways to pickle bools.
92 */
93 #undef TRUE
94 #define TRUE "I01\n"
95 #undef FALSE
96 #define FALSE "I00\n"
97
98 /* Keep in synch with pickle.Pickler._BATCHSIZE. This is how many elements
99 * batch_list/dict() pumps out before doing APPENDS/SETITEMS. Nothing will
100 * break if this gets out of synch with pickle.py, but it's unclear that
101 * would help anything either.
102 */
103 #define BATCHSIZE 1000
104
105 static char MARKv = MARK;
106
107 static PyObject *PickleError;
108 static PyObject *PicklingError;
109 static PyObject *UnpickleableError;
110 static PyObject *UnpicklingError;
111 static PyObject *BadPickleGet;
112
113 /* As the name says, an empty tuple. */
114 static PyObject *empty_tuple;
115
116 /* copy_reg.dispatch_table, {type_object: pickling_function} */
117 static PyObject *dispatch_table;
118
119 /* For EXT[124] opcodes. */
120 /* copy_reg._extension_registry, {(module_name, function_name): code} */
121 static PyObject *extension_registry;
122 /* copy_reg._inverted_registry, {code: (module_name, function_name)} */
123 static PyObject *inverted_registry;
124 /* copy_reg._extension_cache, {code: object} */
125 static PyObject *extension_cache;
126
127 /* For looking up name pairs in copy_reg._extension_registry. */
128 static PyObject *two_tuple;
129
130 static PyObject *__class___str, *__getinitargs___str, *__dict___str,
131 *__getstate___str, *__setstate___str, *__name___str, *__reduce___str,
132 *__reduce_ex___str,
133 *write_str, *append_str,
134 *read_str, *readline_str, *__main___str,
135 *dispatch_table_str;
136
137 /*************************************************************************
138 Internal Data type for pickle data. */
139
140 typedef struct {
141 PyObject_HEAD
142 Py_ssize_t length; /* number of initial slots in data currently used */
143 Py_ssize_t size; /* number of slots in data allocated */
144 PyObject **data;
145 } Pdata;
146
147 static void
Pdata_dealloc(Pdata * self)148 Pdata_dealloc(Pdata *self)
149 {
150 Py_ssize_t i;
151 PyObject **p;
152
153 for (i = self->length, p = self->data; --i >= 0; p++) {
154 Py_DECREF(*p);
155 }
156 if (self->data)
157 free(self->data);
158 PyObject_Del(self);
159 }
160
161 static PyTypeObject PdataType = {
162 PyVarObject_HEAD_INIT(NULL, 0) "cPickle.Pdata", sizeof(Pdata), 0,
163 (destructor)Pdata_dealloc,
164 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0L,0L,0L,0L, ""
165 };
166
167 #define Pdata_Check(O) (Py_TYPE(O) == &PdataType)
168
169 static PyObject *
Pdata_New(void)170 Pdata_New(void)
171 {
172 Pdata *self;
173
174 if (!(self = PyObject_New(Pdata, &PdataType)))
175 return NULL;
176 self->size = 8;
177 self->length = 0;
178 self->data = malloc(self->size * sizeof(PyObject*));
179 if (self->data)
180 return (PyObject*)self;
181 Py_DECREF(self);
182 return PyErr_NoMemory();
183 }
184
185 static int
stackUnderflow(void)186 stackUnderflow(void)
187 {
188 PyErr_SetString(UnpicklingError, "unpickling stack underflow");
189 return -1;
190 }
191
192 /* Retain only the initial clearto items. If clearto >= the current
193 * number of items, this is a (non-erroneous) NOP.
194 */
195 static int
Pdata_clear(Pdata * self,Py_ssize_t clearto)196 Pdata_clear(Pdata *self, Py_ssize_t clearto)
197 {
198 Py_ssize_t i;
199 PyObject **p;
200
201 if (clearto < 0) return stackUnderflow();
202 if (clearto >= self->length) return 0;
203
204 for (i = self->length, p = self->data + clearto;
205 --i >= clearto;
206 p++) {
207 Py_CLEAR(*p);
208 }
209 self->length = clearto;
210
211 return 0;
212 }
213
214 static int
Pdata_grow(Pdata * self)215 Pdata_grow(Pdata *self)
216 {
217 Py_ssize_t bigger;
218 Py_ssize_t nbytes;
219
220 PyObject **tmp;
221
222 if (self->size > (PY_SSIZE_T_MAX >> 1))
223 goto nomemory;
224 bigger = self->size << 1;
225 if (bigger > (PY_SSIZE_T_MAX / sizeof(PyObject *)))
226 goto nomemory;
227 nbytes = bigger * sizeof(PyObject *);
228 tmp = realloc(self->data, nbytes);
229 if (tmp == NULL)
230 goto nomemory;
231 self->data = tmp;
232 self->size = bigger;
233 return 0;
234
235 nomemory:
236 PyErr_NoMemory();
237 return -1;
238 }
239
240 /* D is a Pdata*. Pop the topmost element and store it into V, which
241 * must be an lvalue holding PyObject*. On stack underflow, UnpicklingError
242 * is raised and V is set to NULL. D and V may be evaluated several times.
243 */
244 #define PDATA_POP(D, V) { \
245 if ((D)->length) \
246 (V) = (D)->data[--((D)->length)]; \
247 else { \
248 PyErr_SetString(UnpicklingError, "bad pickle data"); \
249 (V) = NULL; \
250 } \
251 }
252
253 /* PDATA_PUSH and PDATA_APPEND both push rvalue PyObject* O on to Pdata*
254 * D. If the Pdata stack can't be grown to hold the new value, both
255 * raise MemoryError and execute "return ER". The difference is in ownership
256 * of O after: _PUSH transfers ownership of O from the caller to the stack
257 * (no incref of O is done, and in case of error O is decrefed), while
258 * _APPEND pushes a new reference.
259 */
260
261 /* Push O on stack D, giving ownership of O to the stack. */
262 #define PDATA_PUSH(D, O, ER) { \
263 if (((Pdata*)(D))->length == ((Pdata*)(D))->size && \
264 Pdata_grow((Pdata*)(D)) < 0) { \
265 Py_DECREF(O); \
266 return ER; \
267 } \
268 ((Pdata*)(D))->data[((Pdata*)(D))->length++] = (O); \
269 }
270
271 /* Push O on stack D, pushing a new reference. */
272 #define PDATA_APPEND(D, O, ER) { \
273 if (((Pdata*)(D))->length == ((Pdata*)(D))->size && \
274 Pdata_grow((Pdata*)(D)) < 0) \
275 return ER; \
276 Py_INCREF(O); \
277 ((Pdata*)(D))->data[((Pdata*)(D))->length++] = (O); \
278 }
279
280
281 static PyObject *
Pdata_popTuple(Pdata * self,Py_ssize_t start)282 Pdata_popTuple(Pdata *self, Py_ssize_t start)
283 {
284 PyObject *r;
285 Py_ssize_t i, j, l;
286
287 l = self->length-start;
288 r = PyTuple_New(l);
289 if (r == NULL)
290 return NULL;
291 for (i = start, j = 0 ; j < l; i++, j++)
292 PyTuple_SET_ITEM(r, j, self->data[i]);
293
294 self->length = start;
295 return r;
296 }
297
298 static PyObject *
Pdata_popList(Pdata * self,Py_ssize_t start)299 Pdata_popList(Pdata *self, Py_ssize_t start)
300 {
301 PyObject *r;
302 Py_ssize_t i, j, l;
303
304 l=self->length-start;
305 if (!( r=PyList_New(l))) return NULL;
306 for (i=start, j=0 ; j < l; i++, j++)
307 PyList_SET_ITEM(r, j, self->data[i]);
308
309 self->length=start;
310 return r;
311 }
312
313 /*************************************************************************/
314
315 #define ARG_TUP(self, o) { \
316 if (self->arg || (self->arg=PyTuple_New(1))) { \
317 Py_XDECREF(PyTuple_GET_ITEM(self->arg,0)); \
318 PyTuple_SET_ITEM(self->arg,0,o); \
319 } \
320 else { \
321 Py_DECREF(o); \
322 } \
323 }
324
325 #define FREE_ARG_TUP(self) { \
326 if (Py_REFCNT(self->arg) > 1) { \
327 Py_CLEAR(self->arg); \
328 } \
329 }
330
331 typedef struct Picklerobject {
332 PyObject_HEAD
333 FILE *fp;
334 PyObject *write;
335 PyObject *file;
336 PyObject *memo;
337 PyObject *arg;
338 PyObject *pers_func;
339 PyObject *inst_pers_func;
340
341 /* pickle protocol number, >= 0 */
342 int proto;
343
344 /* bool, true if proto > 0 */
345 int bin;
346
347 int fast; /* Fast mode doesn't save in memo, don't use if circ ref */
348 Py_ssize_t (*write_func)(struct Picklerobject *, const char *, Py_ssize_t);
349 char *write_buf;
350 Py_ssize_t buf_size;
351 PyObject *dispatch_table;
352 int fast_container; /* count nested container dumps */
353 PyObject *fast_memo;
354 } Picklerobject;
355
356 #ifndef PY_CPICKLE_FAST_LIMIT
357 #define PY_CPICKLE_FAST_LIMIT 50
358 #endif
359
360 static PyTypeObject Picklertype;
361
362 typedef struct Unpicklerobject {
363 PyObject_HEAD
364 FILE *fp;
365 PyObject *file;
366 PyObject *readline;
367 PyObject *read;
368 PyObject *memo;
369 PyObject *arg;
370 Pdata *stack;
371 PyObject *mark;
372 PyObject *pers_func;
373 PyObject *last_string;
374 Py_ssize_t *marks;
375 Py_ssize_t num_marks;
376 Py_ssize_t marks_size;
377 Py_ssize_t (*read_func)(struct Unpicklerobject *, char **, Py_ssize_t);
378 Py_ssize_t (*readline_func)(struct Unpicklerobject *, char **);
379 Py_ssize_t buf_size;
380 char *buf;
381 PyObject *find_class;
382 } Unpicklerobject;
383
384 static PyTypeObject Unpicklertype;
385
386 /* Forward decls that need the above structs */
387 static int save(Picklerobject *, PyObject *, int);
388 static int put2(Picklerobject *, PyObject *);
389
390 static
391 PyObject *
cPickle_ErrFormat(PyObject * ErrType,char * stringformat,char * format,...)392 cPickle_ErrFormat(PyObject *ErrType, char *stringformat, char *format, ...)
393 {
394 va_list va;
395 PyObject *args=0, *retval=0;
396 va_start(va, format);
397
398 if (format) args = Py_VaBuildValue(format, va);
399 va_end(va);
400 if (format && ! args) return NULL;
401 if (stringformat && !(retval=PyString_FromString(stringformat)))
402 return NULL;
403
404 if (retval) {
405 if (args) {
406 PyObject *v;
407 v=PyString_Format(retval, args);
408 Py_DECREF(retval);
409 Py_DECREF(args);
410 if (! v) return NULL;
411 retval=v;
412 }
413 }
414 else
415 if (args) retval=args;
416 else {
417 PyErr_SetObject(ErrType,Py_None);
418 return NULL;
419 }
420 PyErr_SetObject(ErrType,retval);
421 Py_DECREF(retval);
422 return NULL;
423 }
424
425 static Py_ssize_t
write_file(Picklerobject * self,const char * s,Py_ssize_t n)426 write_file(Picklerobject *self, const char *s, Py_ssize_t n)
427 {
428 size_t nbyteswritten;
429
430 if (s == NULL) {
431 return 0;
432 }
433
434 PyFile_IncUseCount((PyFileObject *)self->file);
435 Py_BEGIN_ALLOW_THREADS
436 nbyteswritten = fwrite(s, sizeof(char), n, self->fp);
437 Py_END_ALLOW_THREADS
438 PyFile_DecUseCount((PyFileObject *)self->file);
439 if (nbyteswritten != (size_t)n) {
440 PyErr_SetFromErrno(PyExc_IOError);
441 return -1;
442 }
443
444 return n;
445 }
446
447 static Py_ssize_t
write_cStringIO(Picklerobject * self,const char * s,Py_ssize_t n)448 write_cStringIO(Picklerobject *self, const char *s, Py_ssize_t n)
449 {
450 Py_ssize_t len = n;
451
452 if (s == NULL) {
453 return 0;
454 }
455
456 while (n > INT_MAX) {
457 if (PycStringIO->cwrite((PyObject *)self->file, s, INT_MAX) != INT_MAX) {
458 return -1;
459 }
460 n -= INT_MAX;
461 }
462
463 if (PycStringIO->cwrite((PyObject *)self->file, s, n) != n) {
464 return -1;
465 }
466
467 return len;
468 }
469
470 static Py_ssize_t
write_none(Picklerobject * self,const char * s,Py_ssize_t n)471 write_none(Picklerobject *self, const char *s, Py_ssize_t n)
472 {
473 if (s == NULL) return 0;
474 return n;
475 }
476
477 static Py_ssize_t
write_other(Picklerobject * self,const char * s,Py_ssize_t n)478 write_other(Picklerobject *self, const char *s, Py_ssize_t n)
479 {
480 PyObject *py_str = 0, *junk = 0;
481
482 if (s == NULL) {
483 if (!( self->buf_size )) return 0;
484 py_str = PyString_FromStringAndSize(self->write_buf,
485 self->buf_size);
486 if (!py_str)
487 return -1;
488 }
489 else {
490 if (self->buf_size && n > WRITE_BUF_SIZE - self->buf_size) {
491 if (write_other(self, NULL, 0) < 0)
492 return -1;
493 }
494
495 if (n > WRITE_BUF_SIZE) {
496 if (!( py_str =
497 PyString_FromStringAndSize(s, n)))
498 return -1;
499 }
500 else {
501 memcpy(self->write_buf + self->buf_size, s, n);
502 self->buf_size += n;
503 return n;
504 }
505 }
506
507 if (self->write) {
508 /* object with write method */
509 ARG_TUP(self, py_str);
510 if (self->arg) {
511 junk = PyObject_Call(self->write, self->arg, NULL);
512 FREE_ARG_TUP(self);
513 }
514 if (junk) Py_DECREF(junk);
515 else return -1;
516 }
517 else
518 PDATA_PUSH(self->file, py_str, -1);
519
520 self->buf_size = 0;
521 return n;
522 }
523
524
525 static Py_ssize_t
read_file(Unpicklerobject * self,char ** s,Py_ssize_t n)526 read_file(Unpicklerobject *self, char **s, Py_ssize_t n)
527 {
528 size_t nbytesread;
529
530 if (self->buf_size == 0) {
531 Py_ssize_t size;
532
533 size = ((n < 32) ? 32 : n);
534 if (!( self->buf = (char *)malloc(size))) {
535 PyErr_NoMemory();
536 return -1;
537 }
538
539 self->buf_size = size;
540 }
541 else if (n > self->buf_size) {
542 char *newbuf = (char *)realloc(self->buf, n);
543 if (!newbuf) {
544 PyErr_NoMemory();
545 return -1;
546 }
547 self->buf = newbuf;
548 self->buf_size = n;
549 }
550
551 PyFile_IncUseCount((PyFileObject *)self->file);
552 Py_BEGIN_ALLOW_THREADS
553 nbytesread = fread(self->buf, sizeof(char), n, self->fp);
554 Py_END_ALLOW_THREADS
555 PyFile_DecUseCount((PyFileObject *)self->file);
556 if (nbytesread != (size_t)n) {
557 if (feof(self->fp)) {
558 PyErr_SetNone(PyExc_EOFError);
559 return -1;
560 }
561
562 PyErr_SetFromErrno(PyExc_IOError);
563 return -1;
564 }
565
566 *s = self->buf;
567
568 return n;
569 }
570
571
572 static Py_ssize_t
readline_file(Unpicklerobject * self,char ** s)573 readline_file(Unpicklerobject *self, char **s)
574 {
575 Py_ssize_t i;
576
577 if (self->buf_size == 0) {
578 if (!( self->buf = (char *)malloc(40))) {
579 PyErr_NoMemory();
580 return -1;
581 }
582 self->buf_size = 40;
583 }
584
585 i = 0;
586 while (1) {
587 Py_ssize_t bigger;
588 char *newbuf;
589 for (; i < (self->buf_size - 1); i++) {
590 if (feof(self->fp) ||
591 (self->buf[i] = getc(self->fp)) == '\n') {
592 self->buf[i + 1] = '\0';
593 *s = self->buf;
594 return i + 1;
595 }
596 }
597 if (self->buf_size > (PY_SSIZE_T_MAX >> 1)) {
598 PyErr_NoMemory();
599 return -1;
600 }
601 bigger = self->buf_size << 1;
602 newbuf = (char *)realloc(self->buf, bigger);
603 if (newbuf == NULL) {
604 PyErr_NoMemory();
605 return -1;
606 }
607 self->buf = newbuf;
608 self->buf_size = bigger;
609 }
610 }
611
612
613 static Py_ssize_t
read_cStringIO(Unpicklerobject * self,char ** s,Py_ssize_t n)614 read_cStringIO(Unpicklerobject *self, char **s, Py_ssize_t n)
615 {
616 Py_ssize_t len = n;
617 char *start, *end = NULL;
618
619 while (1) {
620 int k;
621 char *ptr;
622 if (n > INT_MAX)
623 k = INT_MAX;
624 else
625 k = (int)n;
626 if (PycStringIO->cread((PyObject *)self->file, &ptr, k) != k) {
627 PyErr_SetNone(PyExc_EOFError);
628 return -1;
629 }
630 if (end == NULL)
631 start = ptr;
632 else if (ptr != end) {
633 /* non-continuous area */
634 return -1;
635 }
636 if (n <= INT_MAX)
637 break;
638 end = ptr + INT_MAX;
639 n -= INT_MAX;
640 }
641
642 *s = start;
643
644 return len;
645 }
646
647
648 static Py_ssize_t
readline_cStringIO(Unpicklerobject * self,char ** s)649 readline_cStringIO(Unpicklerobject *self, char **s)
650 {
651 Py_ssize_t n = 0;
652 char *start = NULL, *end = NULL;
653
654 while (1) {
655 int k;
656 char *ptr;
657 if ((k = PycStringIO->creadline((PyObject *)self->file, &ptr)) < 0) {
658 return -1;
659 }
660 n += k;
661 if (end == NULL)
662 start = ptr;
663 else if (ptr != end) {
664 /* non-continuous area */
665 return -1;
666 }
667 if (k == 0 || ptr[k - 1] == '\n')
668 break;
669 end = ptr + k;
670 }
671
672 *s = start;
673
674 return n;
675 }
676
677
678 static Py_ssize_t
read_other(Unpicklerobject * self,char ** s,Py_ssize_t n)679 read_other(Unpicklerobject *self, char **s, Py_ssize_t n)
680 {
681 PyObject *bytes, *str=0;
682
683 if (!( bytes = PyInt_FromSsize_t(n))) return -1;
684
685 ARG_TUP(self, bytes);
686 if (self->arg) {
687 str = PyObject_Call(self->read, self->arg, NULL);
688 FREE_ARG_TUP(self);
689 }
690 if (! str) return -1;
691
692 Py_XDECREF(self->last_string);
693 self->last_string = str;
694
695 if (! (*s = PyString_AsString(str))) return -1;
696
697 if (PyString_GET_SIZE(str) != n) {
698 PyErr_SetNone(PyExc_EOFError);
699 return -1;
700 }
701
702 return n;
703 }
704
705
706 static Py_ssize_t
readline_other(Unpicklerobject * self,char ** s)707 readline_other(Unpicklerobject *self, char **s)
708 {
709 PyObject *str;
710 Py_ssize_t str_size;
711
712 if (!( str = PyObject_CallObject(self->readline, empty_tuple))) {
713 return -1;
714 }
715
716 if ((str_size = PyString_Size(str)) < 0)
717 return -1;
718
719 Py_XDECREF(self->last_string);
720 self->last_string = str;
721
722 if (! (*s = PyString_AsString(str)))
723 return -1;
724
725 return str_size;
726 }
727
728 /* Copy the first n bytes from s into newly malloc'ed memory, plus a
729 * trailing 0 byte. Return a pointer to that, or NULL if out of memory.
730 * The caller is responsible for free()'ing the return value.
731 */
732 static char *
pystrndup(const char * s,Py_ssize_t n)733 pystrndup(const char *s, Py_ssize_t n)
734 {
735 char *r = (char *)malloc(n+1);
736 if (r == NULL)
737 return (char*)PyErr_NoMemory();
738 memcpy(r, s, n);
739 r[n] = 0;
740 return r;
741 }
742
743
744 static int
get(Picklerobject * self,PyObject * id)745 get(Picklerobject *self, PyObject *id)
746 {
747 PyObject *value, *mv;
748 Py_ssize_t c_value;
749 char s[30];
750 size_t len;
751
752 if (!( mv = PyDict_GetItem(self->memo, id))) {
753 PyErr_SetObject(PyExc_KeyError, id);
754 return -1;
755 }
756
757 if (!( value = PyTuple_GetItem(mv, 0)))
758 return -1;
759
760 if (!( PyInt_Check(value))) {
761 PyErr_SetString(PicklingError, "no int where int expected in memo");
762 return -1;
763 }
764 c_value = PyInt_AS_LONG((PyIntObject*)value);
765
766 if (!self->bin) {
767 s[0] = GET;
768 PyOS_snprintf(s + 1, sizeof(s) - 1,
769 "%" PY_FORMAT_SIZE_T "d\n", c_value);
770 len = strlen(s);
771 }
772 else if (Pdata_Check(self->file)) {
773 if (write_other(self, NULL, 0) < 0) return -1;
774 PDATA_APPEND(self->file, mv, -1);
775 return 0;
776 }
777 else {
778 if (c_value < 256) {
779 s[0] = BINGET;
780 s[1] = (int)(c_value & 0xff);
781 len = 2;
782 }
783 else {
784 s[0] = LONG_BINGET;
785 s[1] = (int)(c_value & 0xff);
786 s[2] = (int)((c_value >> 8) & 0xff);
787 s[3] = (int)((c_value >> 16) & 0xff);
788 s[4] = (int)((c_value >> 24) & 0xff);
789 len = 5;
790 }
791 }
792
793 if (self->write_func(self, s, len) < 0)
794 return -1;
795
796 return 0;
797 }
798
799
800 static int
put(Picklerobject * self,PyObject * ob)801 put(Picklerobject *self, PyObject *ob)
802 {
803 if (Py_REFCNT(ob) < 2 || self->fast)
804 return 0;
805
806 return put2(self, ob);
807 }
808
809
810 static int
put2(Picklerobject * self,PyObject * ob)811 put2(Picklerobject *self, PyObject *ob)
812 {
813 char c_str[30];
814 Py_ssize_t len, p;
815 int res = -1;
816 PyObject *py_ob_id = 0, *memo_len = 0, *t = 0;
817
818 if (self->fast)
819 return 0;
820
821 if ((p = PyDict_Size(self->memo)) < 0)
822 goto finally;
823
824 /* Make sure memo keys are positive! */
825 /* XXX Why?
826 * XXX And does "positive" really mean non-negative?
827 * XXX pickle.py starts with PUT index 0, not 1. This makes for
828 * XXX gratuitous differences between the pickling modules.
829 */
830 p++;
831
832 if (!( py_ob_id = PyLong_FromVoidPtr(ob)))
833 goto finally;
834
835 if (!( memo_len = PyInt_FromLong(p)))
836 goto finally;
837
838 if (!( t = PyTuple_New(2)))
839 goto finally;
840
841 PyTuple_SET_ITEM(t, 0, memo_len);
842 Py_INCREF(memo_len);
843 PyTuple_SET_ITEM(t, 1, ob);
844 Py_INCREF(ob);
845
846 if (PyDict_SetItem(self->memo, py_ob_id, t) < 0)
847 goto finally;
848
849 if (!self->bin) {
850 c_str[0] = PUT;
851 PyOS_snprintf(c_str + 1, sizeof(c_str) - 1,
852 "%" PY_FORMAT_SIZE_T "d\n", p);
853 len = strlen(c_str);
854 }
855 else if (Pdata_Check(self->file)) {
856 if (write_other(self, NULL, 0) < 0) return -1;
857 PDATA_APPEND(self->file, memo_len, -1);
858 res=0; /* Job well done ;) */
859 goto finally;
860 }
861 else {
862 if (p >= 256) {
863 c_str[0] = LONG_BINPUT;
864 c_str[1] = (int)(p & 0xff);
865 c_str[2] = (int)((p >> 8) & 0xff);
866 c_str[3] = (int)((p >> 16) & 0xff);
867 c_str[4] = (int)((p >> 24) & 0xff);
868 len = 5;
869 }
870 else {
871 c_str[0] = BINPUT;
872 c_str[1] = p;
873 len = 2;
874 }
875 }
876
877 if (self->write_func(self, c_str, len) < 0)
878 goto finally;
879
880 res = 0;
881
882 finally:
883 Py_XDECREF(py_ob_id);
884 Py_XDECREF(memo_len);
885 Py_XDECREF(t);
886
887 return res;
888 }
889
890 static PyObject *
whichmodule(PyObject * global,PyObject * global_name)891 whichmodule(PyObject *global, PyObject *global_name)
892 {
893 Py_ssize_t i, j;
894 PyObject *module = 0, *modules_dict = 0,
895 *global_name_attr = 0, *name = 0;
896
897 module = PyObject_GetAttrString(global, "__module__");
898 if (module)
899 return module;
900 if (PyErr_ExceptionMatches(PyExc_AttributeError))
901 PyErr_Clear();
902 else
903 return NULL;
904
905 if (!( modules_dict = PySys_GetObject("modules")))
906 return NULL;
907
908 i = 0;
909 while ((j = PyDict_Next(modules_dict, &i, &name, &module))) {
910
911 if (PyObject_Compare(name, __main___str)==0) continue;
912
913 global_name_attr = PyObject_GetAttr(module, global_name);
914 if (!global_name_attr) {
915 if (PyErr_ExceptionMatches(PyExc_AttributeError))
916 PyErr_Clear();
917 else
918 return NULL;
919 continue;
920 }
921
922 if (global_name_attr != global) {
923 Py_DECREF(global_name_attr);
924 continue;
925 }
926
927 Py_DECREF(global_name_attr);
928
929 break;
930 }
931
932 /* The following implements the rule in pickle.py added in 1.5
933 that used __main__ if no module is found. I don't actually
934 like this rule. jlf
935 */
936 if (!j) {
937 name=__main___str;
938 }
939
940 Py_INCREF(name);
941 return name;
942 }
943
944
945 static int
fast_save_enter(Picklerobject * self,PyObject * obj)946 fast_save_enter(Picklerobject *self, PyObject *obj)
947 {
948 /* if fast_container < 0, we're doing an error exit. */
949 if (++self->fast_container >= PY_CPICKLE_FAST_LIMIT) {
950 PyObject *key = NULL;
951 if (self->fast_memo == NULL) {
952 self->fast_memo = PyDict_New();
953 if (self->fast_memo == NULL) {
954 self->fast_container = -1;
955 return 0;
956 }
957 }
958 key = PyLong_FromVoidPtr(obj);
959 if (key == NULL)
960 return 0;
961 if (PyDict_GetItem(self->fast_memo, key)) {
962 Py_DECREF(key);
963 PyErr_Format(PyExc_ValueError,
964 "fast mode: can't pickle cyclic objects "
965 "including object type %s at %p",
966 Py_TYPE(obj)->tp_name, obj);
967 self->fast_container = -1;
968 return 0;
969 }
970 if (PyDict_SetItem(self->fast_memo, key, Py_None) < 0) {
971 Py_DECREF(key);
972 self->fast_container = -1;
973 return 0;
974 }
975 Py_DECREF(key);
976 }
977 return 1;
978 }
979
980 int
fast_save_leave(Picklerobject * self,PyObject * obj)981 fast_save_leave(Picklerobject *self, PyObject *obj)
982 {
983 if (self->fast_container-- >= PY_CPICKLE_FAST_LIMIT) {
984 PyObject *key = PyLong_FromVoidPtr(obj);
985 if (key == NULL)
986 return 0;
987 if (PyDict_DelItem(self->fast_memo, key) < 0) {
988 Py_DECREF(key);
989 return 0;
990 }
991 Py_DECREF(key);
992 }
993 return 1;
994 }
995
996 static int
save_none(Picklerobject * self,PyObject * args)997 save_none(Picklerobject *self, PyObject *args)
998 {
999 static char none = NONE;
1000 if (self->write_func(self, &none, 1) < 0)
1001 return -1;
1002
1003 return 0;
1004 }
1005
1006 static int
save_bool(Picklerobject * self,PyObject * args)1007 save_bool(Picklerobject *self, PyObject *args)
1008 {
1009 static const char *buf[2] = {FALSE, TRUE};
1010 static char len[2] = {sizeof(FALSE)-1, sizeof(TRUE)-1};
1011 long l = PyInt_AS_LONG((PyIntObject *)args);
1012
1013 if (self->proto >= 2) {
1014 char opcode = l ? NEWTRUE : NEWFALSE;
1015 if (self->write_func(self, &opcode, 1) < 0)
1016 return -1;
1017 }
1018 else if (self->write_func(self, buf[l], len[l]) < 0)
1019 return -1;
1020 return 0;
1021 }
1022
1023 static int
save_int(Picklerobject * self,PyObject * args)1024 save_int(Picklerobject *self, PyObject *args)
1025 {
1026 char c_str[32];
1027 long l = PyInt_AS_LONG((PyIntObject *)args);
1028 Py_ssize_t len = 0;
1029
1030 if (!self->bin
1031 #if SIZEOF_LONG > 4
1032 || l > 0x7fffffffL
1033 || l < -0x80000000L
1034 #endif
1035 ) {
1036 /* Text-mode pickle, or long too big to fit in the 4-byte
1037 * signed BININT format: store as a string.
1038 */
1039 c_str[0] = INT;
1040 PyOS_snprintf(c_str + 1, sizeof(c_str) - 1, "%ld\n", l);
1041 if (self->write_func(self, c_str, strlen(c_str)) < 0)
1042 return -1;
1043 }
1044 else {
1045 /* Binary pickle and l fits in a signed 4-byte int. */
1046 c_str[1] = (int)( l & 0xff);
1047 c_str[2] = (int)((l >> 8) & 0xff);
1048 c_str[3] = (int)((l >> 16) & 0xff);
1049 c_str[4] = (int)((l >> 24) & 0xff);
1050
1051 if ((c_str[4] == 0) && (c_str[3] == 0)) {
1052 if (c_str[2] == 0) {
1053 c_str[0] = BININT1;
1054 len = 2;
1055 }
1056 else {
1057 c_str[0] = BININT2;
1058 len = 3;
1059 }
1060 }
1061 else {
1062 c_str[0] = BININT;
1063 len = 5;
1064 }
1065
1066 if (self->write_func(self, c_str, len) < 0)
1067 return -1;
1068 }
1069
1070 return 0;
1071 }
1072
1073
1074 static int
save_long(Picklerobject * self,PyObject * args)1075 save_long(Picklerobject *self, PyObject *args)
1076 {
1077 Py_ssize_t size;
1078 int res = -1;
1079 PyObject *repr = NULL;
1080
1081 static char l = LONG;
1082
1083 if (self->proto >= 2) {
1084 /* Linear-time pickling. */
1085 size_t nbits;
1086 size_t nbytes;
1087 unsigned char *pdata;
1088 char c_str[5];
1089 int i;
1090 int sign = _PyLong_Sign(args);
1091
1092 if (sign == 0) {
1093 /* It's 0 -- an empty bytestring. */
1094 c_str[0] = LONG1;
1095 c_str[1] = 0;
1096 i = self->write_func(self, c_str, 2);
1097 if (i < 0) goto finally;
1098 res = 0;
1099 goto finally;
1100 }
1101 nbits = _PyLong_NumBits(args);
1102 if (nbits == (size_t)-1 && PyErr_Occurred())
1103 goto finally;
1104 /* How many bytes do we need? There are nbits >> 3 full
1105 * bytes of data, and nbits & 7 leftover bits. If there
1106 * are any leftover bits, then we clearly need another
1107 * byte. Wnat's not so obvious is that we *probably*
1108 * need another byte even if there aren't any leftovers:
1109 * the most-significant bit of the most-significant byte
1110 * acts like a sign bit, and it's usually got a sense
1111 * opposite of the one we need. The exception is longs
1112 * of the form -(2**(8*j-1)) for j > 0. Such a long is
1113 * its own 256's-complement, so has the right sign bit
1114 * even without the extra byte. That's a pain to check
1115 * for in advance, though, so we always grab an extra
1116 * byte at the start, and cut it back later if possible.
1117 */
1118 nbytes = (nbits >> 3) + 1;
1119 if (nbytes > INT_MAX) {
1120 PyErr_SetString(PyExc_OverflowError, "long too large "
1121 "to pickle");
1122 goto finally;
1123 }
1124 repr = PyString_FromStringAndSize(NULL, (int)nbytes);
1125 if (repr == NULL) goto finally;
1126 pdata = (unsigned char *)PyString_AS_STRING(repr);
1127 i = _PyLong_AsByteArray((PyLongObject *)args,
1128 pdata, nbytes,
1129 1 /* little endian */, 1 /* signed */);
1130 if (i < 0) goto finally;
1131 /* If the long is negative, this may be a byte more than
1132 * needed. This is so iff the MSB is all redundant sign
1133 * bits.
1134 */
1135 if (sign < 0 && nbytes > 1 && pdata[nbytes - 1] == 0xff &&
1136 (pdata[nbytes - 2] & 0x80) != 0)
1137 --nbytes;
1138
1139 if (nbytes < 256) {
1140 c_str[0] = LONG1;
1141 c_str[1] = (char)nbytes;
1142 size = 2;
1143 }
1144 else {
1145 c_str[0] = LONG4;
1146 size = (int)nbytes;
1147 for (i = 1; i < 5; i++) {
1148 c_str[i] = (char)(size & 0xff);
1149 size >>= 8;
1150 }
1151 size = 5;
1152 }
1153 i = self->write_func(self, c_str, size);
1154 if (i < 0) goto finally;
1155 i = self->write_func(self, (char *)pdata, (int)nbytes);
1156 if (i < 0) goto finally;
1157 res = 0;
1158 goto finally;
1159 }
1160
1161 /* proto < 2: write the repr and newline. This is quadratic-time
1162 * (in the number of digits), in both directions.
1163 */
1164 if (!( repr = PyObject_Repr(args)))
1165 goto finally;
1166
1167 if ((size = PyString_Size(repr)) < 0)
1168 goto finally;
1169
1170 if (self->write_func(self, &l, 1) < 0)
1171 goto finally;
1172
1173 if (self->write_func(self,
1174 PyString_AS_STRING((PyStringObject *)repr),
1175 size) < 0)
1176 goto finally;
1177
1178 if (self->write_func(self, "\n", 1) < 0)
1179 goto finally;
1180
1181 res = 0;
1182
1183 finally:
1184 Py_XDECREF(repr);
1185 return res;
1186 }
1187
1188
1189 static int
save_float(Picklerobject * self,PyObject * args)1190 save_float(Picklerobject *self, PyObject *args)
1191 {
1192 double x = PyFloat_AS_DOUBLE((PyFloatObject *)args);
1193
1194 if (self->bin) {
1195 char str[9];
1196 str[0] = BINFLOAT;
1197 if (_PyFloat_Pack8(x, (unsigned char *)&str[1], 0) < 0)
1198 return -1;
1199 if (self->write_func(self, str, 9) < 0)
1200 return -1;
1201 }
1202 else {
1203 int result = -1;
1204 char *buf = NULL;
1205 char op = FLOAT;
1206
1207 if (self->write_func(self, &op, 1) < 0)
1208 goto done;
1209
1210 buf = PyOS_double_to_string(x, 'g', 17, 0, NULL);
1211 if (!buf) {
1212 PyErr_NoMemory();
1213 goto done;
1214 }
1215
1216 if (self->write_func(self, buf, strlen(buf)) < 0)
1217 goto done;
1218
1219 if (self->write_func(self, "\n", 1) < 0)
1220 goto done;
1221
1222 result = 0;
1223 done:
1224 PyMem_Free(buf);
1225 return result;
1226 }
1227
1228 return 0;
1229 }
1230
1231
1232 static int
save_string(Picklerobject * self,PyObject * args,int doput)1233 save_string(Picklerobject *self, PyObject *args, int doput)
1234 {
1235 Py_ssize_t size, len;
1236 PyObject *repr=0;
1237
1238 if ((size = PyString_Size(args)) < 0)
1239 return -1;
1240
1241 if (!self->bin) {
1242 char *repr_str;
1243
1244 static char string = STRING;
1245
1246 if (!( repr = PyObject_Repr(args)))
1247 return -1;
1248
1249 if ((len = PyString_Size(repr)) < 0)
1250 goto err;
1251 repr_str = PyString_AS_STRING((PyStringObject *)repr);
1252
1253 if (self->write_func(self, &string, 1) < 0)
1254 goto err;
1255
1256 if (self->write_func(self, repr_str, len) < 0)
1257 goto err;
1258
1259 if (self->write_func(self, "\n", 1) < 0)
1260 goto err;
1261
1262 Py_XDECREF(repr);
1263 }
1264 else {
1265 int i;
1266 char c_str[5];
1267
1268 if (size < 256) {
1269 c_str[0] = SHORT_BINSTRING;
1270 c_str[1] = size;
1271 len = 2;
1272 }
1273 else if (size <= INT_MAX) {
1274 c_str[0] = BINSTRING;
1275 for (i = 1; i < 5; i++)
1276 c_str[i] = (int)(size >> ((i - 1) * 8));
1277 len = 5;
1278 }
1279 else
1280 return -1; /* string too large */
1281
1282 if (self->write_func(self, c_str, len) < 0)
1283 return -1;
1284
1285 if (size > 128 && Pdata_Check(self->file)) {
1286 if (write_other(self, NULL, 0) < 0) return -1;
1287 PDATA_APPEND(self->file, args, -1);
1288 }
1289 else {
1290 if (self->write_func(self,
1291 PyString_AS_STRING(
1292 (PyStringObject *)args),
1293 size) < 0)
1294 return -1;
1295 }
1296 }
1297
1298 if (doput)
1299 if (put(self, args) < 0)
1300 return -1;
1301
1302 return 0;
1303
1304 err:
1305 Py_XDECREF(repr);
1306 return -1;
1307 }
1308
1309
1310 #ifdef Py_USING_UNICODE
1311 /* A copy of PyUnicode_EncodeRawUnicodeEscape() that also translates
1312 backslash and newline characters to \uXXXX escapes. */
1313 static PyObject *
modified_EncodeRawUnicodeEscape(const Py_UNICODE * s,Py_ssize_t size)1314 modified_EncodeRawUnicodeEscape(const Py_UNICODE *s, Py_ssize_t size)
1315 {
1316 PyObject *repr;
1317 char *p;
1318 char *q;
1319
1320 static const char *hexdigit = "0123456789abcdef";
1321 #ifdef Py_UNICODE_WIDE
1322 const Py_ssize_t expandsize = 10;
1323 #else
1324 const Py_ssize_t expandsize = 6;
1325 #endif
1326
1327 if (size > PY_SSIZE_T_MAX / expandsize)
1328 return PyErr_NoMemory();
1329
1330 repr = PyString_FromStringAndSize(NULL, expandsize * size);
1331 if (repr == NULL)
1332 return NULL;
1333 if (size == 0)
1334 return repr;
1335
1336 p = q = PyString_AS_STRING(repr);
1337 while (size-- > 0) {
1338 Py_UNICODE ch = *s++;
1339 #ifdef Py_UNICODE_WIDE
1340 /* Map 32-bit characters to '\Uxxxxxxxx' */
1341 if (ch >= 0x10000) {
1342 *p++ = '\\';
1343 *p++ = 'U';
1344 *p++ = hexdigit[(ch >> 28) & 0xf];
1345 *p++ = hexdigit[(ch >> 24) & 0xf];
1346 *p++ = hexdigit[(ch >> 20) & 0xf];
1347 *p++ = hexdigit[(ch >> 16) & 0xf];
1348 *p++ = hexdigit[(ch >> 12) & 0xf];
1349 *p++ = hexdigit[(ch >> 8) & 0xf];
1350 *p++ = hexdigit[(ch >> 4) & 0xf];
1351 *p++ = hexdigit[ch & 15];
1352 }
1353 else
1354 #else
1355 /* Map UTF-16 surrogate pairs to '\U00xxxxxx' */
1356 if (ch >= 0xD800 && ch < 0xDC00) {
1357 Py_UNICODE ch2;
1358 Py_UCS4 ucs;
1359
1360 ch2 = *s++;
1361 size--;
1362 if (ch2 >= 0xDC00 && ch2 <= 0xDFFF) {
1363 ucs = (((ch & 0x03FF) << 10) | (ch2 & 0x03FF)) + 0x00010000;
1364 *p++ = '\\';
1365 *p++ = 'U';
1366 *p++ = hexdigit[(ucs >> 28) & 0xf];
1367 *p++ = hexdigit[(ucs >> 24) & 0xf];
1368 *p++ = hexdigit[(ucs >> 20) & 0xf];
1369 *p++ = hexdigit[(ucs >> 16) & 0xf];
1370 *p++ = hexdigit[(ucs >> 12) & 0xf];
1371 *p++ = hexdigit[(ucs >> 8) & 0xf];
1372 *p++ = hexdigit[(ucs >> 4) & 0xf];
1373 *p++ = hexdigit[ucs & 0xf];
1374 continue;
1375 }
1376 /* Fall through: isolated surrogates are copied as-is */
1377 s--;
1378 size++;
1379 }
1380 #endif
1381 /* Map 16-bit characters to '\uxxxx' */
1382 if (ch >= 256 || ch == '\\' || ch == '\n') {
1383 *p++ = '\\';
1384 *p++ = 'u';
1385 *p++ = hexdigit[(ch >> 12) & 0xf];
1386 *p++ = hexdigit[(ch >> 8) & 0xf];
1387 *p++ = hexdigit[(ch >> 4) & 0xf];
1388 *p++ = hexdigit[ch & 15];
1389 }
1390 /* Copy everything else as-is */
1391 else
1392 *p++ = (char) ch;
1393 }
1394 *p = '\0';
1395 _PyString_Resize(&repr, p - q);
1396 return repr;
1397 }
1398
1399 static int
save_unicode(Picklerobject * self,PyObject * args,int doput)1400 save_unicode(Picklerobject *self, PyObject *args, int doput)
1401 {
1402 Py_ssize_t size, len;
1403 PyObject *repr=0;
1404
1405 if (!PyUnicode_Check(args))
1406 return -1;
1407
1408 if (!self->bin) {
1409 char *repr_str;
1410 static char string = UNICODE;
1411
1412 repr = modified_EncodeRawUnicodeEscape(
1413 PyUnicode_AS_UNICODE(args), PyUnicode_GET_SIZE(args));
1414 if (!repr)
1415 return -1;
1416
1417 if ((len = PyString_Size(repr)) < 0)
1418 goto err;
1419 repr_str = PyString_AS_STRING((PyStringObject *)repr);
1420
1421 if (self->write_func(self, &string, 1) < 0)
1422 goto err;
1423
1424 if (self->write_func(self, repr_str, len) < 0)
1425 goto err;
1426
1427 if (self->write_func(self, "\n", 1) < 0)
1428 goto err;
1429
1430 Py_XDECREF(repr);
1431 }
1432 else {
1433 int i;
1434 char c_str[5];
1435
1436 if (!( repr = PyUnicode_AsUTF8String(args)))
1437 return -1;
1438
1439 if ((size = PyString_Size(repr)) < 0)
1440 goto err;
1441 if (size > INT_MAX)
1442 return -1; /* string too large */
1443
1444 c_str[0] = BINUNICODE;
1445 for (i = 1; i < 5; i++)
1446 c_str[i] = (int)(size >> ((i - 1) * 8));
1447 len = 5;
1448
1449 if (self->write_func(self, c_str, len) < 0)
1450 goto err;
1451
1452 if (size > 128 && Pdata_Check(self->file)) {
1453 if (write_other(self, NULL, 0) < 0)
1454 goto err;
1455 PDATA_APPEND(self->file, repr, -1);
1456 }
1457 else {
1458 if (self->write_func(self, PyString_AS_STRING(repr),
1459 size) < 0)
1460 goto err;
1461 }
1462
1463 Py_DECREF(repr);
1464 }
1465
1466 if (doput)
1467 if (put(self, args) < 0)
1468 return -1;
1469
1470 return 0;
1471
1472 err:
1473 Py_XDECREF(repr);
1474 return -1;
1475 }
1476 #endif
1477
1478 /* A helper for save_tuple. Push the len elements in tuple t on the stack. */
1479 static int
store_tuple_elements(Picklerobject * self,PyObject * t,int len)1480 store_tuple_elements(Picklerobject *self, PyObject *t, int len)
1481 {
1482 Py_ssize_t i;
1483 int res = -1; /* guilty until proved innocent */
1484
1485 assert(PyTuple_Size(t) == len);
1486
1487 for (i = 0; i < len; i++) {
1488 PyObject *element = PyTuple_GET_ITEM(t, i);
1489
1490 if (element == NULL)
1491 goto finally;
1492 if (save(self, element, 0) < 0)
1493 goto finally;
1494 }
1495 res = 0;
1496
1497 finally:
1498 return res;
1499 }
1500
1501 /* Tuples are ubiquitous in the pickle protocols, so many techniques are
1502 * used across protocols to minimize the space needed to pickle them.
1503 * Tuples are also the only builtin immutable type that can be recursive
1504 * (a tuple can be reached from itself), and that requires some subtle
1505 * magic so that it works in all cases. IOW, this is a long routine.
1506 */
1507 static int
save_tuple(Picklerobject * self,PyObject * args)1508 save_tuple(Picklerobject *self, PyObject *args)
1509 {
1510 PyObject *py_tuple_id = NULL;
1511 Py_ssize_t len, i;
1512 int res = -1;
1513
1514 static char tuple = TUPLE;
1515 static char pop = POP;
1516 static char pop_mark = POP_MARK;
1517 static char len2opcode[] = {EMPTY_TUPLE, TUPLE1, TUPLE2, TUPLE3};
1518
1519 if ((len = PyTuple_Size(args)) < 0)
1520 goto finally;
1521
1522 if (len == 0) {
1523 char c_str[2];
1524
1525 if (self->proto) {
1526 c_str[0] = EMPTY_TUPLE;
1527 len = 1;
1528 }
1529 else {
1530 c_str[0] = MARK;
1531 c_str[1] = TUPLE;
1532 len = 2;
1533 }
1534 if (self->write_func(self, c_str, len) >= 0)
1535 res = 0;
1536 /* Don't memoize an empty tuple. */
1537 goto finally;
1538 }
1539
1540 /* A non-empty tuple. */
1541
1542 /* id(tuple) isn't in the memo now. If it shows up there after
1543 * saving the tuple elements, the tuple must be recursive, in
1544 * which case we'll pop everything we put on the stack, and fetch
1545 * its value from the memo.
1546 */
1547 py_tuple_id = PyLong_FromVoidPtr(args);
1548 if (py_tuple_id == NULL)
1549 goto finally;
1550
1551 if (len <= 3 && self->proto >= 2) {
1552 /* Use TUPLE{1,2,3} opcodes. */
1553 if (store_tuple_elements(self, args, len) < 0)
1554 goto finally;
1555 if (PyDict_GetItem(self->memo, py_tuple_id)) {
1556 /* pop the len elements */
1557 for (i = 0; i < len; ++i)
1558 if (self->write_func(self, &pop, 1) < 0)
1559 goto finally;
1560 /* fetch from memo */
1561 if (get(self, py_tuple_id) < 0)
1562 goto finally;
1563 res = 0;
1564 goto finally;
1565 }
1566 /* Not recursive. */
1567 if (self->write_func(self, len2opcode + len, 1) < 0)
1568 goto finally;
1569 goto memoize;
1570 }
1571
1572 /* proto < 2 and len > 0, or proto >= 2 and len > 3.
1573 * Generate MARK elt1 elt2 ... TUPLE
1574 */
1575 if (self->write_func(self, &MARKv, 1) < 0)
1576 goto finally;
1577
1578 if (store_tuple_elements(self, args, len) < 0)
1579 goto finally;
1580
1581 if (PyDict_GetItem(self->memo, py_tuple_id)) {
1582 /* pop the stack stuff we pushed */
1583 if (self->bin) {
1584 if (self->write_func(self, &pop_mark, 1) < 0)
1585 goto finally;
1586 }
1587 else {
1588 /* Note that we pop one more than len, to remove
1589 * the MARK too.
1590 */
1591 for (i = 0; i <= len; i++)
1592 if (self->write_func(self, &pop, 1) < 0)
1593 goto finally;
1594 }
1595 /* fetch from memo */
1596 if (get(self, py_tuple_id) >= 0)
1597 res = 0;
1598 goto finally;
1599 }
1600
1601 /* Not recursive. */
1602 if (self->write_func(self, &tuple, 1) < 0)
1603 goto finally;
1604
1605 memoize:
1606 if (put(self, args) >= 0)
1607 res = 0;
1608
1609 finally:
1610 Py_XDECREF(py_tuple_id);
1611 return res;
1612 }
1613
1614 /* iter is an iterator giving items, and we batch up chunks of
1615 * MARK item item ... item APPENDS
1616 * opcode sequences. Calling code should have arranged to first create an
1617 * empty list, or list-like object, for the APPENDS to operate on.
1618 * Returns 0 on success, <0 on error.
1619 */
1620 static int
batch_list(Picklerobject * self,PyObject * iter)1621 batch_list(Picklerobject *self, PyObject *iter)
1622 {
1623 PyObject *obj = NULL;
1624 PyObject *firstitem = NULL;
1625 int i, n;
1626
1627 static char append = APPEND;
1628 static char appends = APPENDS;
1629
1630 assert(iter != NULL);
1631
1632 if (self->proto == 0) {
1633 /* APPENDS isn't available; do one at a time. */
1634 for (;;) {
1635 obj = PyIter_Next(iter);
1636 if (obj == NULL) {
1637 if (PyErr_Occurred())
1638 return -1;
1639 break;
1640 }
1641 i = save(self, obj, 0);
1642 Py_DECREF(obj);
1643 if (i < 0)
1644 return -1;
1645 if (self->write_func(self, &append, 1) < 0)
1646 return -1;
1647 }
1648 return 0;
1649 }
1650
1651 /* proto > 0: write in batches of BATCHSIZE. */
1652 do {
1653 /* Get first item */
1654 firstitem = PyIter_Next(iter);
1655 if (firstitem == NULL) {
1656 if (PyErr_Occurred())
1657 goto BatchFailed;
1658
1659 /* nothing more to add */
1660 break;
1661 }
1662
1663 /* Try to get a second item */
1664 obj = PyIter_Next(iter);
1665 if (obj == NULL) {
1666 if (PyErr_Occurred())
1667 goto BatchFailed;
1668
1669 /* Only one item to write */
1670 if (save(self, firstitem, 0) < 0)
1671 goto BatchFailed;
1672 if (self->write_func(self, &append, 1) < 0)
1673 goto BatchFailed;
1674 Py_CLEAR(firstitem);
1675 break;
1676 }
1677
1678 /* More than one item to write */
1679
1680 /* Pump out MARK, items, APPENDS. */
1681 if (self->write_func(self, &MARKv, 1) < 0)
1682 goto BatchFailed;
1683
1684 if (save(self, firstitem, 0) < 0)
1685 goto BatchFailed;
1686 Py_CLEAR(firstitem);
1687 n = 1;
1688
1689 /* Fetch and save up to BATCHSIZE items */
1690 while (obj) {
1691 if (save(self, obj, 0) < 0)
1692 goto BatchFailed;
1693 Py_CLEAR(obj);
1694 n += 1;
1695
1696 if (n == BATCHSIZE)
1697 break;
1698
1699 obj = PyIter_Next(iter);
1700 if (obj == NULL) {
1701 if (PyErr_Occurred())
1702 goto BatchFailed;
1703 break;
1704 }
1705 }
1706
1707 if (self->write_func(self, &appends, 1) < 0)
1708 goto BatchFailed;
1709
1710 } while (n == BATCHSIZE);
1711 return 0;
1712
1713 BatchFailed:
1714 Py_XDECREF(firstitem);
1715 Py_XDECREF(obj);
1716 return -1;
1717 }
1718
1719 static int
save_list(Picklerobject * self,PyObject * args)1720 save_list(Picklerobject *self, PyObject *args)
1721 {
1722 int res = -1;
1723 char s[3];
1724 Py_ssize_t len;
1725 PyObject *iter;
1726
1727 if (self->fast && !fast_save_enter(self, args))
1728 goto finally;
1729
1730 /* Create an empty list. */
1731 if (self->bin) {
1732 s[0] = EMPTY_LIST;
1733 len = 1;
1734 }
1735 else {
1736 s[0] = MARK;
1737 s[1] = LIST;
1738 len = 2;
1739 }
1740
1741 if (self->write_func(self, s, len) < 0)
1742 goto finally;
1743
1744 /* Get list length, and bow out early if empty. */
1745 if ((len = PyList_Size(args)) < 0)
1746 goto finally;
1747
1748 /* Memoize. */
1749 if (len == 0) {
1750 if (put(self, args) >= 0)
1751 res = 0;
1752 goto finally;
1753 }
1754 if (put2(self, args) < 0)
1755 goto finally;
1756
1757 /* Materialize the list elements. */
1758 iter = PyObject_GetIter(args);
1759 if (iter == NULL)
1760 goto finally;
1761
1762 if (Py_EnterRecursiveCall(" while pickling an object") == 0)
1763 {
1764 res = batch_list(self, iter);
1765 Py_LeaveRecursiveCall();
1766 }
1767 Py_DECREF(iter);
1768
1769 finally:
1770 if (self->fast && !fast_save_leave(self, args))
1771 res = -1;
1772
1773 return res;
1774 }
1775
1776
1777 /* iter is an iterator giving (key, value) pairs, and we batch up chunks of
1778 * MARK key value ... key value SETITEMS
1779 * opcode sequences. Calling code should have arranged to first create an
1780 * empty dict, or dict-like object, for the SETITEMS to operate on.
1781 * Returns 0 on success, <0 on error.
1782 *
1783 * This is very much like batch_list(). The difference between saving
1784 * elements directly, and picking apart two-tuples, is so long-winded at
1785 * the C level, though, that attempts to combine these routines were too
1786 * ugly to bear.
1787 */
1788 static int
batch_dict(Picklerobject * self,PyObject * iter)1789 batch_dict(Picklerobject *self, PyObject *iter)
1790 {
1791 PyObject *p = NULL;
1792 PyObject *firstitem = NULL;
1793 int i, n;
1794
1795 static char setitem = SETITEM;
1796 static char setitems = SETITEMS;
1797
1798 assert(iter != NULL);
1799
1800 if (self->proto == 0) {
1801 /* SETITEMS isn't available; do one at a time. */
1802 for (;;) {
1803 p = PyIter_Next(iter);
1804 if (p == NULL) {
1805 if (PyErr_Occurred())
1806 return -1;
1807 break;
1808 }
1809 if (!PyTuple_Check(p) || PyTuple_Size(p) != 2) {
1810 PyErr_SetString(PyExc_TypeError, "dict items "
1811 "iterator must return 2-tuples");
1812 return -1;
1813 }
1814 i = save(self, PyTuple_GET_ITEM(p, 0), 0);
1815 if (i >= 0)
1816 i = save(self, PyTuple_GET_ITEM(p, 1), 0);
1817 Py_DECREF(p);
1818 if (i < 0)
1819 return -1;
1820 if (self->write_func(self, &setitem, 1) < 0)
1821 return -1;
1822 }
1823 return 0;
1824 }
1825
1826 /* proto > 0: write in batches of BATCHSIZE. */
1827 do {
1828 /* Get first item */
1829 firstitem = PyIter_Next(iter);
1830 if (firstitem == NULL) {
1831 if (PyErr_Occurred())
1832 goto BatchFailed;
1833
1834 /* nothing more to add */
1835 break;
1836 }
1837 if (!PyTuple_Check(firstitem) || PyTuple_Size(firstitem) != 2) {
1838 PyErr_SetString(PyExc_TypeError, "dict items "
1839 "iterator must return 2-tuples");
1840 goto BatchFailed;
1841 }
1842
1843 /* Try to get a second item */
1844 p = PyIter_Next(iter);
1845 if (p == NULL) {
1846 if (PyErr_Occurred())
1847 goto BatchFailed;
1848
1849 /* Only one item to write */
1850 if (save(self, PyTuple_GET_ITEM(firstitem, 0), 0) < 0)
1851 goto BatchFailed;
1852 if (save(self, PyTuple_GET_ITEM(firstitem, 1), 0) < 0)
1853 goto BatchFailed;
1854 if (self->write_func(self, &setitem, 1) < 0)
1855 goto BatchFailed;
1856 Py_CLEAR(firstitem);
1857 break;
1858 }
1859
1860 /* More than one item to write */
1861
1862 /* Pump out MARK, items, SETITEMS. */
1863 if (self->write_func(self, &MARKv, 1) < 0)
1864 goto BatchFailed;
1865
1866 if (save(self, PyTuple_GET_ITEM(firstitem, 0), 0) < 0)
1867 goto BatchFailed;
1868 if (save(self, PyTuple_GET_ITEM(firstitem, 1), 0) < 0)
1869 goto BatchFailed;
1870 Py_CLEAR(firstitem);
1871 n = 1;
1872
1873 /* Fetch and save up to BATCHSIZE items */
1874 while (p) {
1875 if (!PyTuple_Check(p) || PyTuple_Size(p) != 2) {
1876 PyErr_SetString(PyExc_TypeError, "dict items "
1877 "iterator must return 2-tuples");
1878 goto BatchFailed;
1879 }
1880 if (save(self, PyTuple_GET_ITEM(p, 0), 0) < 0)
1881 goto BatchFailed;
1882 if (save(self, PyTuple_GET_ITEM(p, 1), 0) < 0)
1883 goto BatchFailed;
1884 Py_CLEAR(p);
1885 n += 1;
1886
1887 if (n == BATCHSIZE)
1888 break;
1889
1890 p = PyIter_Next(iter);
1891 if (p == NULL) {
1892 if (PyErr_Occurred())
1893 goto BatchFailed;
1894 break;
1895 }
1896 }
1897
1898 if (self->write_func(self, &setitems, 1) < 0)
1899 goto BatchFailed;
1900
1901 } while (n == BATCHSIZE);
1902 return 0;
1903
1904 BatchFailed:
1905 Py_XDECREF(firstitem);
1906 Py_XDECREF(p);
1907 return -1;
1908 }
1909
1910 /* This is a variant of batch_dict() above that specializes for dicts, with no
1911 * support for dict subclasses. Like batch_dict(), we batch up chunks of
1912 * MARK key value ... key value SETITEMS
1913 * opcode sequences. Calling code should have arranged to first create an
1914 * empty dict, or dict-like object, for the SETITEMS to operate on.
1915 * Returns 0 on success, -1 on error.
1916 *
1917 * Note that this currently doesn't work for protocol 0.
1918 */
1919 static int
batch_dict_exact(Picklerobject * self,PyObject * obj)1920 batch_dict_exact(Picklerobject *self, PyObject *obj)
1921 {
1922 PyObject *key = NULL, *value = NULL;
1923 int i;
1924 Py_ssize_t dict_size, ppos = 0;
1925
1926 static char setitem = SETITEM;
1927 static char setitems = SETITEMS;
1928
1929 assert(obj != NULL);
1930 assert(self->proto > 0);
1931
1932 dict_size = PyDict_Size(obj);
1933
1934 /* Special-case len(d) == 1 to save space. */
1935 if (dict_size == 1) {
1936 PyDict_Next(obj, &ppos, &key, &value);
1937 if (save(self, key, 0) < 0)
1938 return -1;
1939 if (save(self, value, 0) < 0)
1940 return -1;
1941 if (self->write_func(self, &setitem, 1) < 0)
1942 return -1;
1943 return 0;
1944 }
1945
1946 /* Write in batches of BATCHSIZE. */
1947 do {
1948 i = 0;
1949 if (self->write_func(self, &MARKv, 1) < 0)
1950 return -1;
1951 while (PyDict_Next(obj, &ppos, &key, &value)) {
1952 if (save(self, key, 0) < 0)
1953 return -1;
1954 if (save(self, value, 0) < 0)
1955 return -1;
1956 if (++i == BATCHSIZE)
1957 break;
1958 }
1959 if (self->write_func(self, &setitems, 1) < 0)
1960 return -1;
1961 if (PyDict_Size(obj) != dict_size) {
1962 PyErr_Format(
1963 PyExc_RuntimeError,
1964 "dictionary changed size during iteration");
1965 return -1;
1966 }
1967
1968 } while (i == BATCHSIZE);
1969 return 0;
1970 }
1971
1972 static int
save_dict(Picklerobject * self,PyObject * args)1973 save_dict(Picklerobject *self, PyObject *args)
1974 {
1975 int res = -1;
1976 char s[3];
1977 Py_ssize_t len;
1978
1979 if (self->fast && !fast_save_enter(self, args))
1980 goto finally;
1981
1982 /* Create an empty dict. */
1983 if (self->bin) {
1984 s[0] = EMPTY_DICT;
1985 len = 1;
1986 }
1987 else {
1988 s[0] = MARK;
1989 s[1] = DICT;
1990 len = 2;
1991 }
1992
1993 if (self->write_func(self, s, len) < 0)
1994 goto finally;
1995
1996 /* Get dict size, and bow out early if empty. */
1997 if ((len = PyDict_Size(args)) < 0)
1998 goto finally;
1999
2000 if (len == 0) {
2001 if (put(self, args) >= 0)
2002 res = 0;
2003 goto finally;
2004 }
2005 if (put2(self, args) < 0)
2006 goto finally;
2007
2008 /* Materialize the dict items. */
2009 if (PyDict_CheckExact(args) && self->proto > 0) {
2010 /* We can take certain shortcuts if we know this is a dict and
2011 not a dict subclass. */
2012 if (Py_EnterRecursiveCall(" while pickling an object") == 0) {
2013 res = batch_dict_exact(self, args);
2014 Py_LeaveRecursiveCall();
2015 }
2016 } else {
2017 PyObject *iter = PyObject_CallMethod(args, "iteritems", "()");
2018 if (iter == NULL)
2019 goto finally;
2020 if (Py_EnterRecursiveCall(" while pickling an object") == 0) {
2021 res = batch_dict(self, iter);
2022 Py_LeaveRecursiveCall();
2023 }
2024 Py_DECREF(iter);
2025 }
2026
2027 finally:
2028 if (self->fast && !fast_save_leave(self, args))
2029 res = -1;
2030
2031 return res;
2032 }
2033
2034
2035 static int
save_inst(Picklerobject * self,PyObject * args)2036 save_inst(Picklerobject *self, PyObject *args)
2037 {
2038 PyObject *class = 0, *module = 0, *name = 0, *state = 0,
2039 *getinitargs_func = 0, *getstate_func = 0, *class_args = 0;
2040 char *module_str, *name_str;
2041 int module_size, name_size, res = -1;
2042
2043 static char inst = INST, obj = OBJ, build = BUILD;
2044
2045 if (self->fast && !fast_save_enter(self, args))
2046 goto finally;
2047
2048 if (self->write_func(self, &MARKv, 1) < 0)
2049 goto finally;
2050
2051 if (!( class = PyObject_GetAttr(args, __class___str)))
2052 goto finally;
2053
2054 if (self->bin) {
2055 if (save(self, class, 0) < 0)
2056 goto finally;
2057 }
2058
2059 if ((getinitargs_func = PyObject_GetAttr(args, __getinitargs___str))) {
2060 PyObject *element = 0;
2061 Py_ssize_t i, len;
2062
2063 if (!( class_args =
2064 PyObject_Call(getinitargs_func, empty_tuple, NULL)))
2065 goto finally;
2066
2067 if ((len = PyObject_Size(class_args)) < 0)
2068 goto finally;
2069
2070 for (i = 0; i < len; i++) {
2071 if (!( element = PySequence_GetItem(class_args, i)))
2072 goto finally;
2073
2074 if (save(self, element, 0) < 0) {
2075 Py_DECREF(element);
2076 goto finally;
2077 }
2078
2079 Py_DECREF(element);
2080 }
2081 }
2082 else {
2083 if (PyErr_ExceptionMatches(PyExc_AttributeError))
2084 PyErr_Clear();
2085 else
2086 goto finally;
2087 }
2088
2089 if (!self->bin) {
2090 if (!( name = ((PyClassObject *)class)->cl_name )) {
2091 PyErr_SetString(PicklingError, "class has no name");
2092 goto finally;
2093 }
2094
2095 if (!( module = whichmodule(class, name)))
2096 goto finally;
2097
2098
2099 if ((module_size = PyString_Size(module)) < 0 ||
2100 (name_size = PyString_Size(name)) < 0)
2101 goto finally;
2102
2103 module_str = PyString_AS_STRING((PyStringObject *)module);
2104 name_str = PyString_AS_STRING((PyStringObject *)name);
2105
2106 if (self->write_func(self, &inst, 1) < 0)
2107 goto finally;
2108
2109 if (self->write_func(self, module_str, module_size) < 0)
2110 goto finally;
2111
2112 if (self->write_func(self, "\n", 1) < 0)
2113 goto finally;
2114
2115 if (self->write_func(self, name_str, name_size) < 0)
2116 goto finally;
2117
2118 if (self->write_func(self, "\n", 1) < 0)
2119 goto finally;
2120 }
2121 else if (self->write_func(self, &obj, 1) < 0) {
2122 goto finally;
2123 }
2124
2125 if ((getstate_func = PyObject_GetAttr(args, __getstate___str))) {
2126 state = PyObject_Call(getstate_func, empty_tuple, NULL);
2127 if (!state)
2128 goto finally;
2129 }
2130 else {
2131 if (PyErr_ExceptionMatches(PyExc_AttributeError))
2132 PyErr_Clear();
2133 else
2134 goto finally;
2135
2136 if (!( state = PyObject_GetAttr(args, __dict___str))) {
2137 if (PyErr_ExceptionMatches(PyExc_AttributeError))
2138 PyErr_Clear();
2139 else
2140 goto finally;
2141 res = 0;
2142 goto finally;
2143 }
2144 }
2145
2146 if (!PyDict_Check(state)) {
2147 if (put2(self, args) < 0)
2148 goto finally;
2149 }
2150 else {
2151 if (put(self, args) < 0)
2152 goto finally;
2153 }
2154
2155 if (save(self, state, 0) < 0)
2156 goto finally;
2157
2158 if (self->write_func(self, &build, 1) < 0)
2159 goto finally;
2160
2161 res = 0;
2162
2163 finally:
2164 if (self->fast && !fast_save_leave(self, args))
2165 res = -1;
2166
2167 Py_XDECREF(module);
2168 Py_XDECREF(class);
2169 Py_XDECREF(state);
2170 Py_XDECREF(getinitargs_func);
2171 Py_XDECREF(getstate_func);
2172 Py_XDECREF(class_args);
2173
2174 return res;
2175 }
2176
2177
2178 static int
save_global(Picklerobject * self,PyObject * args,PyObject * name)2179 save_global(Picklerobject *self, PyObject *args, PyObject *name)
2180 {
2181 PyObject *global_name = 0, *module = 0, *mod = 0, *klass = 0;
2182 char *name_str, *module_str;
2183 int module_size, name_size, res = -1;
2184
2185 static char global = GLOBAL;
2186
2187 if (name) {
2188 global_name = name;
2189 Py_INCREF(global_name);
2190 }
2191 else {
2192 if (!( global_name = PyObject_GetAttr(args, __name___str)))
2193 goto finally;
2194 }
2195
2196 if (!( module = whichmodule(args, global_name)))
2197 goto finally;
2198
2199 if ((module_size = PyString_Size(module)) < 0 ||
2200 (name_size = PyString_Size(global_name)) < 0)
2201 goto finally;
2202
2203 module_str = PyString_AS_STRING((PyStringObject *)module);
2204 name_str = PyString_AS_STRING((PyStringObject *)global_name);
2205
2206 /* XXX This can be doing a relative import. Clearly it shouldn't,
2207 but I don't know how to stop it. :-( */
2208 mod = PyImport_ImportModule(module_str);
2209 if (mod == NULL) {
2210 cPickle_ErrFormat(PicklingError,
2211 "Can't pickle %s: import of module %s "
2212 "failed",
2213 "OS", args, module);
2214 goto finally;
2215 }
2216 klass = PyObject_GetAttrString(mod, name_str);
2217 if (klass == NULL) {
2218 cPickle_ErrFormat(PicklingError,
2219 "Can't pickle %s: attribute lookup %s.%s "
2220 "failed",
2221 "OSS", args, module, global_name);
2222 goto finally;
2223 }
2224 if (klass != args) {
2225 Py_DECREF(klass);
2226 cPickle_ErrFormat(PicklingError,
2227 "Can't pickle %s: it's not the same object "
2228 "as %s.%s",
2229 "OSS", args, module, global_name);
2230 goto finally;
2231 }
2232 Py_DECREF(klass);
2233
2234 if (self->proto >= 2) {
2235 /* See whether this is in the extension registry, and if
2236 * so generate an EXT opcode.
2237 */
2238 PyObject *py_code; /* extension code as Python object */
2239 long code; /* extension code as C value */
2240 char c_str[5];
2241 int n;
2242
2243 PyTuple_SET_ITEM(two_tuple, 0, module);
2244 PyTuple_SET_ITEM(two_tuple, 1, global_name);
2245 py_code = PyDict_GetItem(extension_registry, two_tuple);
2246 if (py_code == NULL)
2247 goto gen_global; /* not registered */
2248
2249 /* Verify py_code has the right type and value. */
2250 if (!PyInt_Check(py_code)) {
2251 cPickle_ErrFormat(PicklingError, "Can't pickle %s: "
2252 "extension code %s isn't an integer",
2253 "OO", args, py_code);
2254 goto finally;
2255 }
2256 code = PyInt_AS_LONG(py_code);
2257 if (code <= 0 || code > 0x7fffffffL) {
2258 cPickle_ErrFormat(PicklingError, "Can't pickle %s: "
2259 "extension code %ld is out of range",
2260 "Ol", args, code);
2261 goto finally;
2262 }
2263
2264 /* Generate an EXT opcode. */
2265 if (code <= 0xff) {
2266 c_str[0] = EXT1;
2267 c_str[1] = (char)code;
2268 n = 2;
2269 }
2270 else if (code <= 0xffff) {
2271 c_str[0] = EXT2;
2272 c_str[1] = (char)(code & 0xff);
2273 c_str[2] = (char)((code >> 8) & 0xff);
2274 n = 3;
2275 }
2276 else {
2277 c_str[0] = EXT4;
2278 c_str[1] = (char)(code & 0xff);
2279 c_str[2] = (char)((code >> 8) & 0xff);
2280 c_str[3] = (char)((code >> 16) & 0xff);
2281 c_str[4] = (char)((code >> 24) & 0xff);
2282 n = 5;
2283 }
2284
2285 if (self->write_func(self, c_str, n) >= 0)
2286 res = 0;
2287 goto finally; /* and don't memoize */
2288 }
2289
2290 gen_global:
2291 if (self->write_func(self, &global, 1) < 0)
2292 goto finally;
2293
2294 if (self->write_func(self, module_str, module_size) < 0)
2295 goto finally;
2296
2297 if (self->write_func(self, "\n", 1) < 0)
2298 goto finally;
2299
2300 if (self->write_func(self, name_str, name_size) < 0)
2301 goto finally;
2302
2303 if (self->write_func(self, "\n", 1) < 0)
2304 goto finally;
2305
2306 if (put(self, args) < 0)
2307 goto finally;
2308
2309 res = 0;
2310
2311 finally:
2312 Py_XDECREF(module);
2313 Py_XDECREF(global_name);
2314 Py_XDECREF(mod);
2315
2316 return res;
2317 }
2318
2319 static int
save_pers(Picklerobject * self,PyObject * args,PyObject * f)2320 save_pers(Picklerobject *self, PyObject *args, PyObject *f)
2321 {
2322 PyObject *pid = 0;
2323 Py_ssize_t size;
2324 int res = -1;
2325
2326 static char persid = PERSID, binpersid = BINPERSID;
2327
2328 Py_INCREF(args);
2329 ARG_TUP(self, args);
2330 if (self->arg) {
2331 pid = PyObject_Call(f, self->arg, NULL);
2332 FREE_ARG_TUP(self);
2333 }
2334 if (! pid) return -1;
2335
2336 if (pid != Py_None) {
2337 if (!self->bin) {
2338 if (!PyString_Check(pid)) {
2339 PyErr_SetString(PicklingError,
2340 "persistent id must be string");
2341 goto finally;
2342 }
2343
2344 if (self->write_func(self, &persid, 1) < 0)
2345 goto finally;
2346
2347 if ((size = PyString_Size(pid)) < 0)
2348 goto finally;
2349
2350 if (self->write_func(self,
2351 PyString_AS_STRING(
2352 (PyStringObject *)pid),
2353 size) < 0)
2354 goto finally;
2355
2356 if (self->write_func(self, "\n", 1) < 0)
2357 goto finally;
2358
2359 res = 1;
2360 goto finally;
2361 }
2362 else if (save(self, pid, 1) >= 0) {
2363 if (self->write_func(self, &binpersid, 1) < 0)
2364 res = -1;
2365 else
2366 res = 1;
2367 }
2368
2369 goto finally;
2370 }
2371
2372 res = 0;
2373
2374 finally:
2375 Py_XDECREF(pid);
2376
2377 return res;
2378 }
2379
2380 /* We're saving ob, and args is the 2-thru-5 tuple returned by the
2381 * appropriate __reduce__ method for ob.
2382 */
2383 static int
save_reduce(Picklerobject * self,PyObject * args,PyObject * fn,PyObject * ob)2384 save_reduce(Picklerobject *self, PyObject *args, PyObject *fn, PyObject *ob)
2385 {
2386 PyObject *callable;
2387 PyObject *argtup;
2388 PyObject *state = NULL;
2389 PyObject *listitems = Py_None;
2390 PyObject *dictitems = Py_None;
2391 Py_ssize_t size;
2392
2393 int use_newobj = self->proto >= 2;
2394
2395 static char reduce = REDUCE;
2396 static char build = BUILD;
2397 static char newobj = NEWOBJ;
2398
2399 size = PyTuple_Size(args);
2400 if (size < 2 || size > 5) {
2401 cPickle_ErrFormat(PicklingError, "tuple returned by "
2402 "%s must contain 2 through 5 elements",
2403 "O", fn);
2404 return -1;
2405 }
2406
2407 if (! PyArg_UnpackTuple(args, "save_reduce", 2, 5,
2408 &callable,
2409 &argtup,
2410 &state,
2411 &listitems,
2412 &dictitems))
2413 return -1;
2414
2415 if (!PyTuple_Check(argtup)) {
2416 cPickle_ErrFormat(PicklingError, "Second element of "
2417 "tuple returned by %s must be a tuple",
2418 "O", fn);
2419 return -1;
2420 }
2421
2422 if (state == Py_None)
2423 state = NULL;
2424
2425 if (listitems == Py_None)
2426 listitems = NULL;
2427 else if (!PyIter_Check(listitems)) {
2428 cPickle_ErrFormat(PicklingError, "Fourth element of "
2429 "tuple returned by %s must be an iterator, not %s",
2430 "Os", fn, Py_TYPE(listitems)->tp_name);
2431 return -1;
2432 }
2433
2434 if (dictitems == Py_None)
2435 dictitems = NULL;
2436 else if (!PyIter_Check(dictitems)) {
2437 cPickle_ErrFormat(PicklingError, "Fifth element of "
2438 "tuple returned by %s must be an iterator, not %s",
2439 "Os", fn, Py_TYPE(dictitems)->tp_name);
2440 return -1;
2441 }
2442
2443 /* Protocol 2 special case: if callable's name is __newobj__, use
2444 * NEWOBJ. This consumes a lot of code.
2445 */
2446 if (use_newobj) {
2447 PyObject *temp = PyObject_GetAttr(callable, __name___str);
2448
2449 if (temp == NULL) {
2450 if (PyErr_ExceptionMatches(PyExc_AttributeError))
2451 PyErr_Clear();
2452 else
2453 return -1;
2454 use_newobj = 0;
2455 }
2456 else {
2457 use_newobj = PyString_Check(temp) &&
2458 strcmp(PyString_AS_STRING(temp),
2459 "__newobj__") == 0;
2460 Py_DECREF(temp);
2461 }
2462 }
2463 if (use_newobj) {
2464 PyObject *cls;
2465 PyObject *newargtup;
2466 Py_ssize_t n, i;
2467
2468 /* Sanity checks. */
2469 n = PyTuple_Size(argtup);
2470 if (n < 1) {
2471 PyErr_SetString(PicklingError, "__newobj__ arglist "
2472 "is empty");
2473 return -1;
2474 }
2475
2476 cls = PyTuple_GET_ITEM(argtup, 0);
2477 if (! PyObject_HasAttrString(cls, "__new__")) {
2478 PyErr_SetString(PicklingError, "args[0] from "
2479 "__newobj__ args has no __new__");
2480 return -1;
2481 }
2482
2483 /* XXX How could ob be NULL? */
2484 if (ob != NULL) {
2485 PyObject *ob_dot_class;
2486
2487 ob_dot_class = PyObject_GetAttr(ob, __class___str);
2488 if (ob_dot_class == NULL) {
2489 if (PyErr_ExceptionMatches(
2490 PyExc_AttributeError))
2491 PyErr_Clear();
2492 else
2493 return -1;
2494 }
2495 i = ob_dot_class != cls; /* true iff a problem */
2496 Py_XDECREF(ob_dot_class);
2497 if (i) {
2498 PyErr_SetString(PicklingError, "args[0] from "
2499 "__newobj__ args has the wrong class");
2500 return -1;
2501 }
2502 }
2503
2504 /* Save the class and its __new__ arguments. */
2505 if (save(self, cls, 0) < 0)
2506 return -1;
2507
2508 newargtup = PyTuple_New(n-1); /* argtup[1:] */
2509 if (newargtup == NULL)
2510 return -1;
2511 for (i = 1; i < n; ++i) {
2512 PyObject *temp = PyTuple_GET_ITEM(argtup, i);
2513 Py_INCREF(temp);
2514 PyTuple_SET_ITEM(newargtup, i-1, temp);
2515 }
2516 i = save(self, newargtup, 0);
2517 Py_DECREF(newargtup);
2518 if (i < 0)
2519 return -1;
2520
2521 /* Add NEWOBJ opcode. */
2522 if (self->write_func(self, &newobj, 1) < 0)
2523 return -1;
2524 }
2525 else {
2526 /* Not using NEWOBJ. */
2527 if (save(self, callable, 0) < 0 ||
2528 save(self, argtup, 0) < 0 ||
2529 self->write_func(self, &reduce, 1) < 0)
2530 return -1;
2531 }
2532
2533 /* Memoize. */
2534 /* XXX How can ob be NULL? */
2535 if (ob != NULL) {
2536 if (state && !PyDict_Check(state)) {
2537 if (put2(self, ob) < 0)
2538 return -1;
2539 }
2540 else if (put(self, ob) < 0)
2541 return -1;
2542 }
2543
2544
2545 if (listitems && batch_list(self, listitems) < 0)
2546 return -1;
2547
2548 if (dictitems && batch_dict(self, dictitems) < 0)
2549 return -1;
2550
2551 if (state) {
2552 if (save(self, state, 0) < 0 ||
2553 self->write_func(self, &build, 1) < 0)
2554 return -1;
2555 }
2556
2557 return 0;
2558 }
2559
2560 static int
save(Picklerobject * self,PyObject * args,int pers_save)2561 save(Picklerobject *self, PyObject *args, int pers_save)
2562 {
2563 PyTypeObject *type;
2564 PyObject *py_ob_id = 0, *__reduce__ = 0, *t = 0;
2565 int res = -1;
2566 int tmp;
2567
2568 if (Py_EnterRecursiveCall(" while pickling an object"))
2569 return -1;
2570
2571 if (!pers_save && self->pers_func) {
2572 if ((tmp = save_pers(self, args, self->pers_func)) != 0) {
2573 res = tmp;
2574 goto finally;
2575 }
2576 }
2577
2578 if (args == Py_None) {
2579 res = save_none(self, args);
2580 goto finally;
2581 }
2582
2583 type = Py_TYPE(args);
2584
2585 switch (type->tp_name[0]) {
2586 case 'b':
2587 if (args == Py_False || args == Py_True) {
2588 res = save_bool(self, args);
2589 goto finally;
2590 }
2591 break;
2592 case 'i':
2593 if (type == &PyInt_Type) {
2594 res = save_int(self, args);
2595 goto finally;
2596 }
2597 break;
2598
2599 case 'l':
2600 if (type == &PyLong_Type) {
2601 res = save_long(self, args);
2602 goto finally;
2603 }
2604 break;
2605
2606 case 'f':
2607 if (type == &PyFloat_Type) {
2608 res = save_float(self, args);
2609 goto finally;
2610 }
2611 break;
2612
2613 case 't':
2614 if (type == &PyTuple_Type && PyTuple_Size(args) == 0) {
2615 res = save_tuple(self, args);
2616 goto finally;
2617 }
2618 break;
2619
2620 case 's':
2621 if ((type == &PyString_Type) && (PyString_GET_SIZE(args) < 2)) {
2622 res = save_string(self, args, 0);
2623 goto finally;
2624 }
2625 break;
2626
2627 #ifdef Py_USING_UNICODE
2628 case 'u':
2629 if ((type == &PyUnicode_Type) && (PyString_GET_SIZE(args) < 2)) {
2630 res = save_unicode(self, args, 0);
2631 goto finally;
2632 }
2633 break;
2634 #endif
2635 }
2636
2637 if (Py_REFCNT(args) > 1) {
2638 if (!( py_ob_id = PyLong_FromVoidPtr(args)))
2639 goto finally;
2640
2641 if (PyDict_GetItem(self->memo, py_ob_id)) {
2642 if (get(self, py_ob_id) < 0)
2643 goto finally;
2644
2645 res = 0;
2646 goto finally;
2647 }
2648 }
2649
2650 switch (type->tp_name[0]) {
2651 case 's':
2652 if (type == &PyString_Type) {
2653 res = save_string(self, args, 1);
2654 goto finally;
2655 }
2656 break;
2657
2658 #ifdef Py_USING_UNICODE
2659 case 'u':
2660 if (type == &PyUnicode_Type) {
2661 res = save_unicode(self, args, 1);
2662 goto finally;
2663 }
2664 break;
2665 #endif
2666
2667 case 't':
2668 if (type == &PyTuple_Type) {
2669 res = save_tuple(self, args);
2670 goto finally;
2671 }
2672 if (type == &PyType_Type) {
2673 res = save_global(self, args, NULL);
2674 goto finally;
2675 }
2676 break;
2677
2678 case 'l':
2679 if (type == &PyList_Type) {
2680 res = save_list(self, args);
2681 goto finally;
2682 }
2683 break;
2684
2685 case 'd':
2686 if (type == &PyDict_Type) {
2687 res = save_dict(self, args);
2688 goto finally;
2689 }
2690 break;
2691
2692 case 'i':
2693 if (type == &PyInstance_Type) {
2694 res = save_inst(self, args);
2695 goto finally;
2696 }
2697 break;
2698
2699 case 'c':
2700 if (type == &PyClass_Type) {
2701 res = save_global(self, args, NULL);
2702 goto finally;
2703 }
2704 break;
2705
2706 case 'f':
2707 if (type == &PyFunction_Type) {
2708 res = save_global(self, args, NULL);
2709 if (res && PyErr_ExceptionMatches(PickleError)) {
2710 /* fall back to reduce */
2711 PyErr_Clear();
2712 break;
2713 }
2714 goto finally;
2715 }
2716 break;
2717
2718 case 'b':
2719 if (type == &PyCFunction_Type) {
2720 res = save_global(self, args, NULL);
2721 goto finally;
2722 }
2723 }
2724
2725 if (!pers_save && self->inst_pers_func) {
2726 if ((tmp = save_pers(self, args, self->inst_pers_func)) != 0) {
2727 res = tmp;
2728 goto finally;
2729 }
2730 }
2731
2732 /* Get a reduction callable, and call it. This may come from
2733 * copy_reg.dispatch_table, the object's __reduce_ex__ method,
2734 * or the object's __reduce__ method.
2735 */
2736 __reduce__ = PyDict_GetItem(dispatch_table, (PyObject *)type);
2737 if (__reduce__ != NULL) {
2738 Py_INCREF(__reduce__);
2739 Py_INCREF(args);
2740 ARG_TUP(self, args);
2741 if (self->arg) {
2742 t = PyObject_Call(__reduce__, self->arg, NULL);
2743 FREE_ARG_TUP(self);
2744 }
2745 }
2746 else {
2747 if (PyType_IsSubtype(type, &PyType_Type)) {
2748 res = save_global(self, args, NULL);
2749 goto finally;
2750 }
2751
2752 /* Check for a __reduce_ex__ method. */
2753 __reduce__ = PyObject_GetAttr(args, __reduce_ex___str);
2754 if (__reduce__ != NULL) {
2755 t = PyInt_FromLong(self->proto);
2756 if (t != NULL) {
2757 ARG_TUP(self, t);
2758 t = NULL;
2759 if (self->arg) {
2760 t = PyObject_Call(__reduce__,
2761 self->arg, NULL);
2762 FREE_ARG_TUP(self);
2763 }
2764 }
2765 }
2766 else {
2767 if (PyErr_ExceptionMatches(PyExc_AttributeError))
2768 PyErr_Clear();
2769 else
2770 goto finally;
2771 /* Check for a __reduce__ method. */
2772 __reduce__ = PyObject_GetAttr(args, __reduce___str);
2773 if (__reduce__ != NULL) {
2774 t = PyObject_Call(__reduce__,
2775 empty_tuple, NULL);
2776 }
2777 else {
2778 PyErr_SetObject(UnpickleableError, args);
2779 goto finally;
2780 }
2781 }
2782 }
2783
2784 if (t == NULL)
2785 goto finally;
2786
2787 if (PyString_Check(t)) {
2788 res = save_global(self, args, t);
2789 goto finally;
2790 }
2791
2792 if (!PyTuple_Check(t)) {
2793 cPickle_ErrFormat(PicklingError, "Value returned by "
2794 "%s must be string or tuple",
2795 "O", __reduce__);
2796 goto finally;
2797 }
2798
2799 res = save_reduce(self, t, __reduce__, args);
2800
2801 finally:
2802 Py_LeaveRecursiveCall();
2803 Py_XDECREF(py_ob_id);
2804 Py_XDECREF(__reduce__);
2805 Py_XDECREF(t);
2806
2807 return res;
2808 }
2809
2810
2811 static int
dump(Picklerobject * self,PyObject * args)2812 dump(Picklerobject *self, PyObject *args)
2813 {
2814 static char stop = STOP;
2815
2816 if (self->proto >= 2) {
2817 char bytes[2];
2818
2819 bytes[0] = PROTO;
2820 assert(self->proto >= 0 && self->proto < 256);
2821 bytes[1] = (char)self->proto;
2822 if (self->write_func(self, bytes, 2) < 0)
2823 return -1;
2824 }
2825
2826 if (save(self, args, 0) < 0)
2827 return -1;
2828
2829 if (self->write_func(self, &stop, 1) < 0)
2830 return -1;
2831
2832 if (self->write_func(self, NULL, 0) < 0)
2833 return -1;
2834
2835 return 0;
2836 }
2837
2838 static PyObject *
Pickle_clear_memo(Picklerobject * self,PyObject * args)2839 Pickle_clear_memo(Picklerobject *self, PyObject *args)
2840 {
2841 if (self->memo)
2842 PyDict_Clear(self->memo);
2843 Py_INCREF(Py_None);
2844 return Py_None;
2845 }
2846
2847 static PyObject *
Pickle_getvalue(Picklerobject * self,PyObject * args)2848 Pickle_getvalue(Picklerobject *self, PyObject *args)
2849 {
2850 Py_ssize_t l, i, rsize, ssize, clear=1, lm;
2851 long ik;
2852 PyObject *k, *r;
2853 char *s, *p, *have_get;
2854 Pdata *data;
2855
2856 /* Can be called by Python code or C code */
2857 if (args && !PyArg_ParseTuple(args, "|i:getvalue", &clear))
2858 return NULL;
2859
2860 /* Check to make sure we are based on a list */
2861 if (! Pdata_Check(self->file)) {
2862 PyErr_SetString(PicklingError,
2863 "Attempt to getvalue() a non-list-based pickler");
2864 return NULL;
2865 }
2866
2867 /* flush write buffer */
2868 if (write_other(self, NULL, 0) < 0) return NULL;
2869
2870 data=(Pdata*)self->file;
2871 l=data->length;
2872
2873 /* set up an array to hold get/put status */
2874 lm = PyDict_Size(self->memo);
2875 if (lm < 0) return NULL;
2876 lm++;
2877 have_get = malloc(lm);
2878 if (have_get == NULL) return PyErr_NoMemory();
2879 memset(have_get, 0, lm);
2880
2881 /* Scan for gets. */
2882 for (rsize = 0, i = l; --i >= 0; ) {
2883 k = data->data[i];
2884
2885 if (PyString_Check(k))
2886 rsize += PyString_GET_SIZE(k);
2887
2888 else if (PyInt_Check(k)) { /* put */
2889 ik = PyInt_AS_LONG((PyIntObject*)k);
2890 if (ik >= lm || ik == 0) {
2891 PyErr_SetString(PicklingError,
2892 "Invalid get data");
2893 goto err;
2894 }
2895 if (have_get[ik]) /* with matching get */
2896 rsize += ik < 256 ? 2 : 5;
2897 }
2898
2899 else if (! (PyTuple_Check(k) &&
2900 PyTuple_GET_SIZE(k) == 2 &&
2901 PyInt_Check((k = PyTuple_GET_ITEM(k, 0))))
2902 ) {
2903 PyErr_SetString(PicklingError,
2904 "Unexpected data in internal list");
2905 goto err;
2906 }
2907
2908 else { /* put */
2909 ik = PyInt_AS_LONG((PyIntObject *)k);
2910 if (ik >= lm || ik == 0) {
2911 PyErr_SetString(PicklingError,
2912 "Invalid get data");
2913 return NULL;
2914 }
2915 have_get[ik] = 1;
2916 rsize += ik < 256 ? 2 : 5;
2917 }
2918 }
2919
2920 /* Now generate the result */
2921 r = PyString_FromStringAndSize(NULL, rsize);
2922 if (r == NULL) goto err;
2923 s = PyString_AS_STRING((PyStringObject *)r);
2924
2925 for (i = 0; i < l; i++) {
2926 k = data->data[i];
2927
2928 if (PyString_Check(k)) {
2929 ssize = PyString_GET_SIZE(k);
2930 if (ssize) {
2931 p=PyString_AS_STRING((PyStringObject *)k);
2932 while (--ssize >= 0)
2933 *s++ = *p++;
2934 }
2935 }
2936
2937 else if (PyTuple_Check(k)) { /* get */
2938 ik = PyInt_AS_LONG((PyIntObject *)
2939 PyTuple_GET_ITEM(k, 0));
2940 if (ik < 256) {
2941 *s++ = BINGET;
2942 *s++ = (int)(ik & 0xff);
2943 }
2944 else {
2945 *s++ = LONG_BINGET;
2946 *s++ = (int)(ik & 0xff);
2947 *s++ = (int)((ik >> 8) & 0xff);
2948 *s++ = (int)((ik >> 16) & 0xff);
2949 *s++ = (int)((ik >> 24) & 0xff);
2950 }
2951 }
2952
2953 else { /* put */
2954 ik = PyInt_AS_LONG((PyIntObject*)k);
2955
2956 if (have_get[ik]) { /* with matching get */
2957 if (ik < 256) {
2958 *s++ = BINPUT;
2959 *s++ = (int)(ik & 0xff);
2960 }
2961 else {
2962 *s++ = LONG_BINPUT;
2963 *s++ = (int)(ik & 0xff);
2964 *s++ = (int)((ik >> 8) & 0xff);
2965 *s++ = (int)((ik >> 16) & 0xff);
2966 *s++ = (int)((ik >> 24) & 0xff);
2967 }
2968 }
2969 }
2970 }
2971
2972 if (clear) {
2973 PyDict_Clear(self->memo);
2974 Pdata_clear(data, 0);
2975 }
2976
2977 free(have_get);
2978 return r;
2979 err:
2980 free(have_get);
2981 return NULL;
2982 }
2983
2984 static PyObject *
Pickler_dump(Picklerobject * self,PyObject * args)2985 Pickler_dump(Picklerobject *self, PyObject *args)
2986 {
2987 PyObject *ob;
2988 int get=0;
2989
2990 if (!( PyArg_ParseTuple(args, "O|i:dump", &ob, &get)))
2991 return NULL;
2992
2993 if (dump(self, ob) < 0)
2994 return NULL;
2995
2996 if (get) return Pickle_getvalue(self, NULL);
2997
2998 /* XXX Why does dump() return self? */
2999 Py_INCREF(self);
3000 return (PyObject*)self;
3001 }
3002
3003
3004 static struct PyMethodDef Pickler_methods[] =
3005 {
3006 {"dump", (PyCFunction)Pickler_dump, METH_VARARGS,
3007 PyDoc_STR("dump(object) -- "
3008 "Write an object in pickle format to the object's pickle stream")},
3009 {"clear_memo", (PyCFunction)Pickle_clear_memo, METH_NOARGS,
3010 PyDoc_STR("clear_memo() -- Clear the picklers memo")},
3011 {"getvalue", (PyCFunction)Pickle_getvalue, METH_VARARGS,
3012 PyDoc_STR("getvalue() -- Finish picking a list-based pickle")},
3013 {NULL, NULL} /* sentinel */
3014 };
3015
3016
3017 static Picklerobject *
newPicklerobject(PyObject * file,int proto)3018 newPicklerobject(PyObject *file, int proto)
3019 {
3020 Picklerobject *self;
3021
3022 if (proto < 0)
3023 proto = HIGHEST_PROTOCOL;
3024 if (proto > HIGHEST_PROTOCOL) {
3025 PyErr_Format(PyExc_ValueError, "pickle protocol %d asked for; "
3026 "the highest available protocol is %d",
3027 proto, HIGHEST_PROTOCOL);
3028 return NULL;
3029 }
3030
3031 self = PyObject_GC_New(Picklerobject, &Picklertype);
3032 if (self == NULL)
3033 return NULL;
3034 self->proto = proto;
3035 self->bin = proto > 0;
3036 self->fp = NULL;
3037 self->write = NULL;
3038 self->memo = NULL;
3039 self->arg = NULL;
3040 self->pers_func = NULL;
3041 self->inst_pers_func = NULL;
3042 self->write_buf = NULL;
3043 self->fast = 0;
3044 self->fast_container = 0;
3045 self->fast_memo = NULL;
3046 self->buf_size = 0;
3047 self->dispatch_table = NULL;
3048
3049 self->file = NULL;
3050 if (file)
3051 Py_INCREF(file);
3052 else {
3053 file = Pdata_New();
3054 if (file == NULL)
3055 goto err;
3056 }
3057 self->file = file;
3058
3059 if (!( self->memo = PyDict_New()))
3060 goto err;
3061
3062 if (PyFile_Check(file)) {
3063 self->fp = PyFile_AsFile(file);
3064 if (self->fp == NULL) {
3065 PyErr_SetString(PyExc_ValueError,
3066 "I/O operation on closed file");
3067 goto err;
3068 }
3069 self->write_func = write_file;
3070 }
3071 else if (PycStringIO_OutputCheck(file)) {
3072 self->write_func = write_cStringIO;
3073 }
3074 else if (file == Py_None) {
3075 self->write_func = write_none;
3076 }
3077 else {
3078 self->write_func = write_other;
3079
3080 if (! Pdata_Check(file)) {
3081 self->write = PyObject_GetAttr(file, write_str);
3082 if (!self->write) {
3083 PyErr_Clear();
3084 PyErr_SetString(PyExc_TypeError,
3085 "argument must have 'write' "
3086 "attribute");
3087 goto err;
3088 }
3089 }
3090
3091 self->write_buf = (char *)PyMem_Malloc(WRITE_BUF_SIZE);
3092 if (self->write_buf == NULL) {
3093 PyErr_NoMemory();
3094 goto err;
3095 }
3096 }
3097
3098 if (PyEval_GetRestricted()) {
3099 /* Restricted execution, get private tables */
3100 PyObject *m = PyImport_ImportModule("copy_reg");
3101
3102 if (m == NULL)
3103 goto err;
3104 self->dispatch_table = PyObject_GetAttr(m, dispatch_table_str);
3105 Py_DECREF(m);
3106 if (self->dispatch_table == NULL)
3107 goto err;
3108 }
3109 else {
3110 self->dispatch_table = dispatch_table;
3111 Py_INCREF(dispatch_table);
3112 }
3113 PyObject_GC_Track(self);
3114
3115 return self;
3116
3117 err:
3118 Py_DECREF(self);
3119 return NULL;
3120 }
3121
3122
3123 static PyObject *
get_Pickler(PyObject * self,PyObject * args,PyObject * kwds)3124 get_Pickler(PyObject *self, PyObject *args, PyObject *kwds)
3125 {
3126 static char *kwlist[] = {"file", "protocol", NULL};
3127 PyObject *file = NULL;
3128 int proto = 0;
3129
3130 /* XXX
3131 * The documented signature is Pickler(file, protocol=0), but this
3132 * accepts Pickler() and Pickler(integer) too. The meaning then
3133 * is clear as mud, undocumented, and not supported by pickle.py.
3134 * I'm told Zope uses this, but I haven't traced into this code
3135 * far enough to figure out what it means.
3136 */
3137 if (!PyArg_ParseTuple(args, "|i:Pickler", &proto)) {
3138 PyErr_Clear();
3139 proto = 0;
3140 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|i:Pickler",
3141 kwlist, &file, &proto))
3142 return NULL;
3143 }
3144 return (PyObject *)newPicklerobject(file, proto);
3145 }
3146
3147
3148 static void
Pickler_dealloc(Picklerobject * self)3149 Pickler_dealloc(Picklerobject *self)
3150 {
3151 PyObject_GC_UnTrack(self);
3152 Py_XDECREF(self->write);
3153 Py_XDECREF(self->memo);
3154 Py_XDECREF(self->fast_memo);
3155 Py_XDECREF(self->arg);
3156 Py_XDECREF(self->file);
3157 Py_XDECREF(self->pers_func);
3158 Py_XDECREF(self->inst_pers_func);
3159 Py_XDECREF(self->dispatch_table);
3160 PyMem_Free(self->write_buf);
3161 Py_TYPE(self)->tp_free((PyObject *)self);
3162 }
3163
3164 static int
Pickler_traverse(Picklerobject * self,visitproc visit,void * arg)3165 Pickler_traverse(Picklerobject *self, visitproc visit, void *arg)
3166 {
3167 Py_VISIT(self->write);
3168 Py_VISIT(self->memo);
3169 Py_VISIT(self->fast_memo);
3170 Py_VISIT(self->arg);
3171 Py_VISIT(self->file);
3172 Py_VISIT(self->pers_func);
3173 Py_VISIT(self->inst_pers_func);
3174 Py_VISIT(self->dispatch_table);
3175 return 0;
3176 }
3177
3178 static int
Pickler_clear(Picklerobject * self)3179 Pickler_clear(Picklerobject *self)
3180 {
3181 Py_CLEAR(self->write);
3182 Py_CLEAR(self->memo);
3183 Py_CLEAR(self->fast_memo);
3184 Py_CLEAR(self->arg);
3185 Py_CLEAR(self->file);
3186 Py_CLEAR(self->pers_func);
3187 Py_CLEAR(self->inst_pers_func);
3188 Py_CLEAR(self->dispatch_table);
3189 return 0;
3190 }
3191
3192 static PyObject *
Pickler_get_pers_func(Picklerobject * p)3193 Pickler_get_pers_func(Picklerobject *p)
3194 {
3195 if (p->pers_func == NULL)
3196 PyErr_SetString(PyExc_AttributeError, "persistent_id");
3197 else
3198 Py_INCREF(p->pers_func);
3199 return p->pers_func;
3200 }
3201
3202 static int
Pickler_set_pers_func(Picklerobject * p,PyObject * v)3203 Pickler_set_pers_func(Picklerobject *p, PyObject *v)
3204 {
3205 if (v == NULL) {
3206 PyErr_SetString(PyExc_TypeError,
3207 "attribute deletion is not supported");
3208 return -1;
3209 }
3210 Py_XDECREF(p->pers_func);
3211 Py_INCREF(v);
3212 p->pers_func = v;
3213 return 0;
3214 }
3215
3216 static int
Pickler_set_inst_pers_func(Picklerobject * p,PyObject * v)3217 Pickler_set_inst_pers_func(Picklerobject *p, PyObject *v)
3218 {
3219 if (v == NULL) {
3220 PyErr_SetString(PyExc_TypeError,
3221 "attribute deletion is not supported");
3222 return -1;
3223 }
3224 Py_XDECREF(p->inst_pers_func);
3225 Py_INCREF(v);
3226 p->inst_pers_func = v;
3227 return 0;
3228 }
3229
3230 static PyObject *
Pickler_get_memo(Picklerobject * p)3231 Pickler_get_memo(Picklerobject *p)
3232 {
3233 if (p->memo == NULL)
3234 PyErr_SetString(PyExc_AttributeError, "memo");
3235 else
3236 Py_INCREF(p->memo);
3237 return p->memo;
3238 }
3239
3240 static int
Pickler_set_memo(Picklerobject * p,PyObject * v)3241 Pickler_set_memo(Picklerobject *p, PyObject *v)
3242 {
3243 if (v == NULL) {
3244 PyErr_SetString(PyExc_TypeError,
3245 "attribute deletion is not supported");
3246 return -1;
3247 }
3248 if (!PyDict_Check(v)) {
3249 PyErr_SetString(PyExc_TypeError, "memo must be a dictionary");
3250 return -1;
3251 }
3252 Py_XDECREF(p->memo);
3253 Py_INCREF(v);
3254 p->memo = v;
3255 return 0;
3256 }
3257
3258 static PyObject *
Pickler_get_error(Picklerobject * p)3259 Pickler_get_error(Picklerobject *p)
3260 {
3261 /* why is this an attribute on the Pickler? */
3262 Py_INCREF(PicklingError);
3263 return PicklingError;
3264 }
3265
3266 static PyMemberDef Pickler_members[] = {
3267 {"binary", T_INT, offsetof(Picklerobject, bin)},
3268 {"fast", T_INT, offsetof(Picklerobject, fast)},
3269 {NULL}
3270 };
3271
3272 static PyGetSetDef Pickler_getsets[] = {
3273 {"persistent_id", (getter)Pickler_get_pers_func,
3274 (setter)Pickler_set_pers_func},
3275 {"inst_persistent_id", NULL, (setter)Pickler_set_inst_pers_func},
3276 {"memo", (getter)Pickler_get_memo, (setter)Pickler_set_memo},
3277 {"PicklingError", (getter)Pickler_get_error, NULL},
3278 {NULL}
3279 };
3280
3281 PyDoc_STRVAR(Picklertype__doc__,
3282 "Objects that know how to pickle objects\n");
3283
3284 static PyTypeObject Picklertype = {
3285 PyVarObject_HEAD_INIT(NULL, 0)
3286 "cPickle.Pickler", /*tp_name*/
3287 sizeof(Picklerobject), /*tp_basicsize*/
3288 0,
3289 (destructor)Pickler_dealloc, /* tp_dealloc */
3290 0, /* tp_print */
3291 0, /* tp_getattr */
3292 0, /* tp_setattr */
3293 0, /* tp_compare */
3294 0, /* tp_repr */
3295 0, /* tp_as_number */
3296 0, /* tp_as_sequence */
3297 0, /* tp_as_mapping */
3298 0, /* tp_hash */
3299 0, /* tp_call */
3300 0, /* tp_str */
3301 PyObject_GenericGetAttr, /* tp_getattro */
3302 PyObject_GenericSetAttr, /* tp_setattro */
3303 0, /* tp_as_buffer */
3304 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
3305 Picklertype__doc__, /* tp_doc */
3306 (traverseproc)Pickler_traverse, /* tp_traverse */
3307 (inquiry)Pickler_clear, /* tp_clear */
3308 0, /* tp_richcompare */
3309 0, /* tp_weaklistoffset */
3310 0, /* tp_iter */
3311 0, /* tp_iternext */
3312 Pickler_methods, /* tp_methods */
3313 Pickler_members, /* tp_members */
3314 Pickler_getsets, /* tp_getset */
3315 };
3316
3317 static PyObject *
find_class(PyObject * py_module_name,PyObject * py_global_name,PyObject * fc)3318 find_class(PyObject *py_module_name, PyObject *py_global_name, PyObject *fc)
3319 {
3320 PyObject *global = 0, *module;
3321
3322 if (fc) {
3323 if (fc==Py_None) {
3324 PyErr_SetString(UnpicklingError, "Global and instance "
3325 "pickles are not supported.");
3326 return NULL;
3327 }
3328 return PyObject_CallFunctionObjArgs(fc, py_module_name,
3329 py_global_name, NULL);
3330 }
3331
3332 module = PySys_GetObject("modules");
3333 if (module == NULL)
3334 return NULL;
3335
3336 module = PyDict_GetItem(module, py_module_name);
3337 if (module == NULL) {
3338 module = PyImport_Import(py_module_name);
3339 if (!module)
3340 return NULL;
3341 global = PyObject_GetAttr(module, py_global_name);
3342 Py_DECREF(module);
3343 }
3344 else
3345 global = PyObject_GetAttr(module, py_global_name);
3346 return global;
3347 }
3348
3349 static Py_ssize_t
marker(Unpicklerobject * self)3350 marker(Unpicklerobject *self)
3351 {
3352 if (self->num_marks < 1) {
3353 PyErr_SetString(UnpicklingError, "could not find MARK");
3354 return -1;
3355 }
3356
3357 return self->marks[--self->num_marks];
3358 }
3359
3360
3361 static int
load_none(Unpicklerobject * self)3362 load_none(Unpicklerobject *self)
3363 {
3364 PDATA_APPEND(self->stack, Py_None, -1);
3365 return 0;
3366 }
3367
3368 static int
bad_readline(void)3369 bad_readline(void)
3370 {
3371 PyErr_SetString(UnpicklingError, "pickle data was truncated");
3372 return -1;
3373 }
3374
3375 static int
load_int(Unpicklerobject * self)3376 load_int(Unpicklerobject *self)
3377 {
3378 PyObject *py_int = 0;
3379 char *endptr, *s;
3380 Py_ssize_t len;
3381 int res = -1;
3382 long l;
3383
3384 if ((len = self->readline_func(self, &s)) < 0) return -1;
3385 if (len < 2) return bad_readline();
3386 if (!( s=pystrndup(s,len))) return -1;
3387
3388 errno = 0;
3389 l = strtol(s, &endptr, 0);
3390
3391 if (errno || (*endptr != '\n') || (endptr[1] != '\0')) {
3392 /* Hm, maybe we've got something long. Let's try reading
3393 it as a Python long object. */
3394 errno = 0;
3395 py_int = PyLong_FromString(s, NULL, 0);
3396 if (py_int == NULL) {
3397 PyErr_SetString(PyExc_ValueError,
3398 "could not convert string to int");
3399 goto finally;
3400 }
3401 }
3402 else {
3403 if (len == 3 && (l == 0 || l == 1)) {
3404 if (!( py_int = PyBool_FromLong(l))) goto finally;
3405 }
3406 else {
3407 if (!( py_int = PyInt_FromLong(l))) goto finally;
3408 }
3409 }
3410
3411 free(s);
3412 PDATA_PUSH(self->stack, py_int, -1);
3413 return 0;
3414
3415 finally:
3416 free(s);
3417
3418 return res;
3419 }
3420
3421 static int
load_bool(Unpicklerobject * self,PyObject * boolean)3422 load_bool(Unpicklerobject *self, PyObject *boolean)
3423 {
3424 assert(boolean == Py_True || boolean == Py_False);
3425 PDATA_APPEND(self->stack, boolean, -1);
3426 return 0;
3427 }
3428
3429 /* s contains x bytes of a little-endian integer. Return its value as a
3430 * C int. Obscure: when x is 1 or 2, this is an unsigned little-endian
3431 * int, but when x is 4 it's a signed one. This is an historical source
3432 * of x-platform bugs.
3433 */
3434 static long
calc_binint(char * s,int x)3435 calc_binint(char *s, int x)
3436 {
3437 unsigned char c;
3438 int i;
3439 long l;
3440
3441 for (i = 0, l = 0L; i < x; i++) {
3442 c = (unsigned char)s[i];
3443 l |= (long)c << (i * 8);
3444 }
3445 #if SIZEOF_LONG > 4
3446 /* Unlike BININT1 and BININT2, BININT (more accurately BININT4)
3447 * is signed, so on a box with longs bigger than 4 bytes we need
3448 * to extend a BININT's sign bit to the full width.
3449 */
3450 if (x == 4 && l & (1L << 31))
3451 l |= (~0L) << 32;
3452 #endif
3453 return l;
3454 }
3455
3456
3457 static int
load_binintx(Unpicklerobject * self,char * s,int x)3458 load_binintx(Unpicklerobject *self, char *s, int x)
3459 {
3460 PyObject *py_int = 0;
3461 long l;
3462
3463 l = calc_binint(s, x);
3464
3465 if (!( py_int = PyInt_FromLong(l)))
3466 return -1;
3467
3468 PDATA_PUSH(self->stack, py_int, -1);
3469 return 0;
3470 }
3471
3472
3473 static int
load_binint(Unpicklerobject * self)3474 load_binint(Unpicklerobject *self)
3475 {
3476 char *s;
3477
3478 if (self->read_func(self, &s, 4) < 0)
3479 return -1;
3480
3481 return load_binintx(self, s, 4);
3482 }
3483
3484
3485 static int
load_binint1(Unpicklerobject * self)3486 load_binint1(Unpicklerobject *self)
3487 {
3488 char *s;
3489
3490 if (self->read_func(self, &s, 1) < 0)
3491 return -1;
3492
3493 return load_binintx(self, s, 1);
3494 }
3495
3496
3497 static int
load_binint2(Unpicklerobject * self)3498 load_binint2(Unpicklerobject *self)
3499 {
3500 char *s;
3501
3502 if (self->read_func(self, &s, 2) < 0)
3503 return -1;
3504
3505 return load_binintx(self, s, 2);
3506 }
3507
3508 static int
load_long(Unpicklerobject * self)3509 load_long(Unpicklerobject *self)
3510 {
3511 PyObject *l = 0;
3512 char *end, *s;
3513 Py_ssize_t len;
3514 int res = -1;
3515
3516 if ((len = self->readline_func(self, &s)) < 0) return -1;
3517 if (len < 2) return bad_readline();
3518 if (!( s=pystrndup(s,len))) return -1;
3519
3520 if (!( l = PyLong_FromString(s, &end, 0)))
3521 goto finally;
3522
3523 free(s);
3524 PDATA_PUSH(self->stack, l, -1);
3525 return 0;
3526
3527 finally:
3528 free(s);
3529
3530 return res;
3531 }
3532
3533 /* 'size' bytes contain the # of bytes of little-endian 256's-complement
3534 * data following.
3535 */
3536 static int
load_counted_long(Unpicklerobject * self,int size)3537 load_counted_long(Unpicklerobject *self, int size)
3538 {
3539 Py_ssize_t i;
3540 char *nbytes;
3541 unsigned char *pdata;
3542 PyObject *along;
3543
3544 assert(size == 1 || size == 4);
3545 i = self->read_func(self, &nbytes, size);
3546 if (i < 0) return -1;
3547
3548 size = calc_binint(nbytes, size);
3549 if (size < 0) {
3550 /* Corrupt or hostile pickle -- we never write one like
3551 * this.
3552 */
3553 PyErr_SetString(UnpicklingError, "LONG pickle has negative "
3554 "byte count");
3555 return -1;
3556 }
3557
3558 if (size == 0)
3559 along = PyLong_FromLong(0L);
3560 else {
3561 /* Read the raw little-endian bytes & convert. */
3562 i = self->read_func(self, (char **)&pdata, size);
3563 if (i < 0) return -1;
3564 along = _PyLong_FromByteArray(pdata, (size_t)size,
3565 1 /* little endian */, 1 /* signed */);
3566 }
3567 if (along == NULL)
3568 return -1;
3569 PDATA_PUSH(self->stack, along, -1);
3570 return 0;
3571 }
3572
3573 static int
load_float(Unpicklerobject * self)3574 load_float(Unpicklerobject *self)
3575 {
3576 PyObject *py_float = 0;
3577 char *endptr, *s;
3578 Py_ssize_t len;
3579 int res = -1;
3580 double d;
3581
3582 if ((len = self->readline_func(self, &s)) < 0) return -1;
3583 if (len < 2) return bad_readline();
3584 if (!( s=pystrndup(s,len))) return -1;
3585
3586 d = PyOS_string_to_double(s, &endptr, PyExc_OverflowError);
3587
3588 if (d == -1.0 && PyErr_Occurred()) {
3589 goto finally;
3590 } else if ((endptr[0] != '\n') || (endptr[1] != '\0')) {
3591 PyErr_SetString(PyExc_ValueError,
3592 "could not convert string to float");
3593 goto finally;
3594 }
3595
3596 if (!( py_float = PyFloat_FromDouble(d)))
3597 goto finally;
3598
3599 free(s);
3600 PDATA_PUSH(self->stack, py_float, -1);
3601 return 0;
3602
3603 finally:
3604 free(s);
3605
3606 return res;
3607 }
3608
3609 static int
load_binfloat(Unpicklerobject * self)3610 load_binfloat(Unpicklerobject *self)
3611 {
3612 PyObject *py_float;
3613 double x;
3614 char *p;
3615
3616 if (self->read_func(self, &p, 8) < 0)
3617 return -1;
3618
3619 x = _PyFloat_Unpack8((unsigned char *)p, 0);
3620 if (x == -1.0 && PyErr_Occurred())
3621 return -1;
3622
3623 py_float = PyFloat_FromDouble(x);
3624 if (py_float == NULL)
3625 return -1;
3626
3627 PDATA_PUSH(self->stack, py_float, -1);
3628 return 0;
3629 }
3630
3631 static int
load_string(Unpicklerobject * self)3632 load_string(Unpicklerobject *self)
3633 {
3634 PyObject *str = 0;
3635 Py_ssize_t len;
3636 int res = -1;
3637 char *s, *p;
3638
3639 if ((len = self->readline_func(self, &s)) < 0) return -1;
3640 if (len < 2) return bad_readline();
3641 if (!( s=pystrndup(s,len))) return -1;
3642
3643
3644 /* Strip outermost quotes */
3645 while (len > 0 && s[len-1] <= ' ')
3646 len--;
3647 if (len > 1 && s[0]=='"' && s[len-1]=='"') {
3648 s[len-1] = '\0';
3649 p = s + 1 ;
3650 len -= 2;
3651 }
3652 else if (len > 1 && s[0]=='\'' && s[len-1]=='\'') {
3653 s[len-1] = '\0';
3654 p = s + 1 ;
3655 len -= 2;
3656 }
3657 else
3658 goto insecure;
3659 /********************************************/
3660
3661 str = PyString_DecodeEscape(p, len, NULL, 0, NULL);
3662 free(s);
3663 if (str) {
3664 PDATA_PUSH(self->stack, str, -1);
3665 res = 0;
3666 }
3667 return res;
3668
3669 insecure:
3670 free(s);
3671 PyErr_SetString(PyExc_ValueError,"insecure string pickle");
3672 return -1;
3673 }
3674
3675
3676 static int
load_binstring(Unpicklerobject * self)3677 load_binstring(Unpicklerobject *self)
3678 {
3679 PyObject *py_string = 0;
3680 Py_ssize_t l;
3681 char *s;
3682
3683 if (self->read_func(self, &s, 4) < 0) return -1;
3684
3685 l = calc_binint(s, 4);
3686 if (l < 0) {
3687 /* Corrupt or hostile pickle -- we never write one like
3688 * this.
3689 */
3690 PyErr_SetString(UnpicklingError,
3691 "BINSTRING pickle has negative byte count");
3692 return -1;
3693 }
3694
3695 if (self->read_func(self, &s, l) < 0)
3696 return -1;
3697
3698 if (!( py_string = PyString_FromStringAndSize(s, l)))
3699 return -1;
3700
3701 PDATA_PUSH(self->stack, py_string, -1);
3702 return 0;
3703 }
3704
3705
3706 static int
load_short_binstring(Unpicklerobject * self)3707 load_short_binstring(Unpicklerobject *self)
3708 {
3709 PyObject *py_string = 0;
3710 unsigned char l;
3711 char *s;
3712
3713 if (self->read_func(self, &s, 1) < 0)
3714 return -1;
3715
3716 l = (unsigned char)s[0];
3717
3718 if (self->read_func(self, &s, l) < 0) return -1;
3719
3720 if (!( py_string = PyString_FromStringAndSize(s, l))) return -1;
3721
3722 PDATA_PUSH(self->stack, py_string, -1);
3723 return 0;
3724 }
3725
3726
3727 #ifdef Py_USING_UNICODE
3728 static int
load_unicode(Unpicklerobject * self)3729 load_unicode(Unpicklerobject *self)
3730 {
3731 PyObject *str = 0;
3732 Py_ssize_t len;
3733 char *s;
3734
3735 if ((len = self->readline_func(self, &s)) < 0) return -1;
3736 if (len < 1) return bad_readline();
3737
3738 if (!( str = PyUnicode_DecodeRawUnicodeEscape(s, len - 1, NULL)))
3739 return -1;
3740
3741 PDATA_PUSH(self->stack, str, -1);
3742 return 0;
3743 }
3744 #endif
3745
3746
3747 #ifdef Py_USING_UNICODE
3748 static int
load_binunicode(Unpicklerobject * self)3749 load_binunicode(Unpicklerobject *self)
3750 {
3751 PyObject *unicode;
3752 Py_ssize_t l;
3753 char *s;
3754
3755 if (self->read_func(self, &s, 4) < 0) return -1;
3756
3757 l = calc_binint(s, 4);
3758 if (l < 0) {
3759 /* Corrupt or hostile pickle -- we never write one like
3760 * this.
3761 */
3762 PyErr_SetString(UnpicklingError,
3763 "BINUNICODE pickle has negative byte count");
3764 return -1;
3765 }
3766
3767 if (self->read_func(self, &s, l) < 0)
3768 return -1;
3769
3770 if (!( unicode = PyUnicode_DecodeUTF8(s, l, NULL)))
3771 return -1;
3772
3773 PDATA_PUSH(self->stack, unicode, -1);
3774 return 0;
3775 }
3776 #endif
3777
3778
3779 static int
load_tuple(Unpicklerobject * self)3780 load_tuple(Unpicklerobject *self)
3781 {
3782 PyObject *tup;
3783 Py_ssize_t i;
3784
3785 if ((i = marker(self)) < 0) return -1;
3786 if (!( tup=Pdata_popTuple(self->stack, i))) return -1;
3787 PDATA_PUSH(self->stack, tup, -1);
3788 return 0;
3789 }
3790
3791 static int
load_counted_tuple(Unpicklerobject * self,int len)3792 load_counted_tuple(Unpicklerobject *self, int len)
3793 {
3794 PyObject *tup = PyTuple_New(len);
3795
3796 if (tup == NULL)
3797 return -1;
3798
3799 while (--len >= 0) {
3800 PyObject *element;
3801
3802 PDATA_POP(self->stack, element);
3803 if (element == NULL)
3804 return -1;
3805 PyTuple_SET_ITEM(tup, len, element);
3806 }
3807 PDATA_PUSH(self->stack, tup, -1);
3808 return 0;
3809 }
3810
3811 static int
load_empty_list(Unpicklerobject * self)3812 load_empty_list(Unpicklerobject *self)
3813 {
3814 PyObject *list;
3815
3816 if (!( list=PyList_New(0))) return -1;
3817 PDATA_PUSH(self->stack, list, -1);
3818 return 0;
3819 }
3820
3821 static int
load_empty_dict(Unpicklerobject * self)3822 load_empty_dict(Unpicklerobject *self)
3823 {
3824 PyObject *dict;
3825
3826 if (!( dict=PyDict_New())) return -1;
3827 PDATA_PUSH(self->stack, dict, -1);
3828 return 0;
3829 }
3830
3831
3832 static int
load_list(Unpicklerobject * self)3833 load_list(Unpicklerobject *self)
3834 {
3835 PyObject *list = 0;
3836 Py_ssize_t i;
3837
3838 if ((i = marker(self)) < 0) return -1;
3839 if (!( list=Pdata_popList(self->stack, i))) return -1;
3840 PDATA_PUSH(self->stack, list, -1);
3841 return 0;
3842 }
3843
3844 static int
load_dict(Unpicklerobject * self)3845 load_dict(Unpicklerobject *self)
3846 {
3847 PyObject *dict, *key, *value;
3848 Py_ssize_t i, j, k;
3849
3850 if ((i = marker(self)) < 0) return -1;
3851 j=self->stack->length;
3852
3853 if (!( dict = PyDict_New())) return -1;
3854
3855 for (k = i+1; k < j; k += 2) {
3856 key =self->stack->data[k-1];
3857 value=self->stack->data[k ];
3858 if (PyDict_SetItem(dict, key, value) < 0) {
3859 Py_DECREF(dict);
3860 return -1;
3861 }
3862 }
3863 Pdata_clear(self->stack, i);
3864 PDATA_PUSH(self->stack, dict, -1);
3865 return 0;
3866 }
3867
3868 static PyObject *
Instance_New(PyObject * cls,PyObject * args)3869 Instance_New(PyObject *cls, PyObject *args)
3870 {
3871 PyObject *r = 0;
3872
3873 if (PyClass_Check(cls)) {
3874 int l;
3875
3876 if ((l=PyObject_Size(args)) < 0) goto err;
3877 if (!( l )) {
3878 PyObject *__getinitargs__;
3879
3880 __getinitargs__ = PyObject_GetAttr(cls,
3881 __getinitargs___str);
3882 if (!__getinitargs__) {
3883 /* We have a class with no __getinitargs__,
3884 so bypass usual construction */
3885 PyObject *inst;
3886
3887 PyErr_Clear();
3888 if (!( inst=PyInstance_NewRaw(cls, NULL)))
3889 goto err;
3890 return inst;
3891 }
3892 Py_DECREF(__getinitargs__);
3893 }
3894
3895 if ((r=PyInstance_New(cls, args, NULL))) return r;
3896 else goto err;
3897 }
3898
3899 if ((r=PyObject_CallObject(cls, args))) return r;
3900
3901 err:
3902 {
3903 PyObject *tp, *v, *tb, *tmp_value;
3904
3905 PyErr_Fetch(&tp, &v, &tb);
3906 tmp_value = v;
3907 /* NULL occurs when there was a KeyboardInterrupt */
3908 if (tmp_value == NULL)
3909 tmp_value = Py_None;
3910 if ((r = PyTuple_Pack(3, tmp_value, cls, args))) {
3911 Py_XDECREF(v);
3912 v=r;
3913 }
3914 PyErr_Restore(tp,v,tb);
3915 }
3916 return NULL;
3917 }
3918
3919
3920 static int
load_obj(Unpicklerobject * self)3921 load_obj(Unpicklerobject *self)
3922 {
3923 PyObject *class, *tup, *obj=0;
3924 Py_ssize_t i;
3925
3926 if ((i = marker(self)) < 0) return -1;
3927 if (!( tup=Pdata_popTuple(self->stack, i+1))) return -1;
3928 PDATA_POP(self->stack, class);
3929 if (class) {
3930 obj = Instance_New(class, tup);
3931 Py_DECREF(class);
3932 }
3933 Py_DECREF(tup);
3934
3935 if (! obj) return -1;
3936 PDATA_PUSH(self->stack, obj, -1);
3937 return 0;
3938 }
3939
3940
3941 static int
load_inst(Unpicklerobject * self)3942 load_inst(Unpicklerobject *self)
3943 {
3944 PyObject *tup, *class=0, *obj=0, *module_name, *class_name;
3945 Py_ssize_t i, len;
3946 char *s;
3947
3948 if ((i = marker(self)) < 0) return -1;
3949
3950 if ((len = self->readline_func(self, &s)) < 0) return -1;
3951 if (len < 2) return bad_readline();
3952 module_name = PyString_FromStringAndSize(s, len - 1);
3953 if (!module_name) return -1;
3954
3955 if ((len = self->readline_func(self, &s)) >= 0) {
3956 if (len < 2) return bad_readline();
3957 if ((class_name = PyString_FromStringAndSize(s, len - 1))) {
3958 class = find_class(module_name, class_name,
3959 self->find_class);
3960 Py_DECREF(class_name);
3961 }
3962 }
3963 Py_DECREF(module_name);
3964
3965 if (! class) return -1;
3966
3967 if ((tup=Pdata_popTuple(self->stack, i))) {
3968 obj = Instance_New(class, tup);
3969 Py_DECREF(tup);
3970 }
3971 Py_DECREF(class);
3972
3973 if (! obj) return -1;
3974
3975 PDATA_PUSH(self->stack, obj, -1);
3976 return 0;
3977 }
3978
3979 static int
load_newobj(Unpicklerobject * self)3980 load_newobj(Unpicklerobject *self)
3981 {
3982 PyObject *args = NULL;
3983 PyObject *clsraw = NULL;
3984 PyTypeObject *cls; /* clsraw cast to its true type */
3985 PyObject *obj;
3986
3987 /* Stack is ... cls argtuple, and we want to call
3988 * cls.__new__(cls, *argtuple).
3989 */
3990 PDATA_POP(self->stack, args);
3991 if (args == NULL) goto Fail;
3992 if (! PyTuple_Check(args)) {
3993 PyErr_SetString(UnpicklingError, "NEWOBJ expected an arg "
3994 "tuple.");
3995 goto Fail;
3996 }
3997
3998 PDATA_POP(self->stack, clsraw);
3999 cls = (PyTypeObject *)clsraw;
4000 if (cls == NULL) goto Fail;
4001 if (! PyType_Check(cls)) {
4002 PyErr_SetString(UnpicklingError, "NEWOBJ class argument "
4003 "isn't a type object");
4004 goto Fail;
4005 }
4006 if (cls->tp_new == NULL) {
4007 PyErr_SetString(UnpicklingError, "NEWOBJ class argument "
4008 "has NULL tp_new");
4009 goto Fail;
4010 }
4011
4012 /* Call __new__. */
4013 obj = cls->tp_new(cls, args, NULL);
4014 if (obj == NULL) goto Fail;
4015
4016 Py_DECREF(args);
4017 Py_DECREF(clsraw);
4018 PDATA_PUSH(self->stack, obj, -1);
4019 return 0;
4020
4021 Fail:
4022 Py_XDECREF(args);
4023 Py_XDECREF(clsraw);
4024 return -1;
4025 }
4026
4027 static int
load_global(Unpicklerobject * self)4028 load_global(Unpicklerobject *self)
4029 {
4030 PyObject *class = 0, *module_name = 0, *class_name = 0;
4031 Py_ssize_t len;
4032 char *s;
4033
4034 if ((len = self->readline_func(self, &s)) < 0) return -1;
4035 if (len < 2) return bad_readline();
4036 module_name = PyString_FromStringAndSize(s, len - 1);
4037 if (!module_name) return -1;
4038
4039 if ((len = self->readline_func(self, &s)) >= 0) {
4040 if (len < 2) {
4041 Py_DECREF(module_name);
4042 return bad_readline();
4043 }
4044 if ((class_name = PyString_FromStringAndSize(s, len - 1))) {
4045 class = find_class(module_name, class_name,
4046 self->find_class);
4047 Py_DECREF(class_name);
4048 }
4049 }
4050 Py_DECREF(module_name);
4051
4052 if (! class) return -1;
4053 PDATA_PUSH(self->stack, class, -1);
4054 return 0;
4055 }
4056
4057
4058 static int
load_persid(Unpicklerobject * self)4059 load_persid(Unpicklerobject *self)
4060 {
4061 PyObject *pid = 0;
4062 Py_ssize_t len;
4063 char *s;
4064
4065 if (self->pers_func) {
4066 if ((len = self->readline_func(self, &s)) < 0) return -1;
4067 if (len < 2) return bad_readline();
4068
4069 pid = PyString_FromStringAndSize(s, len - 1);
4070 if (!pid) return -1;
4071
4072 if (PyList_Check(self->pers_func)) {
4073 if (PyList_Append(self->pers_func, pid) < 0) {
4074 Py_DECREF(pid);
4075 return -1;
4076 }
4077 }
4078 else {
4079 ARG_TUP(self, pid);
4080 if (self->arg) {
4081 pid = PyObject_Call(self->pers_func, self->arg,
4082 NULL);
4083 FREE_ARG_TUP(self);
4084 }
4085 }
4086
4087 if (! pid) return -1;
4088
4089 PDATA_PUSH(self->stack, pid, -1);
4090 return 0;
4091 }
4092 else {
4093 PyErr_SetString(UnpicklingError,
4094 "A load persistent id instruction was encountered,\n"
4095 "but no persistent_load function was specified.");
4096 return -1;
4097 }
4098 }
4099
4100 static int
load_binpersid(Unpicklerobject * self)4101 load_binpersid(Unpicklerobject *self)
4102 {
4103 PyObject *pid = 0;
4104
4105 if (self->pers_func) {
4106 PDATA_POP(self->stack, pid);
4107 if (! pid) return -1;
4108
4109 if (PyList_Check(self->pers_func)) {
4110 if (PyList_Append(self->pers_func, pid) < 0) {
4111 Py_DECREF(pid);
4112 return -1;
4113 }
4114 }
4115 else {
4116 ARG_TUP(self, pid);
4117 if (self->arg) {
4118 pid = PyObject_Call(self->pers_func, self->arg,
4119 NULL);
4120 FREE_ARG_TUP(self);
4121 }
4122 if (! pid) return -1;
4123 }
4124
4125 PDATA_PUSH(self->stack, pid, -1);
4126 return 0;
4127 }
4128 else {
4129 PyErr_SetString(UnpicklingError,
4130 "A load persistent id instruction was encountered,\n"
4131 "but no persistent_load function was specified.");
4132 return -1;
4133 }
4134 }
4135
4136
4137 static int
load_pop(Unpicklerobject * self)4138 load_pop(Unpicklerobject *self)
4139 {
4140 Py_ssize_t len = self->stack->length;
4141
4142 /* Note that we split the (pickle.py) stack into two stacks,
4143 an object stack and a mark stack. We have to be clever and
4144 pop the right one. We do this by looking at the top of the
4145 mark stack first, and only signalling a stack underflow if
4146 the object stack is empty and the mark stack doesn't match
4147 our expectations.
4148 */
4149 if (self->num_marks > 0 && self->marks[self->num_marks - 1] == len) {
4150 self->num_marks--;
4151 } else if (len > 0) {
4152 len--;
4153 Py_DECREF(self->stack->data[len]);
4154 self->stack->length = len;
4155 } else {
4156 return stackUnderflow();
4157 }
4158 return 0;
4159 }
4160
4161
4162 static int
load_pop_mark(Unpicklerobject * self)4163 load_pop_mark(Unpicklerobject *self)
4164 {
4165 Py_ssize_t i;
4166
4167 if ((i = marker(self)) < 0)
4168 return -1;
4169
4170 Pdata_clear(self->stack, i);
4171
4172 return 0;
4173 }
4174
4175
4176 static int
load_dup(Unpicklerobject * self)4177 load_dup(Unpicklerobject *self)
4178 {
4179 PyObject *last;
4180 Py_ssize_t len;
4181
4182 if ((len = self->stack->length) <= 0) return stackUnderflow();
4183 last=self->stack->data[len-1];
4184 Py_INCREF(last);
4185 PDATA_PUSH(self->stack, last, -1);
4186 return 0;
4187 }
4188
4189
4190 static int
load_get(Unpicklerobject * self)4191 load_get(Unpicklerobject *self)
4192 {
4193 PyObject *py_str = 0, *value = 0;
4194 Py_ssize_t len;
4195 char *s;
4196 int rc;
4197
4198 if ((len = self->readline_func(self, &s)) < 0) return -1;
4199 if (len < 2) return bad_readline();
4200
4201 if (!( py_str = PyString_FromStringAndSize(s, len - 1))) return -1;
4202
4203 value = PyDict_GetItem(self->memo, py_str);
4204 if (! value) {
4205 PyErr_SetObject(BadPickleGet, py_str);
4206 rc = -1;
4207 }
4208 else {
4209 PDATA_APPEND(self->stack, value, -1);
4210 rc = 0;
4211 }
4212
4213 Py_DECREF(py_str);
4214 return rc;
4215 }
4216
4217
4218 static int
load_binget(Unpicklerobject * self)4219 load_binget(Unpicklerobject *self)
4220 {
4221 PyObject *py_key = 0, *value = 0;
4222 unsigned char key;
4223 char *s;
4224 int rc;
4225
4226 if (self->read_func(self, &s, 1) < 0) return -1;
4227
4228 key = (unsigned char)s[0];
4229 if (!( py_key = PyInt_FromLong((long)key))) return -1;
4230
4231 value = PyDict_GetItem(self->memo, py_key);
4232 if (! value) {
4233 PyErr_SetObject(BadPickleGet, py_key);
4234 rc = -1;
4235 }
4236 else {
4237 PDATA_APPEND(self->stack, value, -1);
4238 rc = 0;
4239 }
4240
4241 Py_DECREF(py_key);
4242 return rc;
4243 }
4244
4245
4246 static int
load_long_binget(Unpicklerobject * self)4247 load_long_binget(Unpicklerobject *self)
4248 {
4249 PyObject *py_key = 0, *value = 0;
4250 unsigned char c;
4251 char *s;
4252 Py_ssize_t key;
4253 int rc;
4254
4255 if (self->read_func(self, &s, 4) < 0) return -1;
4256
4257 c = (unsigned char)s[0];
4258 key = (long)c;
4259 c = (unsigned char)s[1];
4260 key |= (long)c << 8;
4261 c = (unsigned char)s[2];
4262 key |= (long)c << 16;
4263 c = (unsigned char)s[3];
4264 key |= (long)c << 24;
4265
4266 if (!( py_key = PyInt_FromLong((long)key))) return -1;
4267
4268 value = PyDict_GetItem(self->memo, py_key);
4269 if (! value) {
4270 PyErr_SetObject(BadPickleGet, py_key);
4271 rc = -1;
4272 }
4273 else {
4274 PDATA_APPEND(self->stack, value, -1);
4275 rc = 0;
4276 }
4277
4278 Py_DECREF(py_key);
4279 return rc;
4280 }
4281
4282 /* Push an object from the extension registry (EXT[124]). nbytes is
4283 * the number of bytes following the opcode, holding the index (code) value.
4284 */
4285 static int
load_extension(Unpicklerobject * self,int nbytes)4286 load_extension(Unpicklerobject *self, int nbytes)
4287 {
4288 char *codebytes; /* the nbytes bytes after the opcode */
4289 long code; /* calc_binint returns long */
4290 PyObject *py_code; /* code as a Python int */
4291 PyObject *obj; /* the object to push */
4292 PyObject *pair; /* (module_name, class_name) */
4293 PyObject *module_name, *class_name;
4294
4295 assert(nbytes == 1 || nbytes == 2 || nbytes == 4);
4296 if (self->read_func(self, &codebytes, nbytes) < 0) return -1;
4297 code = calc_binint(codebytes, nbytes);
4298 if (code <= 0) { /* note that 0 is forbidden */
4299 /* Corrupt or hostile pickle. */
4300 PyErr_SetString(UnpicklingError, "EXT specifies code <= 0");
4301 return -1;
4302 }
4303
4304 /* Look for the code in the cache. */
4305 py_code = PyInt_FromLong(code);
4306 if (py_code == NULL) return -1;
4307 obj = PyDict_GetItem(extension_cache, py_code);
4308 if (obj != NULL) {
4309 /* Bingo. */
4310 Py_DECREF(py_code);
4311 PDATA_APPEND(self->stack, obj, -1);
4312 return 0;
4313 }
4314
4315 /* Look up the (module_name, class_name) pair. */
4316 pair = PyDict_GetItem(inverted_registry, py_code);
4317 if (pair == NULL) {
4318 Py_DECREF(py_code);
4319 PyErr_Format(PyExc_ValueError, "unregistered extension "
4320 "code %ld", code);
4321 return -1;
4322 }
4323 /* Since the extension registry is manipulable via Python code,
4324 * confirm that pair is really a 2-tuple of strings.
4325 */
4326 if (!PyTuple_Check(pair) || PyTuple_Size(pair) != 2 ||
4327 !PyString_Check(module_name = PyTuple_GET_ITEM(pair, 0)) ||
4328 !PyString_Check(class_name = PyTuple_GET_ITEM(pair, 1))) {
4329 Py_DECREF(py_code);
4330 PyErr_Format(PyExc_ValueError, "_inverted_registry[%ld] "
4331 "isn't a 2-tuple of strings", code);
4332 return -1;
4333 }
4334 /* Load the object. */
4335 obj = find_class(module_name, class_name, self->find_class);
4336 if (obj == NULL) {
4337 Py_DECREF(py_code);
4338 return -1;
4339 }
4340 /* Cache code -> obj. */
4341 code = PyDict_SetItem(extension_cache, py_code, obj);
4342 Py_DECREF(py_code);
4343 if (code < 0) {
4344 Py_DECREF(obj);
4345 return -1;
4346 }
4347 PDATA_PUSH(self->stack, obj, -1);
4348 return 0;
4349 }
4350
4351 static int
load_put(Unpicklerobject * self)4352 load_put(Unpicklerobject *self)
4353 {
4354 PyObject *py_str = 0, *value = 0;
4355 Py_ssize_t len, l;
4356 char *s;
4357
4358 if ((l = self->readline_func(self, &s)) < 0) return -1;
4359 if (l < 2) return bad_readline();
4360 if (!( len=self->stack->length )) return stackUnderflow();
4361 if (!( py_str = PyString_FromStringAndSize(s, l - 1))) return -1;
4362 value=self->stack->data[len-1];
4363 l=PyDict_SetItem(self->memo, py_str, value);
4364 Py_DECREF(py_str);
4365 return l;
4366 }
4367
4368
4369 static int
load_binput(Unpicklerobject * self)4370 load_binput(Unpicklerobject *self)
4371 {
4372 PyObject *py_key = 0, *value = 0;
4373 unsigned char key;
4374 char *s;
4375 Py_ssize_t len;
4376
4377 if (self->read_func(self, &s, 1) < 0) return -1;
4378 if (!( (len=self->stack->length) > 0 )) return stackUnderflow();
4379
4380 key = (unsigned char)s[0];
4381
4382 if (!( py_key = PyInt_FromLong((long)key))) return -1;
4383 value=self->stack->data[len-1];
4384 len=PyDict_SetItem(self->memo, py_key, value);
4385 Py_DECREF(py_key);
4386 return len;
4387 }
4388
4389
4390 static int
load_long_binput(Unpicklerobject * self)4391 load_long_binput(Unpicklerobject *self)
4392 {
4393 PyObject *py_key = 0, *value = 0;
4394 Py_ssize_t key;
4395 unsigned char c;
4396 char *s;
4397 Py_ssize_t len;
4398
4399 if (self->read_func(self, &s, 4) < 0) return -1;
4400 if (!( len=self->stack->length )) return stackUnderflow();
4401
4402 c = (unsigned char)s[0];
4403 key = (long)c;
4404 c = (unsigned char)s[1];
4405 key |= (long)c << 8;
4406 c = (unsigned char)s[2];
4407 key |= (long)c << 16;
4408 c = (unsigned char)s[3];
4409 key |= (long)c << 24;
4410
4411 if (!( py_key = PyInt_FromLong(key))) return -1;
4412 value=self->stack->data[len-1];
4413 len=PyDict_SetItem(self->memo, py_key, value);
4414 Py_DECREF(py_key);
4415 return len;
4416 }
4417
4418
4419 static int
do_append(Unpicklerobject * self,Py_ssize_t x)4420 do_append(Unpicklerobject *self, Py_ssize_t x)
4421 {
4422 PyObject *value = 0, *list = 0, *append_method = 0;
4423 Py_ssize_t len, i;
4424
4425 len=self->stack->length;
4426 if (!( len >= x && x > 0 )) return stackUnderflow();
4427 /* nothing to do */
4428 if (len==x) return 0;
4429
4430 list=self->stack->data[x-1];
4431
4432 if (PyList_Check(list)) {
4433 PyObject *slice;
4434 int list_len;
4435
4436 slice=Pdata_popList(self->stack, x);
4437 if (! slice) return -1;
4438 list_len = PyList_GET_SIZE(list);
4439 i=PyList_SetSlice(list, list_len, list_len, slice);
4440 Py_DECREF(slice);
4441 return i;
4442 }
4443 else {
4444
4445 if (!( append_method = PyObject_GetAttr(list, append_str)))
4446 return -1;
4447
4448 for (i = x; i < len; i++) {
4449 PyObject *junk;
4450
4451 value=self->stack->data[i];
4452 junk=0;
4453 ARG_TUP(self, value);
4454 if (self->arg) {
4455 junk = PyObject_Call(append_method, self->arg,
4456 NULL);
4457 FREE_ARG_TUP(self);
4458 }
4459 if (! junk) {
4460 Pdata_clear(self->stack, i+1);
4461 self->stack->length=x;
4462 Py_DECREF(append_method);
4463 return -1;
4464 }
4465 Py_DECREF(junk);
4466 }
4467 self->stack->length=x;
4468 Py_DECREF(append_method);
4469 }
4470
4471 return 0;
4472 }
4473
4474
4475 static int
load_append(Unpicklerobject * self)4476 load_append(Unpicklerobject *self)
4477 {
4478 return do_append(self, self->stack->length - 1);
4479 }
4480
4481
4482 static int
load_appends(Unpicklerobject * self)4483 load_appends(Unpicklerobject *self)
4484 {
4485 return do_append(self, marker(self));
4486 }
4487
4488
4489 static Py_ssize_t
do_setitems(Unpicklerobject * self,Py_ssize_t x)4490 do_setitems(Unpicklerobject *self, Py_ssize_t x)
4491 {
4492 PyObject *value = 0, *key = 0, *dict = 0;
4493 Py_ssize_t len, i, r=0;
4494
4495 if (!( (len=self->stack->length) >= x
4496 && x > 0 )) return stackUnderflow();
4497
4498 dict=self->stack->data[x-1];
4499
4500 for (i = x+1; i < len; i += 2) {
4501 key =self->stack->data[i-1];
4502 value=self->stack->data[i ];
4503 if (PyObject_SetItem(dict, key, value) < 0) {
4504 r=-1;
4505 break;
4506 }
4507 }
4508
4509 Pdata_clear(self->stack, x);
4510
4511 return r;
4512 }
4513
4514
4515 static int
load_setitem(Unpicklerobject * self)4516 load_setitem(Unpicklerobject *self)
4517 {
4518 return do_setitems(self, self->stack->length - 2);
4519 }
4520
4521 static int
load_setitems(Unpicklerobject * self)4522 load_setitems(Unpicklerobject *self)
4523 {
4524 return do_setitems(self, marker(self));
4525 }
4526
4527
4528 static int
load_build(Unpicklerobject * self)4529 load_build(Unpicklerobject *self)
4530 {
4531 PyObject *state, *inst, *slotstate;
4532 PyObject *__setstate__;
4533 PyObject *d_key, *d_value;
4534 int res = -1;
4535 Py_ssize_t i;
4536
4537 /* Stack is ... instance, state. We want to leave instance at
4538 * the stack top, possibly mutated via instance.__setstate__(state).
4539 */
4540 if (self->stack->length < 2)
4541 return stackUnderflow();
4542 PDATA_POP(self->stack, state);
4543 if (state == NULL)
4544 return -1;
4545 inst = self->stack->data[self->stack->length - 1];
4546
4547 __setstate__ = PyObject_GetAttr(inst, __setstate___str);
4548 if (__setstate__ != NULL) {
4549 PyObject *junk = NULL;
4550
4551 /* The explicit __setstate__ is responsible for everything. */
4552 ARG_TUP(self, state);
4553 if (self->arg) {
4554 junk = PyObject_Call(__setstate__, self->arg, NULL);
4555 FREE_ARG_TUP(self);
4556 }
4557 Py_DECREF(__setstate__);
4558 if (junk == NULL)
4559 return -1;
4560 Py_DECREF(junk);
4561 return 0;
4562 }
4563 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
4564 return -1;
4565 PyErr_Clear();
4566
4567 /* A default __setstate__. First see whether state embeds a
4568 * slot state dict too (a proto 2 addition).
4569 */
4570 if (PyTuple_Check(state) && PyTuple_Size(state) == 2) {
4571 PyObject *temp = state;
4572 state = PyTuple_GET_ITEM(temp, 0);
4573 slotstate = PyTuple_GET_ITEM(temp, 1);
4574 Py_INCREF(state);
4575 Py_INCREF(slotstate);
4576 Py_DECREF(temp);
4577 }
4578 else
4579 slotstate = NULL;
4580
4581 /* Set inst.__dict__ from the state dict (if any). */
4582 if (state != Py_None) {
4583 PyObject *dict;
4584 if (! PyDict_Check(state)) {
4585 PyErr_SetString(UnpicklingError, "state is not a "
4586 "dictionary");
4587 goto finally;
4588 }
4589 dict = PyObject_GetAttr(inst, __dict___str);
4590 if (dict == NULL)
4591 goto finally;
4592
4593 i = 0;
4594 while (PyDict_Next(state, &i, &d_key, &d_value)) {
4595 /* normally the keys for instance attributes are
4596 interned. we should try to do that here. */
4597 Py_INCREF(d_key);
4598 if (PyString_CheckExact(d_key))
4599 PyString_InternInPlace(&d_key);
4600 if (PyObject_SetItem(dict, d_key, d_value) < 0) {
4601 Py_DECREF(d_key);
4602 goto finally;
4603 }
4604 Py_DECREF(d_key);
4605 }
4606 Py_DECREF(dict);
4607 }
4608
4609 /* Also set instance attributes from the slotstate dict (if any). */
4610 if (slotstate != NULL) {
4611 if (! PyDict_Check(slotstate)) {
4612 PyErr_SetString(UnpicklingError, "slot state is not "
4613 "a dictionary");
4614 goto finally;
4615 }
4616 i = 0;
4617 while (PyDict_Next(slotstate, &i, &d_key, &d_value)) {
4618 if (PyObject_SetAttr(inst, d_key, d_value) < 0)
4619 goto finally;
4620 }
4621 }
4622 res = 0;
4623
4624 finally:
4625 Py_DECREF(state);
4626 Py_XDECREF(slotstate);
4627 return res;
4628 }
4629
4630
4631 static int
load_mark(Unpicklerobject * self)4632 load_mark(Unpicklerobject *self)
4633 {
4634 Py_ssize_t s;
4635
4636 /* Note that we split the (pickle.py) stack into two stacks, an
4637 object stack and a mark stack. Here we push a mark onto the
4638 mark stack.
4639 */
4640
4641 if ((self->num_marks + 1) >= self->marks_size) {
4642 Py_ssize_t *marks;
4643 s=self->marks_size+20;
4644 if (s <= self->num_marks) s=self->num_marks + 1;
4645 if (self->marks == NULL)
4646 marks=(Py_ssize_t *)malloc(s * sizeof(Py_ssize_t));
4647 else
4648 marks=(Py_ssize_t *)realloc(self->marks,
4649 s * sizeof(Py_ssize_t));
4650 if (!marks) {
4651 PyErr_NoMemory();
4652 return -1;
4653 }
4654 self->marks = marks;
4655 self->marks_size = s;
4656 }
4657
4658 self->marks[self->num_marks++] = self->stack->length;
4659
4660 return 0;
4661 }
4662
4663 static int
load_reduce(Unpicklerobject * self)4664 load_reduce(Unpicklerobject *self)
4665 {
4666 PyObject *callable = 0, *arg_tup = 0, *ob = 0;
4667
4668 PDATA_POP(self->stack, arg_tup);
4669 if (! arg_tup) return -1;
4670 PDATA_POP(self->stack, callable);
4671 if (callable) {
4672 ob = Instance_New(callable, arg_tup);
4673 Py_DECREF(callable);
4674 }
4675 Py_DECREF(arg_tup);
4676
4677 if (! ob) return -1;
4678
4679 PDATA_PUSH(self->stack, ob, -1);
4680 return 0;
4681 }
4682
4683 /* Just raises an error if we don't know the protocol specified. PROTO
4684 * is the first opcode for protocols >= 2.
4685 */
4686 static int
load_proto(Unpicklerobject * self)4687 load_proto(Unpicklerobject *self)
4688 {
4689 int i;
4690 char *protobyte;
4691
4692 i = self->read_func(self, &protobyte, 1);
4693 if (i < 0)
4694 return -1;
4695
4696 i = calc_binint(protobyte, 1);
4697 /* No point checking for < 0, since calc_binint returns an unsigned
4698 * int when chewing on 1 byte.
4699 */
4700 assert(i >= 0);
4701 if (i <= HIGHEST_PROTOCOL)
4702 return 0;
4703
4704 PyErr_Format(PyExc_ValueError, "unsupported pickle protocol: %d", i);
4705 return -1;
4706 }
4707
4708 static PyObject *
load(Unpicklerobject * self)4709 load(Unpicklerobject *self)
4710 {
4711 PyObject *err = 0, *val = 0;
4712 char *s;
4713
4714 self->num_marks = 0;
4715 if (self->stack->length) Pdata_clear(self->stack, 0);
4716
4717 while (1) {
4718 if (self->read_func(self, &s, 1) < 0)
4719 break;
4720
4721 switch (s[0]) {
4722 case NONE:
4723 if (load_none(self) < 0)
4724 break;
4725 continue;
4726
4727 case BININT:
4728 if (load_binint(self) < 0)
4729 break;
4730 continue;
4731
4732 case BININT1:
4733 if (load_binint1(self) < 0)
4734 break;
4735 continue;
4736
4737 case BININT2:
4738 if (load_binint2(self) < 0)
4739 break;
4740 continue;
4741
4742 case INT:
4743 if (load_int(self) < 0)
4744 break;
4745 continue;
4746
4747 case LONG:
4748 if (load_long(self) < 0)
4749 break;
4750 continue;
4751
4752 case LONG1:
4753 if (load_counted_long(self, 1) < 0)
4754 break;
4755 continue;
4756
4757 case LONG4:
4758 if (load_counted_long(self, 4) < 0)
4759 break;
4760 continue;
4761
4762 case FLOAT:
4763 if (load_float(self) < 0)
4764 break;
4765 continue;
4766
4767 case BINFLOAT:
4768 if (load_binfloat(self) < 0)
4769 break;
4770 continue;
4771
4772 case BINSTRING:
4773 if (load_binstring(self) < 0)
4774 break;
4775 continue;
4776
4777 case SHORT_BINSTRING:
4778 if (load_short_binstring(self) < 0)
4779 break;
4780 continue;
4781
4782 case STRING:
4783 if (load_string(self) < 0)
4784 break;
4785 continue;
4786
4787 #ifdef Py_USING_UNICODE
4788 case UNICODE:
4789 if (load_unicode(self) < 0)
4790 break;
4791 continue;
4792
4793 case BINUNICODE:
4794 if (load_binunicode(self) < 0)
4795 break;
4796 continue;
4797 #endif
4798
4799 case EMPTY_TUPLE:
4800 if (load_counted_tuple(self, 0) < 0)
4801 break;
4802 continue;
4803
4804 case TUPLE1:
4805 if (load_counted_tuple(self, 1) < 0)
4806 break;
4807 continue;
4808
4809 case TUPLE2:
4810 if (load_counted_tuple(self, 2) < 0)
4811 break;
4812 continue;
4813
4814 case TUPLE3:
4815 if (load_counted_tuple(self, 3) < 0)
4816 break;
4817 continue;
4818
4819 case TUPLE:
4820 if (load_tuple(self) < 0)
4821 break;
4822 continue;
4823
4824 case EMPTY_LIST:
4825 if (load_empty_list(self) < 0)
4826 break;
4827 continue;
4828
4829 case LIST:
4830 if (load_list(self) < 0)
4831 break;
4832 continue;
4833
4834 case EMPTY_DICT:
4835 if (load_empty_dict(self) < 0)
4836 break;
4837 continue;
4838
4839 case DICT:
4840 if (load_dict(self) < 0)
4841 break;
4842 continue;
4843
4844 case OBJ:
4845 if (load_obj(self) < 0)
4846 break;
4847 continue;
4848
4849 case INST:
4850 if (load_inst(self) < 0)
4851 break;
4852 continue;
4853
4854 case NEWOBJ:
4855 if (load_newobj(self) < 0)
4856 break;
4857 continue;
4858
4859 case GLOBAL:
4860 if (load_global(self) < 0)
4861 break;
4862 continue;
4863
4864 case APPEND:
4865 if (load_append(self) < 0)
4866 break;
4867 continue;
4868
4869 case APPENDS:
4870 if (load_appends(self) < 0)
4871 break;
4872 continue;
4873
4874 case BUILD:
4875 if (load_build(self) < 0)
4876 break;
4877 continue;
4878
4879 case DUP:
4880 if (load_dup(self) < 0)
4881 break;
4882 continue;
4883
4884 case BINGET:
4885 if (load_binget(self) < 0)
4886 break;
4887 continue;
4888
4889 case LONG_BINGET:
4890 if (load_long_binget(self) < 0)
4891 break;
4892 continue;
4893
4894 case GET:
4895 if (load_get(self) < 0)
4896 break;
4897 continue;
4898
4899 case EXT1:
4900 if (load_extension(self, 1) < 0)
4901 break;
4902 continue;
4903
4904 case EXT2:
4905 if (load_extension(self, 2) < 0)
4906 break;
4907 continue;
4908
4909 case EXT4:
4910 if (load_extension(self, 4) < 0)
4911 break;
4912 continue;
4913 case MARK:
4914 if (load_mark(self) < 0)
4915 break;
4916 continue;
4917
4918 case BINPUT:
4919 if (load_binput(self) < 0)
4920 break;
4921 continue;
4922
4923 case LONG_BINPUT:
4924 if (load_long_binput(self) < 0)
4925 break;
4926 continue;
4927
4928 case PUT:
4929 if (load_put(self) < 0)
4930 break;
4931 continue;
4932
4933 case POP:
4934 if (load_pop(self) < 0)
4935 break;
4936 continue;
4937
4938 case POP_MARK:
4939 if (load_pop_mark(self) < 0)
4940 break;
4941 continue;
4942
4943 case SETITEM:
4944 if (load_setitem(self) < 0)
4945 break;
4946 continue;
4947
4948 case SETITEMS:
4949 if (load_setitems(self) < 0)
4950 break;
4951 continue;
4952
4953 case STOP:
4954 break;
4955
4956 case PERSID:
4957 if (load_persid(self) < 0)
4958 break;
4959 continue;
4960
4961 case BINPERSID:
4962 if (load_binpersid(self) < 0)
4963 break;
4964 continue;
4965
4966 case REDUCE:
4967 if (load_reduce(self) < 0)
4968 break;
4969 continue;
4970
4971 case PROTO:
4972 if (load_proto(self) < 0)
4973 break;
4974 continue;
4975
4976 case NEWTRUE:
4977 if (load_bool(self, Py_True) < 0)
4978 break;
4979 continue;
4980
4981 case NEWFALSE:
4982 if (load_bool(self, Py_False) < 0)
4983 break;
4984 continue;
4985
4986 case '\0':
4987 /* end of file */
4988 PyErr_SetNone(PyExc_EOFError);
4989 break;
4990
4991 default:
4992 cPickle_ErrFormat(UnpicklingError,
4993 "invalid load key, '%s'.",
4994 "c", s[0]);
4995 return NULL;
4996 }
4997
4998 break;
4999 }
5000
5001 if ((err = PyErr_Occurred())) {
5002 if (err == PyExc_EOFError) {
5003 PyErr_SetNone(PyExc_EOFError);
5004 }
5005 return NULL;
5006 }
5007
5008 PDATA_POP(self->stack, val);
5009 return val;
5010 }
5011
5012
5013 /* No-load functions to support noload, which is used to
5014 find persistent references. */
5015
5016 static int
noload_obj(Unpicklerobject * self)5017 noload_obj(Unpicklerobject *self)
5018 {
5019 Py_ssize_t i;
5020
5021 if ((i = marker(self)) < 0) return -1;
5022 return Pdata_clear(self->stack, i+1);
5023 }
5024
5025
5026 static int
noload_inst(Unpicklerobject * self)5027 noload_inst(Unpicklerobject *self)
5028 {
5029 Py_ssize_t i;
5030 char *s;
5031
5032 if ((i = marker(self)) < 0) return -1;
5033 Pdata_clear(self->stack, i);
5034 if (self->readline_func(self, &s) < 0) return -1;
5035 if (self->readline_func(self, &s) < 0) return -1;
5036 PDATA_APPEND(self->stack, Py_None, -1);
5037 return 0;
5038 }
5039
5040 static int
noload_newobj(Unpicklerobject * self)5041 noload_newobj(Unpicklerobject *self)
5042 {
5043 PyObject *obj;
5044
5045 PDATA_POP(self->stack, obj); /* pop argtuple */
5046 if (obj == NULL) return -1;
5047 Py_DECREF(obj);
5048
5049 PDATA_POP(self->stack, obj); /* pop cls */
5050 if (obj == NULL) return -1;
5051 Py_DECREF(obj);
5052
5053 PDATA_APPEND(self->stack, Py_None, -1);
5054 return 0;
5055 }
5056
5057 static int
noload_global(Unpicklerobject * self)5058 noload_global(Unpicklerobject *self)
5059 {
5060 char *s;
5061
5062 if (self->readline_func(self, &s) < 0) return -1;
5063 if (self->readline_func(self, &s) < 0) return -1;
5064 PDATA_APPEND(self->stack, Py_None,-1);
5065 return 0;
5066 }
5067
5068 static int
noload_reduce(Unpicklerobject * self)5069 noload_reduce(Unpicklerobject *self)
5070 {
5071
5072 if (self->stack->length < 2) return stackUnderflow();
5073 Pdata_clear(self->stack, self->stack->length-2);
5074 PDATA_APPEND(self->stack, Py_None,-1);
5075 return 0;
5076 }
5077
5078 static int
noload_build(Unpicklerobject * self)5079 noload_build(Unpicklerobject *self) {
5080
5081 if (self->stack->length < 1) return stackUnderflow();
5082 Pdata_clear(self->stack, self->stack->length-1);
5083 return 0;
5084 }
5085
5086 static int
noload_extension(Unpicklerobject * self,int nbytes)5087 noload_extension(Unpicklerobject *self, int nbytes)
5088 {
5089 char *codebytes;
5090
5091 assert(nbytes == 1 || nbytes == 2 || nbytes == 4);
5092 if (self->read_func(self, &codebytes, nbytes) < 0) return -1;
5093 PDATA_APPEND(self->stack, Py_None, -1);
5094 return 0;
5095 }
5096
5097 static int
noload_append(Unpicklerobject * self)5098 noload_append(Unpicklerobject *self)
5099 {
5100 return Pdata_clear(self->stack, self->stack->length - 1);
5101 }
5102
5103 static int
noload_appends(Unpicklerobject * self)5104 noload_appends(Unpicklerobject *self)
5105 {
5106 Py_ssize_t i;
5107 if ((i = marker(self)) < 0) return -1;
5108 return Pdata_clear(self->stack, i);
5109 }
5110
5111 static int
noload_setitem(Unpicklerobject * self)5112 noload_setitem(Unpicklerobject *self)
5113 {
5114 return Pdata_clear(self->stack, self->stack->length - 2);
5115 }
5116
5117 static int
noload_setitems(Unpicklerobject * self)5118 noload_setitems(Unpicklerobject *self)
5119 {
5120 Py_ssize_t i;
5121 if ((i = marker(self)) < 0) return -1;
5122 return Pdata_clear(self->stack, i);
5123 }
5124
5125 static PyObject *
noload(Unpicklerobject * self)5126 noload(Unpicklerobject *self)
5127 {
5128 PyObject *err = 0, *val = 0;
5129 char *s;
5130
5131 self->num_marks = 0;
5132 Pdata_clear(self->stack, 0);
5133
5134 while (1) {
5135 if (self->read_func(self, &s, 1) < 0)
5136 break;
5137
5138 switch (s[0]) {
5139 case NONE:
5140 if (load_none(self) < 0)
5141 break;
5142 continue;
5143
5144 case BININT:
5145 if (load_binint(self) < 0)
5146 break;
5147 continue;
5148
5149 case BININT1:
5150 if (load_binint1(self) < 0)
5151 break;
5152 continue;
5153
5154 case BININT2:
5155 if (load_binint2(self) < 0)
5156 break;
5157 continue;
5158
5159 case INT:
5160 if (load_int(self) < 0)
5161 break;
5162 continue;
5163
5164 case LONG:
5165 if (load_long(self) < 0)
5166 break;
5167 continue;
5168
5169 case LONG1:
5170 if (load_counted_long(self, 1) < 0)
5171 break;
5172 continue;
5173
5174 case LONG4:
5175 if (load_counted_long(self, 4) < 0)
5176 break;
5177 continue;
5178
5179 case FLOAT:
5180 if (load_float(self) < 0)
5181 break;
5182 continue;
5183
5184 case BINFLOAT:
5185 if (load_binfloat(self) < 0)
5186 break;
5187 continue;
5188
5189 case BINSTRING:
5190 if (load_binstring(self) < 0)
5191 break;
5192 continue;
5193
5194 case SHORT_BINSTRING:
5195 if (load_short_binstring(self) < 0)
5196 break;
5197 continue;
5198
5199 case STRING:
5200 if (load_string(self) < 0)
5201 break;
5202 continue;
5203
5204 #ifdef Py_USING_UNICODE
5205 case UNICODE:
5206 if (load_unicode(self) < 0)
5207 break;
5208 continue;
5209
5210 case BINUNICODE:
5211 if (load_binunicode(self) < 0)
5212 break;
5213 continue;
5214 #endif
5215
5216 case EMPTY_TUPLE:
5217 if (load_counted_tuple(self, 0) < 0)
5218 break;
5219 continue;
5220
5221 case TUPLE1:
5222 if (load_counted_tuple(self, 1) < 0)
5223 break;
5224 continue;
5225
5226 case TUPLE2:
5227 if (load_counted_tuple(self, 2) < 0)
5228 break;
5229 continue;
5230
5231 case TUPLE3:
5232 if (load_counted_tuple(self, 3) < 0)
5233 break;
5234 continue;
5235
5236 case TUPLE:
5237 if (load_tuple(self) < 0)
5238 break;
5239 continue;
5240
5241 case EMPTY_LIST:
5242 if (load_empty_list(self) < 0)
5243 break;
5244 continue;
5245
5246 case LIST:
5247 if (load_list(self) < 0)
5248 break;
5249 continue;
5250
5251 case EMPTY_DICT:
5252 if (load_empty_dict(self) < 0)
5253 break;
5254 continue;
5255
5256 case DICT:
5257 if (load_dict(self) < 0)
5258 break;
5259 continue;
5260
5261 case OBJ:
5262 if (noload_obj(self) < 0)
5263 break;
5264 continue;
5265
5266 case INST:
5267 if (noload_inst(self) < 0)
5268 break;
5269 continue;
5270
5271 case NEWOBJ:
5272 if (noload_newobj(self) < 0)
5273 break;
5274 continue;
5275
5276 case GLOBAL:
5277 if (noload_global(self) < 0)
5278 break;
5279 continue;
5280
5281 case APPEND:
5282 if (noload_append(self) < 0)
5283 break;
5284 continue;
5285
5286 case APPENDS:
5287 if (noload_appends(self) < 0)
5288 break;
5289 continue;
5290
5291 case BUILD:
5292 if (noload_build(self) < 0)
5293 break;
5294 continue;
5295
5296 case DUP:
5297 if (load_dup(self) < 0)
5298 break;
5299 continue;
5300
5301 case BINGET:
5302 if (load_binget(self) < 0)
5303 break;
5304 continue;
5305
5306 case LONG_BINGET:
5307 if (load_long_binget(self) < 0)
5308 break;
5309 continue;
5310
5311 case GET:
5312 if (load_get(self) < 0)
5313 break;
5314 continue;
5315
5316 case EXT1:
5317 if (noload_extension(self, 1) < 0)
5318 break;
5319 continue;
5320
5321 case EXT2:
5322 if (noload_extension(self, 2) < 0)
5323 break;
5324 continue;
5325
5326 case EXT4:
5327 if (noload_extension(self, 4) < 0)
5328 break;
5329 continue;
5330
5331 case MARK:
5332 if (load_mark(self) < 0)
5333 break;
5334 continue;
5335
5336 case BINPUT:
5337 if (load_binput(self) < 0)
5338 break;
5339 continue;
5340
5341 case LONG_BINPUT:
5342 if (load_long_binput(self) < 0)
5343 break;
5344 continue;
5345
5346 case PUT:
5347 if (load_put(self) < 0)
5348 break;
5349 continue;
5350
5351 case POP:
5352 if (load_pop(self) < 0)
5353 break;
5354 continue;
5355
5356 case POP_MARK:
5357 if (load_pop_mark(self) < 0)
5358 break;
5359 continue;
5360
5361 case SETITEM:
5362 if (noload_setitem(self) < 0)
5363 break;
5364 continue;
5365
5366 case SETITEMS:
5367 if (noload_setitems(self) < 0)
5368 break;
5369 continue;
5370
5371 case STOP:
5372 break;
5373
5374 case PERSID:
5375 if (load_persid(self) < 0)
5376 break;
5377 continue;
5378
5379 case BINPERSID:
5380 if (load_binpersid(self) < 0)
5381 break;
5382 continue;
5383
5384 case REDUCE:
5385 if (noload_reduce(self) < 0)
5386 break;
5387 continue;
5388
5389 case PROTO:
5390 if (load_proto(self) < 0)
5391 break;
5392 continue;
5393
5394 case NEWTRUE:
5395 if (load_bool(self, Py_True) < 0)
5396 break;
5397 continue;
5398
5399 case NEWFALSE:
5400 if (load_bool(self, Py_False) < 0)
5401 break;
5402 continue;
5403 default:
5404 cPickle_ErrFormat(UnpicklingError,
5405 "invalid load key, '%s'.",
5406 "c", s[0]);
5407 return NULL;
5408 }
5409
5410 break;
5411 }
5412
5413 if ((err = PyErr_Occurred())) {
5414 if (err == PyExc_EOFError) {
5415 PyErr_SetNone(PyExc_EOFError);
5416 }
5417 return NULL;
5418 }
5419
5420 PDATA_POP(self->stack, val);
5421 return val;
5422 }
5423
5424
5425 static PyObject *
Unpickler_load(Unpicklerobject * self,PyObject * unused)5426 Unpickler_load(Unpicklerobject *self, PyObject *unused)
5427 {
5428 return load(self);
5429 }
5430
5431 static PyObject *
Unpickler_noload(Unpicklerobject * self,PyObject * unused)5432 Unpickler_noload(Unpicklerobject *self, PyObject *unused)
5433 {
5434 return noload(self);
5435 }
5436
5437
5438 static struct PyMethodDef Unpickler_methods[] = {
5439 {"load", (PyCFunction)Unpickler_load, METH_NOARGS,
5440 PyDoc_STR("load() -- Load a pickle")
5441 },
5442 {"noload", (PyCFunction)Unpickler_noload, METH_NOARGS,
5443 PyDoc_STR(
5444 "noload() -- not load a pickle, but go through most of the motions\n"
5445 "\n"
5446 "This function can be used to read past a pickle without instantiating\n"
5447 "any objects or importing any modules. It can also be used to find all\n"
5448 "persistent references without instantiating any objects or importing\n"
5449 "any modules.\n")
5450 },
5451 {NULL, NULL} /* sentinel */
5452 };
5453
5454
5455 static Unpicklerobject *
newUnpicklerobject(PyObject * f)5456 newUnpicklerobject(PyObject *f)
5457 {
5458 Unpicklerobject *self;
5459
5460 if (!( self = PyObject_GC_New(Unpicklerobject, &Unpicklertype)))
5461 return NULL;
5462
5463 self->file = NULL;
5464 self->arg = NULL;
5465 self->stack = (Pdata*)Pdata_New();
5466 self->pers_func = NULL;
5467 self->last_string = NULL;
5468 self->marks = NULL;
5469 self->num_marks = 0;
5470 self->marks_size = 0;
5471 self->buf_size = 0;
5472 self->read = NULL;
5473 self->readline = NULL;
5474 self->find_class = NULL;
5475
5476 if (!( self->memo = PyDict_New()))
5477 goto err;
5478
5479 if (!self->stack)
5480 goto err;
5481
5482 Py_INCREF(f);
5483 self->file = f;
5484
5485 /* Set read, readline based on type of f */
5486 if (PyFile_Check(f)) {
5487 self->fp = PyFile_AsFile(f);
5488 if (self->fp == NULL) {
5489 PyErr_SetString(PyExc_ValueError,
5490 "I/O operation on closed file");
5491 goto err;
5492 }
5493 self->read_func = read_file;
5494 self->readline_func = readline_file;
5495 }
5496 else if (PycStringIO_InputCheck(f)) {
5497 self->fp = NULL;
5498 self->read_func = read_cStringIO;
5499 self->readline_func = readline_cStringIO;
5500 }
5501 else {
5502
5503 self->fp = NULL;
5504 self->read_func = read_other;
5505 self->readline_func = readline_other;
5506
5507 if (!( (self->readline = PyObject_GetAttr(f, readline_str)) &&
5508 (self->read = PyObject_GetAttr(f, read_str)))) {
5509 PyErr_Clear();
5510 PyErr_SetString( PyExc_TypeError,
5511 "argument must have 'read' and "
5512 "'readline' attributes" );
5513 goto err;
5514 }
5515 }
5516 PyObject_GC_Track(self);
5517
5518 return self;
5519
5520 err:
5521 Py_DECREF((PyObject *)self);
5522 return NULL;
5523 }
5524
5525
5526 static PyObject *
get_Unpickler(PyObject * self,PyObject * file)5527 get_Unpickler(PyObject *self, PyObject *file)
5528 {
5529 return (PyObject *)newUnpicklerobject(file);
5530 }
5531
5532
5533 static void
Unpickler_dealloc(Unpicklerobject * self)5534 Unpickler_dealloc(Unpicklerobject *self)
5535 {
5536 PyObject_GC_UnTrack((PyObject *)self);
5537 Py_XDECREF(self->readline);
5538 Py_XDECREF(self->read);
5539 Py_XDECREF(self->file);
5540 Py_XDECREF(self->memo);
5541 Py_XDECREF(self->stack);
5542 Py_XDECREF(self->pers_func);
5543 Py_XDECREF(self->arg);
5544 Py_XDECREF(self->last_string);
5545 Py_XDECREF(self->find_class);
5546
5547 if (self->marks) {
5548 free(self->marks);
5549 }
5550
5551 if (self->buf_size) {
5552 free(self->buf);
5553 }
5554
5555 Py_TYPE(self)->tp_free((PyObject *)self);
5556 }
5557
5558 static int
Unpickler_traverse(Unpicklerobject * self,visitproc visit,void * arg)5559 Unpickler_traverse(Unpicklerobject *self, visitproc visit, void *arg)
5560 {
5561 Py_VISIT(self->readline);
5562 Py_VISIT(self->read);
5563 Py_VISIT(self->file);
5564 Py_VISIT(self->memo);
5565 Py_VISIT(self->stack);
5566 Py_VISIT(self->pers_func);
5567 Py_VISIT(self->arg);
5568 Py_VISIT(self->last_string);
5569 Py_VISIT(self->find_class);
5570 return 0;
5571 }
5572
5573 static int
Unpickler_clear(Unpicklerobject * self)5574 Unpickler_clear(Unpicklerobject *self)
5575 {
5576 Py_CLEAR(self->readline);
5577 Py_CLEAR(self->read);
5578 Py_CLEAR(self->file);
5579 Py_CLEAR(self->memo);
5580 Py_CLEAR(self->stack);
5581 Py_CLEAR(self->pers_func);
5582 Py_CLEAR(self->arg);
5583 Py_CLEAR(self->last_string);
5584 Py_CLEAR(self->find_class);
5585 return 0;
5586 }
5587
5588 static PyObject *
Unpickler_getattr(Unpicklerobject * self,char * name)5589 Unpickler_getattr(Unpicklerobject *self, char *name)
5590 {
5591 if (!strcmp(name, "persistent_load")) {
5592 if (!self->pers_func) {
5593 PyErr_SetString(PyExc_AttributeError, name);
5594 return NULL;
5595 }
5596
5597 Py_INCREF(self->pers_func);
5598 return self->pers_func;
5599 }
5600
5601 if (!strcmp(name, "find_global")) {
5602 if (!self->find_class) {
5603 PyErr_SetString(PyExc_AttributeError, name);
5604 return NULL;
5605 }
5606
5607 Py_INCREF(self->find_class);
5608 return self->find_class;
5609 }
5610
5611 if (!strcmp(name, "memo")) {
5612 if (!self->memo) {
5613 PyErr_SetString(PyExc_AttributeError, name);
5614 return NULL;
5615 }
5616
5617 Py_INCREF(self->memo);
5618 return self->memo;
5619 }
5620
5621 if (!strcmp(name, "UnpicklingError")) {
5622 Py_INCREF(UnpicklingError);
5623 return UnpicklingError;
5624 }
5625
5626 return Py_FindMethod(Unpickler_methods, (PyObject *)self, name);
5627 }
5628
5629
5630 static int
Unpickler_setattr(Unpicklerobject * self,char * name,PyObject * value)5631 Unpickler_setattr(Unpicklerobject *self, char *name, PyObject *value)
5632 {
5633
5634 if (!strcmp(name, "persistent_load")) {
5635 Py_XDECREF(self->pers_func);
5636 self->pers_func = value;
5637 Py_XINCREF(value);
5638 return 0;
5639 }
5640
5641 if (!strcmp(name, "find_global")) {
5642 Py_XDECREF(self->find_class);
5643 self->find_class = value;
5644 Py_XINCREF(value);
5645 return 0;
5646 }
5647
5648 if (! value) {
5649 PyErr_SetString(PyExc_TypeError,
5650 "attribute deletion is not supported");
5651 return -1;
5652 }
5653
5654 if (strcmp(name, "memo") == 0) {
5655 if (!PyDict_Check(value)) {
5656 PyErr_SetString(PyExc_TypeError,
5657 "memo must be a dictionary");
5658 return -1;
5659 }
5660 Py_XDECREF(self->memo);
5661 self->memo = value;
5662 Py_INCREF(value);
5663 return 0;
5664 }
5665
5666 PyErr_SetString(PyExc_AttributeError, name);
5667 return -1;
5668 }
5669
5670 /* ---------------------------------------------------------------------------
5671 * Module-level functions.
5672 */
5673
5674 /* dump(obj, file, protocol=0). */
5675 static PyObject *
cpm_dump(PyObject * self,PyObject * args,PyObject * kwds)5676 cpm_dump(PyObject *self, PyObject *args, PyObject *kwds)
5677 {
5678 static char *kwlist[] = {"obj", "file", "protocol", NULL};
5679 PyObject *ob, *file, *res = NULL;
5680 Picklerobject *pickler = 0;
5681 int proto = 0;
5682
5683 if (!( PyArg_ParseTupleAndKeywords(args, kwds, "OO|i", kwlist,
5684 &ob, &file, &proto)))
5685 goto finally;
5686
5687 if (!( pickler = newPicklerobject(file, proto)))
5688 goto finally;
5689
5690 if (dump(pickler, ob) < 0)
5691 goto finally;
5692
5693 Py_INCREF(Py_None);
5694 res = Py_None;
5695
5696 finally:
5697 Py_XDECREF(pickler);
5698
5699 return res;
5700 }
5701
5702
5703 /* dumps(obj, protocol=0). */
5704 static PyObject *
cpm_dumps(PyObject * self,PyObject * args,PyObject * kwds)5705 cpm_dumps(PyObject *self, PyObject *args, PyObject *kwds)
5706 {
5707 static char *kwlist[] = {"obj", "protocol", NULL};
5708 PyObject *ob, *file = 0, *res = NULL;
5709 Picklerobject *pickler = 0;
5710 int proto = 0;
5711
5712 if (!( PyArg_ParseTupleAndKeywords(args, kwds, "O|i:dumps", kwlist,
5713 &ob, &proto)))
5714 goto finally;
5715
5716 if (!( file = PycStringIO->NewOutput(128)))
5717 goto finally;
5718
5719 if (!( pickler = newPicklerobject(file, proto)))
5720 goto finally;
5721
5722 if (dump(pickler, ob) < 0)
5723 goto finally;
5724
5725 res = PycStringIO->cgetvalue(file);
5726
5727 finally:
5728 Py_XDECREF(pickler);
5729 Py_XDECREF(file);
5730
5731 return res;
5732 }
5733
5734
5735 /* load(fileobj). */
5736 static PyObject *
cpm_load(PyObject * self,PyObject * ob)5737 cpm_load(PyObject *self, PyObject *ob)
5738 {
5739 Unpicklerobject *unpickler = 0;
5740 PyObject *res = NULL;
5741
5742 if (!( unpickler = newUnpicklerobject(ob)))
5743 goto finally;
5744
5745 res = load(unpickler);
5746
5747 finally:
5748 Py_XDECREF(unpickler);
5749
5750 return res;
5751 }
5752
5753
5754 /* loads(string) */
5755 static PyObject *
cpm_loads(PyObject * self,PyObject * args)5756 cpm_loads(PyObject *self, PyObject *args)
5757 {
5758 PyObject *ob, *file = 0, *res = NULL;
5759 Unpicklerobject *unpickler = 0;
5760
5761 if (!( PyArg_ParseTuple(args, "S:loads", &ob)))
5762 goto finally;
5763
5764 if (!( file = PycStringIO->NewInput(ob)))
5765 goto finally;
5766
5767 if (!( unpickler = newUnpicklerobject(file)))
5768 goto finally;
5769
5770 res = load(unpickler);
5771
5772 finally:
5773 Py_XDECREF(file);
5774 Py_XDECREF(unpickler);
5775
5776 return res;
5777 }
5778
5779
5780 PyDoc_STRVAR(Unpicklertype__doc__,
5781 "Objects that know how to unpickle");
5782
5783 static PyTypeObject Unpicklertype = {
5784 PyVarObject_HEAD_INIT(NULL, 0)
5785 "cPickle.Unpickler", /*tp_name*/
5786 sizeof(Unpicklerobject), /*tp_basicsize*/
5787 0,
5788 (destructor)Unpickler_dealloc, /* tp_dealloc */
5789 0, /* tp_print */
5790 (getattrfunc)Unpickler_getattr, /* tp_getattr */
5791 (setattrfunc)Unpickler_setattr, /* tp_setattr */
5792 0, /* tp_compare */
5793 0, /* tp_repr */
5794 0, /* tp_as_number */
5795 0, /* tp_as_sequence */
5796 0, /* tp_as_mapping */
5797 0, /* tp_hash */
5798 0, /* tp_call */
5799 0, /* tp_str */
5800 0, /* tp_getattro */
5801 0, /* tp_setattro */
5802 0, /* tp_as_buffer */
5803 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
5804 Unpicklertype__doc__, /* tp_doc */
5805 (traverseproc)Unpickler_traverse, /* tp_traverse */
5806 (inquiry)Unpickler_clear, /* tp_clear */
5807 };
5808
5809 static struct PyMethodDef cPickle_methods[] = {
5810 {"dump", (PyCFunction)cpm_dump, METH_VARARGS | METH_KEYWORDS,
5811 PyDoc_STR("dump(obj, file, protocol=0) -- "
5812 "Write an object in pickle format to the given file.\n"
5813 "\n"
5814 "See the Pickler docstring for the meaning of optional argument proto.")
5815 },
5816
5817 {"dumps", (PyCFunction)cpm_dumps, METH_VARARGS | METH_KEYWORDS,
5818 PyDoc_STR("dumps(obj, protocol=0) -- "
5819 "Return a string containing an object in pickle format.\n"
5820 "\n"
5821 "See the Pickler docstring for the meaning of optional argument proto.")
5822 },
5823
5824 {"load", (PyCFunction)cpm_load, METH_O,
5825 PyDoc_STR("load(file) -- Load a pickle from the given file")},
5826
5827 {"loads", (PyCFunction)cpm_loads, METH_VARARGS,
5828 PyDoc_STR("loads(string) -- Load a pickle from the given string")},
5829
5830 {"Pickler", (PyCFunction)get_Pickler, METH_VARARGS | METH_KEYWORDS,
5831 PyDoc_STR("Pickler(file, protocol=0) -- Create a pickler.\n"
5832 "\n"
5833 "This takes a file-like object for writing a pickle data stream.\n"
5834 "The optional proto argument tells the pickler to use the given\n"
5835 "protocol; supported protocols are 0, 1, 2. The default\n"
5836 "protocol is 0, to be backwards compatible. (Protocol 0 is the\n"
5837 "only protocol that can be written to a file opened in text\n"
5838 "mode and read back successfully. When using a protocol higher\n"
5839 "than 0, make sure the file is opened in binary mode, both when\n"
5840 "pickling and unpickling.)\n"
5841 "\n"
5842 "Protocol 1 is more efficient than protocol 0; protocol 2 is\n"
5843 "more efficient than protocol 1.\n"
5844 "\n"
5845 "Specifying a negative protocol version selects the highest\n"
5846 "protocol version supported. The higher the protocol used, the\n"
5847 "more recent the version of Python needed to read the pickle\n"
5848 "produced.\n"
5849 "\n"
5850 "The file parameter must have a write() method that accepts a single\n"
5851 "string argument. It can thus be an open file object, a StringIO\n"
5852 "object, or any other custom object that meets this interface.\n")
5853 },
5854
5855 {"Unpickler", (PyCFunction)get_Unpickler, METH_O,
5856 PyDoc_STR("Unpickler(file) -- Create an unpickler.")},
5857
5858 { NULL, NULL }
5859 };
5860
5861 static int
init_stuff(PyObject * module_dict)5862 init_stuff(PyObject *module_dict)
5863 {
5864 PyObject *copyreg, *t, *r;
5865
5866 #define INIT_STR(S) if (!( S ## _str=PyString_InternFromString(#S))) return -1;
5867
5868 if (PyType_Ready(&Unpicklertype) < 0)
5869 return -1;
5870 if (PyType_Ready(&Picklertype) < 0)
5871 return -1;
5872
5873 INIT_STR(__class__);
5874 INIT_STR(__getinitargs__);
5875 INIT_STR(__dict__);
5876 INIT_STR(__getstate__);
5877 INIT_STR(__setstate__);
5878 INIT_STR(__name__);
5879 INIT_STR(__main__);
5880 INIT_STR(__reduce__);
5881 INIT_STR(__reduce_ex__);
5882 INIT_STR(write);
5883 INIT_STR(append);
5884 INIT_STR(read);
5885 INIT_STR(readline);
5886 INIT_STR(dispatch_table);
5887
5888 if (!( copyreg = PyImport_ImportModule("copy_reg")))
5889 return -1;
5890
5891 /* This is special because we want to use a different
5892 one in restricted mode. */
5893 dispatch_table = PyObject_GetAttr(copyreg, dispatch_table_str);
5894 if (!dispatch_table) return -1;
5895
5896 extension_registry = PyObject_GetAttrString(copyreg,
5897 "_extension_registry");
5898 if (!extension_registry) return -1;
5899
5900 inverted_registry = PyObject_GetAttrString(copyreg,
5901 "_inverted_registry");
5902 if (!inverted_registry) return -1;
5903
5904 extension_cache = PyObject_GetAttrString(copyreg,
5905 "_extension_cache");
5906 if (!extension_cache) return -1;
5907
5908 Py_DECREF(copyreg);
5909
5910 if (!(empty_tuple = PyTuple_New(0)))
5911 return -1;
5912
5913 two_tuple = PyTuple_New(2);
5914 if (two_tuple == NULL)
5915 return -1;
5916 /* We use this temp container with no regard to refcounts, or to
5917 * keeping containees alive. Exempt from GC, because we don't
5918 * want anything looking at two_tuple() by magic.
5919 */
5920 PyObject_GC_UnTrack(two_tuple);
5921
5922 /* Ugh */
5923 if (!( t=PyImport_ImportModule("__builtin__"))) return -1;
5924 if (PyDict_SetItemString(module_dict, "__builtins__", t) < 0)
5925 return -1;
5926
5927 if (!( t=PyDict_New())) return -1;
5928 if (!( r=PyRun_String(
5929 "def __str__(self):\n"
5930 " return self.args and ('%s' % self.args[0]) or '(what)'\n",
5931 Py_file_input,
5932 module_dict, t) )) return -1;
5933 Py_DECREF(r);
5934
5935 PickleError = PyErr_NewException("cPickle.PickleError", NULL, t);
5936 if (!PickleError)
5937 return -1;
5938
5939 Py_DECREF(t);
5940
5941 PicklingError = PyErr_NewException("cPickle.PicklingError",
5942 PickleError, NULL);
5943 if (!PicklingError)
5944 return -1;
5945
5946 if (!( t=PyDict_New())) return -1;
5947 if (!( r=PyRun_String(
5948 "def __str__(self):\n"
5949 " a=self.args\n"
5950 " a=a and type(a[0]) or '(what)'\n"
5951 " return 'Cannot pickle %s objects' % a\n"
5952 , Py_file_input,
5953 module_dict, t) )) return -1;
5954 Py_DECREF(r);
5955
5956 if (!( UnpickleableError = PyErr_NewException(
5957 "cPickle.UnpickleableError", PicklingError, t)))
5958 return -1;
5959
5960 Py_DECREF(t);
5961
5962 if (!( UnpicklingError = PyErr_NewException("cPickle.UnpicklingError",
5963 PickleError, NULL)))
5964 return -1;
5965
5966 if (!( BadPickleGet = PyErr_NewException("cPickle.BadPickleGet",
5967 UnpicklingError, NULL)))
5968 return -1;
5969
5970 if (PyDict_SetItemString(module_dict, "PickleError",
5971 PickleError) < 0)
5972 return -1;
5973
5974 if (PyDict_SetItemString(module_dict, "PicklingError",
5975 PicklingError) < 0)
5976 return -1;
5977
5978 if (PyDict_SetItemString(module_dict, "UnpicklingError",
5979 UnpicklingError) < 0)
5980 return -1;
5981
5982 if (PyDict_SetItemString(module_dict, "UnpickleableError",
5983 UnpickleableError) < 0)
5984 return -1;
5985
5986 if (PyDict_SetItemString(module_dict, "BadPickleGet",
5987 BadPickleGet) < 0)
5988 return -1;
5989
5990 PycString_IMPORT;
5991
5992 return 0;
5993 }
5994
5995 #ifndef PyMODINIT_FUNC /* declarations for DLL import/export */
5996 #define PyMODINIT_FUNC void
5997 #endif
5998 PyMODINIT_FUNC
initcPickle(void)5999 initcPickle(void)
6000 {
6001 PyObject *m, *d, *di, *v, *k;
6002 Py_ssize_t i;
6003 char *rev = "1.71"; /* XXX when does this change? */
6004 PyObject *format_version;
6005 PyObject *compatible_formats;
6006
6007 Py_TYPE(&Picklertype) = &PyType_Type;
6008 Py_TYPE(&Unpicklertype) = &PyType_Type;
6009 Py_TYPE(&PdataType) = &PyType_Type;
6010
6011 /* Initialize some pieces. We need to do this before module creation,
6012 * so we're forced to use a temporary dictionary. :(
6013 */
6014 di = PyDict_New();
6015 if (!di) return;
6016 if (init_stuff(di) < 0) return;
6017
6018 /* Create the module and add the functions */
6019 m = Py_InitModule4("cPickle", cPickle_methods,
6020 cPickle_module_documentation,
6021 (PyObject*)NULL,PYTHON_API_VERSION);
6022 if (m == NULL)
6023 return;
6024
6025 /* Add some symbolic constants to the module */
6026 d = PyModule_GetDict(m);
6027 v = PyString_FromString(rev);
6028 PyDict_SetItemString(d, "__version__", v);
6029 Py_XDECREF(v);
6030
6031 /* Copy data from di. Waaa. */
6032 for (i=0; PyDict_Next(di, &i, &k, &v); ) {
6033 if (PyObject_SetItem(d, k, v) < 0) {
6034 Py_DECREF(di);
6035 return;
6036 }
6037 }
6038 Py_DECREF(di);
6039
6040 i = PyModule_AddIntConstant(m, "HIGHEST_PROTOCOL", HIGHEST_PROTOCOL);
6041 if (i < 0)
6042 return;
6043
6044 /* These are purely informational; no code uses them. */
6045 /* File format version we write. */
6046 format_version = PyString_FromString("2.0");
6047 /* Format versions we can read. */
6048 compatible_formats = Py_BuildValue("[sssss]",
6049 "1.0", /* Original protocol 0 */
6050 "1.1", /* Protocol 0 + INST */
6051 "1.2", /* Original protocol 1 */
6052 "1.3", /* Protocol 1 + BINFLOAT */
6053 "2.0"); /* Original protocol 2 */
6054 PyDict_SetItemString(d, "format_version", format_version);
6055 PyDict_SetItemString(d, "compatible_formats", compatible_formats);
6056 Py_XDECREF(format_version);
6057 Py_XDECREF(compatible_formats);
6058 }
6059