Ruby 4.0.10p0 (2026-11-19 revision a704b7cd95a42cc0cf5f307137bf3aac0285b915)
marshal.c
1/**********************************************************************
2
3 marshal.c -
4
5 $Author$
6 created at: Thu Apr 27 16:30:01 JST 1995
7
8 Copyright (C) 1993-2007 Yukihiro Matsumoto
9
10**********************************************************************/
11
12#include "ruby/internal/config.h"
13
14#include <math.h>
15#ifdef HAVE_FLOAT_H
16#include <float.h>
17#endif
18#ifdef HAVE_IEEEFP_H
19#include <ieeefp.h>
20#endif
21
22#include "encindex.h"
23#include "id_table.h"
24#include "internal.h"
25#include "internal/array.h"
26#include "internal/bignum.h"
27#include "internal/class.h"
28#include "internal/encoding.h"
29#include "internal/error.h"
30#include "internal/hash.h"
31#include "internal/numeric.h"
32#include "internal/object.h"
33#include "internal/struct.h"
34#include "internal/symbol.h"
35#include "internal/util.h"
36#include "internal/vm.h"
37#include "ruby/io.h"
38#include "ruby/ruby.h"
39#include "ruby/st.h"
40#include "ruby/util.h"
41#include "builtin.h"
42#include "shape.h"
44
45#define BITSPERSHORT (2*CHAR_BIT)
46#define SHORTMASK ((1<<BITSPERSHORT)-1)
47#define SHORTDN(x) RSHIFT((x),BITSPERSHORT)
48
49#if SIZEOF_SHORT == SIZEOF_BDIGIT
50#define SHORTLEN(x) (x)
51#else
52static size_t
53shortlen(size_t len, BDIGIT *ds)
54{
55 BDIGIT num;
56 int offset = 0;
57
58 num = ds[len-1];
59 while (num) {
60 num = SHORTDN(num);
61 offset++;
62 }
63 return (len - 1)*SIZEOF_BDIGIT/2 + offset;
64}
65#define SHORTLEN(x) shortlen((x),d)
66#endif
67
68#define MARSHAL_MAJOR 4
69#define MARSHAL_MINOR 8
70
71#define TYPE_NIL '0'
72#define TYPE_TRUE 'T'
73#define TYPE_FALSE 'F'
74#define TYPE_FIXNUM 'i'
75
76#define TYPE_EXTENDED 'e'
77#define TYPE_UCLASS 'C'
78#define TYPE_OBJECT 'o'
79#define TYPE_DATA 'd'
80#define TYPE_USERDEF 'u'
81#define TYPE_USRMARSHAL 'U'
82#define TYPE_FLOAT 'f'
83#define TYPE_BIGNUM 'l'
84#define TYPE_STRING '"'
85#define TYPE_REGEXP '/'
86#define TYPE_ARRAY '['
87#define TYPE_HASH '{'
88#define TYPE_HASH_DEF '}'
89#define TYPE_STRUCT 'S'
90#define TYPE_MODULE_OLD 'M'
91#define TYPE_CLASS 'c'
92#define TYPE_MODULE 'm'
93
94#define TYPE_SYMBOL ':'
95#define TYPE_SYMLINK ';'
96
97#define TYPE_IVAR 'I'
98#define TYPE_LINK '@'
99
100static ID s_dump, s_load, s_mdump, s_mload;
101static ID s_dump_data, s_load_data, s_alloc, s_call;
102static ID s_getbyte, s_read, s_write, s_binmode;
103static ID s_encoding_short, s_ruby2_keywords_flag;
104#define s_encoding_long rb_id_encoding()
105
106#define name_s_dump "_dump"
107#define name_s_load "_load"
108#define name_s_mdump "marshal_dump"
109#define name_s_mload "marshal_load"
110#define name_s_dump_data "_dump_data"
111#define name_s_load_data "_load_data"
112#define name_s_alloc "_alloc"
113#define name_s_call "call"
114#define name_s_getbyte "getbyte"
115#define name_s_read "read"
116#define name_s_write "write"
117#define name_s_binmode "binmode"
118#define name_s_encoding_short "E"
119#define name_s_encoding_long "encoding"
120#define name_s_ruby2_keywords_flag "K"
121
122typedef struct {
123 VALUE newclass;
124 VALUE oldclass;
125 VALUE (*dumper)(VALUE);
126 VALUE (*loader)(VALUE, VALUE);
127} marshal_compat_t;
128
129static st_table *compat_allocator_tbl;
130static VALUE compat_allocator_tbl_wrapper;
131static VALUE rb_marshal_dump_limited(VALUE obj, VALUE port, int limit);
132static VALUE rb_marshal_load_with_proc(VALUE port, VALUE proc, bool freeze);
133
134static st_table *compat_allocator_table(void);
135
136void
137rb_marshal_define_compat(VALUE newclass, VALUE oldclass, VALUE (*dumper)(VALUE), VALUE (*loader)(VALUE, VALUE))
138{
139 marshal_compat_t *compat;
140 rb_alloc_func_t allocator = rb_get_alloc_func(newclass);
141
142 if (!allocator) {
143 rb_raise(rb_eTypeError, "no allocator");
144 }
145
146 compat_allocator_table();
147 compat = ALLOC(marshal_compat_t);
148 compat->newclass = newclass;
149 compat->oldclass = oldclass;
150 compat->dumper = dumper;
151 compat->loader = loader;
152
153 st_insert(compat_allocator_table(), (st_data_t)allocator, (st_data_t)compat);
154 RB_OBJ_WRITTEN(compat_allocator_tbl_wrapper, Qundef, newclass);
155 RB_OBJ_WRITTEN(compat_allocator_tbl_wrapper, Qundef, oldclass);
156}
157
158struct dump_arg {
159 VALUE str, dest;
160 st_table *symbols;
161 st_table *data;
162 st_table *compat_tbl;
163 st_table *encodings;
164 st_table *userdefs;
165 st_index_t num_entries;
166};
167
168struct dump_call_arg {
169 VALUE obj;
170 struct dump_arg *arg;
171 int limit;
172};
173
174static VALUE
175check_dump_arg(VALUE ret, struct dump_arg *arg, const char *name)
176{
177 if (!arg->symbols) {
178 rb_raise(rb_eRuntimeError, "Marshal.dump reentered at %s",
179 name);
180 }
181 return ret;
182}
183
184static VALUE
185check_userdump_arg(VALUE obj, ID sym, int argc, const VALUE *argv,
186 struct dump_arg *arg, const char *name)
187{
188 VALUE ret = rb_funcallv(obj, sym, argc, argv);
189 VALUE klass = CLASS_OF(obj);
190 if (CLASS_OF(ret) == klass) {
191 rb_raise(rb_eRuntimeError, "%"PRIsVALUE"#%s returned same class instance",
192 klass, name);
193 }
194 return check_dump_arg(ret, arg, name);
195}
196
197#define dump_funcall(arg, obj, sym, argc, argv) \
198 check_userdump_arg(obj, sym, argc, argv, arg, name_##sym)
199#define dump_check_funcall(arg, obj, sym, argc, argv) \
200 check_dump_arg(rb_check_funcall(obj, sym, argc, argv), arg, name_##sym)
201
202static void clear_dump_arg(struct dump_arg *arg);
203
204static void
205mark_dump_arg(void *ptr)
206{
207 struct dump_arg *p = ptr;
208 if (!p->symbols)
209 return;
210 rb_mark_set(p->symbols);
211 rb_mark_set(p->data);
212 rb_mark_hash(p->compat_tbl);
213 rb_mark_set(p->userdefs);
214 rb_gc_mark(p->str);
215}
216
217static void
218free_dump_arg(void *ptr)
219{
220 clear_dump_arg(ptr);
221}
222
223static size_t
224memsize_dump_arg(const void *ptr)
225{
226 const struct dump_arg *p = (struct dump_arg *)ptr;
227 size_t memsize = 0;
228 if (p->symbols) memsize += rb_st_memsize(p->symbols);
229 if (p->data) memsize += rb_st_memsize(p->data);
230 if (p->compat_tbl) memsize += rb_st_memsize(p->compat_tbl);
231 if (p->userdefs) memsize += rb_st_memsize(p->userdefs);
232 if (p->encodings) memsize += rb_st_memsize(p->encodings);
233 return memsize;
234}
235
236static const rb_data_type_t dump_arg_data = {
237 "dump_arg",
238 {mark_dump_arg, free_dump_arg, memsize_dump_arg,},
239 0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_EMBEDDABLE
240};
241
242static VALUE
243must_not_be_anonymous(const char *type, VALUE path)
244{
245 char *n = RSTRING_PTR(path);
246
247 if (!rb_enc_asciicompat(rb_enc_get(path))) {
248 /* cannot occur? */
249 rb_raise(rb_eTypeError, "can't dump non-ascii %s name % "PRIsVALUE,
250 type, path);
251 }
252 if (n[0] == '#') {
253 rb_raise(rb_eTypeError, "can't dump anonymous %s % "PRIsVALUE,
254 type, path);
255 }
256 return path;
257}
258
259static VALUE
260class2path(VALUE klass)
261{
262 VALUE path = rb_class_path(klass);
263
264 must_not_be_anonymous((RB_TYPE_P(klass, T_CLASS) ? "class" : "module"), path);
265 if (rb_path_to_class(path) != rb_class_real(klass)) {
266 rb_raise(rb_eTypeError, "% "PRIsVALUE" can't be referred to", path);
267 }
268 return path;
269}
270
271int ruby_marshal_write_long(long x, char *buf);
272static void w_long(long, struct dump_arg*);
273static int w_encoding(VALUE encname, struct dump_call_arg *arg);
274static VALUE encoding_name(VALUE obj, struct dump_arg *arg);
275
276static void
277w_nbyte(const char *s, long n, struct dump_arg *arg)
278{
279 VALUE buf = arg->str;
280 rb_str_buf_cat(buf, s, n);
281 if (arg->dest && RSTRING_LEN(buf) >= BUFSIZ) {
282 rb_io_write(arg->dest, buf);
283 rb_str_resize(buf, 0);
284 }
285}
286
287static void
288w_byte(char c, struct dump_arg *arg)
289{
290 w_nbyte(&c, 1, arg);
291}
292
293static void
294w_bytes(const char *s, long n, struct dump_arg *arg)
295{
296 w_long(n, arg);
297 w_nbyte(s, n, arg);
298}
299
300/* Like w_bytes, but for a Ruby String. Flushing the dump buffer in w_long
301 * can run arbitrary Ruby code through the destination IO's write method,
302 * which can modify the string, so re-validate it before using the pointer. */
303static void
304w_str_bytes(VALUE str, struct dump_arg *arg)
305{
306 long len = RSTRING_LEN(str);
307 const char *ptr = RSTRING_PTR(str);
308 w_long(len, arg);
309 if (RSTRING_PTR(str) != ptr || RSTRING_LEN(str) != len) {
310 rb_raise(rb_eRuntimeError, "string modified during dump");
311 }
312 w_nbyte(ptr, len, arg);
313}
314
315#define w_cstr(s, arg) w_bytes((s), strlen(s), (arg))
316
317static void
318w_short(int x, struct dump_arg *arg)
319{
320 w_byte((char)((x >> 0) & 0xff), arg);
321 w_byte((char)((x >> 8) & 0xff), arg);
322}
323
324static void
325w_long(long x, struct dump_arg *arg)
326{
327 char buf[sizeof(long)+1];
328 int i = ruby_marshal_write_long(x, buf);
329 if (i < 0) {
330 rb_raise(rb_eTypeError, "long too big to dump");
331 }
332 w_nbyte(buf, i, arg);
333}
334
335int
336ruby_marshal_write_long(long x, char *buf)
337{
338 int i;
339
340#if SIZEOF_LONG > 4
341 if (!(RSHIFT(x, 31) == 0 || RSHIFT(x, 31) == -1)) {
342 /* big long does not fit in 4 bytes */
343 return -1;
344 }
345#endif
346
347 if (x == 0) {
348 buf[0] = 0;
349 return 1;
350 }
351 if (0 < x && x < 123) {
352 buf[0] = (char)(x + 5);
353 return 1;
354 }
355 if (-124 < x && x < 0) {
356 buf[0] = (char)((x - 5)&0xff);
357 return 1;
358 }
359 for (i=1;i<(int)sizeof(long)+1;i++) {
360 buf[i] = (char)(x & 0xff);
361 x = RSHIFT(x,8);
362 if (x == 0) {
363 buf[0] = i;
364 break;
365 }
366 if (x == -1) {
367 buf[0] = -i;
368 break;
369 }
370 }
371 return i+1;
372}
373
374#ifdef DBL_MANT_DIG
375#define DECIMAL_MANT (53-16) /* from IEEE754 double precision */
376
377#if DBL_MANT_DIG > 32
378#define MANT_BITS 32
379#elif DBL_MANT_DIG > 24
380#define MANT_BITS 24
381#elif DBL_MANT_DIG > 16
382#define MANT_BITS 16
383#else
384#define MANT_BITS 8
385#endif
386
387static double
388load_mantissa(double d, const char *buf, long len)
389{
390 if (!len) return d;
391 if (--len > 0 && !*buf++) { /* binary mantissa mark */
392 int e, s = d < 0, dig = 0;
393 unsigned long m;
394
395 modf(ldexp(frexp(fabs(d), &e), DECIMAL_MANT), &d);
396 do {
397 m = 0;
398 switch (len) {
399 default: m = *buf++ & 0xff; /* fall through */
400#if MANT_BITS > 24
401 case 3: m = (m << 8) | (*buf++ & 0xff); /* fall through */
402#endif
403#if MANT_BITS > 16
404 case 2: m = (m << 8) | (*buf++ & 0xff); /* fall through */
405#endif
406#if MANT_BITS > 8
407 case 1: m = (m << 8) | (*buf++ & 0xff);
408#endif
409 }
410 dig -= len < MANT_BITS / 8 ? 8 * (unsigned)len : MANT_BITS;
411 d += ldexp((double)m, dig);
412 } while ((len -= MANT_BITS / 8) > 0);
413 d = ldexp(d, e - DECIMAL_MANT);
414 if (s) d = -d;
415 }
416 return d;
417}
418#else
419#define load_mantissa(d, buf, len) (d)
420#endif
421
422#ifdef DBL_DIG
423#define FLOAT_DIG (DBL_DIG+2)
424#else
425#define FLOAT_DIG 17
426#endif
427
428static void
429w_float(double d, struct dump_arg *arg)
430{
431 char buf[FLOAT_DIG + (DECIMAL_MANT + 7) / 8 + 10];
432
433 if (isinf(d)) {
434 if (d < 0) w_cstr("-inf", arg);
435 else w_cstr("inf", arg);
436 }
437 else if (isnan(d)) {
438 w_cstr("nan", arg);
439 }
440 else if (d == 0.0) {
441 if (signbit(d)) w_cstr("-0", arg);
442 else w_cstr("0", arg);
443 }
444 else {
445 int decpt, sign, digs, len = 0;
446 char *e, *p = ruby_dtoa(d, 0, 0, &decpt, &sign, &e);
447 if (sign) buf[len++] = '-';
448 digs = (int)(e - p);
449 if (decpt < -3 || decpt > digs) {
450 buf[len++] = p[0];
451 if (--digs > 0) buf[len++] = '.';
452 memcpy(buf + len, p + 1, digs);
453 len += digs;
454 len += snprintf(buf + len, sizeof(buf) - len, "e%d", decpt - 1);
455 }
456 else if (decpt > 0) {
457 memcpy(buf + len, p, decpt);
458 len += decpt;
459 if ((digs -= decpt) > 0) {
460 buf[len++] = '.';
461 memcpy(buf + len, p + decpt, digs);
462 len += digs;
463 }
464 }
465 else {
466 buf[len++] = '0';
467 buf[len++] = '.';
468 if (decpt) {
469 memset(buf + len, '0', -decpt);
470 len -= decpt;
471 }
472 memcpy(buf + len, p, digs);
473 len += digs;
474 }
475 free(p);
476 w_bytes(buf, len, arg);
477 }
478}
479
480
481static VALUE
482w_encivar(VALUE str, struct dump_arg *arg)
483{
484 VALUE encname = encoding_name(str, arg);
485 if (NIL_P(encname) ||
486 is_ascii_string(str)) {
487 return Qnil;
488 }
489 w_byte(TYPE_IVAR, arg);
490 return encname;
491}
492
493static void
494w_encname(VALUE encname, struct dump_arg *arg)
495{
496 if (!NIL_P(encname)) {
497 struct dump_call_arg c_arg;
498 c_arg.limit = 1;
499 c_arg.arg = arg;
500 w_long(1L, arg);
501 w_encoding(encname, &c_arg);
502 }
503}
504
505static void
506w_symbol(VALUE sym, struct dump_arg *arg)
507{
508 st_data_t num;
509 VALUE encname;
510
511 if (st_lookup(arg->symbols, sym, &num)) {
512 w_byte(TYPE_SYMLINK, arg);
513 w_long((long)num, arg);
514 }
515 else {
516 const VALUE orig_sym = sym;
517 sym = rb_sym2str(sym);
518 if (!sym) {
519 rb_raise(rb_eTypeError, "can't dump anonymous ID %"PRIdVALUE, sym);
520 }
521 encname = w_encivar(sym, arg);
522 w_byte(TYPE_SYMBOL, arg);
523 w_bytes(RSTRING_PTR(sym), RSTRING_LEN(sym), arg);
524 st_add_direct(arg->symbols, orig_sym, arg->symbols->num_entries);
525 w_encname(encname, arg);
526 }
527}
528
529static void
530w_unique(VALUE s, struct dump_arg *arg)
531{
532 must_not_be_anonymous("class", s);
533 w_symbol(rb_str_intern(s), arg);
534}
535
536static void w_object(VALUE,struct dump_arg*,int);
537
538static int
539hash_each(VALUE key, VALUE value, VALUE v)
540{
541 struct dump_call_arg *arg = (void *)v;
542 w_object(key, arg->arg, arg->limit);
543 w_object(value, arg->arg, arg->limit);
544 return ST_CONTINUE;
545}
546
547#define SINGLETON_DUMP_UNABLE_P(klass) \
548 (rb_id_table_size(RCLASS_M_TBL(klass)) > 0 || \
549 rb_ivar_count(klass) > 0)
550
551static void
552w_extended(VALUE klass, struct dump_arg *arg, int check)
553{
554 if (check && RCLASS_SINGLETON_P(klass)) {
555 VALUE origin = RCLASS_ORIGIN(klass);
556 if (SINGLETON_DUMP_UNABLE_P(klass) ||
557 (origin != klass && SINGLETON_DUMP_UNABLE_P(origin))) {
558 rb_raise(rb_eTypeError, "singleton can't be dumped");
559 }
560 klass = RCLASS_SUPER(klass);
561 }
562 while (BUILTIN_TYPE(klass) == T_ICLASS) {
563 if (!RICLASS_IS_ORIGIN_P(klass) ||
564 BUILTIN_TYPE(RBASIC(klass)->klass) != T_MODULE) {
565 VALUE path = rb_class_name(RBASIC(klass)->klass);
566 w_byte(TYPE_EXTENDED, arg);
567 w_unique(path, arg);
568 }
569 klass = RCLASS_SUPER(klass);
570 }
571}
572
573static void
574w_class(char type, VALUE obj, struct dump_arg *arg, int check)
575{
576 VALUE path;
577 st_data_t real_obj;
578 VALUE klass;
579
580 if (arg->compat_tbl &&
581 st_lookup(arg->compat_tbl, (st_data_t)obj, &real_obj)) {
582 obj = (VALUE)real_obj;
583 }
584 klass = CLASS_OF(obj);
585 w_extended(klass, arg, check);
586 w_byte(type, arg);
587 path = class2path(rb_class_real(klass));
588 w_unique(path, arg);
589}
590
591static void
592w_uclass(VALUE obj, VALUE super, struct dump_arg *arg)
593{
594 VALUE klass = CLASS_OF(obj);
595
596 w_extended(klass, arg, TRUE);
597 klass = rb_class_real(klass);
598 if (klass != super) {
599 w_byte(TYPE_UCLASS, arg);
600 w_unique(class2path(klass), arg);
601 }
602}
603
604static bool
605rb_hash_ruby2_keywords_p(VALUE obj)
606{
607 return (RHASH(obj)->basic.flags & RHASH_PASS_AS_KEYWORDS) != 0;
608}
609
610static void
611rb_hash_ruby2_keywords(VALUE obj)
612{
613 RHASH(obj)->basic.flags |= RHASH_PASS_AS_KEYWORDS;
614}
615
616/*
617 * if instance variable name `id` is a special name to be skipped,
618 * returns the name of it. otherwise it cannot be dumped (unnamed),
619 * returns `name` as-is. returns NULL for ID that can be dumped.
620 */
621static inline const char *
622skipping_ivar_name(const ID id, const char *name)
623{
624#define IS_SKIPPED_IVAR(idname) \
625 ((id == idname) && (name = name_##idname, true))
626 if (IS_SKIPPED_IVAR(s_encoding_short)) return name;
627 if (IS_SKIPPED_IVAR(s_ruby2_keywords_flag)) return name;
628 if (IS_SKIPPED_IVAR(s_encoding_long)) return name;
629 if (!rb_id2str(id)) return name;
630 return NULL;
631}
632
633struct w_ivar_arg {
634 struct dump_call_arg *dump;
635 st_data_t num_ivar;
636};
637
638static int
639w_obj_each(ID id, VALUE value, st_data_t a)
640{
641 struct w_ivar_arg *ivarg = (struct w_ivar_arg *)a;
642 struct dump_call_arg *arg = ivarg->dump;
643 const char unnamed[] = "", *ivname = skipping_ivar_name(id, unnamed);
644
645 if (ivname) {
646 if (ivname != unnamed) {
647 rb_warn("instance variable '%s' on class %"PRIsVALUE" is not dumped",
648 ivname, CLASS_OF(arg->obj));
649 }
650 return ST_CONTINUE;
651 }
652 --ivarg->num_ivar;
653 w_symbol(ID2SYM(id), arg->arg);
654 w_object(value, arg->arg, arg->limit);
655 return ST_CONTINUE;
656}
657
658static int
659obj_count_ivars(ID id, VALUE val, st_data_t a)
660{
661 if (!skipping_ivar_name(id, "") && UNLIKELY(!++*(st_index_t *)a)) {
662 rb_raise(rb_eRuntimeError, "too many instance variables");
663 }
664 return ST_CONTINUE;
665}
666
667static VALUE
668encoding_name(VALUE obj, struct dump_arg *arg)
669{
670 if (rb_enc_capable(obj)) {
671 int encidx = rb_enc_get_index(obj);
672 rb_encoding *enc = 0;
673 st_data_t name;
674
675 if (encidx <= 0 || !(enc = rb_enc_from_index(encidx))) {
676 return Qnil;
677 }
678
679 /* special treatment for US-ASCII and UTF-8 */
680 if (encidx == rb_usascii_encindex()) {
681 return Qfalse;
682 }
683 else if (encidx == rb_utf8_encindex()) {
684 return Qtrue;
685 }
686
687 if (arg->encodings ?
688 !st_lookup(arg->encodings, (st_data_t)rb_enc_name(enc), &name) :
689 (arg->encodings = st_init_strcasetable(), 1)) {
690 name = (st_data_t)rb_str_new_cstr(rb_enc_name(enc));
691 st_insert(arg->encodings, (st_data_t)rb_enc_name(enc), name);
692 }
693 return (VALUE)name;
694 }
695 else {
696 return Qnil;
697 }
698}
699
700static int
701w_encoding(VALUE encname, struct dump_call_arg *arg)
702{
703 int limit = arg->limit;
704 if (limit >= 0) ++limit;
705 switch (encname) {
706 case Qfalse:
707 case Qtrue:
708 w_symbol(ID2SYM(s_encoding_short), arg->arg);
709 w_object(encname, arg->arg, limit);
710 return 1;
711 case Qnil:
712 return 0;
713 }
714 w_symbol(ID2SYM(rb_id_encoding()), arg->arg);
715 w_object(encname, arg->arg, limit);
716 return 1;
717}
718
719static st_index_t
720has_ivars(VALUE obj, VALUE encname, VALUE *ivobj)
721{
722 st_index_t num = !NIL_P(encname);
723
724 if (SPECIAL_CONST_P(obj)) goto generic;
725 switch (BUILTIN_TYPE(obj)) {
726 case T_OBJECT:
727 case T_CLASS:
728 case T_MODULE:
729 break; /* counted elsewhere */
730 case T_HASH:
731 if (rb_hash_ruby2_keywords_p(obj)) ++num;
732 /* fall through */
733 default:
734 generic:
735 rb_ivar_foreach(obj, obj_count_ivars, (st_data_t)&num);
736 if (num) *ivobj = obj;
737 }
738
739 return num;
740}
741
742static void
743w_ivar_each(VALUE obj, st_index_t num, struct dump_call_arg *arg)
744{
745 struct w_ivar_arg ivarg = {arg, num};
746 if (!num) return;
747 rb_ivar_foreach_buffered(obj, w_obj_each, (st_data_t)&ivarg);
748}
749
750static void
751w_ivar(st_index_t num, VALUE ivobj, VALUE encname, struct dump_call_arg *arg)
752{
753 w_long(num, arg->arg);
754 num -= w_encoding(encname, arg);
755 if (RB_TYPE_P(ivobj, T_HASH) && rb_hash_ruby2_keywords_p(ivobj)) {
756 int limit = arg->limit;
757 if (limit >= 0) ++limit;
758 w_symbol(ID2SYM(s_ruby2_keywords_flag), arg->arg);
759 w_object(Qtrue, arg->arg, limit);
760 num--;
761 }
762 if (!UNDEF_P(ivobj) && num) {
763 w_ivar_each(ivobj, num, arg);
764 }
765}
766
767static void
768w_objivar(VALUE obj, struct dump_call_arg *arg)
769{
770 st_data_t num = 0;
771
772 rb_ivar_foreach(obj, obj_count_ivars, (st_data_t)&num);
773 w_long(num, arg->arg);
774 w_ivar_each(obj, num, arg);
775}
776
777#if SIZEOF_LONG > 4
778// Optimized dump for fixnum larger than 31-bits
779static void
780w_bigfixnum(VALUE obj, struct dump_arg *arg)
781{
782 RUBY_ASSERT(FIXNUM_P(obj));
783
784 w_byte(TYPE_BIGNUM, arg);
785
786#if SIZEOF_LONG == SIZEOF_VALUE
787 long num, slen_num;
788 num = FIX2LONG(obj);
789#else
790 long long num, slen_num;
791 num = NUM2LL(obj);
792#endif
793
794 char sign = num < 0 ? '-' : '+';
795 w_byte(sign, arg);
796
797 // Guaranteed not to overflow, as FIXNUM is 1-bit less than long
798 if (num < 0) num = -num;
799
800 // calculate the size in shorts
801 int slen = 0;
802 {
803 slen_num = num;
804 while (slen_num) {
805 slen++;
806 slen_num = SHORTDN(slen_num);
807 }
808 }
809
810 RUBY_ASSERT(slen > 0 && slen <= SIZEOF_LONG / 2);
811
812 w_long((long)slen, arg);
813
814 for (int i = 0; i < slen; i++) {
815 w_short(num & SHORTMASK, arg);
816 num = SHORTDN(num);
817 }
818
819 // We aren't adding this object to the link table, but we need to increment
820 // the index.
821 arg->num_entries++;
822
823 RUBY_ASSERT(num == 0);
824}
825#endif
826
827static void
828w_remember(VALUE obj, struct dump_arg *arg)
829{
830 st_add_direct(arg->data, obj, arg->num_entries++);
831}
832
833static void
834w_object(VALUE obj, struct dump_arg *arg, int limit)
835{
836 struct dump_call_arg c_arg;
837 VALUE ivobj = Qundef;
838 st_data_t num;
839 st_index_t hasiv = 0;
840 VALUE encname = Qnil;
841
842 if (limit == 0) {
843 rb_raise(rb_eArgError, "exceed depth limit");
844 }
845
846 if (NIL_P(obj)) {
847 w_byte(TYPE_NIL, arg);
848 }
849 else if (obj == Qtrue) {
850 w_byte(TYPE_TRUE, arg);
851 }
852 else if (obj == Qfalse) {
853 w_byte(TYPE_FALSE, arg);
854 }
855 else if (FIXNUM_P(obj)) {
856#if SIZEOF_LONG <= 4
857 w_byte(TYPE_FIXNUM, arg);
858 w_long(FIX2INT(obj), arg);
859#else
860 if (RSHIFT((long)obj, 31) == 0 || RSHIFT((long)obj, 31) == -1) {
861 w_byte(TYPE_FIXNUM, arg);
862 w_long(FIX2LONG(obj), arg);
863 }
864 else {
865 w_bigfixnum(obj, arg);
866 }
867#endif
868 }
869 else if (SYMBOL_P(obj)) {
870 w_symbol(obj, arg);
871 }
872 else {
873 if (st_lookup(arg->data, obj, &num)) {
874 w_byte(TYPE_LINK, arg);
875 w_long((long)num, arg);
876 return;
877 }
878
879 if (limit > 0) limit--;
880 c_arg.limit = limit;
881 c_arg.arg = arg;
882 c_arg.obj = obj;
883
884 if (FLONUM_P(obj)) {
885 w_remember(obj, arg);
886 w_byte(TYPE_FLOAT, arg);
887 w_float(RFLOAT_VALUE(obj), arg);
888 return;
889 }
890
891 VALUE v;
892
893 if (!RBASIC_CLASS(obj)) {
894 rb_raise(rb_eTypeError, "can't dump internal %s",
895 rb_builtin_type_name(BUILTIN_TYPE(obj)));
896 }
897
898 if (rb_obj_respond_to(obj, s_mdump, TRUE)) {
899 w_remember(obj, arg);
900
901 v = dump_funcall(arg, obj, s_mdump, 0, 0);
902 w_class(TYPE_USRMARSHAL, obj, arg, FALSE);
903 w_object(v, arg, limit);
904 return;
905 }
906 if (rb_obj_respond_to(obj, s_dump, TRUE)) {
907 VALUE ivobj2 = Qundef;
908 st_index_t hasiv2;
909 VALUE encname2;
910
911 if (arg->userdefs && st_is_member(arg->userdefs, (st_data_t)obj)) {
912 rb_raise(rb_eRuntimeError, "can't dump recursive object using _dump()");
913 }
914 v = INT2NUM(limit);
915 v = dump_funcall(arg, obj, s_dump, 1, &v);
916 if (!RB_TYPE_P(v, T_STRING)) {
917 rb_raise(rb_eTypeError, "_dump() must return string");
918 }
919 hasiv = has_ivars(obj, (encname = encoding_name(obj, arg)), &ivobj);
920 hasiv2 = has_ivars(v, (encname2 = encoding_name(v, arg)), &ivobj2);
921 if (hasiv2) {
922 hasiv = hasiv2;
923 ivobj = ivobj2;
924 encname = encname2;
925 }
926 if (hasiv) w_byte(TYPE_IVAR, arg);
927 w_class(TYPE_USERDEF, obj, arg, FALSE);
928 w_str_bytes(v, arg);
929 if (hasiv) {
930 st_data_t userdefs = (st_data_t)obj;
931 if (!arg->userdefs) {
932 arg->userdefs = rb_init_identtable();
933 }
934 st_add_direct(arg->userdefs, userdefs, 0);
935 w_ivar(hasiv, ivobj, encname, &c_arg);
936 st_delete(arg->userdefs, &userdefs, NULL);
937 }
938 w_remember(obj, arg);
939 return;
940 }
941
942 w_remember(obj, arg);
943
944 hasiv = has_ivars(obj, (encname = encoding_name(obj, arg)), &ivobj);
945 {
946 st_data_t compat_data;
947 rb_alloc_func_t allocator = rb_get_alloc_func(RBASIC(obj)->klass);
948 if (st_lookup(compat_allocator_tbl,
949 (st_data_t)allocator,
950 &compat_data)) {
951 marshal_compat_t *compat = (marshal_compat_t*)compat_data;
952 VALUE real_obj = obj;
953 obj = compat->dumper(real_obj);
954 if (!arg->compat_tbl) {
955 arg->compat_tbl = rb_init_identtable();
956 }
957 st_insert(arg->compat_tbl, (st_data_t)obj, (st_data_t)real_obj);
958 if (obj != real_obj && UNDEF_P(ivobj)) hasiv = 0;
959 }
960 }
961 if (hasiv) w_byte(TYPE_IVAR, arg);
962
963 switch (BUILTIN_TYPE(obj)) {
964 case T_CLASS:
965 if (FL_TEST(obj, FL_SINGLETON)) {
966 rb_raise(rb_eTypeError, "singleton class can't be dumped");
967 }
968 {
969 VALUE path = class2path(obj);
970 VALUE encname = w_encivar(path, arg);
971 w_byte(TYPE_CLASS, arg);
972 w_bytes(RSTRING_PTR(path), RSTRING_LEN(path), arg);
973 w_encname(encname, arg);
974 RB_GC_GUARD(path);
975 }
976 break;
977
978 case T_MODULE:
979 {
980 VALUE path = class2path(obj);
981 VALUE encname = w_encivar(path, arg);
982 w_byte(TYPE_MODULE, arg);
983 w_bytes(RSTRING_PTR(path), RSTRING_LEN(path), arg);
984 w_encname(encname, arg);
985 RB_GC_GUARD(path);
986 }
987 break;
988
989 case T_FLOAT:
990 w_byte(TYPE_FLOAT, arg);
991 w_float(RFLOAT_VALUE(obj), arg);
992 break;
993
994 case T_BIGNUM:
995 w_byte(TYPE_BIGNUM, arg);
996 {
997 char sign = BIGNUM_SIGN(obj) ? '+' : '-';
998 size_t len = BIGNUM_LEN(obj);
999 size_t slen;
1000 size_t j;
1001 BDIGIT *d = BIGNUM_DIGITS(obj);
1002
1003 slen = SHORTLEN(len);
1004 if (LONG_MAX < slen) {
1005 rb_raise(rb_eTypeError, "too big Bignum can't be dumped");
1006 }
1007
1008 w_byte(sign, arg);
1009 w_long((long)slen, arg);
1010 for (j = 0; j < len; j++) {
1011#if SIZEOF_BDIGIT > SIZEOF_SHORT
1012 BDIGIT num = *d;
1013 int i;
1014
1015 for (i=0; i<SIZEOF_BDIGIT; i+=SIZEOF_SHORT) {
1016 w_short(num & SHORTMASK, arg);
1017 num = SHORTDN(num);
1018 if (j == len - 1 && num == 0) break;
1019 }
1020#else
1021 w_short(*d, arg);
1022#endif
1023 d++;
1024 }
1025 }
1026 break;
1027
1028 case T_STRING:
1029 w_uclass(obj, rb_cString, arg);
1030 w_byte(TYPE_STRING, arg);
1031 w_str_bytes(obj, arg);
1032 break;
1033
1034 case T_REGEXP:
1035 w_uclass(obj, rb_cRegexp, arg);
1036 w_byte(TYPE_REGEXP, arg);
1037 {
1038 int opts = rb_reg_options(obj);
1039 w_bytes(RREGEXP_SRC_PTR(obj), RREGEXP_SRC_LEN(obj), arg);
1040 w_byte((char)opts, arg);
1041 }
1042 break;
1043
1044 case T_ARRAY:
1045 w_uclass(obj, rb_cArray, arg);
1046 w_byte(TYPE_ARRAY, arg);
1047 {
1048 long i, len = RARRAY_LEN(obj);
1049
1050 w_long(len, arg);
1051 for (i=0; i<RARRAY_LEN(obj); i++) {
1052 w_object(RARRAY_AREF(obj, i), arg, limit);
1053 if (len != RARRAY_LEN(obj)) {
1054 rb_raise(rb_eRuntimeError, "array modified during dump");
1055 }
1056 }
1057 }
1058 break;
1059
1060 case T_HASH:
1061 w_uclass(obj, rb_cHash, arg);
1062 if (rb_hash_compare_by_id_p(obj)) {
1063 w_byte(TYPE_UCLASS, arg);
1064 w_symbol(rb_sym_intern_ascii_cstr("Hash"), arg);
1065 }
1066 if (NIL_P(RHASH_IFNONE(obj))) {
1067 w_byte(TYPE_HASH, arg);
1068 }
1069 else if (FL_TEST(obj, RHASH_PROC_DEFAULT)) {
1070 rb_raise(rb_eTypeError, "can't dump hash with default proc");
1071 }
1072 else {
1073 w_byte(TYPE_HASH_DEF, arg);
1074 }
1075 w_long(rb_hash_size_num(obj), arg);
1076 rb_hash_foreach(obj, hash_each, (st_data_t)&c_arg);
1077 if (!NIL_P(RHASH_IFNONE(obj))) {
1078 w_object(RHASH_IFNONE(obj), arg, limit);
1079 }
1080 break;
1081
1082 case T_STRUCT:
1083 w_class(TYPE_STRUCT, obj, arg, TRUE);
1084 {
1085 long len = RSTRUCT_LEN(obj);
1086 VALUE mem;
1087 long i;
1088
1089 w_long(len, arg);
1090 mem = rb_struct_members(obj);
1091 for (i=0; i<len; i++) {
1092 w_symbol(RARRAY_AREF(mem, i), arg);
1093 w_object(RSTRUCT_GET(obj, i), arg, limit);
1094 }
1095 }
1096 break;
1097
1098 case T_OBJECT:
1099 w_class(TYPE_OBJECT, obj, arg, TRUE);
1100 w_objivar(obj, &c_arg);
1101 break;
1102
1103 case T_DATA:
1104 {
1105 VALUE v;
1106
1107 if (!rb_obj_respond_to(obj, s_dump_data, TRUE)) {
1108 rb_raise(rb_eTypeError,
1109 "no _dump_data is defined for class %"PRIsVALUE,
1110 rb_obj_class(obj));
1111 }
1112 v = dump_funcall(arg, obj, s_dump_data, 0, 0);
1113 w_class(TYPE_DATA, obj, arg, TRUE);
1114 w_object(v, arg, limit);
1115 }
1116 break;
1117
1118 default:
1119 rb_raise(rb_eTypeError, "can't dump %"PRIsVALUE,
1120 rb_obj_class(obj));
1121 break;
1122 }
1123 RB_GC_GUARD(obj);
1124 }
1125 if (hasiv) {
1126 w_ivar(hasiv, ivobj, encname, &c_arg);
1127 }
1128}
1129
1130static void
1131clear_dump_arg(struct dump_arg *arg)
1132{
1133 if (!arg->symbols) return;
1134 st_free_table(arg->symbols);
1135 arg->symbols = 0;
1136 st_free_table(arg->data);
1137 arg->data = 0;
1138 arg->num_entries = 0;
1139 if (arg->compat_tbl) {
1140 st_free_table(arg->compat_tbl);
1141 arg->compat_tbl = 0;
1142 }
1143 if (arg->encodings) {
1144 st_free_table(arg->encodings);
1145 arg->encodings = 0;
1146 }
1147 if (arg->userdefs) {
1148 st_free_table(arg->userdefs);
1149 arg->userdefs = 0;
1150 }
1151}
1152
1153NORETURN(static inline void io_needed(void));
1154static inline void
1155io_needed(void)
1156{
1157 rb_raise(rb_eTypeError, "instance of IO needed");
1158}
1159
1160/*
1161 * call-seq:
1162 * dump( obj [, anIO] , limit=-1 ) -> anIO
1163 *
1164 * Serializes obj and all descendant objects. If anIO is
1165 * specified, the serialized data will be written to it, otherwise the
1166 * data will be returned as a String. If limit is specified, the
1167 * traversal of subobjects will be limited to that depth. If limit is
1168 * negative, no checking of depth will be performed.
1169 *
1170 * class Klass
1171 * def initialize(str)
1172 * @str = str
1173 * end
1174 * def say_hello
1175 * @str
1176 * end
1177 * end
1178 *
1179 * (produces no output)
1180 *
1181 * o = Klass.new("hello\n")
1182 * data = Marshal.dump(o)
1183 * obj = Marshal.load(data)
1184 * obj.say_hello #=> "hello\n"
1185 *
1186 * Marshal can't dump following objects:
1187 * * anonymous Class/Module.
1188 * * objects which are related to system (ex: Dir, File::Stat, IO, File, Socket
1189 * and so on)
1190 * * an instance of MatchData, Method, UnboundMethod, Proc, Thread,
1191 * ThreadGroup, Continuation
1192 * * objects which define singleton methods
1193 */
1194static VALUE
1195marshal_dump(int argc, VALUE *argv, VALUE _)
1196{
1197 VALUE obj, port, a1, a2;
1198 int limit = -1;
1199
1200 port = Qnil;
1201 rb_scan_args(argc, argv, "12", &obj, &a1, &a2);
1202 if (argc == 3) {
1203 if (!NIL_P(a2)) limit = NUM2INT(a2);
1204 if (NIL_P(a1)) io_needed();
1205 port = a1;
1206 }
1207 else if (argc == 2) {
1208 if (FIXNUM_P(a1)) limit = FIX2INT(a1);
1209 else if (NIL_P(a1)) io_needed();
1210 else port = a1;
1211 }
1212 return rb_marshal_dump_limited(obj, port, limit);
1213}
1214
1215VALUE
1216rb_marshal_dump_limited(VALUE obj, VALUE port, int limit)
1217{
1218 struct dump_arg *arg;
1219 VALUE wrapper; /* used to avoid memory leak in case of exception */
1220
1221 wrapper = TypedData_Make_Struct(0, struct dump_arg, &dump_arg_data, arg);
1222 arg->dest = 0;
1223 arg->symbols = st_init_numtable();
1224 arg->data = rb_init_identtable();
1225 arg->num_entries = 0;
1226 arg->compat_tbl = 0;
1227 arg->encodings = 0;
1228 arg->userdefs = 0;
1229 arg->str = rb_str_buf_new(0);
1230 if (!NIL_P(port)) {
1231 if (!rb_respond_to(port, s_write)) {
1232 io_needed();
1233 }
1234 arg->dest = port;
1235 dump_check_funcall(arg, port, s_binmode, 0, 0);
1236 }
1237 else {
1238 port = arg->str;
1239 }
1240
1241 w_byte(MARSHAL_MAJOR, arg);
1242 w_byte(MARSHAL_MINOR, arg);
1243
1244 w_object(obj, arg, limit);
1245 if (arg->dest) {
1246 rb_io_write(arg->dest, arg->str);
1247 rb_str_resize(arg->str, 0);
1248 }
1249 clear_dump_arg(arg);
1250 RB_GC_GUARD(wrapper);
1251
1252 return port;
1253}
1254
1255struct load_arg {
1256 VALUE src;
1257 char *buf;
1258 long bufsize;
1259 long buflen;
1260 long readable;
1261 long offset;
1262 st_table *symbols;
1263 st_table *data;
1264 st_table *partial_objects;
1265 VALUE proc;
1266 st_table *compat_tbl;
1267 bool freeze;
1268};
1269
1270static VALUE
1271check_load_arg(VALUE ret, struct load_arg *arg, const char *name)
1272{
1273 if (!arg->symbols) {
1274 rb_raise(rb_eRuntimeError, "Marshal.load reentered at %s",
1275 name);
1276 }
1277 return ret;
1278}
1279#define load_funcall(arg, obj, sym, argc, argv) \
1280 check_load_arg(rb_funcallv(obj, sym, argc, argv), arg, name_##sym)
1281
1282static void clear_load_arg(struct load_arg *arg);
1283
1284static void
1285mark_load_arg(void *ptr)
1286{
1287 struct load_arg *p = ptr;
1288 if (!p->symbols)
1289 return;
1290 rb_gc_mark(p->src);
1291 rb_gc_mark(p->proc);
1292 rb_mark_tbl(p->symbols);
1293 rb_mark_tbl(p->data);
1294 rb_mark_tbl(p->partial_objects);
1295 rb_mark_hash(p->compat_tbl);
1296}
1297
1298static void
1299free_load_arg(void *ptr)
1300{
1301 clear_load_arg(ptr);
1302}
1303
1304static size_t
1305memsize_load_arg(const void *ptr)
1306{
1307 const struct load_arg *p = (struct load_arg *)ptr;
1308 size_t memsize = 0;
1309 if (p->symbols) memsize += rb_st_memsize(p->symbols);
1310 if (p->data) memsize += rb_st_memsize(p->data);
1311 if (p->partial_objects) memsize += rb_st_memsize(p->partial_objects);
1312 if (p->compat_tbl) memsize += rb_st_memsize(p->compat_tbl);
1313 return memsize;
1314}
1315
1316static const rb_data_type_t load_arg_data = {
1317 "load_arg",
1318 {mark_load_arg, free_load_arg, memsize_load_arg,},
1319 0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_EMBEDDABLE
1320};
1321
1322#define r_entry(v, arg) r_entry0((v), (arg)->data->num_entries, (arg))
1323static VALUE r_object(struct load_arg *arg);
1324static VALUE r_symbol(struct load_arg *arg);
1325
1326NORETURN(static void too_short(void));
1327static void
1328too_short(void)
1329{
1330 rb_raise(rb_eArgError, "marshal data too short");
1331}
1332
1333static st_index_t
1334r_prepare(struct load_arg *arg)
1335{
1336 st_index_t idx = arg->data->num_entries;
1337
1338 st_insert(arg->data, (st_data_t)idx, (st_data_t)Qundef);
1339 return idx;
1340}
1341
1342static unsigned char
1343r_byte1_buffered(struct load_arg *arg)
1344{
1345 if (arg->buflen == 0) {
1346 long readable = arg->readable < arg->bufsize ? arg->readable : arg->bufsize;
1347 long read_len;
1348 VALUE str, n = LONG2NUM(readable);
1349
1350 str = load_funcall(arg, arg->src, s_read, 1, &n);
1351 if (NIL_P(str)) too_short();
1352 StringValue(str);
1353 read_len = RSTRING_LEN(str);
1354 if (UNLIKELY(read_len < readable)) too_short();
1355 if (UNLIKELY(read_len > arg->bufsize)) {
1356 arg->buf = ruby_sized_realloc_n(arg->buf, read_len, 1, arg->bufsize);
1357 arg->bufsize = read_len;
1358 }
1359 memcpy(arg->buf, RSTRING_PTR(str), read_len);
1360 arg->offset = 0;
1361 arg->buflen = read_len;
1362 RB_GC_GUARD(str);
1363 }
1364 arg->buflen--;
1365 return arg->buf[arg->offset++];
1366}
1367
1368static int
1369r_byte(struct load_arg *arg)
1370{
1371 int c;
1372
1373 if (RB_TYPE_P(arg->src, T_STRING)) {
1374 if (RSTRING_LEN(arg->src) > arg->offset) {
1375 c = (unsigned char)RSTRING_PTR(arg->src)[arg->offset++];
1376 }
1377 else {
1378 too_short();
1379 }
1380 }
1381 else {
1382 if (arg->readable >0 || arg->buflen > 0) {
1383 c = r_byte1_buffered(arg);
1384 }
1385 else {
1386 VALUE v = load_funcall(arg, arg->src, s_getbyte, 0, 0);
1387 if (NIL_P(v)) rb_eof_error();
1388 c = (unsigned char)NUM2CHR(v);
1389 }
1390 }
1391 return c;
1392}
1393
1394NORETURN(static void long_toobig(int size));
1395
1396static void
1397long_toobig(int size)
1398{
1399 rb_raise(rb_eTypeError, "long too big for this architecture (size "
1400 STRINGIZE(SIZEOF_LONG)", given %d)", size);
1401}
1402
1403static long
1404r_long(struct load_arg *arg)
1405{
1406 register long x;
1407 int c = (signed char)r_byte(arg);
1408 long i;
1409
1410 if (c == 0) return 0;
1411 if (c > 0) {
1412 if (4 < c && c < 128) {
1413 return c - 5;
1414 }
1415 if (c > (int)sizeof(long)) long_toobig(c);
1416 x = 0;
1417 for (i=0;i<c;i++) {
1418 x |= (long)r_byte(arg) << (8*i);
1419 }
1420 }
1421 else {
1422 if (-129 < c && c < -4) {
1423 return c + 5;
1424 }
1425 c = -c;
1426 if (c > (int)sizeof(long)) long_toobig(c);
1427 x = -1;
1428 for (i=0;i<c;i++) {
1429 x &= ~((long)0xff << (8*i));
1430 x |= (long)r_byte(arg) << (8*i);
1431 }
1432 }
1433 return x;
1434}
1435
1436long
1437ruby_marshal_read_long(const char **buf, long len)
1438{
1439 long x;
1440 struct RString src = {RBASIC_INIT};
1441 struct load_arg arg;
1442 memset(&arg, 0, sizeof(arg));
1443 arg.src = rb_setup_fake_str(&src, *buf, len, 0);
1444 x = r_long(&arg);
1445 *buf += arg.offset;
1446 return x;
1447}
1448
1449static long
1450r_keep_readable(struct load_arg *arg, long len, size_t size)
1451{
1452 if (UNLIKELY(len < 0)) {
1453 rb_raise(rb_eArgError, "negative length");
1454 }
1455 if (UNLIKELY((unsigned long)len > SIZE_MAX / size || arg->readable >= LONG_MAX - len)) {
1456 rb_raise(rb_eArgError, "marshaled data too big");
1457 }
1458 return len;
1459}
1460
1461static VALUE
1462r_bytes1(long len, struct load_arg *arg)
1463{
1464 VALUE str, n = LONG2NUM(len);
1465
1466 str = load_funcall(arg, arg->src, s_read, 1, &n);
1467 if (NIL_P(str)) too_short();
1468 StringValue(str);
1469 if (RSTRING_LEN(str) != len) too_short();
1470
1471 return str;
1472}
1473
1474static VALUE
1475r_bytes1_buffered(long len, struct load_arg *arg)
1476{
1477 VALUE str;
1478
1479 if (len <= arg->buflen) {
1480 str = rb_str_new(arg->buf+arg->offset, len);
1481 arg->offset += len;
1482 arg->buflen -= len;
1483 }
1484 else {
1485 long buflen = arg->buflen;
1486 long readable = arg->readable + 1;
1487 long tmp_len, read_len, need_len = len - buflen;
1488 VALUE tmp, n;
1489
1490 readable = readable < arg->bufsize ? readable : arg->bufsize;
1491 read_len = need_len > readable ? need_len : readable;
1492 n = LONG2NUM(read_len);
1493 tmp = load_funcall(arg, arg->src, s_read, 1, &n);
1494 if (NIL_P(tmp)) too_short();
1495 StringValue(tmp);
1496
1497 tmp_len = RSTRING_LEN(tmp);
1498
1499 if (tmp_len < need_len) too_short();
1500
1501 str = rb_str_new(arg->buf+arg->offset, buflen);
1502 rb_str_cat(str, RSTRING_PTR(tmp), need_len);
1503
1504 if (tmp_len > need_len) {
1505 buflen = tmp_len - need_len;
1506 if (UNLIKELY(buflen > arg->bufsize)) {
1507 arg->buf = ruby_sized_realloc_n(arg->buf, buflen, 1, arg->bufsize);
1508 arg->bufsize = buflen;
1509 }
1510 memcpy(arg->buf, RSTRING_PTR(tmp)+need_len, buflen);
1511 arg->buflen = buflen;
1512 }
1513 else {
1514 arg->buflen = 0;
1515 }
1516 arg->offset = 0;
1517 }
1518
1519 return str;
1520}
1521
1522#define r_bytes(arg) r_bytes0(r_long(arg), (arg))
1523
1524static VALUE
1525r_bytes0(long len, struct load_arg *arg)
1526{
1527 VALUE str;
1528
1529 if (len == 0) return rb_str_new(0, 0);
1530 if (RB_TYPE_P(arg->src, T_STRING)) {
1531 if (RSTRING_LEN(arg->src) - arg->offset >= len) {
1532 str = rb_str_new(RSTRING_PTR(arg->src)+arg->offset, len);
1533 arg->offset += len;
1534 }
1535 else {
1536 too_short();
1537 }
1538 }
1539 else {
1540 if (arg->readable > 0 || arg->buflen > 0) {
1541 str = r_bytes1_buffered(len, arg);
1542 }
1543 else {
1544 str = r_bytes1(len, arg);
1545 }
1546 }
1547 return str;
1548}
1549
1550static inline int
1551name_equal(const char *name, size_t nlen, const char *p, long l)
1552{
1553 if ((size_t)l != nlen || *p != *name) return 0;
1554 return nlen == 1 || memcmp(p+1, name+1, nlen-1) == 0;
1555}
1556
1557static int
1558sym2encidx(VALUE sym, VALUE val)
1559{
1560 RBIMPL_ATTR_NONSTRING() static const char name_encoding[8] = "encoding";
1561 const char *p;
1562 long l;
1563 if (rb_enc_get_index(sym) != ENCINDEX_US_ASCII) return -1;
1564 RSTRING_GETMEM(sym, p, l);
1565 if (l <= 0) return -1;
1566 if (name_equal(name_encoding, sizeof(name_encoding), p, l)) {
1567 int idx = rb_enc_find_index(StringValueCStr(val));
1568 return idx;
1569 }
1570 if (name_equal(name_s_encoding_short, rb_strlen_lit(name_s_encoding_short), p, l)) {
1571 if (val == Qfalse) return rb_usascii_encindex();
1572 else if (val == Qtrue) return rb_utf8_encindex();
1573 /* bogus ignore */
1574 }
1575 return -1;
1576}
1577
1578static int
1579symname_equal(VALUE sym, const char *name, size_t nlen)
1580{
1581 const char *p;
1582 long l;
1583 if (rb_enc_get_index(sym) != ENCINDEX_US_ASCII) return 0;
1584 RSTRING_GETMEM(sym, p, l);
1585 return name_equal(name, nlen, p, l);
1586}
1587
1588#define BUILD_ASSERT_POSITIVE(n) \
1589 /* make 0 negative to workaround the "zero size array" GCC extension, */ \
1590 ((sizeof(char [2*(ssize_t)(n)-1])+1)/2) /* assuming no overflow */
1591#define symname_equal_lit(sym, sym_name) \
1592 symname_equal(sym, sym_name, BUILD_ASSERT_POSITIVE(rb_strlen_lit(sym_name)))
1593
1594static VALUE
1595r_symlink(struct load_arg *arg)
1596{
1597 st_data_t sym;
1598 long num = r_long(arg);
1599
1600 if (!st_lookup(arg->symbols, num, &sym)) {
1601 rb_raise(rb_eArgError, "bad symbol");
1602 }
1603 return (VALUE)sym;
1604}
1605
1606static VALUE
1607r_symreal(struct load_arg *arg, int ivar)
1608{
1609 VALUE s = r_bytes(arg);
1610 VALUE sym;
1611 int idx = -1;
1612 st_index_t n = arg->symbols->num_entries;
1613
1614 if (rb_enc_str_asciionly_p(s)) rb_enc_associate_index(s, ENCINDEX_US_ASCII);
1615 st_insert(arg->symbols, (st_data_t)n, (st_data_t)s);
1616 if (ivar) {
1617 long num = r_long(arg);
1618 while (num-- > 0) {
1619 sym = r_symbol(arg);
1620 idx = sym2encidx(sym, r_object(arg));
1621 }
1622 }
1623 if (idx > 0) {
1624 rb_enc_associate_index(s, idx);
1625 if (is_broken_string(s)) {
1626 rb_raise(rb_eArgError, "invalid byte sequence in %s: %+"PRIsVALUE,
1627 rb_enc_name(rb_enc_from_index(idx)), s);
1628 }
1629 }
1630
1631 return s;
1632}
1633
1634static VALUE
1635r_symbol(struct load_arg *arg)
1636{
1637 int type, ivar = 0;
1638
1639 again:
1640 switch ((type = r_byte(arg))) {
1641 default:
1642 rb_raise(rb_eArgError, "dump format error for symbol(0x%x)", type);
1643 case TYPE_IVAR:
1644 ivar = 1;
1645 goto again;
1646 case TYPE_SYMBOL:
1647 return r_symreal(arg, ivar);
1648 case TYPE_SYMLINK:
1649 if (ivar) {
1650 rb_raise(rb_eArgError, "dump format error (symlink with encoding)");
1651 }
1652 return r_symlink(arg);
1653 }
1654}
1655
1656static VALUE
1657r_unique(struct load_arg *arg)
1658{
1659 return r_symbol(arg);
1660}
1661
1662static VALUE
1663r_string(struct load_arg *arg)
1664{
1665 return r_bytes(arg);
1666}
1667
1668static VALUE
1669r_entry0(VALUE v, st_index_t num, struct load_arg *arg)
1670{
1671 st_data_t real_obj = (st_data_t)v;
1672 if (arg->compat_tbl) {
1673 /* real_obj is kept if not found */
1674 st_lookup(arg->compat_tbl, v, &real_obj);
1675 }
1676 st_insert(arg->data, num, real_obj);
1677 st_insert(arg->partial_objects, (st_data_t)real_obj, Qtrue);
1678 return v;
1679}
1680
1681static VALUE
1682r_fixup_compat(VALUE v, struct load_arg *arg)
1683{
1684 st_data_t data;
1685 st_data_t key = (st_data_t)v;
1686 if (arg->compat_tbl && st_delete(arg->compat_tbl, &key, &data)) {
1687 VALUE real_obj = (VALUE)data;
1688 rb_alloc_func_t allocator = rb_get_alloc_func(CLASS_OF(real_obj));
1689 if (st_lookup(compat_allocator_tbl, (st_data_t)allocator, &data)) {
1690 marshal_compat_t *compat = (marshal_compat_t*)data;
1691 compat->loader(real_obj, v);
1692 }
1693 v = real_obj;
1694 }
1695 return v;
1696}
1697
1698static VALUE
1699r_post_proc(VALUE v, struct load_arg *arg)
1700{
1701 if (arg->proc) {
1702 v = load_funcall(arg, arg->proc, s_call, 1, &v);
1703 }
1704 return v;
1705}
1706
1707static VALUE
1708r_leave(VALUE v, struct load_arg *arg, bool partial)
1709{
1710 v = r_fixup_compat(v, arg);
1711 if (!partial) {
1712 st_data_t data;
1713 st_data_t key = (st_data_t)v;
1714 st_delete(arg->partial_objects, &key, &data);
1715 if (arg->freeze) {
1716 if (RB_TYPE_P(v, T_MODULE) || RB_TYPE_P(v, T_CLASS)) {
1717 // noop
1718 }
1719 else if (RB_TYPE_P(v, T_STRING)) {
1720 v = rb_str_to_interned_str(v);
1721 }
1722 else {
1723 OBJ_FREEZE(v);
1724 }
1725 }
1726 v = r_post_proc(v, arg);
1727 }
1728 return v;
1729}
1730
1731static int
1732copy_ivar_i(ID vid, VALUE value, st_data_t arg)
1733{
1734 VALUE obj = (VALUE)arg;
1735
1736 if (!rb_ivar_defined(obj, vid))
1737 rb_ivar_set(obj, vid, value);
1738 return ST_CONTINUE;
1739}
1740
1741static VALUE
1742r_copy_ivar(VALUE v, VALUE data)
1743{
1744 rb_ivar_foreach(data, copy_ivar_i, (st_data_t)v);
1745 return v;
1746}
1747
1748#define override_ivar_error(type, str) \
1749 rb_raise(rb_eTypeError, \
1750 "can't override instance variable of "type" '%"PRIsVALUE"'", \
1751 (str))
1752
1753static int
1754r_ivar_encoding(VALUE obj, struct load_arg *arg, VALUE sym, VALUE val)
1755{
1756 int idx = sym2encidx(sym, val);
1757 if (idx >= 0) {
1758 if (rb_enc_capable(obj)) {
1759 rb_enc_associate_index(obj, idx);
1760 }
1761 else {
1762 rb_raise(rb_eArgError, "%"PRIsVALUE" is not enc_capable", obj);
1763 }
1764 return TRUE;
1765 }
1766 return FALSE;
1767}
1768
1769static long
1770r_encname(VALUE obj, struct load_arg *arg)
1771{
1772 long len = r_long(arg);
1773 if (len > 0) {
1774 VALUE sym = r_symbol(arg);
1775 VALUE val = r_object(arg);
1776 len -= r_ivar_encoding(obj, arg, sym, val);
1777 }
1778 return len;
1779}
1780
1781static void
1782r_ivar(VALUE obj, int *has_encoding, struct load_arg *arg)
1783{
1784 long len;
1785
1786 len = r_long(arg);
1787 if (len > 0) {
1788 if (RB_TYPE_P(obj, T_MODULE)) {
1789 override_ivar_error("module", rb_mod_name(obj));
1790 }
1791 else if (RB_TYPE_P(obj, T_CLASS)) {
1792 override_ivar_error("class", rb_class_name(obj));
1793 }
1794 do {
1795 VALUE sym = r_symbol(arg);
1796 VALUE val = r_object(arg);
1797 if (r_ivar_encoding(obj, arg, sym, val)) {
1798 if (has_encoding) *has_encoding = TRUE;
1799 }
1800 else if (symname_equal_lit(sym, name_s_ruby2_keywords_flag)) {
1801 if (RB_TYPE_P(obj, T_HASH)) {
1802 rb_hash_ruby2_keywords(obj);
1803 }
1804 else {
1805 rb_raise(rb_eArgError, "ruby2_keywords flag is given but %"PRIsVALUE" is not a Hash", obj);
1806 }
1807 }
1808 else {
1809 rb_ivar_set(obj, rb_intern_str(sym), val);
1810 }
1811 } while (--len > 0);
1812 }
1813}
1814
1815static VALUE
1816path2class(VALUE path)
1817{
1818 VALUE v = rb_path_to_class(path);
1819
1820 if (!RB_TYPE_P(v, T_CLASS)) {
1821 rb_raise(rb_eArgError, "%"PRIsVALUE" does not refer to class", path);
1822 }
1823 return v;
1824}
1825
1826#define path2module(path) must_be_module(rb_path_to_class(path), path)
1827
1828static VALUE
1829must_be_module(VALUE v, VALUE path)
1830{
1831 if (!RB_TYPE_P(v, T_MODULE)) {
1832 rb_raise(rb_eArgError, "%"PRIsVALUE" does not refer to module", path);
1833 }
1834 return v;
1835}
1836
1837static VALUE
1838obj_alloc_by_klass(VALUE klass, struct load_arg *arg, VALUE *oldclass)
1839{
1840 st_data_t data;
1841 rb_alloc_func_t allocator;
1842
1843 allocator = rb_get_alloc_func(klass);
1844 if (st_lookup(compat_allocator_tbl, (st_data_t)allocator, &data)) {
1845 marshal_compat_t *compat = (marshal_compat_t*)data;
1846 VALUE real_obj = rb_obj_alloc(klass);
1847 VALUE obj = rb_obj_alloc(compat->oldclass);
1848 if (oldclass) *oldclass = compat->oldclass;
1849
1850 if (!arg->compat_tbl) {
1851 arg->compat_tbl = rb_init_identtable();
1852 }
1853 st_insert(arg->compat_tbl, (st_data_t)obj, (st_data_t)real_obj);
1854 return obj;
1855 }
1856
1857 return rb_obj_alloc(klass);
1858}
1859
1860static VALUE
1861obj_alloc_by_path(VALUE path, struct load_arg *arg)
1862{
1863 return obj_alloc_by_klass(path2class(path), arg, 0);
1864}
1865
1866static VALUE
1867append_extmod(VALUE obj, VALUE extmod)
1868{
1869 long i = RARRAY_LEN(extmod);
1870 while (i > 0) {
1871 VALUE m = RARRAY_AREF(extmod, --i);
1872 rb_extend_object(obj, m);
1873 }
1874 return obj;
1875}
1876
1877#define prohibit_ivar(type, str) do { \
1878 if (!ivp || !*ivp) break; \
1879 override_ivar_error(type, str); \
1880 } while (0)
1881
1882static VALUE r_object_for(struct load_arg *arg, bool partial, int *ivp, VALUE extmod, int type);
1883
1884static VALUE
1885r_object0(struct load_arg *arg, bool partial, int *ivp, VALUE extmod)
1886{
1887 int type = r_byte(arg);
1888 return r_object_for(arg, partial, ivp, extmod, type);
1889}
1890
1891static VALUE
1892r_object_for(struct load_arg *arg, bool partial, int *ivp, VALUE extmod, int type)
1893{
1894 VALUE (*hash_new_with_size)(st_index_t) = rb_hash_new_with_size;
1895 VALUE v = Qnil;
1896 long id;
1897 st_data_t link;
1898
1899 switch (type) {
1900 case TYPE_LINK:
1901 id = r_long(arg);
1902 if (!st_lookup(arg->data, (st_data_t)id, &link)) {
1903 rb_raise(rb_eArgError, "dump format error (unlinked)");
1904 }
1905 v = (VALUE)link;
1906 if (!st_lookup(arg->partial_objects, (st_data_t)v, &link)) {
1907 if (arg->freeze && RB_TYPE_P(v, T_STRING)) {
1908 v = rb_str_to_interned_str(v);
1909 }
1910 v = r_post_proc(v, arg);
1911 }
1912 break;
1913
1914 case TYPE_IVAR:
1915 {
1916 int ivar = TRUE;
1917 v = r_object0(arg, true, &ivar, extmod);
1918 if (ivar) r_ivar(v, NULL, arg);
1919 v = r_leave(v, arg, partial);
1920 }
1921 break;
1922
1923 case TYPE_EXTENDED:
1924 {
1925 VALUE path = r_unique(arg);
1926 VALUE m = rb_path_to_class(path);
1927 if (NIL_P(extmod)) extmod = rb_ary_hidden_new(0);
1928
1929 if (RB_TYPE_P(m, T_CLASS)) { /* prepended */
1930 VALUE c;
1931
1932 v = r_object0(arg, true, 0, Qnil);
1933 c = CLASS_OF(v);
1934 if (c != m || FL_TEST(c, FL_SINGLETON)) {
1935 rb_raise(rb_eArgError,
1936 "prepended class %"PRIsVALUE" differs from class %"PRIsVALUE,
1937 path, rb_class_name(c));
1938 }
1939 c = rb_singleton_class(v);
1940 while (RARRAY_LEN(extmod) > 0) {
1941 m = rb_ary_pop(extmod);
1942 rb_prepend_module(c, m);
1943 }
1944 }
1945 else {
1946 must_be_module(m, path);
1947 rb_ary_push(extmod, m);
1948
1949 v = r_object0(arg, true, 0, extmod);
1950 while (RARRAY_LEN(extmod) > 0) {
1951 m = rb_ary_pop(extmod);
1952 rb_extend_object(v, m);
1953 }
1954 }
1955 v = r_leave(v, arg, partial);
1956 }
1957 break;
1958
1959 case TYPE_UCLASS:
1960 {
1961 VALUE c = path2class(r_unique(arg));
1962
1963 if (FL_TEST(c, FL_SINGLETON)) {
1964 rb_raise(rb_eTypeError, "singleton can't be loaded");
1965 }
1966 type = r_byte(arg);
1967 if ((c == rb_cHash) &&
1968 /* Hack for compare_by_identify */
1969 (type == TYPE_HASH || type == TYPE_HASH_DEF)) {
1970 hash_new_with_size = rb_ident_hash_new_with_size;
1971 goto type_hash;
1972 }
1973 v = r_object_for(arg, partial, 0, extmod, type);
1974 if (RB_SPECIAL_CONST_P(v) || RB_TYPE_P(v, T_OBJECT) || RB_TYPE_P(v, T_CLASS)) {
1975 goto format_error;
1976 }
1977 if (RB_TYPE_P(v, T_MODULE) || !RTEST(rb_class_inherited_p(c, RBASIC(v)->klass))) {
1978 VALUE tmp = rb_obj_alloc(c);
1979
1980 if (TYPE(v) != TYPE(tmp)) goto format_error;
1981 }
1982 if (RB_TYPE_P(v, T_STRUCT) &&
1983 RSTRUCT_LEN(v) != RARRAY_LEN(rb_struct_s_members(c))) {
1984 rb_raise(rb_eTypeError, "struct %"PRIsVALUE" not compatible (struct size differs)",
1985 rb_class_name(c));
1986 }
1987 RBASIC_SET_CLASS(v, c);
1988 }
1989 break;
1990
1991 format_error:
1992 rb_raise(rb_eArgError, "dump format error (user class)");
1993
1994 case TYPE_NIL:
1995 v = Qnil;
1996 v = r_leave(v, arg, false);
1997 break;
1998
1999 case TYPE_TRUE:
2000 v = Qtrue;
2001 v = r_leave(v, arg, false);
2002 break;
2003
2004 case TYPE_FALSE:
2005 v = Qfalse;
2006 v = r_leave(v, arg, false);
2007 break;
2008
2009 case TYPE_FIXNUM:
2010 {
2011 long i = r_long(arg);
2012 v = LONG2FIX(i);
2013 }
2014 v = r_leave(v, arg, false);
2015 break;
2016
2017 case TYPE_FLOAT:
2018 {
2019 double d;
2020 VALUE str = r_bytes(arg);
2021 const char *ptr = RSTRING_PTR(str);
2022
2023 if (strcmp(ptr, "nan") == 0) {
2024 d = nan("");
2025 }
2026 else if (strcmp(ptr, "inf") == 0) {
2027 d = HUGE_VAL;
2028 }
2029 else if (strcmp(ptr, "-inf") == 0) {
2030 d = -HUGE_VAL;
2031 }
2032 else {
2033 char *e;
2034 d = strtod(ptr, &e);
2035 d = load_mantissa(d, e, RSTRING_LEN(str) - (e - ptr));
2036 }
2037 v = DBL2NUM(d);
2038 v = r_entry(v, arg);
2039 v = r_leave(v, arg, false);
2040 }
2041 break;
2042
2043 case TYPE_BIGNUM:
2044 {
2045 long len;
2046 VALUE data;
2047 int sign;
2048
2049 sign = r_byte(arg);
2050 if (sign != '+' && sign != '-') {
2051 rb_raise(rb_eArgError, "invalid Bignum sign");
2052 }
2053 len = r_keep_readable(arg, r_long(arg), 2);
2054
2055 if (SIZEOF_VALUE >= 8 && len <= 4) {
2056 // Representable within uintptr, likely FIXNUM
2057 VALUE num = 0;
2058 for (int i = 0; i < len; i++) {
2059 num |= (VALUE)r_byte(arg) << (i * 16);
2060 num |= (VALUE)r_byte(arg) << (i * 16 + 8);
2061 }
2062#if SIZEOF_VALUE == SIZEOF_LONG
2063 v = ULONG2NUM(num);
2064#else
2065 v = ULL2NUM(num);
2066#endif
2067 if (sign == '-') {
2068 v = rb_int_uminus(v);
2069 }
2070 }
2071 else {
2072 data = r_bytes0(len * 2, arg);
2073 v = rb_integer_unpack(RSTRING_PTR(data), len, 2, 0,
2074 INTEGER_PACK_LITTLE_ENDIAN | (sign == '-' ? INTEGER_PACK_NEGATIVE : 0));
2075 rb_str_resize(data, 0L);
2076 }
2077 v = r_entry(v, arg);
2078 v = r_leave(v, arg, false);
2079 }
2080 break;
2081
2082 case TYPE_STRING:
2083 v = r_entry(r_string(arg), arg);
2084 v = r_leave(v, arg, partial);
2085 break;
2086
2087 case TYPE_REGEXP:
2088 {
2089 VALUE str = r_bytes(arg);
2090 int options = r_byte(arg);
2091 int has_encoding = FALSE;
2092 st_index_t idx = r_prepare(arg);
2093
2094 if (ivp) {
2095 r_ivar(str, &has_encoding, arg);
2096 *ivp = FALSE;
2097 }
2098 if (!has_encoding) {
2099 /* 1.8 compatibility; remove escapes undefined in 1.8 */
2100 char *ptr = RSTRING_PTR(str), *dst = ptr, *src = ptr;
2101 long len = RSTRING_LEN(str);
2102 long bs = 0;
2103 for (; len-- > 0; *dst++ = *src++) {
2104 switch (*src) {
2105 case '\\': bs++; break;
2106 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
2107 case 'm': case 'o': case 'p': case 'q': case 'u': case 'y':
2108 case 'E': case 'F': case 'H': case 'I': case 'J': case 'K':
2109 case 'L': case 'N': case 'O': case 'P': case 'Q': case 'R':
2110 case 'S': case 'T': case 'U': case 'V': case 'X': case 'Y':
2111 if (bs & 1) --dst;
2112 /* fall through */
2113 default: bs = 0; break;
2114 }
2115 }
2116 rb_str_set_len(str, dst - ptr);
2117 }
2118 VALUE regexp = rb_reg_new_str(str, options);
2119 r_copy_ivar(regexp, str);
2120
2121 v = r_entry0(regexp, idx, arg);
2122 v = r_leave(v, arg, partial);
2123 }
2124 break;
2125
2126 case TYPE_ARRAY:
2127 {
2128 long len = r_keep_readable(arg, r_long(arg), 1);
2129
2130 v = rb_ary_new2(len);
2131 v = r_entry(v, arg);
2132 arg->readable += len - 1;
2133 while (len--) {
2134 rb_ary_push(v, r_object(arg));
2135 arg->readable--;
2136 }
2137 v = r_leave(v, arg, partial);
2138 arg->readable++;
2139 }
2140 break;
2141
2142 case TYPE_HASH:
2143 case TYPE_HASH_DEF:
2144 type_hash:
2145 {
2146 long len = r_keep_readable(arg, r_long(arg), 2);
2147
2148 v = hash_new_with_size(len);
2149 v = r_entry(v, arg);
2150 arg->readable += (len - 1) * 2;
2151 while (len--) {
2152 VALUE key = r_object(arg);
2153 VALUE value = r_object(arg);
2154 rb_hash_aset(v, key, value);
2155 arg->readable -= 2;
2156 }
2157 arg->readable += 2;
2158 if (type == TYPE_HASH_DEF) {
2159 RHASH_SET_IFNONE(v, r_object(arg));
2160 }
2161 v = r_leave(v, arg, partial);
2162 }
2163 break;
2164
2165 case TYPE_STRUCT:
2166 {
2167 VALUE mem, values;
2168 long i;
2169 VALUE slot;
2170 st_index_t idx = r_prepare(arg);
2171 VALUE klass = path2class(r_unique(arg));
2172 long len = r_keep_readable(arg, r_long(arg), 2);
2173
2174 v = rb_obj_alloc(klass);
2175 if (!RB_TYPE_P(v, T_STRUCT)) {
2176 rb_raise(rb_eTypeError, "class %"PRIsVALUE" not a struct", rb_class_name(klass));
2177 }
2178 mem = rb_struct_s_members(klass);
2179 if (RARRAY_LEN(mem) != len) {
2180 rb_raise(rb_eTypeError, "struct %"PRIsVALUE" not compatible (struct size differs)",
2181 rb_class_name(klass));
2182 }
2183
2184 arg->readable += (len - 1) * 2;
2185 v = r_entry0(v, idx, arg);
2186 values = rb_ary_new2(len);
2187 {
2188 VALUE keywords = Qfalse;
2189 if (RTEST(rb_struct_s_keyword_init(klass))) {
2190 keywords = rb_hash_new();
2191 rb_ary_push(values, keywords);
2192 }
2193
2194 for (i=0; i<len; i++) {
2195 VALUE n = rb_sym2str(RARRAY_AREF(mem, i));
2196 slot = r_symbol(arg);
2197
2198 if (!rb_str_equal(n, slot)) {
2199 rb_raise(rb_eTypeError, "struct %"PRIsVALUE" not compatible (:%"PRIsVALUE" for :%"PRIsVALUE")",
2200 rb_class_name(klass),
2201 slot, n);
2202 }
2203 if (keywords) {
2204 rb_hash_aset(keywords, RARRAY_AREF(mem, i), r_object(arg));
2205 }
2206 else {
2207 rb_ary_push(values, r_object(arg));
2208 }
2209 arg->readable -= 2;
2210 }
2211 }
2212 rb_struct_initialize(v, values);
2213 v = r_leave(v, arg, partial);
2214 arg->readable += 2;
2215 }
2216 break;
2217
2218 case TYPE_USERDEF:
2219 {
2220 VALUE name = r_unique(arg);
2221 VALUE klass = path2class(name);
2222 VALUE data;
2223 st_data_t d;
2224
2225 if (!rb_obj_respond_to(klass, s_load, TRUE)) {
2226 rb_raise(rb_eTypeError, "class %"PRIsVALUE" needs to have method '_load'",
2227 name);
2228 }
2229 data = r_string(arg);
2230 if (ivp) {
2231 r_ivar(data, NULL, arg);
2232 *ivp = FALSE;
2233 }
2234 v = load_funcall(arg, klass, s_load, 1, &data);
2235 v = r_entry(v, arg);
2236 if (st_lookup(compat_allocator_tbl, (st_data_t)rb_get_alloc_func(klass), &d)) {
2237 marshal_compat_t *compat = (marshal_compat_t*)d;
2238 v = compat->loader(klass, v);
2239 }
2240 if (!partial) {
2241 if (arg->freeze) {
2242 OBJ_FREEZE(v);
2243 }
2244 v = r_post_proc(v, arg);
2245 }
2246 }
2247 break;
2248
2249 case TYPE_USRMARSHAL:
2250 {
2251 VALUE name = r_unique(arg);
2252 VALUE klass = path2class(name);
2253 VALUE oldclass = 0;
2254 VALUE data;
2255
2256 v = obj_alloc_by_klass(klass, arg, &oldclass);
2257 if (!NIL_P(extmod)) {
2258 /* for the case marshal_load is overridden */
2259 append_extmod(v, extmod);
2260 }
2261 if (!rb_obj_respond_to(v, s_mload, TRUE)) {
2262 rb_raise(rb_eTypeError, "instance of %"PRIsVALUE" needs to have method 'marshal_load'",
2263 name);
2264 }
2265 v = r_entry(v, arg);
2266 data = r_object(arg);
2267 load_funcall(arg, v, s_mload, 1, &data);
2268 v = r_fixup_compat(v, arg);
2269 v = r_copy_ivar(v, data);
2270 if (arg->freeze) {
2271 OBJ_FREEZE(v);
2272 }
2273 v = r_post_proc(v, arg);
2274 if (!NIL_P(extmod)) {
2275 if (oldclass) append_extmod(v, extmod);
2276 rb_ary_clear(extmod);
2277 }
2278 }
2279 break;
2280
2281 case TYPE_OBJECT:
2282 {
2283 st_index_t idx = r_prepare(arg);
2284 v = obj_alloc_by_path(r_unique(arg), arg);
2285 if (!RB_TYPE_P(v, T_OBJECT)) {
2286 rb_raise(rb_eArgError, "dump format error");
2287 }
2288 v = r_entry0(v, idx, arg);
2289 r_ivar(v, NULL, arg);
2290 v = r_leave(v, arg, partial);
2291 }
2292 break;
2293
2294 case TYPE_DATA:
2295 {
2296 VALUE name = r_unique(arg);
2297 VALUE klass = path2class(name);
2298 VALUE oldclass = 0;
2299 VALUE r;
2300
2301 v = obj_alloc_by_klass(klass, arg, &oldclass);
2302 if (!RB_TYPE_P(v, T_DATA)) {
2303 rb_raise(rb_eArgError, "dump format error");
2304 }
2305 v = r_entry(v, arg);
2306 if (!rb_obj_respond_to(v, s_load_data, TRUE)) {
2307 rb_raise(rb_eTypeError,
2308 "class %"PRIsVALUE" needs to have instance method '_load_data'",
2309 name);
2310 }
2311 r = r_object0(arg, partial, 0, extmod);
2312 load_funcall(arg, v, s_load_data, 1, &r);
2313 v = r_leave(v, arg, partial);
2314 }
2315 break;
2316
2317 case TYPE_MODULE_OLD:
2318 {
2319 VALUE str = r_bytes(arg);
2320
2321 v = rb_path_to_class(str);
2322 prohibit_ivar("class/module", str);
2323 v = r_entry(v, arg);
2324 v = r_leave(v, arg, partial);
2325 }
2326 break;
2327
2328 case TYPE_CLASS:
2329 {
2330 VALUE str = r_bytes(arg);
2331
2332 if (ivp && *ivp > 0) *ivp = r_encname(str, arg) > 0;
2333 v = path2class(str);
2334 prohibit_ivar("class", str);
2335 v = r_entry(v, arg);
2336 v = r_leave(v, arg, partial);
2337 }
2338 break;
2339
2340 case TYPE_MODULE:
2341 {
2342 VALUE str = r_bytes(arg);
2343
2344 if (ivp && *ivp > 0) *ivp = r_encname(str, arg) > 0;
2345 v = path2module(str);
2346 prohibit_ivar("module", str);
2347 v = r_entry(v, arg);
2348 v = r_leave(v, arg, partial);
2349 }
2350 break;
2351
2352 case TYPE_SYMBOL:
2353 if (ivp) {
2354 v = r_symreal(arg, *ivp);
2355 *ivp = FALSE;
2356 }
2357 else {
2358 v = r_symreal(arg, 0);
2359 }
2360 v = rb_str_intern(v);
2361 v = r_leave(v, arg, partial);
2362 break;
2363
2364 case TYPE_SYMLINK:
2365 v = rb_str_intern(r_symlink(arg));
2366 break;
2367
2368 default:
2369 rb_raise(rb_eArgError, "dump format error(0x%x)", type);
2370 break;
2371 }
2372
2373 if (UNDEF_P(v)) {
2374 rb_raise(rb_eArgError, "dump format error (bad link)");
2375 }
2376
2377 return v;
2378}
2379
2380static VALUE
2381r_object(struct load_arg *arg)
2382{
2383 return r_object0(arg, false, 0, Qnil);
2384}
2385
2386static void
2387clear_load_arg(struct load_arg *arg)
2388{
2389 xfree(arg->buf);
2390 arg->buf = NULL;
2391 arg->bufsize = 0;
2392 arg->buflen = 0;
2393 arg->offset = 0;
2394 arg->readable = 0;
2395 if (!arg->symbols) return;
2396 st_free_table(arg->symbols);
2397 arg->symbols = 0;
2398 st_free_table(arg->data);
2399 arg->data = 0;
2400 st_free_table(arg->partial_objects);
2401 arg->partial_objects = 0;
2402 if (arg->compat_tbl) {
2403 st_free_table(arg->compat_tbl);
2404 arg->compat_tbl = 0;
2405 }
2406}
2407
2408VALUE
2409rb_marshal_load_with_proc(VALUE port, VALUE proc, bool freeze)
2410{
2411 int major, minor;
2412 VALUE v;
2413 VALUE wrapper; /* used to avoid memory leak in case of exception */
2414 struct load_arg *arg;
2415
2416 v = rb_check_string_type(port);
2417 if (!NIL_P(v)) {
2418 port = v;
2419 }
2420 else if (rb_respond_to(port, s_getbyte) && rb_respond_to(port, s_read)) {
2421 rb_check_funcall(port, s_binmode, 0, 0);
2422 }
2423 else {
2424 io_needed();
2425 }
2426 wrapper = TypedData_Make_Struct(0, struct load_arg, &load_arg_data, arg);
2427 arg->src = port;
2428 arg->offset = 0;
2429 arg->symbols = st_init_numtable();
2430 arg->data = rb_init_identtable();
2431 arg->partial_objects = rb_init_identtable();
2432 arg->compat_tbl = 0;
2433 arg->proc = 0;
2434 arg->readable = 0;
2435 arg->freeze = freeze;
2436
2437 if (NIL_P(v)) {
2438 arg->bufsize = BUFSIZ;
2439 arg->buf = xmalloc(BUFSIZ);
2440 }
2441 else {
2442 arg->bufsize = 0;
2443 arg->buf = 0;
2444 }
2445
2446 major = r_byte(arg);
2447 minor = r_byte(arg);
2448 if (major != MARSHAL_MAJOR || minor > MARSHAL_MINOR) {
2449 clear_load_arg(arg);
2450 rb_raise(rb_eTypeError, "incompatible marshal file format (can't be read)\n\
2451\tformat version %d.%d required; %d.%d given",
2452 MARSHAL_MAJOR, MARSHAL_MINOR, major, minor);
2453 }
2454 if (RTEST(ruby_verbose) && minor != MARSHAL_MINOR) {
2455 rb_warn("incompatible marshal file format (can be read)\n\
2456\tformat version %d.%d required; %d.%d given",
2457 MARSHAL_MAJOR, MARSHAL_MINOR, major, minor);
2458 }
2459
2460 if (!NIL_P(proc)) arg->proc = proc;
2461 v = r_object(arg);
2462 clear_load_arg(arg);
2463 RB_GC_GUARD(wrapper);
2464
2465 return v;
2466}
2467
2468static VALUE
2469marshal_load(rb_execution_context_t *ec, VALUE mod, VALUE source, VALUE proc, VALUE freeze)
2470{
2471 return rb_marshal_load_with_proc(source, proc, RTEST(freeze));
2472}
2473
2474#include "marshal.rbinc"
2475
2476/*
2477 * The marshaling library converts collections of Ruby objects into a
2478 * byte stream, allowing them to be stored outside the currently
2479 * active script. This data may subsequently be read and the original
2480 * objects reconstituted.
2481 *
2482 * Marshaled data has major and minor version numbers stored along
2483 * with the object information. In normal use, marshaling can only
2484 * load data written with the same major version number and an equal
2485 * or lower minor version number. If Ruby's ``verbose'' flag is set
2486 * (normally using -d, -v, -w, or --verbose) the major and minor
2487 * numbers must match exactly. Marshal versioning is independent of
2488 * Ruby's version numbers. You can extract the version by reading the
2489 * first two bytes of marshaled data.
2490 *
2491 * str = Marshal.dump("thing")
2492 * RUBY_VERSION #=> "1.9.0"
2493 * str[0].ord #=> 4
2494 * str[1].ord #=> 8
2495 *
2496 * Some objects cannot be dumped: if the objects to be dumped include
2497 * bindings, procedure or method objects, instances of class IO, or
2498 * singleton objects, a TypeError will be raised.
2499 *
2500 * If your class has special serialization needs (for example, if you
2501 * want to serialize in some specific format), or if it contains
2502 * objects that would otherwise not be serializable, you can implement
2503 * your own serialization strategy.
2504 *
2505 * There are two methods of doing this, your object can define either
2506 * marshal_dump and marshal_load or _dump and _load. marshal_dump will take
2507 * precedence over _dump if both are defined. marshal_dump may result in
2508 * smaller Marshal strings.
2509 *
2510 * == Security considerations
2511 *
2512 * By design, Marshal.load can deserialize almost any class loaded into the
2513 * Ruby process. In many cases this can lead to remote code execution if the
2514 * Marshal data is loaded from an untrusted source.
2515 *
2516 * As a result, Marshal.load is not suitable as a general purpose serialization
2517 * format and you should never unmarshal user supplied input or other untrusted
2518 * data.
2519 *
2520 * If you need to deserialize untrusted data, use JSON or another serialization
2521 * format that is only able to load simple, 'primitive' types such as String,
2522 * Array, Hash, etc. Never allow user input to specify arbitrary types to
2523 * deserialize into.
2524 *
2525 * == marshal_dump and marshal_load
2526 *
2527 * When dumping an object the method marshal_dump will be called.
2528 * marshal_dump must return a result containing the information necessary for
2529 * marshal_load to reconstitute the object. The result can be any object.
2530 *
2531 * When loading an object dumped using marshal_dump the object is first
2532 * allocated then marshal_load is called with the result from marshal_dump.
2533 * marshal_load must recreate the object from the information in the result.
2534 *
2535 * Example:
2536 *
2537 * class MyObj
2538 * def initialize name, version, data
2539 * @name = name
2540 * @version = version
2541 * @data = data
2542 * end
2543 *
2544 * def marshal_dump
2545 * [@name, @version]
2546 * end
2547 *
2548 * def marshal_load array
2549 * @name, @version = array
2550 * end
2551 * end
2552 *
2553 * == _dump and _load
2554 *
2555 * Use _dump and _load when you need to allocate the object you're restoring
2556 * yourself.
2557 *
2558 * When dumping an object the instance method _dump is called with an Integer
2559 * which indicates the maximum depth of objects to dump (a value of -1 implies
2560 * that you should disable depth checking). _dump must return a String
2561 * containing the information necessary to reconstitute the object.
2562 *
2563 * The class method _load should take a String and use it to return an object
2564 * of the same class.
2565 *
2566 * Example:
2567 *
2568 * class MyObj
2569 * def initialize name, version, data
2570 * @name = name
2571 * @version = version
2572 * @data = data
2573 * end
2574 *
2575 * def _dump level
2576 * [@name, @version].join ':'
2577 * end
2578 *
2579 * def self._load args
2580 * new(*args.split(':'))
2581 * end
2582 * end
2583 *
2584 * Since Marshal.dump outputs a string you can have _dump return a Marshal
2585 * string which is Marshal.loaded in _load for complex objects.
2586 */
2587void
2588Init_marshal(void)
2589{
2590 VALUE rb_mMarshal = rb_define_module("Marshal");
2591#define set_id(sym) sym = rb_intern_const(name_##sym)
2592 set_id(s_dump);
2593 set_id(s_load);
2594 set_id(s_mdump);
2595 set_id(s_mload);
2596 set_id(s_dump_data);
2597 set_id(s_load_data);
2598 set_id(s_alloc);
2599 set_id(s_call);
2600 set_id(s_getbyte);
2601 set_id(s_read);
2602 set_id(s_write);
2603 set_id(s_binmode);
2604 set_id(s_encoding_short);
2605 set_id(s_ruby2_keywords_flag);
2606
2607 rb_define_module_function(rb_mMarshal, "dump", marshal_dump, -1);
2608
2609 /* major version */
2610 rb_define_const(rb_mMarshal, "MAJOR_VERSION", INT2FIX(MARSHAL_MAJOR));
2611 /* minor version */
2612 rb_define_const(rb_mMarshal, "MINOR_VERSION", INT2FIX(MARSHAL_MINOR));
2613}
2614
2615static int
2616marshal_compat_table_mark_and_move_i(st_data_t key, st_data_t value, st_data_t _)
2617{
2618 marshal_compat_t *p = (marshal_compat_t *)value;
2619 rb_gc_mark_and_move(&p->newclass);
2620 rb_gc_mark_and_move(&p->oldclass);
2621 return ST_CONTINUE;
2622}
2623
2624static void
2625marshal_compat_table_mark_and_move(void *tbl)
2626{
2627 if (!tbl) return;
2628 st_foreach(tbl, marshal_compat_table_mark_and_move_i, 0);
2629}
2630
2631static int
2632marshal_compat_table_free_i(st_data_t key, st_data_t value, st_data_t _)
2633{
2634 xfree((marshal_compat_t *)value);
2635 return ST_CONTINUE;
2636}
2637
2638static void
2639marshal_compat_table_free(void *data)
2640{
2641 st_foreach(data, marshal_compat_table_free_i, 0);
2642 st_free_table(data);
2643}
2644
2645static size_t
2646marshal_compat_table_memsize(const void *data)
2647{
2648 return st_memsize(data) + sizeof(marshal_compat_t) * st_table_size(data);
2649}
2650
2651static const rb_data_type_t marshal_compat_type = {
2652 .wrap_struct_name = "marshal_compat_table",
2653 .function = {
2654 .dmark = marshal_compat_table_mark_and_move,
2655 .dfree = marshal_compat_table_free,
2656 .dsize = marshal_compat_table_memsize,
2657 .dcompact = marshal_compat_table_mark_and_move,
2658 },
2659 .flags = RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FREE_IMMEDIATELY,
2660};
2661
2662static st_table *
2663compat_allocator_table(void)
2664{
2665 if (compat_allocator_tbl) return compat_allocator_tbl;
2666 compat_allocator_tbl = st_init_numtable();
2667 compat_allocator_tbl_wrapper =
2668 TypedData_Wrap_Struct(0, &marshal_compat_type, compat_allocator_tbl);
2669 rb_vm_register_global_object(compat_allocator_tbl_wrapper);
2670 return compat_allocator_tbl;
2671}
2672
2673VALUE
2674rb_marshal_dump(VALUE obj, VALUE port)
2675{
2676 return rb_marshal_dump_limited(obj, port, -1);
2677}
2678
2679VALUE
2680rb_marshal_load(VALUE port)
2681{
2682 return rb_marshal_load_with_proc(port, Qnil, false);
2683}
int len
Length of the buffer.
Definition io.h:8
Defines RBIMPL_ATTR_NONSTRING.