Branch data Line data Source code
1 : :
2 : : /* Write Python objects to files and read them back.
3 : : This is primarily intended for writing and reading compiled Python code,
4 : : even though dicts, lists, sets and frozensets, not commonly seen in
5 : : code objects, are supported.
6 : : Version 3 of this protocol properly supports circular links
7 : : and sharing. */
8 : :
9 : : #define PY_SSIZE_T_CLEAN
10 : :
11 : : #include "Python.h"
12 : : #include "pycore_call.h" // _PyObject_CallNoArgs()
13 : : #include "pycore_code.h" // _PyCode_New()
14 : : #include "pycore_hashtable.h" // _Py_hashtable_t
15 : : #include "marshal.h" // Py_MARSHAL_VERSION
16 : :
17 : : /*[clinic input]
18 : : module marshal
19 : : [clinic start generated code]*/
20 : : /*[clinic end generated code: output=da39a3ee5e6b4b0d input=c982b7930dee17db]*/
21 : :
22 : : #include "clinic/marshal.c.h"
23 : :
24 : : /* High water mark to determine when the marshalled object is dangerously deep
25 : : * and risks coring the interpreter. When the object stack gets this deep,
26 : : * raise an exception instead of continuing.
27 : : * On Windows debug builds, reduce this value.
28 : : *
29 : : * BUG: https://bugs.python.org/issue33720
30 : : * On Windows PGO builds, the r_object function overallocates its stack and
31 : : * can cause a stack overflow. We reduce the maximum depth for all Windows
32 : : * releases to protect against this.
33 : : * #if defined(MS_WINDOWS) && defined(_DEBUG)
34 : : */
35 : : #if defined(MS_WINDOWS)
36 : : #define MAX_MARSHAL_STACK_DEPTH 1000
37 : : #else
38 : : #define MAX_MARSHAL_STACK_DEPTH 2000
39 : : #endif
40 : :
41 : : #define TYPE_NULL '0'
42 : : #define TYPE_NONE 'N'
43 : : #define TYPE_FALSE 'F'
44 : : #define TYPE_TRUE 'T'
45 : : #define TYPE_STOPITER 'S'
46 : : #define TYPE_ELLIPSIS '.'
47 : : #define TYPE_INT 'i'
48 : : /* TYPE_INT64 is not generated anymore.
49 : : Supported for backward compatibility only. */
50 : : #define TYPE_INT64 'I'
51 : : #define TYPE_FLOAT 'f'
52 : : #define TYPE_BINARY_FLOAT 'g'
53 : : #define TYPE_COMPLEX 'x'
54 : : #define TYPE_BINARY_COMPLEX 'y'
55 : : #define TYPE_LONG 'l'
56 : : #define TYPE_STRING 's'
57 : : #define TYPE_INTERNED 't'
58 : : #define TYPE_REF 'r'
59 : : #define TYPE_TUPLE '('
60 : : #define TYPE_LIST '['
61 : : #define TYPE_DICT '{'
62 : : #define TYPE_CODE 'c'
63 : : #define TYPE_UNICODE 'u'
64 : : #define TYPE_UNKNOWN '?'
65 : : #define TYPE_SET '<'
66 : : #define TYPE_FROZENSET '>'
67 : : #define FLAG_REF '\x80' /* with a type, add obj to index */
68 : :
69 : : #define TYPE_ASCII 'a'
70 : : #define TYPE_ASCII_INTERNED 'A'
71 : : #define TYPE_SMALL_TUPLE ')'
72 : : #define TYPE_SHORT_ASCII 'z'
73 : : #define TYPE_SHORT_ASCII_INTERNED 'Z'
74 : :
75 : : #define WFERR_OK 0
76 : : #define WFERR_UNMARSHALLABLE 1
77 : : #define WFERR_NESTEDTOODEEP 2
78 : : #define WFERR_NOMEMORY 3
79 : :
80 : : typedef struct {
81 : : FILE *fp;
82 : : int error; /* see WFERR_* values */
83 : : int depth;
84 : : PyObject *str;
85 : : char *ptr;
86 : : const char *end;
87 : : char *buf;
88 : : _Py_hashtable_t *hashtable;
89 : : int version;
90 : : } WFILE;
91 : :
92 : : #define w_byte(c, p) do { \
93 : : if ((p)->ptr != (p)->end || w_reserve((p), 1)) \
94 : : *(p)->ptr++ = (c); \
95 : : } while(0)
96 : :
97 : : static void
98 : 15 : w_flush(WFILE *p)
99 : : {
100 : : assert(p->fp != NULL);
101 : 15 : fwrite(p->buf, 1, p->ptr - p->buf, p->fp);
102 : 15 : p->ptr = p->buf;
103 : 15 : }
104 : :
105 : : static int
106 : 25848 : w_reserve(WFILE *p, Py_ssize_t needed)
107 : : {
108 : : Py_ssize_t pos, size, delta;
109 [ - + ]: 25848 : if (p->ptr == NULL)
110 : 0 : return 0; /* An error already occurred */
111 [ - + ]: 25848 : if (p->fp != NULL) {
112 : 0 : w_flush(p);
113 : 0 : return needed <= p->end - p->ptr;
114 : : }
115 : : assert(p->str != NULL);
116 : 25848 : pos = p->ptr - p->buf;
117 : 25848 : size = PyBytes_GET_SIZE(p->str);
118 [ - + ]: 25848 : if (size > 16*1024*1024)
119 : 0 : delta = (size >> 3); /* 12.5% overallocation */
120 : : else
121 : 25848 : delta = size + 1024;
122 : 25848 : delta = Py_MAX(delta, needed);
123 [ - + ]: 25848 : if (delta > PY_SSIZE_T_MAX - size) {
124 : 0 : p->error = WFERR_NOMEMORY;
125 : 0 : return 0;
126 : : }
127 : 25848 : size += delta;
128 [ - + ]: 25848 : if (_PyBytes_Resize(&p->str, size) != 0) {
129 : 0 : p->end = p->ptr = p->buf = NULL;
130 : 0 : return 0;
131 : : }
132 : : else {
133 : 25848 : p->buf = PyBytes_AS_STRING(p->str);
134 : 25848 : p->ptr = p->buf + pos;
135 : 25848 : p->end = p->buf + size;
136 : 25848 : return 1;
137 : : }
138 : : }
139 : :
140 : : static void
141 : 2117647 : w_string(const void *s, Py_ssize_t n, WFILE *p)
142 : : {
143 : : Py_ssize_t m;
144 [ + + - + ]: 2117647 : if (!n || p->ptr == NULL)
145 : 11184 : return;
146 : 2106463 : m = p->end - p->ptr;
147 [ + + ]: 2106463 : if (p->fp != NULL) {
148 [ + + ]: 30 : if (n <= m) {
149 : 25 : memcpy(p->ptr, s, n);
150 : 25 : p->ptr += n;
151 : : }
152 : : else {
153 : 5 : w_flush(p);
154 : 5 : fwrite(s, 1, n, p->fp);
155 : : }
156 : : }
157 : : else {
158 [ + + + - ]: 2106433 : if (n <= m || w_reserve(p, n - m)) {
159 : 2106433 : memcpy(p->ptr, s, n);
160 : 2106433 : p->ptr += n;
161 : : }
162 : : }
163 : : }
164 : :
165 : : static void
166 : 24377 : w_short(int x, WFILE *p)
167 : : {
168 [ + + + - ]: 24377 : w_byte((char)( x & 0xff), p);
169 [ - + - - ]: 24377 : w_byte((char)((x>> 8) & 0xff), p);
170 : 24377 : }
171 : :
172 : : static void
173 : 5054998 : w_long(long x, WFILE *p)
174 : : {
175 [ + + + - ]: 5054998 : w_byte((char)( x & 0xff), p);
176 [ + + + - ]: 5054998 : w_byte((char)((x>> 8) & 0xff), p);
177 [ + + + - ]: 5054998 : w_byte((char)((x>>16) & 0xff), p);
178 [ + + + - ]: 5054998 : w_byte((char)((x>>24) & 0xff), p);
179 : 5054998 : }
180 : :
181 : : #define SIZE32_MAX 0x7FFFFFFF
182 : :
183 : : #if SIZEOF_SIZE_T > 4
184 : : # define W_SIZE(n, p) do { \
185 : : if ((n) > SIZE32_MAX) { \
186 : : (p)->depth--; \
187 : : (p)->error = WFERR_UNMARSHALLABLE; \
188 : : return; \
189 : : } \
190 : : w_long((long)(n), p); \
191 : : } while(0)
192 : : #else
193 : : # define W_SIZE w_long
194 : : #endif
195 : :
196 : : static void
197 : 745730 : w_pstring(const void *s, Py_ssize_t n, WFILE *p)
198 : : {
199 [ - + ]: 745730 : W_SIZE(n, p);
200 : 745730 : w_string(s, n, p);
201 : : }
202 : :
203 : : static void
204 : 1365396 : w_short_pstring(const void *s, Py_ssize_t n, WFILE *p)
205 : : {
206 [ + + + - ]: 1365396 : w_byte(Py_SAFE_DOWNCAST(n, Py_ssize_t, unsigned char), p);
207 : 1365396 : w_string(s, n, p);
208 : 1365396 : }
209 : :
210 : : /* We assume that Python ints are stored internally in base some power of
211 : : 2**15; for the sake of portability we'll always read and write them in base
212 : : exactly 2**15. */
213 : :
214 : : #define PyLong_MARSHAL_SHIFT 15
215 : : #define PyLong_MARSHAL_BASE ((short)1 << PyLong_MARSHAL_SHIFT)
216 : : #define PyLong_MARSHAL_MASK (PyLong_MARSHAL_BASE - 1)
217 : : #if PyLong_SHIFT % PyLong_MARSHAL_SHIFT != 0
218 : : #error "PyLong_SHIFT must be a multiple of PyLong_MARSHAL_SHIFT"
219 : : #endif
220 : : #define PyLong_MARSHAL_RATIO (PyLong_SHIFT / PyLong_MARSHAL_SHIFT)
221 : :
222 : : #define W_TYPE(t, p) do { \
223 : : w_byte((t) | flag, (p)); \
224 : : } while(0)
225 : :
226 : : static void
227 : 6616 : w_PyLong(const PyLongObject *ob, char flag, WFILE *p)
228 : : {
229 : : Py_ssize_t i, j, n, l;
230 : : digit d;
231 : :
232 [ - + - - ]: 6616 : W_TYPE(TYPE_LONG, p);
233 [ - + ]: 6616 : if (Py_SIZE(ob) == 0) {
234 : 0 : w_long((long)0, p);
235 : 0 : return;
236 : : }
237 : :
238 : : /* set l to number of base PyLong_MARSHAL_BASE digits */
239 [ + + ]: 6616 : n = Py_ABS(Py_SIZE(ob));
240 : 6616 : l = (n-1) * PyLong_MARSHAL_RATIO;
241 : 6616 : d = ob->ob_digit[n-1];
242 : : assert(d != 0); /* a PyLong is always normalized */
243 : : do {
244 : 9121 : d >>= PyLong_MARSHAL_SHIFT;
245 : 9121 : l++;
246 [ + + ]: 9121 : } while (d != 0);
247 [ - + ]: 6616 : if (l > SIZE32_MAX) {
248 : 0 : p->depth--;
249 : 0 : p->error = WFERR_UNMARSHALLABLE;
250 : 0 : return;
251 : : }
252 [ + + ]: 6616 : w_long((long)(Py_SIZE(ob) > 0 ? l : -l), p);
253 : :
254 [ + + ]: 14244 : for (i=0; i < n-1; i++) {
255 : 7628 : d = ob->ob_digit[i];
256 [ + + ]: 22884 : for (j=0; j < PyLong_MARSHAL_RATIO; j++) {
257 : 15256 : w_short(d & PyLong_MARSHAL_MASK, p);
258 : 15256 : d >>= PyLong_MARSHAL_SHIFT;
259 : : }
260 : : assert (d == 0);
261 : : }
262 : 6616 : d = ob->ob_digit[n-1];
263 : : do {
264 : 9121 : w_short(d & PyLong_MARSHAL_MASK, p);
265 : 9121 : d >>= PyLong_MARSHAL_SHIFT;
266 [ + + ]: 9121 : } while (d != 0);
267 : : }
268 : :
269 : : static void
270 : 6521 : w_float_bin(double v, WFILE *p)
271 : : {
272 : : char buf[8];
273 [ - + ]: 6521 : if (PyFloat_Pack8(v, buf, 1) < 0) {
274 : 0 : p->error = WFERR_UNMARSHALLABLE;
275 : 0 : return;
276 : : }
277 : 6521 : w_string(buf, 8, p);
278 : : }
279 : :
280 : : static void
281 : 461 : w_float_str(double v, WFILE *p)
282 : : {
283 : 461 : char *buf = PyOS_double_to_string(v, 'g', 17, 0, NULL);
284 [ - + ]: 461 : if (!buf) {
285 : 0 : p->error = WFERR_NOMEMORY;
286 : 0 : return;
287 : : }
288 : 461 : w_short_pstring(buf, strlen(buf), p);
289 : 461 : PyMem_Free(buf);
290 : : }
291 : :
292 : : static int
293 : 5899996 : w_ref(PyObject *v, char *flag, WFILE *p)
294 : : {
295 : : _Py_hashtable_entry_t *entry;
296 : : int w;
297 : :
298 [ + + - + ]: 5899996 : if (p->version < 3 || p->hashtable == NULL)
299 : 11476 : return 0; /* not writing object references */
300 : :
301 : : /* If it has only one reference, it definitely isn't shared.
302 : : * But we use TYPE_REF always for interned string, to PYC file stable
303 : : * as possible.
304 : : */
305 [ + + + + ]: 7790721 : if (Py_REFCNT(v) == 1 &&
306 [ + + ]: 2462930 : !(PyUnicode_CheckExact(v) && PyUnicode_CHECK_INTERNED(v))) {
307 : 1773913 : return 0;
308 : : }
309 : :
310 : 4114607 : entry = _Py_hashtable_get_entry(p->hashtable, v);
311 [ + + ]: 4114607 : if (entry != NULL) {
312 : : /* write the reference index to the stream */
313 : 2732809 : w = (int)(uintptr_t)entry->value;
314 : : /* we don't store "long" indices in the dict */
315 : : assert(0 <= w && w <= 0x7fffffff);
316 [ + + + - ]: 2732809 : w_byte(TYPE_REF, p);
317 : 2732809 : w_long(w, p);
318 : 2732809 : return 1;
319 : : } else {
320 : 1381798 : size_t s = p->hashtable->nentries;
321 : : /* we don't support long indices */
322 [ - + ]: 1381798 : if (s >= 0x7fffffff) {
323 : 0 : PyErr_SetString(PyExc_ValueError, "too many objects");
324 : 0 : goto err;
325 : : }
326 : 1381798 : w = (int)s;
327 : 1381798 : Py_INCREF(v);
328 [ - + ]: 1381798 : if (_Py_hashtable_set(p->hashtable, v, (void *)(uintptr_t)w) < 0) {
329 : 0 : Py_DECREF(v);
330 : 0 : goto err;
331 : : }
332 : 1381798 : *flag |= FLAG_REF;
333 : 1381798 : return 0;
334 : : }
335 : 0 : err:
336 : 0 : p->error = WFERR_UNMARSHALLABLE;
337 : 0 : return 1;
338 : : }
339 : :
340 : : static void
341 : : w_complex_object(PyObject *v, char flag, WFILE *p);
342 : :
343 : : static void
344 : 6093269 : w_object(PyObject *v, WFILE *p)
345 : : {
346 : 6093269 : char flag = '\0';
347 : :
348 : 6093269 : p->depth++;
349 : :
350 [ + + ]: 6093269 : if (p->depth > MAX_MARSHAL_STACK_DEPTH) {
351 : 1 : p->error = WFERR_NESTEDTOODEEP;
352 : : }
353 [ + + ]: 6093268 : else if (v == NULL) {
354 [ + + + - ]: 121 : w_byte(TYPE_NULL, p);
355 : : }
356 [ + + ]: 6093147 : else if (v == Py_None) {
357 [ + + + - ]: 155224 : w_byte(TYPE_NONE, p);
358 : : }
359 [ + + ]: 5937923 : else if (v == PyExc_StopIteration) {
360 [ - + - - ]: 1 : w_byte(TYPE_STOPITER, p);
361 : : }
362 [ + + ]: 5937922 : else if (v == Py_Ellipsis) {
363 [ - + - - ]: 589 : w_byte(TYPE_ELLIPSIS, p);
364 : : }
365 [ + + ]: 5937333 : else if (v == Py_False) {
366 [ + + + - ]: 17795 : w_byte(TYPE_FALSE, p);
367 : : }
368 [ + + ]: 5919538 : else if (v == Py_True) {
369 [ - + - - ]: 19542 : w_byte(TYPE_TRUE, p);
370 : : }
371 [ + + ]: 5899996 : else if (!w_ref(v, &flag, p))
372 : 3167187 : w_complex_object(v, flag, p);
373 : :
374 : 6093269 : p->depth--;
375 : 6093269 : }
376 : :
377 : : static void
378 : 3167187 : w_complex_object(PyObject *v, char flag, WFILE *p)
379 : : {
380 : : Py_ssize_t i, n;
381 : :
382 [ + + ]: 3167187 : if (PyLong_CheckExact(v)) {
383 : : int overflow;
384 : 206643 : long x = PyLong_AsLongAndOverflow(v, &overflow);
385 [ + + ]: 206643 : if (overflow) {
386 : 528 : w_PyLong((PyLongObject *)v, flag, p);
387 : : }
388 : : else {
389 : : #if SIZEOF_LONG > 4
390 : 206115 : long y = Py_ARITHMETIC_RIGHT_SHIFT(long, x, 31);
391 [ + + + + ]: 206115 : if (y && y != -1) {
392 : : /* Too large for TYPE_INT */
393 : 6088 : w_PyLong((PyLongObject*)v, flag, p);
394 : : }
395 : : else
396 : : #endif
397 : : {
398 [ + + + - ]: 200027 : W_TYPE(TYPE_INT, p);
399 : 200027 : w_long(x, p);
400 : : }
401 : : }
402 : : }
403 [ + + ]: 2960544 : else if (PyFloat_CheckExact(v)) {
404 [ + + ]: 6446 : if (p->version > 1) {
405 [ + + + - ]: 6013 : W_TYPE(TYPE_BINARY_FLOAT, p);
406 : 6013 : w_float_bin(PyFloat_AS_DOUBLE(v), p);
407 : : }
408 : : else {
409 [ - + - - ]: 433 : W_TYPE(TYPE_FLOAT, p);
410 : 433 : w_float_str(PyFloat_AS_DOUBLE(v), p);
411 : : }
412 : : }
413 [ + + ]: 2954098 : else if (PyComplex_CheckExact(v)) {
414 [ + + ]: 268 : if (p->version > 1) {
415 [ - + - - ]: 254 : W_TYPE(TYPE_BINARY_COMPLEX, p);
416 : 254 : w_float_bin(PyComplex_RealAsDouble(v), p);
417 : 254 : w_float_bin(PyComplex_ImagAsDouble(v), p);
418 : : }
419 : : else {
420 [ - + - - ]: 14 : W_TYPE(TYPE_COMPLEX, p);
421 : 14 : w_float_str(PyComplex_RealAsDouble(v), p);
422 : 14 : w_float_str(PyComplex_ImagAsDouble(v), p);
423 : : }
424 : : }
425 [ + + ]: 2953830 : else if (PyBytes_CheckExact(v)) {
426 [ + + + - ]: 675187 : W_TYPE(TYPE_STRING, p);
427 : 675187 : w_pstring(PyBytes_AS_STRING(v), PyBytes_GET_SIZE(v), p);
428 : : }
429 [ + + ]: 2278643 : else if (PyUnicode_CheckExact(v)) {
430 [ + + + + ]: 2820961 : if (p->version >= 4 && PyUnicode_IS_ASCII(v)) {
431 : 1385490 : int is_short = PyUnicode_GET_LENGTH(v) < 256;
432 [ + + ]: 1385490 : if (is_short) {
433 [ + + ]: 1364935 : if (PyUnicode_CHECK_INTERNED(v))
434 [ + + + - ]: 932291 : W_TYPE(TYPE_SHORT_ASCII_INTERNED, p);
435 : : else
436 [ + + + - ]: 432644 : W_TYPE(TYPE_SHORT_ASCII, p);
437 : 1364935 : w_short_pstring(PyUnicode_1BYTE_DATA(v),
438 : : PyUnicode_GET_LENGTH(v), p);
439 : : }
440 : : else {
441 [ + + ]: 20555 : if (PyUnicode_CHECK_INTERNED(v))
442 [ - + - - ]: 33 : W_TYPE(TYPE_ASCII_INTERNED, p);
443 : : else
444 [ + + + - ]: 20522 : W_TYPE(TYPE_ASCII, p);
445 : 20555 : w_pstring(PyUnicode_1BYTE_DATA(v),
446 : : PyUnicode_GET_LENGTH(v), p);
447 : : }
448 : : }
449 : : else {
450 : : PyObject *utf8;
451 : 49981 : utf8 = PyUnicode_AsEncodedString(v, "utf8", "surrogatepass");
452 [ - + ]: 49981 : if (utf8 == NULL) {
453 : 0 : p->depth--;
454 : 0 : p->error = WFERR_UNMARSHALLABLE;
455 : 0 : return;
456 : : }
457 [ + + + + ]: 49981 : if (p->version >= 3 && PyUnicode_CHECK_INTERNED(v))
458 [ - + - - ]: 714 : W_TYPE(TYPE_INTERNED, p);
459 : : else
460 [ + + + - ]: 49267 : W_TYPE(TYPE_UNICODE, p);
461 : 49981 : w_pstring(PyBytes_AS_STRING(utf8), PyBytes_GET_SIZE(utf8), p);
462 : 49981 : Py_DECREF(utf8);
463 : : }
464 : : }
465 [ + + ]: 843172 : else if (PyTuple_CheckExact(v)) {
466 : 610918 : n = PyTuple_GET_SIZE(v);
467 [ + + + + ]: 610918 : if (p->version >= 4 && n < 256) {
468 [ + + + - ]: 608530 : W_TYPE(TYPE_SMALL_TUPLE, p);
469 [ + + + - ]: 608530 : w_byte((unsigned char)n, p);
470 : : }
471 : : else {
472 [ + + + - ]: 2388 : W_TYPE(TYPE_TUPLE, p);
473 [ - + ]: 2388 : W_SIZE(n, p);
474 : : }
475 [ + + ]: 4402420 : for (i = 0; i < n; i++) {
476 : 3791502 : w_object(PyTuple_GET_ITEM(v, i), p);
477 : : }
478 : : }
479 [ + + ]: 232254 : else if (PyList_CheckExact(v)) {
480 [ - + - - ]: 4040 : W_TYPE(TYPE_LIST, p);
481 : 4040 : n = PyList_GET_SIZE(v);
482 [ - + ]: 4040 : W_SIZE(n, p);
483 [ + + ]: 13124 : for (i = 0; i < n; i++) {
484 : 9084 : w_object(PyList_GET_ITEM(v, i), p);
485 : : }
486 : : }
487 [ + + ]: 228214 : else if (PyDict_CheckExact(v)) {
488 : : Py_ssize_t pos;
489 : : PyObject *key, *value;
490 [ - + - - ]: 121 : W_TYPE(TYPE_DICT, p);
491 : : /* This one is NULL object terminated! */
492 : 121 : pos = 0;
493 [ + + ]: 394 : while (PyDict_Next(v, &pos, &key, &value)) {
494 : 273 : w_object(key, p);
495 : 273 : w_object(value, p);
496 : : }
497 : 121 : w_object((PyObject *)NULL, p);
498 : : }
499 [ + + + + ]: 229110 : else if (PyAnySet_CheckExact(v)) {
500 : : PyObject *value;
501 : 1017 : Py_ssize_t pos = 0;
502 : : Py_hash_t hash;
503 : :
504 [ + + ]: 1017 : if (PyFrozenSet_CheckExact(v))
505 [ - + - - ]: 981 : W_TYPE(TYPE_FROZENSET, p);
506 : : else
507 [ - + - - ]: 36 : W_TYPE(TYPE_SET, p);
508 : 1017 : n = PySet_GET_SIZE(v);
509 [ - + ]: 1017 : W_SIZE(n, p);
510 : : // bpo-37596: To support reproducible builds, sets and frozensets need
511 : : // to have their elements serialized in a consistent order (even when
512 : : // they have been scrambled by hash randomization). To ensure this, we
513 : : // use an order equivalent to sorted(v, key=marshal.dumps):
514 : 1017 : PyObject *pairs = PyList_New(n);
515 [ - + ]: 1017 : if (pairs == NULL) {
516 : 0 : p->error = WFERR_NOMEMORY;
517 : 0 : return;
518 : : }
519 : 1017 : Py_ssize_t i = 0;
520 [ + + ]: 6884 : while (_PySet_NextEntry(v, &pos, &value, &hash)) {
521 : 5867 : PyObject *dump = PyMarshal_WriteObjectToString(value, p->version);
522 [ - + ]: 5867 : if (dump == NULL) {
523 : 0 : p->error = WFERR_UNMARSHALLABLE;
524 : 0 : Py_DECREF(pairs);
525 : 0 : return;
526 : : }
527 : 5867 : PyObject *pair = PyTuple_Pack(2, dump, value);
528 : 5867 : Py_DECREF(dump);
529 [ - + ]: 5867 : if (pair == NULL) {
530 : 0 : p->error = WFERR_NOMEMORY;
531 : 0 : Py_DECREF(pairs);
532 : 0 : return;
533 : : }
534 : 5867 : PyList_SET_ITEM(pairs, i++, pair);
535 : : }
536 : : assert(i == n);
537 [ - + ]: 1017 : if (PyList_Sort(pairs)) {
538 : 0 : p->error = WFERR_NOMEMORY;
539 : 0 : Py_DECREF(pairs);
540 : 0 : return;
541 : : }
542 [ + + ]: 6884 : for (Py_ssize_t i = 0; i < n; i++) {
543 : 5867 : PyObject *pair = PyList_GET_ITEM(pairs, i);
544 : 5867 : value = PyTuple_GET_ITEM(pair, 1);
545 : 5867 : w_object(value, p);
546 : : }
547 : 1017 : Py_DECREF(pairs);
548 : : }
549 [ + + ]: 227076 : else if (PyCode_Check(v)) {
550 : 227061 : PyCodeObject *co = (PyCodeObject *)v;
551 : 227061 : PyObject *co_code = _PyCode_GetCode(co);
552 [ - + ]: 227061 : if (co_code == NULL) {
553 : 0 : p->error = WFERR_NOMEMORY;
554 : 0 : return;
555 : : }
556 [ + + + - ]: 227061 : W_TYPE(TYPE_CODE, p);
557 : 227061 : w_long(co->co_argcount, p);
558 : 227061 : w_long(co->co_posonlyargcount, p);
559 : 227061 : w_long(co->co_kwonlyargcount, p);
560 : 227061 : w_long(co->co_stacksize, p);
561 : 227061 : w_long(co->co_flags, p);
562 : 227061 : w_object(co_code, p);
563 : 227061 : w_object(co->co_consts, p);
564 : 227061 : w_object(co->co_names, p);
565 : 227061 : w_object(co->co_localsplusnames, p);
566 : 227061 : w_object(co->co_localspluskinds, p);
567 : 227061 : w_object(co->co_filename, p);
568 : 227061 : w_object(co->co_name, p);
569 : 227061 : w_object(co->co_qualname, p);
570 : 227061 : w_long(co->co_firstlineno, p);
571 : 227061 : w_object(co->co_linetable, p);
572 : 227061 : w_object(co->co_exceptiontable, p);
573 : 227061 : Py_DECREF(co_code);
574 : : }
575 [ + + ]: 15 : else if (PyObject_CheckBuffer(v)) {
576 : : /* Write unknown bytes-like objects as a bytes object */
577 : : Py_buffer view;
578 [ - + ]: 7 : if (PyObject_GetBuffer(v, &view, PyBUF_SIMPLE) != 0) {
579 [ # # # # ]: 0 : w_byte(TYPE_UNKNOWN, p);
580 : 0 : p->depth--;
581 : 0 : p->error = WFERR_UNMARSHALLABLE;
582 : 0 : return;
583 : : }
584 [ - + - - ]: 7 : W_TYPE(TYPE_STRING, p);
585 : 7 : w_pstring(view.buf, view.len, p);
586 : 7 : PyBuffer_Release(&view);
587 : : }
588 : : else {
589 [ - + - - ]: 8 : W_TYPE(TYPE_UNKNOWN, p);
590 : 8 : p->error = WFERR_UNMARSHALLABLE;
591 : : }
592 : : }
593 : :
594 : : static void
595 : 1381798 : w_decref_entry(void *key)
596 : : {
597 : 1381798 : PyObject *entry_key = (PyObject *)key;
598 : 1381798 : Py_XDECREF(entry_key);
599 : 1381798 : }
600 : :
601 : : static int
602 : 15539 : w_init_refs(WFILE *wf, int version)
603 : : {
604 [ + + ]: 15539 : if (version >= 3) {
605 : 14986 : wf->hashtable = _Py_hashtable_new_full(_Py_hashtable_hash_ptr,
606 : : _Py_hashtable_compare_direct,
607 : : w_decref_entry, NULL, NULL);
608 [ - + ]: 14986 : if (wf->hashtable == NULL) {
609 : : PyErr_NoMemory();
610 : 0 : return -1;
611 : : }
612 : : }
613 : 15539 : return 0;
614 : : }
615 : :
616 : : static void
617 : 15539 : w_clear_refs(WFILE *wf)
618 : : {
619 [ + + ]: 15539 : if (wf->hashtable != NULL) {
620 : 14986 : _Py_hashtable_destroy(wf->hashtable);
621 : : }
622 : 15539 : }
623 : :
624 : : /* version currently has no effect for writing ints. */
625 : : void
626 : 5 : PyMarshal_WriteLongToFile(long x, FILE *fp, int version)
627 : : {
628 : : char buf[4];
629 : : WFILE wf;
630 : 5 : memset(&wf, 0, sizeof(wf));
631 : 5 : wf.fp = fp;
632 : 5 : wf.ptr = wf.buf = buf;
633 : 5 : wf.end = wf.ptr + sizeof(buf);
634 : 5 : wf.error = WFERR_OK;
635 : 5 : wf.version = version;
636 : 5 : w_long(x, &wf);
637 : 5 : w_flush(&wf);
638 : 5 : }
639 : :
640 : : void
641 : 5 : PyMarshal_WriteObjectToFile(PyObject *x, FILE *fp, int version)
642 : : {
643 : : char buf[BUFSIZ];
644 : : WFILE wf;
645 [ - + ]: 5 : if (PySys_Audit("marshal.dumps", "Oi", x, version) < 0) {
646 : 0 : return; /* caller must check PyErr_Occurred() */
647 : : }
648 : 5 : memset(&wf, 0, sizeof(wf));
649 : 5 : wf.fp = fp;
650 : 5 : wf.ptr = wf.buf = buf;
651 : 5 : wf.end = wf.ptr + sizeof(buf);
652 : 5 : wf.error = WFERR_OK;
653 : 5 : wf.version = version;
654 [ - + ]: 5 : if (w_init_refs(&wf, version)) {
655 : 0 : return; /* caller must check PyErr_Occurred() */
656 : : }
657 : 5 : w_object(x, &wf);
658 : 5 : w_clear_refs(&wf);
659 : 5 : w_flush(&wf);
660 : : }
661 : :
662 : : typedef struct {
663 : : FILE *fp;
664 : : int depth;
665 : : PyObject *readable; /* Stream-like object being read from */
666 : : const char *ptr;
667 : : const char *end;
668 : : char *buf;
669 : : Py_ssize_t buf_size;
670 : : PyObject *refs; /* a list */
671 : : } RFILE;
672 : :
673 : : static const char *
674 : 211977392 : r_string(Py_ssize_t n, RFILE *p)
675 : : {
676 : 211977392 : Py_ssize_t read = -1;
677 : :
678 [ + + ]: 211977392 : if (p->ptr != NULL) {
679 : : /* Fast path for loads() */
680 : 211856269 : const char *res = p->ptr;
681 : 211856269 : Py_ssize_t left = p->end - p->ptr;
682 [ + + ]: 211856269 : if (left < n) {
683 : 51 : PyErr_SetString(PyExc_EOFError,
684 : : "marshal data too short");
685 : 51 : return NULL;
686 : : }
687 : 211856218 : p->ptr += n;
688 : 211856218 : return res;
689 : : }
690 [ + + ]: 121123 : if (p->buf == NULL) {
691 : 1153 : p->buf = PyMem_Malloc(n);
692 [ - + ]: 1153 : if (p->buf == NULL) {
693 : : PyErr_NoMemory();
694 : 0 : return NULL;
695 : : }
696 : 1153 : p->buf_size = n;
697 : : }
698 [ + + ]: 119970 : else if (p->buf_size < n) {
699 : 1119 : char *tmp = PyMem_Realloc(p->buf, n);
700 [ - + ]: 1119 : if (tmp == NULL) {
701 : : PyErr_NoMemory();
702 : 0 : return NULL;
703 : : }
704 : 1119 : p->buf = tmp;
705 : 1119 : p->buf_size = n;
706 : : }
707 : :
708 [ + + ]: 121123 : if (!p->readable) {
709 : : assert(p->fp != NULL);
710 : 164 : read = fread(p->buf, 1, n, p->fp);
711 : : }
712 : : else {
713 : : PyObject *res, *mview;
714 : : Py_buffer buf;
715 : :
716 [ - + ]: 120959 : if (PyBuffer_FillInfo(&buf, NULL, p->buf, n, 0, PyBUF_CONTIG) == -1)
717 : 0 : return NULL;
718 : 120959 : mview = PyMemoryView_FromBuffer(&buf);
719 [ - + ]: 120959 : if (mview == NULL)
720 : 0 : return NULL;
721 : :
722 : 120959 : res = _PyObject_CallMethod(p->readable, &_Py_ID(readinto), "N", mview);
723 [ + - ]: 120959 : if (res != NULL) {
724 : 120959 : read = PyNumber_AsSsize_t(res, PyExc_ValueError);
725 : 120959 : Py_DECREF(res);
726 : : }
727 : : }
728 [ + + ]: 121123 : if (read != n) {
729 [ + - ]: 10 : if (!PyErr_Occurred()) {
730 [ + + ]: 10 : if (read > n)
731 : 4 : PyErr_Format(PyExc_ValueError,
732 : : "read() returned too much data: "
733 : : "%zd bytes requested, %zd returned",
734 : : n, read);
735 : : else
736 : 6 : PyErr_SetString(PyExc_EOFError,
737 : : "EOF read where not expected");
738 : : }
739 : 10 : return NULL;
740 : : }
741 : 121113 : return p->buf;
742 : : }
743 : :
744 : : static int
745 : 238981292 : r_byte(RFILE *p)
746 : : {
747 : 238981292 : int c = EOF;
748 : :
749 [ + + ]: 238981292 : if (p->ptr != NULL) {
750 [ + + ]: 238924264 : if (p->ptr < p->end)
751 : 238924230 : c = (unsigned char) *p->ptr++;
752 : 238924264 : return c;
753 : : }
754 [ + + ]: 57028 : if (!p->readable) {
755 : : assert(p->fp);
756 : 44 : c = getc(p->fp);
757 : : }
758 : : else {
759 : 56984 : const char *ptr = r_string(1, p);
760 [ + - ]: 56984 : if (ptr != NULL)
761 : 56984 : c = *(const unsigned char *) ptr;
762 : : }
763 : 57028 : return c;
764 : : }
765 : :
766 : : static int
767 : 71900 : r_short(RFILE *p)
768 : : {
769 : 71900 : short x = -1;
770 : : const unsigned char *buffer;
771 : :
772 : 71900 : buffer = (const unsigned char *) r_string(2, p);
773 [ + + ]: 71900 : if (buffer != NULL) {
774 : 71898 : x = buffer[0];
775 : 71898 : x |= buffer[1] << 8;
776 : : /* Sign-extension, in case short greater than 16 bits */
777 : 71898 : x |= -(x & 0x8000);
778 : : }
779 : 71900 : return x;
780 : : }
781 : :
782 : : static long
783 : 145636620 : r_long(RFILE *p)
784 : : {
785 : 145636620 : long x = -1;
786 : : const unsigned char *buffer;
787 : :
788 : 145636620 : buffer = (const unsigned char *) r_string(4, p);
789 [ + + ]: 145636620 : if (buffer != NULL) {
790 : 145636581 : x = buffer[0];
791 : 145636581 : x |= (long)buffer[1] << 8;
792 : 145636581 : x |= (long)buffer[2] << 16;
793 : 145636581 : x |= (long)buffer[3] << 24;
794 : : #if SIZEOF_LONG > 4
795 : : /* Sign extension for 64-bit machines */
796 : 145636581 : x |= -(x & 0x80000000L);
797 : : #endif
798 : : }
799 : 145636620 : return x;
800 : : }
801 : :
802 : : /* r_long64 deals with the TYPE_INT64 code. */
803 : : static PyObject *
804 : 260 : r_long64(RFILE *p)
805 : : {
806 : 260 : const unsigned char *buffer = (const unsigned char *) r_string(8, p);
807 [ + + ]: 260 : if (buffer == NULL) {
808 : 2 : return NULL;
809 : : }
810 : 258 : return _PyLong_FromByteArray(buffer, 8,
811 : : 1 /* little endian */,
812 : : 1 /* signed */);
813 : : }
814 : :
815 : : static PyObject *
816 : 19912 : r_PyLong(RFILE *p)
817 : : {
818 : : PyLongObject *ob;
819 : : long n, size, i;
820 : : int j, md, shorts_in_top_digit;
821 : : digit d;
822 : :
823 : 19912 : n = r_long(p);
824 [ + + ]: 19912 : if (PyErr_Occurred())
825 : 2 : return NULL;
826 [ - + ]: 19910 : if (n == 0)
827 : 0 : return (PyObject *)_PyLong_New(0);
828 [ + - - + ]: 19910 : if (n < -SIZE32_MAX || n > SIZE32_MAX) {
829 : 0 : PyErr_SetString(PyExc_ValueError,
830 : : "bad marshal data (long size out of range)");
831 : 0 : return NULL;
832 : : }
833 : :
834 : 19910 : size = 1 + (Py_ABS(n) - 1) / PyLong_MARSHAL_RATIO;
835 : 19910 : shorts_in_top_digit = 1 + (Py_ABS(n) - 1) % PyLong_MARSHAL_RATIO;
836 : 19910 : ob = _PyLong_New(size);
837 [ - + ]: 19910 : if (ob == NULL)
838 : 0 : return NULL;
839 : :
840 [ + + ]: 19910 : Py_SET_SIZE(ob, n > 0 ? size : -size);
841 : :
842 [ + + ]: 44670 : for (i = 0; i < size-1; i++) {
843 : 24760 : d = 0;
844 [ + + ]: 74280 : for (j=0; j < PyLong_MARSHAL_RATIO; j++) {
845 : 49520 : md = r_short(p);
846 [ - + ]: 49520 : if (PyErr_Occurred()) {
847 : 0 : Py_DECREF(ob);
848 : 0 : return NULL;
849 : : }
850 [ + - - + ]: 49520 : if (md < 0 || md > PyLong_MARSHAL_BASE)
851 : 0 : goto bad_digit;
852 : 49520 : d += (digit)md << j*PyLong_MARSHAL_SHIFT;
853 : : }
854 : 24760 : ob->ob_digit[i] = d;
855 : : }
856 : :
857 : 19910 : d = 0;
858 [ + + ]: 42286 : for (j=0; j < shorts_in_top_digit; j++) {
859 : 22378 : md = r_short(p);
860 [ + + ]: 22378 : if (PyErr_Occurred()) {
861 : 1 : Py_DECREF(ob);
862 : 1 : return NULL;
863 : : }
864 [ + - - + ]: 22377 : if (md < 0 || md > PyLong_MARSHAL_BASE)
865 : 0 : goto bad_digit;
866 : : /* topmost marshal digit should be nonzero */
867 [ + + + + ]: 22377 : if (md == 0 && j == shorts_in_top_digit - 1) {
868 : 1 : Py_DECREF(ob);
869 : 1 : PyErr_SetString(PyExc_ValueError,
870 : : "bad marshal data (unnormalized long data)");
871 : 1 : return NULL;
872 : : }
873 : 22376 : d += (digit)md << j*PyLong_MARSHAL_SHIFT;
874 : : }
875 [ - + ]: 19908 : if (PyErr_Occurred()) {
876 : 0 : Py_DECREF(ob);
877 : 0 : return NULL;
878 : : }
879 : : /* top digit should be nonzero, else the resulting PyLong won't be
880 : : normalized */
881 : 19908 : ob->ob_digit[size-1] = d;
882 : 19908 : return (PyObject *)ob;
883 : 0 : bad_digit:
884 : 0 : Py_DECREF(ob);
885 : 0 : PyErr_SetString(PyExc_ValueError,
886 : : "bad marshal data (digit out of range in long)");
887 : 0 : return NULL;
888 : : }
889 : :
890 : : static double
891 : 102669 : r_float_bin(RFILE *p)
892 : : {
893 : 102669 : const char *buf = r_string(8, p);
894 [ + + ]: 102669 : if (buf == NULL)
895 : 6 : return -1;
896 : 102663 : return PyFloat_Unpack8(buf, 1);
897 : : }
898 : :
899 : : /* Issue #33720: Disable inlining for reducing the C stack consumption
900 : : on PGO builds. */
901 : : Py_NO_INLINE static double
902 : 466 : r_float_str(RFILE *p)
903 : : {
904 : : int n;
905 : : char buf[256];
906 : : const char *ptr;
907 : 466 : n = r_byte(p);
908 [ + + ]: 466 : if (n == EOF) {
909 : 5 : PyErr_SetString(PyExc_EOFError,
910 : : "EOF read where object expected");
911 : 5 : return -1;
912 : : }
913 : 461 : ptr = r_string(n, p);
914 [ - + ]: 461 : if (ptr == NULL) {
915 : 0 : return -1;
916 : : }
917 : 461 : memcpy(buf, ptr, n);
918 : 461 : buf[n] = '\0';
919 : 461 : return PyOS_string_to_double(buf, NULL, NULL);
920 : : }
921 : :
922 : : /* allocate the reflist index for a new object. Return -1 on failure */
923 : : static Py_ssize_t
924 : 7075359 : r_ref_reserve(int flag, RFILE *p)
925 : : {
926 [ + + ]: 7075359 : if (flag) { /* currently only FLAG_REF is defined */
927 : 163529 : Py_ssize_t idx = PyList_GET_SIZE(p->refs);
928 [ - + ]: 163529 : if (idx >= 0x7ffffffe) {
929 : 0 : PyErr_SetString(PyExc_ValueError, "bad marshal data (index list too large)");
930 : 0 : return -1;
931 : : }
932 [ - + ]: 163529 : if (PyList_Append(p->refs, Py_None) < 0)
933 : 0 : return -1;
934 : 163529 : return idx;
935 : : } else
936 : 6911830 : return 0;
937 : : }
938 : :
939 : : /* insert the new object 'o' to the reflist at previously
940 : : * allocated index 'idx'.
941 : : * 'o' can be NULL, in which case nothing is done.
942 : : * if 'o' was non-NULL, and the function succeeds, 'o' is returned.
943 : : * if 'o' was non-NULL, and the function fails, 'o' is released and
944 : : * NULL returned. This simplifies error checking at the call site since
945 : : * a single test for NULL for the function result is enough.
946 : : */
947 : : static PyObject *
948 : 7075357 : r_ref_insert(PyObject *o, Py_ssize_t idx, int flag, RFILE *p)
949 : : {
950 [ + + + + ]: 7075357 : if (o != NULL && flag) { /* currently only FLAG_REF is defined */
951 : 163528 : PyObject *tmp = PyList_GET_ITEM(p->refs, idx);
952 : 163528 : Py_INCREF(o);
953 : 163528 : PyList_SET_ITEM(p->refs, idx, o);
954 : 163528 : Py_DECREF(tmp);
955 : : }
956 : 7075357 : return o;
957 : : }
958 : :
959 : : /* combination of both above, used when an object can be
960 : : * created whenever it is seen in the file, as opposed to
961 : : * after having loaded its sub-objects.
962 : : */
963 : : static PyObject *
964 : 43784846 : r_ref(PyObject *o, int flag, RFILE *p)
965 : : {
966 : : assert(flag & FLAG_REF);
967 [ + + ]: 43784846 : if (o == NULL)
968 : 3 : return NULL;
969 [ - + ]: 43784843 : if (PyList_Append(p->refs, o) < 0) {
970 : 0 : Py_DECREF(o); /* release the new object */
971 : 0 : return NULL;
972 : : }
973 : 43784843 : return o;
974 : : }
975 : :
976 : : static PyObject *
977 : 177582653 : r_object(RFILE *p)
978 : : {
979 : : /* NULL is a valid return value, it does not necessarily means that
980 : : an exception is set. */
981 : : PyObject *v, *v2;
982 : 177582653 : Py_ssize_t idx = 0;
983 : : long i, n;
984 : 177582653 : int type, code = r_byte(p);
985 : 177582653 : int flag, is_interned = 0;
986 : 177582653 : PyObject *retval = NULL;
987 : :
988 [ + + ]: 177582653 : if (code == EOF) {
989 : 20 : PyErr_SetString(PyExc_EOFError,
990 : : "EOF read where object expected");
991 : 20 : return NULL;
992 : : }
993 : :
994 : 177582633 : p->depth++;
995 : :
996 [ + + ]: 177582633 : if (p->depth > MAX_MARSHAL_STACK_DEPTH) {
997 : 5 : p->depth--;
998 : 5 : PyErr_SetString(PyExc_ValueError, "recursion limit exceeded");
999 : 5 : return NULL;
1000 : : }
1001 : :
1002 : 177582628 : flag = code & FLAG_REF;
1003 : 177582628 : type = code & ~FLAG_REF;
1004 : :
1005 : : #define R_REF(O) do{\
1006 : : if (flag) \
1007 : : O = r_ref(O, flag, p);\
1008 : : } while (0)
1009 : :
1010 [ + + + + : 177582628 : switch (type) {
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + ]
1011 : :
1012 : 2185 : case TYPE_NULL:
1013 : 2185 : break;
1014 : :
1015 : 4319582 : case TYPE_NONE:
1016 : 4319582 : Py_INCREF(Py_None);
1017 : 4319582 : retval = Py_None;
1018 : 4319582 : break;
1019 : :
1020 : 3 : case TYPE_STOPITER:
1021 : 3 : Py_INCREF(PyExc_StopIteration);
1022 : 3 : retval = PyExc_StopIteration;
1023 : 3 : break;
1024 : :
1025 : 14252 : case TYPE_ELLIPSIS:
1026 : 14252 : Py_INCREF(Py_Ellipsis);
1027 : 14252 : retval = Py_Ellipsis;
1028 : 14252 : break;
1029 : :
1030 : 656284 : case TYPE_FALSE:
1031 : 656284 : Py_INCREF(Py_False);
1032 : 656284 : retval = Py_False;
1033 : 656284 : break;
1034 : :
1035 : 674895 : case TYPE_TRUE:
1036 : 674895 : Py_INCREF(Py_True);
1037 : 674895 : retval = Py_True;
1038 : 674895 : break;
1039 : :
1040 : 1915118 : case TYPE_INT:
1041 : 1915118 : n = r_long(p);
1042 [ + + ]: 1915118 : retval = PyErr_Occurred() ? NULL : PyLong_FromLong(n);
1043 [ + + ]: 1915118 : R_REF(retval);
1044 : 1915118 : break;
1045 : :
1046 : 260 : case TYPE_INT64:
1047 : 260 : retval = r_long64(p);
1048 [ + + ]: 260 : R_REF(retval);
1049 : 260 : break;
1050 : :
1051 : 19912 : case TYPE_LONG:
1052 : 19912 : retval = r_PyLong(p);
1053 [ + + ]: 19912 : R_REF(retval);
1054 : 19912 : break;
1055 : :
1056 : 436 : case TYPE_FLOAT:
1057 : : {
1058 : 436 : double x = r_float_str(p);
1059 [ + + + - ]: 436 : if (x == -1.0 && PyErr_Occurred())
1060 : 3 : break;
1061 : 433 : retval = PyFloat_FromDouble(x);
1062 [ - + ]: 433 : R_REF(retval);
1063 : 433 : break;
1064 : : }
1065 : :
1066 : 101522 : case TYPE_BINARY_FLOAT:
1067 : : {
1068 : 101522 : double x = r_float_bin(p);
1069 [ + + + + ]: 101522 : if (x == -1.0 && PyErr_Occurred())
1070 : 3 : break;
1071 : 101519 : retval = PyFloat_FromDouble(x);
1072 [ + + ]: 101519 : R_REF(retval);
1073 : 101519 : break;
1074 : : }
1075 : :
1076 : 16 : case TYPE_COMPLEX:
1077 : : {
1078 : : Py_complex c;
1079 : 16 : c.real = r_float_str(p);
1080 [ + + + - ]: 16 : if (c.real == -1.0 && PyErr_Occurred())
1081 : 2 : break;
1082 : 14 : c.imag = r_float_str(p);
1083 [ - + - - ]: 14 : if (c.imag == -1.0 && PyErr_Occurred())
1084 : 0 : break;
1085 : 14 : retval = PyComplex_FromCComplex(c);
1086 [ - + ]: 14 : R_REF(retval);
1087 : 14 : break;
1088 : : }
1089 : :
1090 : 575 : case TYPE_BINARY_COMPLEX:
1091 : : {
1092 : : Py_complex c;
1093 : 575 : c.real = r_float_bin(p);
1094 [ + + + + ]: 575 : if (c.real == -1.0 && PyErr_Occurred())
1095 : 3 : break;
1096 : 572 : c.imag = r_float_bin(p);
1097 [ + + - + ]: 572 : if (c.imag == -1.0 && PyErr_Occurred())
1098 : 0 : break;
1099 : 572 : retval = PyComplex_FromCComplex(c);
1100 [ + + ]: 572 : R_REF(retval);
1101 : 572 : break;
1102 : : }
1103 : :
1104 : 21090572 : case TYPE_STRING:
1105 : : {
1106 : : const char *ptr;
1107 : 21090572 : n = r_long(p);
1108 [ + + ]: 21090572 : if (PyErr_Occurred())
1109 : 2 : break;
1110 [ + - - + ]: 21090570 : if (n < 0 || n > SIZE32_MAX) {
1111 : 0 : PyErr_SetString(PyExc_ValueError, "bad marshal data (bytes object size out of range)");
1112 : 0 : break;
1113 : : }
1114 : 21090570 : v = PyBytes_FromStringAndSize((char *)NULL, n);
1115 [ - + ]: 21090570 : if (v == NULL)
1116 : 0 : break;
1117 : 21090570 : ptr = r_string(n, p);
1118 [ + + ]: 21090570 : if (ptr == NULL) {
1119 : 1 : Py_DECREF(v);
1120 : 1 : break;
1121 : : }
1122 : 21090569 : memcpy(PyBytes_AS_STRING(v), ptr, n);
1123 : 21090569 : retval = v;
1124 [ + + ]: 21090569 : R_REF(retval);
1125 : 21090569 : break;
1126 : : }
1127 : :
1128 : 28 : case TYPE_ASCII_INTERNED:
1129 : 28 : is_interned = 1;
1130 : : /* fall through */
1131 : 723721 : case TYPE_ASCII:
1132 : 723721 : n = r_long(p);
1133 [ + + ]: 723721 : if (PyErr_Occurred())
1134 : 4 : break;
1135 [ + - - + ]: 723717 : if (n < 0 || n > SIZE32_MAX) {
1136 : 0 : PyErr_SetString(PyExc_ValueError, "bad marshal data (string size out of range)");
1137 : 0 : break;
1138 : : }
1139 : 723717 : goto _read_ascii;
1140 : :
1141 : 31596493 : case TYPE_SHORT_ASCII_INTERNED:
1142 : 31596493 : is_interned = 1;
1143 : : /* fall through */
1144 : 44164676 : case TYPE_SHORT_ASCII:
1145 : 44164676 : n = r_byte(p);
1146 [ + + ]: 44164676 : if (n == EOF) {
1147 : 6 : PyErr_SetString(PyExc_EOFError,
1148 : : "EOF read where object expected");
1149 : 6 : break;
1150 : : }
1151 : 44164670 : _read_ascii:
1152 : : {
1153 : : const char *ptr;
1154 : 44888387 : ptr = r_string(n, p);
1155 [ + + ]: 44888387 : if (ptr == NULL)
1156 : 11 : break;
1157 : 44888376 : v = PyUnicode_FromKindAndData(PyUnicode_1BYTE_KIND, ptr, n);
1158 [ - + ]: 44888376 : if (v == NULL)
1159 : 0 : break;
1160 [ + + ]: 44888376 : if (is_interned)
1161 : 31596504 : PyUnicode_InternInPlace(&v);
1162 : 44888376 : retval = v;
1163 [ + + ]: 44888376 : R_REF(retval);
1164 : 44888376 : break;
1165 : : }
1166 : :
1167 : 666 : case TYPE_INTERNED:
1168 : 666 : is_interned = 1;
1169 : : /* fall through */
1170 : 129557 : case TYPE_UNICODE:
1171 : : {
1172 : : const char *buffer;
1173 : :
1174 : 129557 : n = r_long(p);
1175 [ + + ]: 129557 : if (PyErr_Occurred())
1176 : 4 : break;
1177 [ + - - + ]: 129553 : if (n < 0 || n > SIZE32_MAX) {
1178 : 0 : PyErr_SetString(PyExc_ValueError, "bad marshal data (string size out of range)");
1179 : 0 : break;
1180 : : }
1181 [ + + ]: 129553 : if (n != 0) {
1182 : 129541 : buffer = r_string(n, p);
1183 [ - + ]: 129541 : if (buffer == NULL)
1184 : 0 : break;
1185 : 129541 : v = PyUnicode_DecodeUTF8(buffer, n, "surrogatepass");
1186 : : }
1187 : : else {
1188 : 12 : v = PyUnicode_New(0, 0);
1189 : : }
1190 [ - + ]: 129553 : if (v == NULL)
1191 : 0 : break;
1192 [ + + ]: 129553 : if (is_interned)
1193 : 664 : PyUnicode_InternInPlace(&v);
1194 : 129553 : retval = v;
1195 [ + + ]: 129553 : R_REF(retval);
1196 : 129553 : break;
1197 : : }
1198 : :
1199 : 17233497 : case TYPE_SMALL_TUPLE:
1200 : 17233497 : n = (unsigned char) r_byte(p);
1201 [ - + ]: 17233497 : if (PyErr_Occurred())
1202 : 0 : break;
1203 : 17233497 : goto _read_tuple;
1204 : 22156 : case TYPE_TUPLE:
1205 : 22156 : n = r_long(p);
1206 [ + + ]: 22156 : if (PyErr_Occurred())
1207 : 10 : break;
1208 [ + - - + ]: 22146 : if (n < 0 || n > SIZE32_MAX) {
1209 : 0 : PyErr_SetString(PyExc_ValueError, "bad marshal data (tuple size out of range)");
1210 : 0 : break;
1211 : : }
1212 : 22146 : _read_tuple:
1213 : 17255643 : v = PyTuple_New(n);
1214 [ + + ]: 17255643 : R_REF(v);
1215 [ - + ]: 17255643 : if (v == NULL)
1216 : 0 : break;
1217 : :
1218 [ + + ]: 124089735 : for (i = 0; i < n; i++) {
1219 : 106838112 : v2 = r_object(p);
1220 [ + + ]: 106838112 : if ( v2 == NULL ) {
1221 [ - + ]: 4020 : if (!PyErr_Occurred())
1222 : 0 : PyErr_SetString(PyExc_TypeError,
1223 : : "NULL object in marshal data for tuple");
1224 : 4020 : Py_DECREF(v);
1225 : 4020 : v = NULL;
1226 : 4020 : break;
1227 : : }
1228 : 106834092 : PyTuple_SET_ITEM(v, i, v2);
1229 : : }
1230 : 17255643 : retval = v;
1231 : 17255643 : break;
1232 : :
1233 : 4141 : case TYPE_LIST:
1234 : 4141 : n = r_long(p);
1235 [ + + ]: 4141 : if (PyErr_Occurred())
1236 : 2 : break;
1237 [ + - - + ]: 4139 : if (n < 0 || n > SIZE32_MAX) {
1238 : 0 : PyErr_SetString(PyExc_ValueError, "bad marshal data (list size out of range)");
1239 : 0 : break;
1240 : : }
1241 : 4139 : v = PyList_New(n);
1242 [ + + ]: 4139 : R_REF(v);
1243 [ - + ]: 4139 : if (v == NULL)
1244 : 0 : break;
1245 [ + + ]: 8325 : for (i = 0; i < n; i++) {
1246 : 6186 : v2 = r_object(p);
1247 [ + + ]: 6186 : if ( v2 == NULL ) {
1248 [ - + ]: 2000 : if (!PyErr_Occurred())
1249 : 0 : PyErr_SetString(PyExc_TypeError,
1250 : : "NULL object in marshal data for list");
1251 : 2000 : Py_DECREF(v);
1252 : 2000 : v = NULL;
1253 : 2000 : break;
1254 : : }
1255 : 4186 : PyList_SET_ITEM(v, i, v2);
1256 : : }
1257 : 4139 : retval = v;
1258 : 4139 : break;
1259 : :
1260 : 4184 : case TYPE_DICT:
1261 : 4184 : v = PyDict_New();
1262 [ + + ]: 4184 : R_REF(v);
1263 [ + - ]: 4184 : if (v == NULL)
1264 : 0 : break;
1265 : 5502 : for (;;) {
1266 : : PyObject *key, *val;
1267 : 9686 : key = r_object(p);
1268 [ + + ]: 9686 : if (key == NULL)
1269 : 2185 : break;
1270 : 7501 : val = r_object(p);
1271 [ + + ]: 7501 : if (val == NULL) {
1272 : 1999 : Py_DECREF(key);
1273 : 1999 : break;
1274 : : }
1275 [ - + ]: 5502 : if (PyDict_SetItem(v, key, val) < 0) {
1276 : 0 : Py_DECREF(key);
1277 : 0 : Py_DECREF(val);
1278 : 0 : break;
1279 : : }
1280 : 5502 : Py_DECREF(key);
1281 : 5502 : Py_DECREF(val);
1282 : : }
1283 [ + + ]: 4184 : if (PyErr_Occurred()) {
1284 : 2002 : Py_DECREF(v);
1285 : 2002 : v = NULL;
1286 : : }
1287 : 4184 : retval = v;
1288 : 4184 : break;
1289 : :
1290 : 30112 : case TYPE_SET:
1291 : : case TYPE_FROZENSET:
1292 : 30112 : n = r_long(p);
1293 [ + + ]: 30112 : if (PyErr_Occurred())
1294 : 8 : break;
1295 [ + - - + ]: 30104 : if (n < 0 || n > SIZE32_MAX) {
1296 : 0 : PyErr_SetString(PyExc_ValueError, "bad marshal data (set size out of range)");
1297 : 0 : break;
1298 : : }
1299 : :
1300 [ - + - - ]: 30104 : if (n == 0 && type == TYPE_FROZENSET) {
1301 : : /* call frozenset() to get the empty frozenset singleton */
1302 : 0 : v = _PyObject_CallNoArgs((PyObject*)&PyFrozenSet_Type);
1303 [ # # ]: 0 : if (v == NULL)
1304 : 0 : break;
1305 [ # # ]: 0 : R_REF(v);
1306 : 0 : retval = v;
1307 : : }
1308 : : else {
1309 [ + + ]: 30104 : v = (type == TYPE_SET) ? PySet_New(NULL) : PyFrozenSet_New(NULL);
1310 [ + + ]: 30104 : if (type == TYPE_SET) {
1311 [ + + ]: 36 : R_REF(v);
1312 : : } else {
1313 : : /* must use delayed registration of frozensets because they must
1314 : : * be init with a refcount of 1
1315 : : */
1316 : 30068 : idx = r_ref_reserve(flag, p);
1317 [ - + ]: 30068 : if (idx < 0)
1318 [ # # ]: 0 : Py_CLEAR(v); /* signal error */
1319 : : }
1320 [ - + ]: 30104 : if (v == NULL)
1321 : 0 : break;
1322 : :
1323 [ + + ]: 127003 : for (i = 0; i < n; i++) {
1324 : 98903 : v2 = r_object(p);
1325 [ + + ]: 98903 : if ( v2 == NULL ) {
1326 [ - + ]: 2004 : if (!PyErr_Occurred())
1327 : 0 : PyErr_SetString(PyExc_TypeError,
1328 : : "NULL object in marshal data for set");
1329 : 2004 : Py_DECREF(v);
1330 : 2004 : v = NULL;
1331 : 2004 : break;
1332 : : }
1333 [ - + ]: 96899 : if (PySet_Add(v, v2) == -1) {
1334 : 0 : Py_DECREF(v);
1335 : 0 : Py_DECREF(v2);
1336 : 0 : v = NULL;
1337 : 0 : break;
1338 : : }
1339 : 96899 : Py_DECREF(v2);
1340 : : }
1341 [ + + ]: 30104 : if (type != TYPE_SET)
1342 : 30068 : v = r_ref_insert(v, idx, flag, p);
1343 : 30104 : retval = v;
1344 : : }
1345 : 30104 : break;
1346 : :
1347 : 7045291 : case TYPE_CODE:
1348 : : {
1349 : : int argcount;
1350 : : int posonlyargcount;
1351 : : int kwonlyargcount;
1352 : : int stacksize;
1353 : : int flags;
1354 : 7045291 : PyObject *code = NULL;
1355 : 7045291 : PyObject *consts = NULL;
1356 : 7045291 : PyObject *names = NULL;
1357 : 7045291 : PyObject *localsplusnames = NULL;
1358 : 7045291 : PyObject *localspluskinds = NULL;
1359 : 7045291 : PyObject *filename = NULL;
1360 : 7045291 : PyObject *name = NULL;
1361 : 7045291 : PyObject *qualname = NULL;
1362 : : int firstlineno;
1363 : 7045291 : PyObject* linetable = NULL;
1364 : 7045291 : PyObject *exceptiontable = NULL;
1365 : :
1366 : 7045291 : idx = r_ref_reserve(flag, p);
1367 [ - + ]: 7045291 : if (idx < 0)
1368 : 0 : break;
1369 : :
1370 : 7045291 : v = NULL;
1371 : :
1372 : : /* XXX ignore long->int overflows for now */
1373 : 7045291 : argcount = (int)r_long(p);
1374 [ + + ]: 7045291 : if (PyErr_Occurred())
1375 : 2 : goto code_error;
1376 : 7045289 : posonlyargcount = (int)r_long(p);
1377 [ - + ]: 7045289 : if (PyErr_Occurred()) {
1378 : 0 : goto code_error;
1379 : : }
1380 : 7045289 : kwonlyargcount = (int)r_long(p);
1381 [ - + ]: 7045289 : if (PyErr_Occurred())
1382 : 0 : goto code_error;
1383 : 7045289 : stacksize = (int)r_long(p);
1384 [ - + ]: 7045289 : if (PyErr_Occurred())
1385 : 0 : goto code_error;
1386 : 7045289 : flags = (int)r_long(p);
1387 [ - + ]: 7045289 : if (PyErr_Occurred())
1388 : 0 : goto code_error;
1389 : 7045289 : code = r_object(p);
1390 [ - + ]: 7045289 : if (code == NULL)
1391 : 0 : goto code_error;
1392 : 7045289 : consts = r_object(p);
1393 [ - + ]: 7045289 : if (consts == NULL)
1394 : 0 : goto code_error;
1395 : 7045289 : names = r_object(p);
1396 [ - + ]: 7045289 : if (names == NULL)
1397 : 0 : goto code_error;
1398 : 7045289 : localsplusnames = r_object(p);
1399 [ - + ]: 7045289 : if (localsplusnames == NULL)
1400 : 0 : goto code_error;
1401 : 7045289 : localspluskinds = r_object(p);
1402 [ - + ]: 7045289 : if (localspluskinds == NULL)
1403 : 0 : goto code_error;
1404 : 7045289 : filename = r_object(p);
1405 [ - + ]: 7045289 : if (filename == NULL)
1406 : 0 : goto code_error;
1407 : 7045289 : name = r_object(p);
1408 [ - + ]: 7045289 : if (name == NULL)
1409 : 0 : goto code_error;
1410 : 7045289 : qualname = r_object(p);
1411 [ - + ]: 7045289 : if (qualname == NULL)
1412 : 0 : goto code_error;
1413 : 7045289 : firstlineno = (int)r_long(p);
1414 [ - + - - ]: 7045289 : if (firstlineno == -1 && PyErr_Occurred())
1415 : 0 : break;
1416 : 7045289 : linetable = r_object(p);
1417 [ - + ]: 7045289 : if (linetable == NULL)
1418 : 0 : goto code_error;
1419 : 7045289 : exceptiontable = r_object(p);
1420 [ - + ]: 7045289 : if (exceptiontable == NULL)
1421 : 0 : goto code_error;
1422 : :
1423 : 7045289 : struct _PyCodeConstructor con = {
1424 : : .filename = filename,
1425 : : .name = name,
1426 : : .qualname = qualname,
1427 : : .flags = flags,
1428 : :
1429 : : .code = code,
1430 : : .firstlineno = firstlineno,
1431 : : .linetable = linetable,
1432 : :
1433 : : .consts = consts,
1434 : : .names = names,
1435 : :
1436 : : .localsplusnames = localsplusnames,
1437 : : .localspluskinds = localspluskinds,
1438 : :
1439 : : .argcount = argcount,
1440 : : .posonlyargcount = posonlyargcount,
1441 : : .kwonlyargcount = kwonlyargcount,
1442 : :
1443 : : .stacksize = stacksize,
1444 : :
1445 : : .exceptiontable = exceptiontable,
1446 : : };
1447 : :
1448 [ - + ]: 7045289 : if (_PyCode_Validate(&con) < 0) {
1449 : 0 : goto code_error;
1450 : : }
1451 : :
1452 : 7045289 : v = (PyObject *)_PyCode_New(&con);
1453 [ - + ]: 7045289 : if (v == NULL) {
1454 : 0 : goto code_error;
1455 : : }
1456 : :
1457 : 7045289 : v = r_ref_insert(v, idx, flag, p);
1458 : :
1459 : 7045291 : code_error:
1460 : 7045291 : Py_XDECREF(code);
1461 : 7045291 : Py_XDECREF(consts);
1462 : 7045291 : Py_XDECREF(names);
1463 : 7045291 : Py_XDECREF(localsplusnames);
1464 : 7045291 : Py_XDECREF(localspluskinds);
1465 : 7045291 : Py_XDECREF(filename);
1466 : 7045291 : Py_XDECREF(name);
1467 : 7045291 : Py_XDECREF(qualname);
1468 : 7045291 : Py_XDECREF(linetable);
1469 : 7045291 : Py_XDECREF(exceptiontable);
1470 : : }
1471 : 7045291 : retval = v;
1472 : 7045291 : break;
1473 : :
1474 : 79429481 : case TYPE_REF:
1475 : 79429481 : n = r_long(p);
1476 [ + + - + ]: 79429481 : if (n < 0 || n >= PyList_GET_SIZE(p->refs)) {
1477 [ + - + - ]: 2 : if (n == -1 && PyErr_Occurred())
1478 : 2 : break;
1479 : 0 : PyErr_SetString(PyExc_ValueError, "bad marshal data (invalid reference)");
1480 : 0 : break;
1481 : : }
1482 : 79429479 : v = PyList_GET_ITEM(p->refs, n);
1483 [ - + ]: 79429479 : if (v == Py_None) {
1484 : 0 : PyErr_SetString(PyExc_ValueError, "bad marshal data (invalid reference)");
1485 : 0 : break;
1486 : : }
1487 : 79429479 : Py_INCREF(v);
1488 : 79429479 : retval = v;
1489 : 79429479 : break;
1490 : :
1491 : 200 : default:
1492 : : /* Bogus data got written, which isn't ideal.
1493 : : This will let you keep working and recover. */
1494 : 200 : PyErr_SetString(PyExc_ValueError, "bad marshal data (unknown type code)");
1495 : 200 : break;
1496 : :
1497 : : }
1498 : 177582628 : p->depth--;
1499 : 177582628 : return retval;
1500 : : }
1501 : :
1502 : : static PyObject *
1503 : 169375 : read_object(RFILE *p)
1504 : : {
1505 : : PyObject *v;
1506 [ - + ]: 169375 : if (PyErr_Occurred()) {
1507 : 0 : fprintf(stderr, "XXX readobject called with exception set\n");
1508 : 0 : return NULL;
1509 : : }
1510 [ + + + - ]: 169375 : if (p->ptr && p->end) {
1511 [ - + ]: 168337 : if (PySys_Audit("marshal.loads", "y#", p->ptr, (Py_ssize_t)(p->end - p->ptr)) < 0) {
1512 : 0 : return NULL;
1513 : : }
1514 [ + + + - ]: 1038 : } else if (p->fp || p->readable) {
1515 [ - + ]: 1038 : if (PySys_Audit("marshal.load", NULL) < 0) {
1516 : 0 : return NULL;
1517 : : }
1518 : : }
1519 : 169375 : v = r_object(p);
1520 [ + + + + ]: 169375 : if (v == NULL && !PyErr_Occurred())
1521 : 3 : PyErr_SetString(PyExc_TypeError, "NULL object in marshal data for object");
1522 : 169375 : return v;
1523 : : }
1524 : :
1525 : : int
1526 : 2 : PyMarshal_ReadShortFromFile(FILE *fp)
1527 : : {
1528 : : RFILE rf;
1529 : : int res;
1530 : : assert(fp);
1531 : 2 : rf.readable = NULL;
1532 : 2 : rf.fp = fp;
1533 : 2 : rf.end = rf.ptr = NULL;
1534 : 2 : rf.buf = NULL;
1535 : 2 : res = r_short(&rf);
1536 [ + - ]: 2 : if (rf.buf != NULL)
1537 : 2 : PyMem_Free(rf.buf);
1538 : 2 : return res;
1539 : : }
1540 : :
1541 : : long
1542 : 114 : PyMarshal_ReadLongFromFile(FILE *fp)
1543 : : {
1544 : : RFILE rf;
1545 : : long res;
1546 : 114 : rf.fp = fp;
1547 : 114 : rf.readable = NULL;
1548 : 114 : rf.ptr = rf.end = NULL;
1549 : 114 : rf.buf = NULL;
1550 : 114 : res = r_long(&rf);
1551 [ + - ]: 114 : if (rf.buf != NULL)
1552 : 114 : PyMem_Free(rf.buf);
1553 : 114 : return res;
1554 : : }
1555 : :
1556 : : /* Return size of file in bytes; < 0 if unknown or INT_MAX if too big */
1557 : : static off_t
1558 : 38 : getfilesize(FILE *fp)
1559 : : {
1560 : : struct _Py_stat_struct st;
1561 [ - + ]: 38 : if (_Py_fstat_noraise(fileno(fp), &st) != 0)
1562 : 0 : return -1;
1563 : : #if SIZEOF_OFF_T == 4
1564 : : else if (st.st_size >= INT_MAX)
1565 : : return (off_t)INT_MAX;
1566 : : #endif
1567 : : else
1568 : 38 : return (off_t)st.st_size;
1569 : : }
1570 : :
1571 : : /* If we can get the size of the file up-front, and it's reasonably small,
1572 : : * read it in one gulp and delegate to ...FromString() instead. Much quicker
1573 : : * than reading a byte at a time from file; speeds .pyc imports.
1574 : : * CAUTION: since this may read the entire remainder of the file, don't
1575 : : * call it unless you know you're done with the file.
1576 : : */
1577 : : PyObject *
1578 : 38 : PyMarshal_ReadLastObjectFromFile(FILE *fp)
1579 : : {
1580 : : /* REASONABLE_FILE_LIMIT is by defn something big enough for Tkinter.pyc. */
1581 : : #define REASONABLE_FILE_LIMIT (1L << 18)
1582 : : off_t filesize;
1583 : 38 : filesize = getfilesize(fp);
1584 [ + - + - ]: 38 : if (filesize > 0 && filesize <= REASONABLE_FILE_LIMIT) {
1585 : 38 : char* pBuf = (char *)PyMem_Malloc(filesize);
1586 [ + - ]: 38 : if (pBuf != NULL) {
1587 : 38 : size_t n = fread(pBuf, 1, (size_t)filesize, fp);
1588 : 38 : PyObject* v = PyMarshal_ReadObjectFromString(pBuf, n);
1589 : 38 : PyMem_Free(pBuf);
1590 : 38 : return v;
1591 : : }
1592 : :
1593 : : }
1594 : : /* We don't have fstat, or we do but the file is larger than
1595 : : * REASONABLE_FILE_LIMIT or malloc failed -- read a byte at a time.
1596 : : */
1597 : 0 : return PyMarshal_ReadObjectFromFile(fp);
1598 : :
1599 : : #undef REASONABLE_FILE_LIMIT
1600 : : }
1601 : :
1602 : : PyObject *
1603 : 10 : PyMarshal_ReadObjectFromFile(FILE *fp)
1604 : : {
1605 : : RFILE rf;
1606 : : PyObject *result;
1607 : 10 : rf.fp = fp;
1608 : 10 : rf.readable = NULL;
1609 : 10 : rf.depth = 0;
1610 : 10 : rf.ptr = rf.end = NULL;
1611 : 10 : rf.buf = NULL;
1612 : 10 : rf.refs = PyList_New(0);
1613 [ - + ]: 10 : if (rf.refs == NULL)
1614 : 0 : return NULL;
1615 : 10 : result = read_object(&rf);
1616 : 10 : Py_DECREF(rf.refs);
1617 [ + + ]: 10 : if (rf.buf != NULL)
1618 : 9 : PyMem_Free(rf.buf);
1619 : 10 : return result;
1620 : : }
1621 : :
1622 : : PyObject *
1623 : 3257 : PyMarshal_ReadObjectFromString(const char *str, Py_ssize_t len)
1624 : : {
1625 : : RFILE rf;
1626 : : PyObject *result;
1627 : 3257 : rf.fp = NULL;
1628 : 3257 : rf.readable = NULL;
1629 : 3257 : rf.ptr = str;
1630 : 3257 : rf.end = str + len;
1631 : 3257 : rf.buf = NULL;
1632 : 3257 : rf.depth = 0;
1633 : 3257 : rf.refs = PyList_New(0);
1634 [ - + ]: 3257 : if (rf.refs == NULL)
1635 : 0 : return NULL;
1636 : 3257 : result = read_object(&rf);
1637 : 3257 : Py_DECREF(rf.refs);
1638 [ - + ]: 3257 : if (rf.buf != NULL)
1639 : 0 : PyMem_Free(rf.buf);
1640 : 3257 : return result;
1641 : : }
1642 : :
1643 : : PyObject *
1644 : 15534 : PyMarshal_WriteObjectToString(PyObject *x, int version)
1645 : : {
1646 : : WFILE wf;
1647 : :
1648 [ - + ]: 15534 : if (PySys_Audit("marshal.dumps", "Oi", x, version) < 0) {
1649 : 0 : return NULL;
1650 : : }
1651 : 15534 : memset(&wf, 0, sizeof(wf));
1652 : 15534 : wf.str = PyBytes_FromStringAndSize((char *)NULL, 50);
1653 [ - + ]: 15534 : if (wf.str == NULL)
1654 : 0 : return NULL;
1655 : 15534 : wf.ptr = wf.buf = PyBytes_AS_STRING(wf.str);
1656 : 15534 : wf.end = wf.ptr + PyBytes_GET_SIZE(wf.str);
1657 : 15534 : wf.error = WFERR_OK;
1658 : 15534 : wf.version = version;
1659 [ - + ]: 15534 : if (w_init_refs(&wf, version)) {
1660 : 0 : Py_DECREF(wf.str);
1661 : 0 : return NULL;
1662 : : }
1663 : 15534 : w_object(x, &wf);
1664 : 15534 : w_clear_refs(&wf);
1665 [ + - ]: 15534 : if (wf.str != NULL) {
1666 : 15534 : const char *base = PyBytes_AS_STRING(wf.str);
1667 [ - + ]: 15534 : if (_PyBytes_Resize(&wf.str, (Py_ssize_t)(wf.ptr - base)) < 0)
1668 : 0 : return NULL;
1669 : : }
1670 [ + + ]: 15534 : if (wf.error != WFERR_OK) {
1671 : 9 : Py_XDECREF(wf.str);
1672 [ - + ]: 9 : if (wf.error == WFERR_NOMEMORY)
1673 : : PyErr_NoMemory();
1674 : : else
1675 : 9 : PyErr_SetString(PyExc_ValueError,
1676 [ + + ]: 9 : (wf.error==WFERR_UNMARSHALLABLE)?"unmarshallable object"
1677 : : :"object too deeply nested to marshal");
1678 : 9 : return NULL;
1679 : : }
1680 : 15525 : return wf.str;
1681 : : }
1682 : :
1683 : : /* And an interface for Python programs... */
1684 : : /*[clinic input]
1685 : : marshal.dump
1686 : :
1687 : : value: object
1688 : : Must be a supported type.
1689 : : file: object
1690 : : Must be a writeable binary file.
1691 : : version: int(c_default="Py_MARSHAL_VERSION") = version
1692 : : Indicates the data format that dump should use.
1693 : : /
1694 : :
1695 : : Write the value on the open file.
1696 : :
1697 : : If the value has (or contains an object that has) an unsupported type, a
1698 : : ValueError exception is raised - but garbage data will also be written
1699 : : to the file. The object will not be properly read back by load().
1700 : : [clinic start generated code]*/
1701 : :
1702 : : static PyObject *
1703 : 1003 : marshal_dump_impl(PyObject *module, PyObject *value, PyObject *file,
1704 : : int version)
1705 : : /*[clinic end generated code: output=aaee62c7028a7cb2 input=6c7a3c23c6fef556]*/
1706 : : {
1707 : : /* XXX Quick hack -- need to do this differently */
1708 : : PyObject *s;
1709 : : PyObject *res;
1710 : :
1711 : 1003 : s = PyMarshal_WriteObjectToString(value, version);
1712 [ - + ]: 1003 : if (s == NULL)
1713 : 0 : return NULL;
1714 : 1003 : res = _PyObject_CallMethodOneArg(file, &_Py_ID(write), s);
1715 : 1003 : Py_DECREF(s);
1716 : 1003 : return res;
1717 : : }
1718 : :
1719 : : /*[clinic input]
1720 : : marshal.load
1721 : :
1722 : : file: object
1723 : : Must be readable binary file.
1724 : : /
1725 : :
1726 : : Read one value from the open file and return it.
1727 : :
1728 : : If no valid value is read (e.g. because the data has a different Python
1729 : : version's incompatible marshal format), raise EOFError, ValueError or
1730 : : TypeError.
1731 : :
1732 : : Note: If an object containing an unsupported type was marshalled with
1733 : : dump(), load() will substitute None for the unmarshallable type.
1734 : : [clinic start generated code]*/
1735 : :
1736 : : static PyObject *
1737 : 1028 : marshal_load(PyObject *module, PyObject *file)
1738 : : /*[clinic end generated code: output=f8e5c33233566344 input=c85c2b594cd8124a]*/
1739 : : {
1740 : : PyObject *data, *result;
1741 : : RFILE rf;
1742 : :
1743 : : /*
1744 : : * Make a call to the read method, but read zero bytes.
1745 : : * This is to ensure that the object passed in at least
1746 : : * has a read method which returns bytes.
1747 : : * This can be removed if we guarantee good error handling
1748 : : * for r_string()
1749 : : */
1750 : 1028 : data = _PyObject_CallMethod(file, &_Py_ID(read), "i", 0);
1751 [ - + ]: 1028 : if (data == NULL)
1752 : 0 : return NULL;
1753 [ - + ]: 1028 : if (!PyBytes_Check(data)) {
1754 : 0 : PyErr_Format(PyExc_TypeError,
1755 : : "file.read() returned not bytes but %.100s",
1756 : 0 : Py_TYPE(data)->tp_name);
1757 : 0 : result = NULL;
1758 : : }
1759 : : else {
1760 : 1028 : rf.depth = 0;
1761 : 1028 : rf.fp = NULL;
1762 : 1028 : rf.readable = file;
1763 : 1028 : rf.ptr = rf.end = NULL;
1764 : 1028 : rf.buf = NULL;
1765 [ + - ]: 1028 : if ((rf.refs = PyList_New(0)) != NULL) {
1766 : 1028 : result = read_object(&rf);
1767 : 1028 : Py_DECREF(rf.refs);
1768 [ + - ]: 1028 : if (rf.buf != NULL)
1769 : 1028 : PyMem_Free(rf.buf);
1770 : : } else
1771 : 0 : result = NULL;
1772 : : }
1773 : 1028 : Py_DECREF(data);
1774 : 1028 : return result;
1775 : : }
1776 : :
1777 : : /*[clinic input]
1778 : : marshal.dumps
1779 : :
1780 : : value: object
1781 : : Must be a supported type.
1782 : : version: int(c_default="Py_MARSHAL_VERSION") = version
1783 : : Indicates the data format that dumps should use.
1784 : : /
1785 : :
1786 : : Return the bytes object that would be written to a file by dump(value, file).
1787 : :
1788 : : Raise a ValueError exception if value has (or contains an object that has) an
1789 : : unsupported type.
1790 : : [clinic start generated code]*/
1791 : :
1792 : : static PyObject *
1793 : 8660 : marshal_dumps_impl(PyObject *module, PyObject *value, int version)
1794 : : /*[clinic end generated code: output=9c200f98d7256cad input=a2139ea8608e9b27]*/
1795 : : {
1796 : 8660 : return PyMarshal_WriteObjectToString(value, version);
1797 : : }
1798 : :
1799 : : /*[clinic input]
1800 : : marshal.loads
1801 : :
1802 : : bytes: Py_buffer
1803 : : /
1804 : :
1805 : : Convert the bytes-like object to a value.
1806 : :
1807 : : If no valid value is found, raise EOFError, ValueError or TypeError. Extra
1808 : : bytes in the input are ignored.
1809 : : [clinic start generated code]*/
1810 : :
1811 : : static PyObject *
1812 : 165080 : marshal_loads_impl(PyObject *module, Py_buffer *bytes)
1813 : : /*[clinic end generated code: output=9fc65985c93d1bb1 input=6f426518459c8495]*/
1814 : : {
1815 : : RFILE rf;
1816 : 165080 : char *s = bytes->buf;
1817 : 165080 : Py_ssize_t n = bytes->len;
1818 : : PyObject* result;
1819 : 165080 : rf.fp = NULL;
1820 : 165080 : rf.readable = NULL;
1821 : 165080 : rf.ptr = s;
1822 : 165080 : rf.end = s + n;
1823 : 165080 : rf.depth = 0;
1824 [ - + ]: 165080 : if ((rf.refs = PyList_New(0)) == NULL)
1825 : 0 : return NULL;
1826 : 165080 : result = read_object(&rf);
1827 : 165080 : Py_DECREF(rf.refs);
1828 : 165080 : return result;
1829 : : }
1830 : :
1831 : : static PyMethodDef marshal_methods[] = {
1832 : : MARSHAL_DUMP_METHODDEF
1833 : : MARSHAL_LOAD_METHODDEF
1834 : : MARSHAL_DUMPS_METHODDEF
1835 : : MARSHAL_LOADS_METHODDEF
1836 : : {NULL, NULL} /* sentinel */
1837 : : };
1838 : :
1839 : :
1840 : : PyDoc_STRVAR(module_doc,
1841 : : "This module contains functions that can read and write Python values in\n\
1842 : : a binary format. The format is specific to Python, but independent of\n\
1843 : : machine architecture issues.\n\
1844 : : \n\
1845 : : Not all Python object types are supported; in general, only objects\n\
1846 : : whose value is independent from a particular invocation of Python can be\n\
1847 : : written and read by this module. The following types are supported:\n\
1848 : : None, integers, floating point numbers, strings, bytes, bytearrays,\n\
1849 : : tuples, lists, sets, dictionaries, and code objects, where it\n\
1850 : : should be understood that tuples, lists and dictionaries are only\n\
1851 : : supported as long as the values contained therein are themselves\n\
1852 : : supported; and recursive lists and dictionaries should not be written\n\
1853 : : (they will cause infinite loops).\n\
1854 : : \n\
1855 : : Variables:\n\
1856 : : \n\
1857 : : version -- indicates the format that the module uses. Version 0 is the\n\
1858 : : historical format, version 1 shares interned strings and version 2\n\
1859 : : uses a binary format for floating point numbers.\n\
1860 : : Version 3 shares common object references (New in version 3.4).\n\
1861 : : \n\
1862 : : Functions:\n\
1863 : : \n\
1864 : : dump() -- write value to a file\n\
1865 : : load() -- read value from a file\n\
1866 : : dumps() -- marshal value as a bytes object\n\
1867 : : loads() -- read value from a bytes-like object");
1868 : :
1869 : :
1870 : : static int
1871 : 3138 : marshal_module_exec(PyObject *mod)
1872 : : {
1873 [ - + ]: 3138 : if (PyModule_AddIntConstant(mod, "version", Py_MARSHAL_VERSION) < 0) {
1874 : 0 : return -1;
1875 : : }
1876 : 3138 : return 0;
1877 : : }
1878 : :
1879 : : static PyModuleDef_Slot marshalmodule_slots[] = {
1880 : : {Py_mod_exec, marshal_module_exec},
1881 : : {0, NULL}
1882 : : };
1883 : :
1884 : : static struct PyModuleDef marshalmodule = {
1885 : : PyModuleDef_HEAD_INIT,
1886 : : .m_name = "marshal",
1887 : : .m_doc = module_doc,
1888 : : .m_methods = marshal_methods,
1889 : : .m_slots = marshalmodule_slots,
1890 : : };
1891 : :
1892 : : PyMODINIT_FUNC
1893 : 3138 : PyMarshal_Init(void)
1894 : : {
1895 : 3138 : return PyModuleDef_Init(&marshalmodule);
1896 : : }
|
