ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/CBOR-XS/XS.xs
(Generate patch)

Comparing CBOR-XS/XS.xs (file contents):
Revision 1.5 by root, Sat Oct 26 21:14:20 2013 UTC vs.
Revision 1.77 by root, Fri Sep 8 05:47:10 2023 UTC

6#include <string.h> 6#include <string.h>
7#include <stdlib.h> 7#include <stdlib.h>
8#include <stdio.h> 8#include <stdio.h>
9#include <limits.h> 9#include <limits.h>
10#include <float.h> 10#include <float.h>
11#include <inttypes.h>
11 12
13#define ECB_NO_THREADS 1
12#include "ecb.h" 14#include "ecb.h"
13 15
16// compatibility with perl <5.18
17#ifndef HvNAMELEN_get
18# define HvNAMELEN_get(hv) strlen (HvNAME (hv))
19#endif
20#ifndef HvNAMELEN
21# define HvNAMELEN(hv) HvNAMELEN_get (hv)
22#endif
23#ifndef HvNAMEUTF8
24# define HvNAMEUTF8(hv) 0
25#endif
26#ifndef SvREFCNT_inc_NN
27# define SvREFCNT_inc_NN(sv) SvREFCNT_inc (sv)
28#endif
29#ifndef SvREFCNT_dec_NN
30# define SvREFCNT_dec_NN(sv) SvREFCNT_dec (sv)
31#endif
32
33// perl's is_utf8_string interprets len=0 as "calculate len", but we want it to mean 0
34#define cbor_is_utf8_string(str,len) (!(len) || is_utf8_string ((str), (len)))
35
36// known major and minor types
37enum cbor_type
38{
39 MAJOR_SHIFT = 5,
40 MINOR_MASK = 0x1f,
41
42 MAJOR_POS_INT = 0 << MAJOR_SHIFT,
43 MAJOR_NEG_INT = 1 << MAJOR_SHIFT,
44 MAJOR_BYTES = 2 << MAJOR_SHIFT,
45 MAJOR_TEXT = 3 << MAJOR_SHIFT,
46 MAJOR_ARRAY = 4 << MAJOR_SHIFT,
47 MAJOR_MAP = 5 << MAJOR_SHIFT,
48 MAJOR_TAG = 6 << MAJOR_SHIFT,
49 MAJOR_MISC = 7 << MAJOR_SHIFT,
50
51 // INT/STRING/ARRAY/MAP subtypes
52 LENGTH_EXT1 = 24,
53 LENGTH_EXT2 = 25,
54 LENGTH_EXT4 = 26,
55 LENGTH_EXT8 = 27,
56
57 // SIMPLE types (effectively MISC subtypes)
58 SIMPLE_FALSE = 20,
59 SIMPLE_TRUE = 21,
60 SIMPLE_NULL = 22,
61 SIMPLE_UNDEF = 23,
62
63 // MISC subtype (unused)
64 MISC_EXT1 = 24,
65 MISC_FLOAT16 = 25,
66 MISC_FLOAT32 = 26,
67 MISC_FLOAT64 = 27,
68
69 // BYTES/TEXT/ARRAY/MAP
70 MINOR_INDEF = 31,
71};
72
73// known tags
74enum cbor_tag
75{
76 // extensions
77 CBOR_TAG_STRINGREF = 25, // http://cbor.schmorp.de/stringref
78 CBOR_TAG_PERL_OBJECT = 26, // http://cbor.schmorp.de/perl-object
79 CBOR_TAG_GENERIC_OBJECT = 27, // http://cbor.schmorp.de/generic-object
80 CBOR_TAG_VALUE_SHAREABLE = 28, // http://cbor.schmorp.de/value-sharing
81 CBOR_TAG_VALUE_SHAREDREF = 29, // http://cbor.schmorp.de/value-sharing
82 CBOR_TAG_STRINGREF_NAMESPACE = 256, // http://cbor.schmorp.de/stringref
83 CBOR_TAG_INDIRECTION = 22098, // http://cbor.schmorp.de/indirection
84
85 // rfc7049
86 CBOR_TAG_DATETIME = 0, // rfc4287, utf-8
87 CBOR_TAG_TIMESTAMP = 1, // unix timestamp, any
88 CBOR_TAG_POS_BIGNUM = 2, // byte string
89 CBOR_TAG_NEG_BIGNUM = 3, // byte string
90 CBOR_TAG_DECIMAL = 4, // decimal fraction, array
91 CBOR_TAG_BIGFLOAT = 5, // array
92
93 CBOR_TAG_CONV_B64U = 21, // base64url, any
94 CBOR_TAG_CONV_B64 = 22, // base64, any
95 CBOR_TAG_CONV_HEX = 23, // base16, any
96 CBOR_TAG_CBOR = 24, // embedded cbor, byte string
97
98 CBOR_TAG_URI = 32, // URI rfc3986, utf-8
99 CBOR_TAG_B64U = 33, // base64url rfc4648, utf-8
100 CBOR_TAG_B64 = 34, // base6 rfc46484, utf-8
101 CBOR_TAG_REGEX = 35, // regex pcre/ecma262, utf-8
102 CBOR_TAG_MIME = 36, // mime message rfc2045, utf-8
103
104 CBOR_TAG_MAGIC = 55799, // self-describe cbor
105};
106
107// known forced types, also hardcoded in CBOR.pm
108enum
109{
110 AS_CBOR = 0,
111 AS_INT = 1,
112 AS_BYTES = 2,
113 AS_TEXT = 3,
114 AS_FLOAT16 = 4,
115 AS_FLOAT32 = 5,
116 AS_FLOAT64 = 6,
117 AS_MAP = 7,
118 // possibly future enhancements: (generic) float, (generic) string
119};
120
14#define F_SHRINK 0x00000200UL 121#define F_SHRINK 0x00000001UL
15#define F_ALLOW_UNKNOWN 0x00002000UL 122#define F_ALLOW_UNKNOWN 0x00000002UL
123#define F_ALLOW_SHARING 0x00000004UL
124#define F_ALLOW_CYCLES 0x00000008UL
125#define F_FORBID_OBJECTS 0x00000010UL
126#define F_PACK_STRINGS 0x00000020UL
127#define F_TEXT_KEYS 0x00000040UL
128#define F_TEXT_STRINGS 0x00000080UL
129#define F_VALIDATE_UTF8 0x00000100UL
16 130
17#define INIT_SIZE 32 // initial scalar size to be allocated 131#define INIT_SIZE 32 // initial scalar size to be allocated
18 132
19#define SB do { 133#define SB do {
20#define SE } while (0) 134#define SE } while (0)
31#else 145#else
32# define CBOR_SLOW 0 146# define CBOR_SLOW 0
33# define CBOR_STASH cbor_stash 147# define CBOR_STASH cbor_stash
34#endif 148#endif
35 149
36static HV *cbor_stash, *cbor_boolean_stash; // CBOR::XS:: 150static HV *cbor_stash, *types_boolean_stash, *types_error_stash, *cbor_tagged_stash; // CBOR::XS::
37static SV *cbor_true, *cbor_false; 151static SV *types_true, *types_false, *types_error, *sv_cbor, *default_filter;
38 152
39typedef struct { 153typedef struct {
40 U32 flags; 154 U32 flags;
41 U32 max_depth; 155 U32 max_depth;
42 STRLEN max_size; 156 STRLEN max_size;
157 SV *filter;
43 158
44 SV *cb_object; 159 // for the incremental parser
45 HV *cb_sk_object; 160 STRLEN incr_pos; // the current offset into the text
161 STRLEN incr_need; // minimum bytes needed to decode
162 AV *incr_count; // for every nesting level, the number of outstanding values, or -1 for indef.
46} CBOR; 163} CBOR;
47 164
48ecb_inline void 165ecb_inline void
49cbor_init (CBOR *cbor) 166cbor_init (CBOR *cbor)
50{ 167{
51 Zero (cbor, 1, CBOR); 168 Zero (cbor, 1, CBOR);
52 cbor->max_depth = 512; 169 cbor->max_depth = 512;
170}
171
172ecb_inline void
173cbor_free (CBOR *cbor)
174{
175 SvREFCNT_dec (cbor->filter);
176 SvREFCNT_dec (cbor->incr_count);
53} 177}
54 178
55///////////////////////////////////////////////////////////////////////////// 179/////////////////////////////////////////////////////////////////////////////
56// utility functions 180// utility functions
57 181
79 SvPV_renew (sv, SvCUR (sv) + 1); 203 SvPV_renew (sv, SvCUR (sv) + 1);
80#endif 204#endif
81 } 205 }
82} 206}
83 207
84///////////////////////////////////////////////////////////////////////////// 208// minimum length of a string to be registered for stringref
85// fp hell 209ecb_inline STRLEN
86 210minimum_string_length (UV idx)
87//TODO 211{
212 return idx <= 23 ? 3
213 : idx <= 0xffU ? 4
214 : idx <= 0xffffU ? 5
215 : idx <= 0xffffffffU ? 7
216 : 11;
217}
88 218
89///////////////////////////////////////////////////////////////////////////// 219/////////////////////////////////////////////////////////////////////////////
90// encoder 220// encoder
91 221
92// structure used for encoding CBOR 222// structure used for encoding CBOR
95 char *cur; // SvPVX (sv) + current output position 225 char *cur; // SvPVX (sv) + current output position
96 char *end; // SvEND (sv) 226 char *end; // SvEND (sv)
97 SV *sv; // result scalar 227 SV *sv; // result scalar
98 CBOR cbor; 228 CBOR cbor;
99 U32 depth; // recursion level 229 U32 depth; // recursion level
230 HV *stringref[2]; // string => index, or 0 ([0] = bytes, [1] = utf-8)
231 UV stringref_idx;
232 HV *shareable; // ptr => index, or 0
233 UV shareable_idx;
100} enc_t; 234} enc_t;
101 235
102ecb_inline void 236ecb_inline void
103need (enc_t *enc, STRLEN len) 237need (enc_t *enc, STRLEN len)
104{ 238{
105 if (ecb_expect_false (enc->cur + len >= enc->end)) 239 if (ecb_expect_false ((uintptr_t)(enc->end - enc->cur) < len))
106 { 240 {
107 STRLEN cur = enc->cur - (char *)SvPVX (enc->sv); 241 STRLEN cur = enc->cur - (char *)SvPVX (enc->sv);
108 SvGROW (enc->sv, cur + (len < (cur >> 2) ? cur >> 2 : len) + 1); 242 SvGROW (enc->sv, cur + (len < (cur >> 2) ? cur >> 2 : len) + 1);
109 enc->cur = SvPVX (enc->sv) + cur; 243 enc->cur = SvPVX (enc->sv) + cur;
110 enc->end = SvPVX (enc->sv) + SvLEN (enc->sv) - 1; 244 enc->end = SvPVX (enc->sv) + SvLEN (enc->sv) - 1;
111 } 245 }
112} 246}
113 247
248static void encode_sv (enc_t *enc, SV *sv);
249
114ecb_inline void 250ecb_inline void
115encode_ch (enc_t *enc, char ch) 251encode_ch (enc_t *enc, char ch)
116{ 252{
117 need (enc, 1); 253 need (enc, 1);
118 *enc->cur++ = ch; 254 *enc->cur++ = ch;
119} 255}
120 256
257// used for tags, intregers, element counts and so on
121static void 258static void
122encode_uint (enc_t *enc, int major, UV len) 259encode_uint (enc_t *enc, int major, UV len)
123{ 260{
124 need (enc, 9); 261 need (enc, 9);
125 262
126 if (len < 24) 263 if (ecb_expect_true (len < LENGTH_EXT1))
127 *enc->cur++ = major | len; 264 *enc->cur++ = major | len;
128 else if (len <= 0xff) 265 else if (ecb_expect_true (len <= 0xffU))
129 { 266 {
130 *enc->cur++ = major | 24; 267 *enc->cur++ = major | LENGTH_EXT1;
131 *enc->cur++ = len; 268 *enc->cur++ = len;
132 } 269 }
133 else if (len <= 0xffff) 270 else if (len <= 0xffffU)
134 { 271 {
135 *enc->cur++ = major | 25; 272 *enc->cur++ = major | LENGTH_EXT2;
136 *enc->cur++ = len >> 8; 273 *enc->cur++ = len >> 8;
137 *enc->cur++ = len; 274 *enc->cur++ = len;
138 } 275 }
139 else if (len <= 0xffffffff) 276 else if (len <= 0xffffffffU)
140 { 277 {
141 *enc->cur++ = major | 26; 278 *enc->cur++ = major | LENGTH_EXT4;
142 *enc->cur++ = len >> 24; 279 *enc->cur++ = len >> 24;
143 *enc->cur++ = len >> 16; 280 *enc->cur++ = len >> 16;
144 *enc->cur++ = len >> 8; 281 *enc->cur++ = len >> 8;
145 *enc->cur++ = len; 282 *enc->cur++ = len;
146 } 283 }
147 else 284 else
148 { 285 {
149 *enc->cur++ = major | 27; 286 *enc->cur++ = major | LENGTH_EXT8;
150 *enc->cur++ = len >> 56; 287 *enc->cur++ = len >> 56;
151 *enc->cur++ = len >> 48; 288 *enc->cur++ = len >> 48;
152 *enc->cur++ = len >> 40; 289 *enc->cur++ = len >> 40;
153 *enc->cur++ = len >> 32; 290 *enc->cur++ = len >> 32;
154 *enc->cur++ = len >> 24; 291 *enc->cur++ = len >> 24;
156 *enc->cur++ = len >> 8; 293 *enc->cur++ = len >> 8;
157 *enc->cur++ = len; 294 *enc->cur++ = len;
158 } 295 }
159} 296}
160 297
161static void 298// encodes a perl value into a CBOR integer
299ecb_inline void
300encode_int (enc_t *enc, SV *sv)
301{
302 if (SvIsUV (sv))
303 encode_uint (enc, MAJOR_POS_INT, SvUVX (sv));
304 else if (SvIVX (sv) >= 0)
305 encode_uint (enc, MAJOR_POS_INT, SvIVX (sv));
306 else
307 encode_uint (enc, MAJOR_NEG_INT, -(SvIVX (sv) + 1));
308}
309
310ecb_inline void
311encode_tag (enc_t *enc, UV tag)
312{
313 encode_uint (enc, MAJOR_TAG, tag);
314}
315
316// exceptional (hopefully) slow path for byte strings that need to be utf8-encoded
317ecb_noinline static void
162encode_str (enc_t *enc, int utf8, char *str, STRLEN len) 318encode_str_utf8 (enc_t *enc, int utf8, char *str, STRLEN len)
163{ 319{
164 encode_uint (enc, utf8 ? 0x60 : 0x40, len); 320 STRLEN ulen = len;
321 U8 *p, *pend = (U8 *)str + len;
322
323 for (p = (U8 *)str; p < pend; ++p)
324 ulen += *p >> 7; // count set high bits
325
326 encode_uint (enc, MAJOR_TEXT, ulen);
327
328 need (enc, ulen);
329 for (p = (U8 *)str; p < pend; ++p)
330 if (*p < 0x80)
331 *enc->cur++ = *p;
332 else
333 {
334 *enc->cur++ = 0xc0 + (*p >> 6);
335 *enc->cur++ = 0x80 + (*p & 63);
336 }
337}
338
339ecb_inline void
340encode_str (enc_t *enc, int upgrade_utf8, int utf8, char *str, STRLEN len)
341{
342 if (ecb_expect_false (upgrade_utf8))
343 if (!utf8)
344 {
345 encode_str_utf8 (enc, utf8, str, len);
346 return;
347 }
348
349 encode_uint (enc, utf8 ? MAJOR_TEXT : MAJOR_BYTES, len);
165 need (enc, len); 350 need (enc, len);
166 memcpy (enc->cur, str, len); 351 memcpy (enc->cur, str, len);
167 enc->cur += len; 352 enc->cur += len;
168} 353}
169 354
170static void encode_sv (enc_t *enc, SV *sv); 355ecb_inline void
356encode_strref (enc_t *enc, int upgrade_utf8, int utf8, char *str, STRLEN len)
357{
358 if (ecb_expect_false (enc->cbor.flags & F_PACK_STRINGS))
359 {
360 SV **svp = hv_fetch (enc->stringref[!!utf8], str, len, 1);
361
362 if (SvOK (*svp))
363 {
364 // already registered, use stringref
365 encode_tag (enc, CBOR_TAG_STRINGREF);
366 encode_uint (enc, MAJOR_POS_INT, SvUV (*svp));
367 return;
368 }
369 else if (len >= minimum_string_length (enc->stringref_idx))
370 {
371 // register only
372 sv_setuv (*svp, enc->stringref_idx);
373 ++enc->stringref_idx;
374 }
375 }
376
377 encode_str (enc, upgrade_utf8, utf8, str, len);
378}
379
380ecb_inline void
381encode_float16 (enc_t *enc, NV nv)
382{
383 need (enc, 1+2);
384
385 *enc->cur++ = MAJOR_MISC | MISC_FLOAT16;
386
387 uint16_t fp = ecb_float_to_binary16 (nv);
388
389 if (!ecb_big_endian ())
390 fp = ecb_bswap16 (fp);
391
392 memcpy (enc->cur, &fp, 2);
393 enc->cur += 2;
394}
395
396ecb_inline void
397encode_float32 (enc_t *enc, NV nv)
398{
399 need (enc, 1+4);
400
401 *enc->cur++ = MAJOR_MISC | MISC_FLOAT32;
402
403 uint32_t fp = ecb_float_to_binary32 (nv);
404
405 if (!ecb_big_endian ())
406 fp = ecb_bswap32 (fp);
407
408 memcpy (enc->cur, &fp, 4);
409 enc->cur += 4;
410}
411
412ecb_inline void
413encode_float64 (enc_t *enc, NV nv)
414{
415 need (enc, 1+8);
416
417 *enc->cur++ = MAJOR_MISC | MISC_FLOAT64;
418
419 uint64_t fp = ecb_double_to_binary64 (nv);
420
421 if (!ecb_big_endian ())
422 fp = ecb_bswap64 (fp);
423
424 memcpy (enc->cur, &fp, 8);
425 enc->cur += 8;
426}
427
428ecb_inline void
429encode_bool (enc_t *enc, int istrue)
430{
431 encode_ch (enc, istrue ? MAJOR_MISC | SIMPLE_TRUE : MAJOR_MISC | SIMPLE_FALSE);
432}
433
434// encodes an arrayref containing key-value pairs as CBOR map
435ecb_inline void
436encode_array_as_map (enc_t *enc, SV *sv)
437{
438 if (enc->depth >= enc->cbor.max_depth)
439 croak (ERR_NESTING_EXCEEDED);
440
441 ++enc->depth;
442
443 // as_map does error checking for us, but we re-check in case
444 // things have changed.
445
446 if (!SvROK (sv) || SvTYPE (SvRV (sv)) != SVt_PVAV)
447 croak ("CBOR::XS::as_map requires an array reference (did you change the array after calling as_map?)");
448
449 AV *av = (AV *)SvRV (sv);
450 int i, len = av_len (av);
451
452 if (!(len & 1))
453 croak ("CBOR::XS::as_map requires an even number of elements (did you change the array after calling as_map?)");
454
455 encode_uint (enc, MAJOR_MAP, (len + 1) >> 1);
456
457 for (i = 0; i <= len; ++i)
458 {
459 SV **svp = av_fetch (av, i, 0);
460 encode_sv (enc, svp ? *svp : &PL_sv_undef);
461 }
462
463 --enc->depth;
464}
465
466ecb_inline void
467encode_forced (enc_t *enc, UV type, SV *sv)
468{
469 switch (type)
470 {
471 case AS_CBOR:
472 {
473 STRLEN len;
474 char *str = SvPVbyte (sv, len);
475
476 need (enc, len);
477 memcpy (enc->cur, str, len);
478 enc->cur += len;
479 }
480 break;
481
482 case AS_BYTES:
483 {
484 STRLEN len;
485 char *str = SvPVbyte (sv, len);
486 encode_strref (enc, 0, 0, str, len);
487 }
488 break;
489
490 case AS_TEXT:
491 {
492 STRLEN len;
493 char *str = SvPVutf8 (sv, len);
494 encode_strref (enc, 1, 1, str, len);
495 }
496 break;
497
498 case AS_INT: encode_int (enc, sv); break;
499
500 case AS_FLOAT16: encode_float16 (enc, SvNV (sv)); break;
501 case AS_FLOAT32: encode_float32 (enc, SvNV (sv)); break;
502 case AS_FLOAT64: encode_float64 (enc, SvNV (sv)); break;
503
504 case AS_MAP: encode_array_as_map (enc, sv); break;
505
506 default:
507 croak ("encountered malformed CBOR::XS::Tagged object");
508 }
509}
171 510
172static void 511static void
173encode_av (enc_t *enc, AV *av) 512encode_av (enc_t *enc, AV *av)
174{ 513{
175 int i, len = av_len (av); 514 int i, len = av_len (av);
177 if (enc->depth >= enc->cbor.max_depth) 516 if (enc->depth >= enc->cbor.max_depth)
178 croak (ERR_NESTING_EXCEEDED); 517 croak (ERR_NESTING_EXCEEDED);
179 518
180 ++enc->depth; 519 ++enc->depth;
181 520
182 encode_uint (enc, 0x80, len + 1); 521 encode_uint (enc, MAJOR_ARRAY, len + 1);
183 522
523 if (ecb_expect_false (SvMAGICAL (av)))
184 for (i = 0; i <= len; ++i) 524 for (i = 0; i <= len; ++i)
185 { 525 {
186 SV **svp = av_fetch (av, i, 0); 526 SV **svp = av_fetch (av, i, 0);
187 encode_sv (enc, svp ? *svp : &PL_sv_undef); 527 encode_sv (enc, svp ? *svp : &PL_sv_undef);
188 } 528 }
529 else
530 for (i = 0; i <= len; ++i)
531 {
532 SV *sv = AvARRAY (av)[i];
533 encode_sv (enc, sv ? sv : &PL_sv_undef);
534 }
189 535
190 --enc->depth; 536 --enc->depth;
191} 537}
192 538
193static void 539static void
201 ++enc->depth; 547 ++enc->depth;
202 548
203 int pairs = hv_iterinit (hv); 549 int pairs = hv_iterinit (hv);
204 int mg = SvMAGICAL (hv); 550 int mg = SvMAGICAL (hv);
205 551
206 if (mg) 552 if (ecb_expect_false (mg))
207 encode_ch (enc, 0xa0 | 31); 553 encode_ch (enc, MAJOR_MAP | MINOR_INDEF);
208 else 554 else
209 encode_uint (enc, 0xa0, pairs); 555 encode_uint (enc, MAJOR_MAP, pairs);
210 556
211 while ((he = hv_iternext (hv))) 557 while ((he = hv_iternext (hv)))
212 { 558 {
213 if (HeKLEN (he) == HEf_SVKEY) 559 if (HeKLEN (he) == HEf_SVKEY)
214 encode_sv (enc, HeSVKEY (he)); 560 encode_sv (enc, HeSVKEY (he));
215 else 561 else
216 encode_str (enc, HeKUTF8 (he), HeKEY (he), HeKLEN (he)); 562 encode_strref (enc, enc->cbor.flags & (F_TEXT_KEYS | F_TEXT_STRINGS), HeKUTF8 (he), HeKEY (he), HeKLEN (he));
217 563
218 encode_sv (enc, ecb_expect_false (mg) ? hv_iterval (hv, he) : HeVAL (he)); 564 encode_sv (enc, ecb_expect_false (mg) ? hv_iterval (hv, he) : HeVAL (he));
219 } 565 }
220 566
221 if (mg) 567 if (ecb_expect_false (mg))
222 encode_ch (enc, 0xe0 | 31); 568 encode_ch (enc, MAJOR_MISC | MINOR_INDEF);
223 569
224 --enc->depth; 570 --enc->depth;
225} 571}
226 572
227// encode objects, arrays and special \0=false and \1=true values. 573// encode objects, arrays and special \0=false and \1=true values.
228static void 574static void
229encode_rv (enc_t *enc, SV *sv) 575encode_rv (enc_t *enc, SV *sv)
230{ 576{
231 svtype svt;
232
233 SvGETMAGIC (sv); 577 SvGETMAGIC (sv);
578
234 svt = SvTYPE (sv); 579 svtype svt = SvTYPE (sv);
235 580
236 if (ecb_expect_false (SvOBJECT (sv))) 581 if (ecb_expect_false (SvOBJECT (sv)))
237 { 582 {
238 HV *stash = !CBOR_SLOW || cbor_boolean_stash 583 HV *boolean_stash = !CBOR_SLOW || types_boolean_stash
239 ? cbor_boolean_stash 584 ? types_boolean_stash
585 : gv_stashpv ("Types::Serialiser::Boolean", 1);
586 HV *error_stash = !CBOR_SLOW || types_error_stash
587 ? types_error_stash
588 : gv_stashpv ("Types::Serialiser::Error", 1);
589 HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash
590 ? cbor_tagged_stash
240 : gv_stashpv ("CBOR::XS::Boolean", 1); 591 : gv_stashpv ("CBOR::XS::Tagged" , 1);
241 592
242 if (SvSTASH (sv) == stash) 593 HV *stash = SvSTASH (sv);
243 encode_ch (enc, SvIV (sv) ? 0xe0 | 21 : 0xe0 | 20); 594
595 if (stash == boolean_stash)
596 {
597 encode_bool (enc, SvIV (sv));
598 return;
599 }
600 else if (stash == error_stash)
601 {
602 encode_ch (enc, MAJOR_MISC | SIMPLE_UNDEF);
603 return;
604 }
605 else if (stash == tagged_stash)
606 {
607 if (svt != SVt_PVAV)
608 croak ("encountered CBOR::XS::Tagged object that isn't an array");
609
610 switch (av_len ((AV *)sv))
611 {
612 case 2-1:
613 // actually a tagged value
614 encode_uint (enc, MAJOR_TAG, SvUV (*av_fetch ((AV *)sv, 0, 1)));
615 encode_sv (enc, *av_fetch ((AV *)sv, 1, 1));
616 break;
617
618 case 3-1:
619 // a forced type [value, type, undef]
620 encode_forced (enc, SvUV (*av_fetch ((AV *)sv, 1, 1)), *av_fetch ((AV *)sv, 0, 1));
621 break;
622
623 default:
624 croak ("encountered malformed CBOR::XS::Tagged object");
625 }
626
627 return;
628 }
629 }
630
631 if (ecb_expect_false (SvREFCNT (sv) > 1)
632 && ecb_expect_false (enc->cbor.flags & F_ALLOW_SHARING))
633 {
634 if (ecb_expect_false (!enc->shareable))
635 enc->shareable = (HV *)sv_2mortal ((SV *)newHV ());
636
637 SV **svp = hv_fetch (enc->shareable, (char *)&sv, sizeof (sv), 1);
638
639 if (SvOK (*svp))
640 {
641 encode_tag (enc, CBOR_TAG_VALUE_SHAREDREF);
642 encode_uint (enc, MAJOR_POS_INT, SvUV (*svp));
643 return;
644 }
244 else 645 else
245 { 646 {
246#if 0 //TODO 647 sv_setuv (*svp, enc->shareable_idx);
247 if (enc->cbor.flags & F_CONV_BLESSED) 648 ++enc->shareable_idx;
649 encode_tag (enc, CBOR_TAG_VALUE_SHAREABLE);
650 }
651 }
652
653 if (ecb_expect_false (SvOBJECT (sv)))
654 {
655 HV *stash = SvSTASH (sv);
656 GV *method;
657
658 if (enc->cbor.flags & F_FORBID_OBJECTS)
659 croak ("encountered object '%s', but forbid_objects is enabled",
660 SvPV_nolen (sv_2mortal (newRV_inc (sv))));
661 else if ((method = gv_fetchmethod_autoload (stash, "TO_CBOR", 0)))
248 { 662 {
663 dSP;
664
665 ENTER; SAVETMPS;
666 PUSHMARK (SP);
249 // we re-bless the reference to get overload and other niceties right 667 // we re-bless the reference to get overload and other niceties right
250 GV *to_cbor = gv_fetchmethod_autoload (SvSTASH (sv), "TO_CBOR", 0);
251
252 if (to_cbor)
253 {
254 dSP;
255
256 ENTER; SAVETMPS; PUSHMARK (SP);
257 XPUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), SvSTASH (sv))); 668 XPUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash));
258 669
259 // calling with G_SCALAR ensures that we always get a 1 return value
260 PUTBACK; 670 PUTBACK;
671 // G_SCALAR ensures that return value is 1
261 call_sv ((SV *)GvCV (to_cbor), G_SCALAR); 672 call_sv ((SV *)GvCV (method), G_SCALAR);
262 SPAGAIN; 673 SPAGAIN;
263 674
264 // catch this surprisingly common error 675 // catch this surprisingly common error
265 if (SvROK (TOPs) && SvRV (TOPs) == sv) 676 if (SvROK (TOPs) && SvRV (TOPs) == sv)
266 croak ("%s::TO_CBOR method returned same object as was passed instead of a new one", HvNAME (SvSTASH (sv))); 677 croak ("%s::TO_CBOR method returned same object as was passed instead of a new one", HvNAME (stash));
267 678
268 sv = POPs;
269 PUTBACK;
270
271 encode_sv (enc, sv); 679 encode_sv (enc, POPs);
272 680
681 PUTBACK;
682
273 FREETMPS; LEAVE; 683 FREETMPS; LEAVE;
274 } 684 }
275 else if (enc->cbor.flags & F_ALLOW_BLESSED) 685 else if ((method = gv_fetchmethod_autoload (stash, "FREEZE", 0)) != 0)
276 encode_str (enc, "null", 4, 0); 686 {
277 else 687 dSP;
278 croak ("encountered object '%s', but neither allow_blessed enabled nor TO_CBOR method available on it", 688
279 SvPV_nolen (sv_2mortal (newRV_inc (sv)))); 689 ENTER; SAVETMPS;
690 PUSHMARK (SP);
691 EXTEND (SP, 2);
692 // we re-bless the reference to get overload and other niceties right
693 PUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash));
694 PUSHs (sv_cbor);
695
696 PUTBACK;
697 int count = call_sv ((SV *)GvCV (method), G_ARRAY);
698 SPAGAIN;
699
700 // catch this surprisingly common error
701 if (count == 1 && SvROK (TOPs) && SvRV (TOPs) == sv)
702 croak ("%s::FREEZE(CBOR) method returned same object as was passed instead of a new one", HvNAME (stash));
703
704 encode_tag (enc, CBOR_TAG_PERL_OBJECT);
705 encode_uint (enc, MAJOR_ARRAY, count + 1);
706 encode_strref (enc, 0, HvNAMEUTF8 (stash), HvNAME (stash), HvNAMELEN (stash));
707
708 {
709 int i;
710
711 for (i = 0; i < count; ++i)
712 encode_sv (enc, SP[i + 1 - count]);
713
714 SP -= count;
280 } 715 }
281 else if (enc->cbor.flags & F_ALLOW_BLESSED) 716
282 encode_str (enc, "null", 4, 0); 717 PUTBACK;
718
719 FREETMPS; LEAVE;
720 }
283 else 721 else
284 croak ("encountered object '%s', but neither allow_blessed nor convert_blessed settings are enabled", 722 croak ("encountered object '%s', but no TO_CBOR or FREEZE methods available on it",
285 SvPV_nolen (sv_2mortal (newRV_inc (sv)))); 723 SvPV_nolen (sv_2mortal (newRV_inc (sv))));
286#endif
287 }
288 } 724 }
289 else if (svt == SVt_PVHV) 725 else if (svt == SVt_PVHV)
290 encode_hv (enc, (HV *)sv); 726 encode_hv (enc, (HV *)sv);
291 else if (svt == SVt_PVAV) 727 else if (svt == SVt_PVAV)
292 encode_av (enc, (AV *)sv); 728 encode_av (enc, (AV *)sv);
293 else if (svt < SVt_PVAV)
294 {
295 STRLEN len = 0;
296 char *pv = svt ? SvPV (sv, len) : 0;
297
298 if (len == 1 && *pv == '1')
299 encode_ch (enc, 0xe0 | 21);
300 else if (len == 1 && *pv == '0')
301 encode_ch (enc, 0xe0 | 20);
302 else if (enc->cbor.flags & F_ALLOW_UNKNOWN)
303 encode_ch (enc, 0xe0 | 23);
304 else
305 croak ("cannot encode reference to scalar '%s' unless the scalar is 0 or 1",
306 SvPV_nolen (sv_2mortal (newRV_inc (sv))));
307 }
308 else if (enc->cbor.flags & F_ALLOW_UNKNOWN)
309 encode_ch (enc, 0xe0 | 23);
310 else 729 else
311 croak ("encountered %s, but CBOR can only represent references to arrays or hashes", 730 {
312 SvPV_nolen (sv_2mortal (newRV_inc (sv)))); 731 encode_tag (enc, CBOR_TAG_INDIRECTION);
732 encode_sv (enc, sv);
733 }
313} 734}
314 735
315static void 736static void
316encode_nv (enc_t *enc, SV *sv) 737encode_nv (enc_t *enc, SV *sv)
317{ 738{
318 double nv = SvNVX (sv); 739 double nv = SvNVX (sv);
319 740
320 need (enc, 9); 741 need (enc, 9);
321 742
322 if (ecb_expect_false (nv == (U32)nv)) 743 if (ecb_expect_false (nv == (NV)(U32)nv))
323 encode_uint (enc, 0x00, (U32)nv); 744 encode_uint (enc, MAJOR_POS_INT, (U32)nv);
324 //TODO: maybe I32? 745 //TODO: maybe I32?
325 else if (ecb_expect_false (nv == (float)nv)) 746 else if (ecb_expect_false (nv == (float)nv))
326 { 747 encode_float32 (enc, nv);
327 uint32_t fp = ecb_float_to_binary32 (nv);
328
329 *enc->cur++ = 0xe0 | 26;
330
331 if (!ecb_big_endian ())
332 fp = ecb_bswap32 (fp);
333
334 memcpy (enc->cur, &fp, 4);
335 enc->cur += 4;
336 }
337 else 748 else
338 { 749 encode_float64 (enc, nv);
339 uint64_t fp = ecb_double_to_binary64 (nv);
340
341 *enc->cur++ = 0xe0 | 27;
342
343 if (!ecb_big_endian ())
344 fp = ecb_bswap64 (fp);
345
346 memcpy (enc->cur, &fp, 8);
347 enc->cur += 8;
348 }
349} 750}
350 751
351static void 752static void
352encode_sv (enc_t *enc, SV *sv) 753encode_sv (enc_t *enc, SV *sv)
353{ 754{
355 756
356 if (SvPOKp (sv)) 757 if (SvPOKp (sv))
357 { 758 {
358 STRLEN len; 759 STRLEN len;
359 char *str = SvPV (sv, len); 760 char *str = SvPV (sv, len);
360 encode_str (enc, SvUTF8 (sv), str, len); 761 encode_strref (enc, enc->cbor.flags & F_TEXT_STRINGS, SvUTF8 (sv), str, len);
361 } 762 }
362 else if (SvNOKp (sv)) 763 else if (SvNOKp (sv))
363 encode_nv (enc, sv); 764 encode_nv (enc, sv);
364 else if (SvIOKp (sv)) 765 else if (SvIOKp (sv))
365 { 766 encode_int (enc, sv);
366 if (SvIsUV (sv))
367 encode_uint (enc, 0x00, SvUVX (sv));
368 else if (SvIVX (sv) >= 0)
369 encode_uint (enc, 0x00, SvIVX (sv));
370 else
371 encode_uint (enc, 0x20, -(SvIVX (sv) + 1));
372 }
373 else if (SvROK (sv)) 767 else if (SvROK (sv))
374 encode_rv (enc, SvRV (sv)); 768 encode_rv (enc, SvRV (sv));
375 else if (!SvOK (sv)) 769 else if (!SvOK (sv))
376 encode_ch (enc, 0xe0 | 22); 770 encode_ch (enc, MAJOR_MISC | SIMPLE_NULL);
377 else if (enc->cbor.flags & F_ALLOW_UNKNOWN) 771 else if (enc->cbor.flags & F_ALLOW_UNKNOWN)
378 encode_ch (enc, 0xe0 | 23); 772 encode_ch (enc, MAJOR_MISC | SIMPLE_UNDEF);
379 else 773 else
380 croak ("encountered perl type (%s,0x%x) that CBOR cannot handle, check your input data", 774 croak ("encountered perl type (%s,0x%x) that CBOR cannot handle, check your input data",
381 SvPV_nolen (sv), (unsigned int)SvFLAGS (sv)); 775 SvPV_nolen (sv), (unsigned int)SvFLAGS (sv));
382} 776}
383 777
384static SV * 778static SV *
385encode_cbor (SV *scalar, CBOR *cbor) 779encode_cbor (SV *scalar, CBOR *cbor)
386{ 780{
387 enc_t enc; 781 enc_t enc = { 0 };
388 782
389 enc.cbor = *cbor; 783 enc.cbor = *cbor;
390 enc.sv = sv_2mortal (NEWSV (0, INIT_SIZE)); 784 enc.sv = sv_2mortal (NEWSV (0, INIT_SIZE));
391 enc.cur = SvPVX (enc.sv); 785 enc.cur = SvPVX (enc.sv);
392 enc.end = SvEND (enc.sv); 786 enc.end = SvEND (enc.sv);
393 enc.depth = 0;
394 787
395 SvPOK_only (enc.sv); 788 SvPOK_only (enc.sv);
789
790 if (cbor->flags & F_PACK_STRINGS)
791 {
792 encode_tag (&enc, CBOR_TAG_STRINGREF_NAMESPACE);
793 enc.stringref[0]= (HV *)sv_2mortal ((SV *)newHV ());
794 enc.stringref[1]= (HV *)sv_2mortal ((SV *)newHV ());
795 }
796
396 encode_sv (&enc, scalar); 797 encode_sv (&enc, scalar);
397 798
398 SvCUR_set (enc.sv, enc.cur - SvPVX (enc.sv)); 799 SvCUR_set (enc.sv, enc.cur - SvPVX (enc.sv));
399 *SvEND (enc.sv) = 0; // many xs functions expect a trailing 0 for text strings 800 *SvEND (enc.sv) = 0; // many xs functions expect a trailing 0 for text strings
400 801
414 U8 *end; // end of input string 815 U8 *end; // end of input string
415 const char *err; // parse error, if != 0 816 const char *err; // parse error, if != 0
416 CBOR cbor; 817 CBOR cbor;
417 U32 depth; // recursion depth 818 U32 depth; // recursion depth
418 U32 maxdepth; // recursion depth limit 819 U32 maxdepth; // recursion depth limit
820 AV *shareable;
821 AV *stringref;
822 SV *decode_tagged;
823 SV *err_sv; // optional sv for error, needs to be freed
419} dec_t; 824} dec_t;
420 825
421#define ERR(reason) SB if (!dec->err) dec->err = reason; goto fail; SE 826// set dec->err to ERRSV
827ecb_cold static void
828err_errsv (dec_t *dec)
829{
830 if (!dec->err)
831 {
832 dec->err_sv = newSVsv (ERRSV);
422 833
423#define WANT(len) if (ecb_expect_false (dec->cur + len > dec->end)) ERR ("unexpected end of CBOR data") 834 // chop off the trailing \n
835 SvCUR_set (dec->err_sv, SvCUR (dec->err_sv) - 1);
836 *SvEND (dec->err_sv) = 0;
424 837
838 dec->err = SvPVutf8_nolen (dec->err_sv);
839 }
840}
841
842// the following functions are used to reduce code size and help the compiler to optimise
843ecb_cold static void
844err_set (dec_t *dec, const char *reason)
845{
846 if (!dec->err)
847 dec->err = reason;
848}
849
850ecb_cold static void
851err_unexpected_end (dec_t *dec)
852{
853 err_set (dec, "unexpected end of CBOR data");
854}
855
856#define ERR_DO(do) SB do; goto fail; SE
857#define ERR(reason) ERR_DO (err_set (dec, reason))
858#define ERR_ERRSV ERR_DO (err_errsv (dec))
859
860#define WANT(len) if (ecb_expect_false ((uintptr_t)(dec->end - dec->cur) < (STRLEN)len)) ERR_DO (err_unexpected_end (dec))
861
425#define DEC_INC_DEPTH if (++dec->depth > dec->cbor.max_depth) ERR (ERR_NESTING_EXCEEDED) 862#define DEC_INC_DEPTH if (ecb_expect_false (++dec->depth > dec->cbor.max_depth)) ERR (ERR_NESTING_EXCEEDED)
426#define DEC_DEC_DEPTH --dec->depth 863#define DEC_DEC_DEPTH --dec->depth
427 864
428static UV 865static UV
429decode_uint (dec_t *dec) 866decode_uint (dec_t *dec)
430{ 867{
431 switch (*dec->cur & 31) 868 U8 m = *dec->cur & MINOR_MASK;
432 { 869 ++dec->cur;
433 case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
434 case 8: case 9: case 10: case 11: case 12: case 13: case 14: case 15:
435 case 16: case 17: case 18: case 19: case 20: case 21: case 22: case 23:
436 return *dec->cur++ & 31;
437 870
438 case 24: 871 if (ecb_expect_true (m < LENGTH_EXT1))
872 return m;
873 else if (ecb_expect_true (m == LENGTH_EXT1))
874 {
439 WANT (2); 875 WANT (1);
440 dec->cur += 2; 876 dec->cur += 1;
441 return dec->cur[-1]; 877 return dec->cur[-1];
442 878 }
443 case 25: 879 else if (ecb_expect_true (m == LENGTH_EXT2))
880 {
444 WANT (3); 881 WANT (2);
445 dec->cur += 3; 882 dec->cur += 2;
446 return (((UV)dec->cur[-2]) << 8) 883 return (((UV)dec->cur[-2]) << 8)
447 | ((UV)dec->cur[-1]); 884 | ((UV)dec->cur[-1]);
448 885 }
449 case 26: 886 else if (ecb_expect_true (m == LENGTH_EXT4))
887 {
450 WANT (5); 888 WANT (4);
451 dec->cur += 5; 889 dec->cur += 4;
452 return (((UV)dec->cur[-4]) << 24) 890 return (((UV)dec->cur[-4]) << 24)
453 | (((UV)dec->cur[-3]) << 16) 891 | (((UV)dec->cur[-3]) << 16)
454 | (((UV)dec->cur[-2]) << 8) 892 | (((UV)dec->cur[-2]) << 8)
455 | ((UV)dec->cur[-1]); 893 | ((UV)dec->cur[-1]);
456 894 }
457 case 27: 895 else if (ecb_expect_true (m == LENGTH_EXT8))
896 {
458 WANT (9); 897 WANT (8);
459 dec->cur += 9; 898 dec->cur += 8;
899
900 return
901#if UVSIZE < 8
902 0
903#else
460 return (((UV)dec->cur[-8]) << 56) 904 (((UV)dec->cur[-8]) << 56)
461 | (((UV)dec->cur[-7]) << 48) 905 | (((UV)dec->cur[-7]) << 48)
462 | (((UV)dec->cur[-6]) << 40) 906 | (((UV)dec->cur[-6]) << 40)
463 | (((UV)dec->cur[-5]) << 32) 907 | (((UV)dec->cur[-5]) << 32)
908#endif
464 | (((UV)dec->cur[-4]) << 24) 909 | (((UV)dec->cur[-4]) << 24)
465 | (((UV)dec->cur[-3]) << 16) 910 | (((UV)dec->cur[-3]) << 16)
466 | (((UV)dec->cur[-2]) << 8) 911 | (((UV)dec->cur[-2]) << 8)
467 | ((UV)dec->cur[-1]); 912 | ((UV)dec->cur[-1]);
468 913 }
469 default: 914 else
470 ERR ("corrupted CBOR data (unsupported integer minor encoding)"); 915 ERR ("corrupted CBOR data (unsupported integer minor encoding)");
471 }
472 916
473fail: 917fail:
474 return 0; 918 return 0;
475} 919}
476 920
481{ 925{
482 AV *av = newAV (); 926 AV *av = newAV ();
483 927
484 DEC_INC_DEPTH; 928 DEC_INC_DEPTH;
485 929
486 if ((*dec->cur & 31) == 31) 930 if (*dec->cur == (MAJOR_ARRAY | MINOR_INDEF))
487 { 931 {
488 ++dec->cur; 932 ++dec->cur;
489 933
490 for (;;) 934 for (;;)
491 { 935 {
492 WANT (1); 936 WANT (1);
493 937
494 if (*dec->cur == (0xe0 | 31)) 938 if (*dec->cur == (MAJOR_MISC | MINOR_INDEF) || dec->err)
495 { 939 {
496 ++dec->cur; 940 ++dec->cur;
497 break; 941 break;
498 } 942 }
499 943
500 av_push (av, decode_sv (dec)); 944 av_push (av, decode_sv (dec));
501 } 945 }
502 } 946 }
503 else 947 else
504 { 948 {
505 int i, len = decode_uint (dec); 949 UV i, len = decode_uint (dec);
506 950
951 WANT (len); // complexity check for av_fill - need at least one byte per value, do not allow supersize arrays
507 av_fill (av, len - 1); 952 av_fill (av, len - 1);
508 953
509 for (i = 0; i < len; ++i) 954 for (i = 0; i < len; ++i)
510 AvARRAY (av)[i] = decode_sv (dec); 955 AvARRAY (av)[i] = decode_sv (dec);
511 } 956 }
512 957
513 DEC_DEC_DEPTH; 958 DEC_DEC_DEPTH;
514 return newRV_noinc ((SV *)av); 959 return newRV_noinc ((SV *)av);
515 960
516fail: 961fail:
517 SvREFCNT_dec (av); 962 SvREFCNT_dec_NN (av);
518 DEC_DEC_DEPTH; 963 DEC_DEC_DEPTH;
519 return &PL_sv_undef; 964 return &PL_sv_undef;
520} 965}
521 966
967static void
968decode_he (dec_t *dec, HV *hv)
969{
970 // for speed reasons, we specialcase single-string
971 // byte or utf-8 strings as keys, but only when !stringref
972
973 if (ecb_expect_true (!dec->stringref))
974 if (ecb_expect_true ((U8)(*dec->cur - MAJOR_BYTES) <= LENGTH_EXT8))
975 {
976 STRLEN len = decode_uint (dec);
977 char *key = (char *)dec->cur;
978
979 WANT (len);
980 dec->cur += len;
981
982 hv_store (hv, key, len, decode_sv (dec), 0);
983
984 return;
985 }
986 else if (ecb_expect_true ((U8)(*dec->cur - MAJOR_TEXT) <= LENGTH_EXT8))
987 {
988 STRLEN len = decode_uint (dec);
989 char *key = (char *)dec->cur;
990
991 WANT (len);
992 dec->cur += len;
993
994 if (ecb_expect_false (dec->cbor.flags & F_VALIDATE_UTF8))
995 if (!cbor_is_utf8_string ((U8 *)key, len))
996 ERR ("corrupted CBOR data (invalid UTF-8 in map key)");
997
998 hv_store (hv, key, -len, decode_sv (dec), 0);
999
1000 return;
1001 }
1002
1003 SV *k = decode_sv (dec);
1004 SV *v = decode_sv (dec);
1005
1006 // we leak memory if uncaught exceptions are thrown by random magical
1007 // methods, and this is hopefully the only place where it can happen,
1008 // so if there is a chance of an exception, take the very slow path.
1009 // since catching exceptions is "undocumented/internal/forbidden" by
1010 // the new p5p powers, we need to call out to a perl function :/
1011 if (ecb_expect_false (SvAMAGIC (k)))
1012 {
1013 dSP;
1014
1015 ENTER; SAVETMPS;
1016 PUSHMARK (SP);
1017 EXTEND (SP, 3);
1018 PUSHs (sv_2mortal (newRV_inc ((SV *)hv)));
1019 PUSHs (sv_2mortal (k));
1020 PUSHs (sv_2mortal (v));
1021
1022 PUTBACK;
1023 call_pv ("CBOR::XS::_hv_store", G_VOID | G_DISCARD | G_EVAL);
1024 SPAGAIN;
1025
1026 FREETMPS; LEAVE;
1027
1028 if (SvTRUE (ERRSV))
1029 ERR_ERRSV;
1030
1031 return;
1032 }
1033
1034 hv_store_ent (hv, k, v, 0);
1035 SvREFCNT_dec_NN (k);
1036
1037fail:
1038 ;
1039}
1040
522static SV * 1041static SV *
523decode_hv (dec_t *dec) 1042decode_hv (dec_t *dec)
524{ 1043{
525 HV *hv = newHV (); 1044 HV *hv = newHV ();
526 1045
527 DEC_INC_DEPTH; 1046 DEC_INC_DEPTH;
528 1047
529 if ((*dec->cur & 31) == 31) 1048 if (*dec->cur == (MAJOR_MAP | MINOR_INDEF))
530 { 1049 {
531 ++dec->cur; 1050 ++dec->cur;
532 1051
533 for (;;) 1052 for (;;)
534 { 1053 {
535 WANT (1); 1054 WANT (1);
536 1055
537 if (*dec->cur == (0xe0 | 31)) 1056 if (*dec->cur == (MAJOR_MISC | MINOR_INDEF) || dec->err)
538 { 1057 {
539 ++dec->cur; 1058 ++dec->cur;
540 break; 1059 break;
541 } 1060 }
542 1061
543 SV *k = decode_sv (dec); 1062 decode_he (dec, hv);
544 SV *v = decode_sv (dec);
545
546 hv_store_ent (hv, k, v, 0);
547 } 1063 }
548 } 1064 }
549 else 1065 else
550 { 1066 {
551 int len = decode_uint (dec); 1067 UV pairs = decode_uint (dec);
552 1068
1069 WANT (pairs); // complexity check - need at least one byte per value, do not allow supersize hashes
1070
553 while (len--) 1071 while (pairs--)
554 { 1072 decode_he (dec, hv);
555 SV *k = decode_sv (dec);
556 SV *v = decode_sv (dec);
557
558 hv_store_ent (hv, k, v, 0);
559 }
560 } 1073 }
561 1074
562 DEC_DEC_DEPTH; 1075 DEC_DEC_DEPTH;
563 return newRV_noinc ((SV *)hv); 1076 return newRV_noinc ((SV *)hv);
564 1077
565#if 0 1078fail:
566 SV *sv; 1079 SvREFCNT_dec_NN (hv);
567 HV *hv = newHV ();
568
569 DEC_INC_DEPTH; 1080 DEC_DEC_DEPTH;
570 decode_ws (dec); 1081 return &PL_sv_undef;
1082}
571 1083
572 for (;;) 1084static SV *
573 { 1085decode_str (dec_t *dec, int utf8)
574 // heuristic: assume that 1086{
575 // a) decode_str + hv_store_ent are abysmally slow. 1087 SV *sv = 0;
576 // b) most hash keys are short, simple ascii text. 1088
577 // => try to "fast-match" such strings to avoid 1089 if (ecb_expect_false ((*dec->cur & MINOR_MASK) == MINOR_INDEF))
578 // the overhead of decode_str + hv_store_ent.
579 { 1090 {
580 SV *value; 1091 // indefinite length strings
581 char *p = dec->cur; 1092 ++dec->cur;
582 char *e = p + 24; // only try up to 24 bytes
583 1093
1094 U8 major = *dec->cur & MAJOR_MISC;
1095
1096 sv = newSVpvn ("", 0);
1097
584 for (;;) 1098 for (;;)
585 { 1099 {
586 // the >= 0x80 is false on most architectures 1100 WANT (1);
587 if (p == e || *p < 0x20 || *p >= 0x80 || *p == '\\') 1101
1102 if ((*dec->cur - major) > LENGTH_EXT8)
1103 if (*dec->cur == (MAJOR_MISC | MINOR_INDEF))
588 { 1104 {
589 // slow path, back up and use decode_str 1105 ++dec->cur;
590 SV *key = decode_str (dec);
591 if (!key)
592 goto fail;
593
594 decode_ws (dec); EXPECT_CH (':');
595
596 decode_ws (dec);
597 value = decode_sv (dec);
598 if (!value)
599 {
600 SvREFCNT_dec (key);
601 goto fail;
602 }
603
604 hv_store_ent (hv, key, value, 0);
605 SvREFCNT_dec (key);
606
607 break; 1106 break;
608 } 1107 }
609 else if (*p == '"')
610 {
611 // fast path, got a simple key
612 char *key = dec->cur;
613 int len = p - key;
614 dec->cur = p + 1;
615
616 decode_ws (dec); EXPECT_CH (':');
617
618 decode_ws (dec);
619 value = decode_sv (dec);
620 if (!value)
621 goto fail;
622
623 hv_store (hv, key, len, value, 0);
624
625 break;
626 }
627
628 ++p;
629 }
630 }
631
632 decode_ws (dec);
633
634 if (*dec->cur == '}')
635 {
636 ++dec->cur;
637 break;
638 }
639
640 if (*dec->cur != ',')
641 ERR (", or } expected while parsing object/hash");
642
643 ++dec->cur;
644
645 decode_ws (dec);
646
647 if (*dec->cur == '}' && dec->cbor.flags & F_RELAXED)
648 {
649 ++dec->cur;
650 break;
651 }
652 }
653
654 DEC_DEC_DEPTH;
655 sv = newRV_noinc ((SV *)hv);
656
657 // check filter callbacks
658 if (dec->cbor.flags & F_HOOK)
659 {
660 if (dec->cbor.cb_sk_object && HvKEYS (hv) == 1)
661 {
662 HE *cb, *he;
663
664 hv_iterinit (hv);
665 he = hv_iternext (hv);
666 hv_iterinit (hv);
667
668 // the next line creates a mortal sv each time its called.
669 // might want to optimise this for common cases.
670 cb = hv_fetch_ent (dec->cbor.cb_sk_object, hv_iterkeysv (he), 0, 0);
671
672 if (cb)
673 { 1108 else
674 dSP; 1109 ERR ("corrupted CBOR data (invalid chunks in indefinite length string)");
675 int count;
676 1110
677 ENTER; SAVETMPS; PUSHMARK (SP); 1111 STRLEN len = decode_uint (dec);
678 XPUSHs (HeVAL (he));
679 sv_2mortal (sv);
680 1112
681 PUTBACK; count = call_sv (HeVAL (cb), G_ARRAY); SPAGAIN;
682
683 if (count == 1)
684 {
685 sv = newSVsv (POPs);
686 FREETMPS; LEAVE;
687 return sv;
688 }
689
690 SvREFCNT_inc (sv);
691 FREETMPS; LEAVE;
692 }
693 }
694
695 if (dec->cbor.cb_object)
696 {
697 dSP;
698 int count;
699
700 ENTER; SAVETMPS; PUSHMARK (SP);
701 XPUSHs (sv_2mortal (sv));
702
703 PUTBACK; count = call_sv (dec->cbor.cb_object, G_ARRAY); SPAGAIN;
704
705 if (count == 1)
706 {
707 sv = newSVsv (POPs);
708 FREETMPS; LEAVE;
709 return sv;
710 }
711
712 SvREFCNT_inc (sv);
713 FREETMPS; LEAVE;
714 }
715 }
716
717 return sv;
718#endif
719
720fail:
721 SvREFCNT_dec (hv);
722 DEC_DEC_DEPTH;
723 return &PL_sv_undef;
724}
725
726static SV *
727decode_str (dec_t *dec, int utf8)
728{
729 SV *sv;
730
731 if ((*dec->cur & 31) == 31)
732 {
733 ++dec->cur;
734
735 sv = newSVpvn ("", 0);
736
737 // not very fast, and certainly not robust against illegal input
738 for (;;)
739 {
740 WANT (1); 1113 WANT (len);
741 1114 sv_catpvn (sv, dec->cur, len);
742 if (*dec->cur == (0xe0 | 31)) 1115 dec->cur += len;
743 {
744 ++dec->cur;
745 break;
746 }
747
748 SV *sv2 = decode_sv (dec);
749 sv_catsv (sv, sv2);
750 } 1116 }
751 } 1117 }
752 else 1118 else
753 { 1119 {
754 STRLEN len = decode_uint (dec); 1120 STRLEN len = decode_uint (dec);
755 1121
756 WANT (len); 1122 WANT (len);
757 sv = newSVpvn (dec->cur, len); 1123 sv = newSVpvn (dec->cur, len);
758 dec->cur += len; 1124 dec->cur += len;
1125
1126 if (ecb_expect_false (dec->stringref)
1127 && SvCUR (sv) >= minimum_string_length (AvFILLp (dec->stringref) + 1))
1128 av_push (dec->stringref, SvREFCNT_inc_NN (sv));
759 } 1129 }
760 1130
761 if (utf8) 1131 if (utf8)
1132 {
1133 if (ecb_expect_false (dec->cbor.flags & F_VALIDATE_UTF8))
1134 if (!cbor_is_utf8_string (SvPVX (sv), SvCUR (sv)))
1135 ERR ("corrupted CBOR data (invalid UTF-8 in text string)");
1136
762 SvUTF8_on (sv); 1137 SvUTF8_on (sv);
1138 }
763 1139
764 return sv; 1140 return sv;
765 1141
766fail: 1142fail:
1143 SvREFCNT_dec (sv);
767 return &PL_sv_undef; 1144 return &PL_sv_undef;
768} 1145}
769 1146
770static SV * 1147static SV *
771decode_tagged (dec_t *dec) 1148decode_tagged (dec_t *dec)
772{ 1149{
1150 SV *sv = 0;
773 UV tag = decode_uint (dec); 1151 UV tag = decode_uint (dec);
1152
1153 WANT (1);
1154
1155 switch (tag)
1156 {
1157 case CBOR_TAG_MAGIC:
774 SV *sv = decode_sv (dec); 1158 sv = decode_sv (dec);
1159 break;
775 1160
776 if (tag == 55799) // 2.4.5 Self-Describe CBOR 1161 case CBOR_TAG_INDIRECTION:
1162 sv = newRV_noinc (decode_sv (dec));
1163 break;
1164
1165 case CBOR_TAG_STRINGREF_NAMESPACE:
1166 {
1167 // do not use SAVETMPS/FREETMPS, as these will
1168 // erase mortalised caches, e.g. "shareable"
1169 ENTER;
1170
1171 SAVESPTR (dec->stringref);
1172 dec->stringref = (AV *)sv_2mortal ((SV *)newAV ());
1173
1174 sv = decode_sv (dec);
1175
1176 LEAVE;
1177 }
1178 break;
1179
1180 case CBOR_TAG_STRINGREF:
1181 {
1182 if ((*dec->cur >> MAJOR_SHIFT) != (MAJOR_POS_INT >> MAJOR_SHIFT))
1183 ERR ("corrupted CBOR data (stringref index not an unsigned integer)");
1184
1185 UV idx = decode_uint (dec);
1186
1187 if (!dec->stringref || idx >= (UV)(1 + AvFILLp (dec->stringref)))
1188 ERR ("corrupted CBOR data (stringref index out of bounds or outside namespace)");
1189
1190 sv = newSVsv (AvARRAY (dec->stringref)[idx]);
1191 }
1192 break;
1193
1194 case CBOR_TAG_VALUE_SHAREABLE:
1195 {
1196 if (ecb_expect_false (!dec->shareable))
1197 dec->shareable = (AV *)sv_2mortal ((SV *)newAV ());
1198
1199 if (dec->cbor.flags & F_ALLOW_CYCLES)
1200 {
1201 // if cycles are allowed, then we store an AV as value
1202 // while it is being decoded, and gather unresolved
1203 // references in it, to be re4solved after decoding.
1204 int idx, i;
1205 AV *av = newAV ();
1206 av_push (dec->shareable, SvREFCNT_inc_NN ((SV *)av));
1207 idx = AvFILLp (dec->shareable);
1208
1209 sv = decode_sv (dec);
1210
1211 // the AV now contains \undef for all unresolved references,
1212 // so we fix them up here.
1213 for (i = 0; i <= AvFILLp (av); ++i)
1214 SvRV_set (AvARRAY (av)[i], SvREFCNT_inc_NN (SvRV (sv)));
1215
1216 // now replace the AV by a reference to the completed value
1217 SvREFCNT_dec_NN (av);
1218 AvARRAY (dec->shareable)[idx] = SvREFCNT_inc_NN (sv);
1219 }
1220 else
1221 {
1222 av_push (dec->shareable, &PL_sv_undef);
1223 int idx = AvFILLp (dec->shareable);
1224 sv = decode_sv (dec);
1225 av_store (dec->shareable, idx, SvREFCNT_inc_NN (sv));
1226 }
1227 }
1228 break;
1229
1230 case CBOR_TAG_VALUE_SHAREDREF:
1231 {
1232 if ((*dec->cur >> MAJOR_SHIFT) != (MAJOR_POS_INT >> MAJOR_SHIFT))
1233 ERR ("corrupted CBOR data (sharedref index not an unsigned integer)");
1234
1235 UV idx = decode_uint (dec);
1236
1237 if (!dec->shareable || idx >= (UV)(1 + AvFILLp (dec->shareable)))
1238 ERR ("corrupted CBOR data (sharedref index out of bounds)");
1239
1240 sv = AvARRAY (dec->shareable)[idx];
1241
1242 // reference to cycle, we create a new \undef and use that, and also
1243 // registerr it in the AV for later fixing
1244 if (SvTYPE (sv) == SVt_PVAV)
1245 {
1246 AV *av = (AV *)sv;
1247 sv = newRV_noinc (&PL_sv_undef);
1248 av_push (av, sv);
1249 }
1250 else if (sv == &PL_sv_undef) // not yet decoded, but cycles not allowed
1251 ERR ("cyclic CBOR data structure found, but allow_cycles is not enabled");
1252 else // we decoded the object earlier, no cycle
1253 sv = newSVsv (sv);
1254 }
1255 break;
1256
1257 case CBOR_TAG_PERL_OBJECT:
1258 {
1259 if (dec->cbor.flags & F_FORBID_OBJECTS)
1260 goto filter;
1261
1262 sv = decode_sv (dec);
1263
1264 if (!SvROK (sv) || SvTYPE (SvRV (sv)) != SVt_PVAV)
1265 ERR ("corrupted CBOR data (non-array perl object)");
1266
1267 AV *av = (AV *)SvRV (sv);
1268 int len = av_len (av) + 1;
1269 HV *stash = gv_stashsv (*av_fetch (av, 0, 1), 0);
1270
1271 if (!stash)
1272 ERR ("cannot decode perl-object (package does not exist)");
1273
1274 GV *method = gv_fetchmethod_autoload (stash, "THAW", 0);
1275
1276 if (!method)
1277 ERR ("cannot decode perl-object (package does not have a THAW method)");
1278
1279 dSP;
1280
1281 ENTER; SAVETMPS;
1282 PUSHMARK (SP);
1283 EXTEND (SP, len + 1);
1284 // we re-bless the reference to get overload and other niceties right
1285 PUSHs (*av_fetch (av, 0, 1));
1286 PUSHs (sv_cbor);
1287
1288 int i;
1289
1290 for (i = 1; i < len; ++i)
1291 PUSHs (*av_fetch (av, i, 1));
1292
1293 PUTBACK;
1294 call_sv ((SV *)GvCV (method), G_SCALAR | G_EVAL);
1295 SPAGAIN;
1296
1297 if (SvTRUE (ERRSV))
1298 {
1299 FREETMPS; LEAVE;
1300 ERR_ERRSV;
1301 }
1302
1303 SvREFCNT_dec_NN (sv);
1304 sv = SvREFCNT_inc (POPs);
1305
1306 PUTBACK;
1307
1308 FREETMPS; LEAVE;
1309 }
1310 break;
1311
1312 default:
1313 filter:
1314 {
1315 SV *tag_sv = newSVuv (tag);
1316
1317 sv = decode_sv (dec);
1318
1319 dSP;
1320 ENTER; SAVETMPS;
1321 PUSHMARK (SP);
1322 EXTEND (SP, 2);
1323 PUSHs (tag_sv);
1324 PUSHs (sv);
1325
1326 PUTBACK;
1327 int count = call_sv (dec->cbor.filter ? dec->cbor.filter : default_filter, G_ARRAY | G_EVAL);
1328 SPAGAIN;
1329
1330 if (SvTRUE (ERRSV))
1331 {
1332 SvREFCNT_dec_NN (tag_sv);
1333 FREETMPS; LEAVE;
1334 ERR_ERRSV;
1335 }
1336
1337 if (count)
1338 {
1339 SvREFCNT_dec_NN (tag_sv);
1340 SvREFCNT_dec_NN (sv);
1341 sv = SvREFCNT_inc_NN (TOPs);
1342 SP -= count;
1343 }
1344 else
1345 {
1346 AV *av = newAV ();
1347 av_push (av, tag_sv);
1348 av_push (av, sv);
1349
1350 HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash
1351 ? cbor_tagged_stash
1352 : gv_stashpv ("CBOR::XS::Tagged" , 1);
1353 sv = sv_bless (newRV_noinc ((SV *)av), tagged_stash);
1354 }
1355
1356 PUTBACK;
1357
1358 FREETMPS; LEAVE;
1359 }
1360 break;
1361 }
1362
777 return sv; 1363 return sv;
778 1364
779 AV *av = newAV (); 1365fail:
780 av_push (av, newSVuv (tag)); 1366 SvREFCNT_dec (sv);
781 av_push (av, sv); 1367 return &PL_sv_undef;
782 return newRV_noinc ((SV *)av);
783} 1368}
784 1369
785static SV * 1370static SV *
786decode_sv (dec_t *dec) 1371decode_sv (dec_t *dec)
787{ 1372{
788 WANT (1); 1373 WANT (1);
789 1374
790 switch (*dec->cur >> 5) 1375 switch (*dec->cur >> MAJOR_SHIFT)
791 { 1376 {
792 case 0: // unsigned int 1377 case MAJOR_POS_INT >> MAJOR_SHIFT: return newSVuv (decode_uint (dec));
793 //TODO: 64 bit values on 3 2bit perls 1378 case MAJOR_NEG_INT >> MAJOR_SHIFT: return newSViv (-1 - (IV)decode_uint (dec));
794 return newSVuv (decode_uint (dec)); 1379 case MAJOR_BYTES >> MAJOR_SHIFT: return decode_str (dec, 0);
795 case 1: // negative int 1380 case MAJOR_TEXT >> MAJOR_SHIFT: return decode_str (dec, 1);
796 return newSViv (-1 - (IV)decode_uint (dec)); 1381 case MAJOR_ARRAY >> MAJOR_SHIFT: return decode_av (dec);
797 case 2: // octet string 1382 case MAJOR_MAP >> MAJOR_SHIFT: return decode_hv (dec);
798 return decode_str (dec, 0); 1383 case MAJOR_TAG >> MAJOR_SHIFT: return decode_tagged (dec);
799 case 3: // utf-8 string 1384
800 return decode_str (dec, 1); 1385 case MAJOR_MISC >> MAJOR_SHIFT:
801 case 4: // array
802 return decode_av (dec);
803 case 5: // map
804 return decode_hv (dec);
805 case 6: // tag
806 return decode_tagged (dec);
807 case 7: // misc
808 switch (*dec->cur++ & 31) 1386 switch (*dec->cur++ & MINOR_MASK)
809 { 1387 {
810 case 20: 1388 case SIMPLE_FALSE:
811#if CBOR_SLOW 1389#if CBOR_SLOW
812 cbor_false = get_bool ("CBOR::XS::false"); 1390 types_false = get_bool ("Types::Serialiser::false");
813#endif 1391#endif
814 return newSVsv (cbor_false); 1392 return newSVsv (types_false);
815 case 21: 1393 case SIMPLE_TRUE:
816#if CBOR_SLOW 1394#if CBOR_SLOW
817 cbor_true = get_bool ("CBOR::XS::true"); 1395 types_true = get_bool ("Types::Serialiser::true");
818#endif 1396#endif
819 return newSVsv (cbor_true); 1397 return newSVsv (types_true);
820 case 22: 1398 case SIMPLE_NULL:
821 return newSVsv (&PL_sv_undef); 1399 return newSVsv (&PL_sv_undef);
1400 case SIMPLE_UNDEF:
1401#if CBOR_SLOW
1402 types_error = get_bool ("Types::Serialiser::error");
1403#endif
1404 return newSVsv (types_error);
822 1405
823 case 25: 1406 case MISC_FLOAT16:
824 { 1407 {
825 WANT (2); 1408 WANT (2);
826 1409
827 uint16_t fp = (dec->cur[0] << 8) | dec->cur[1]; 1410 uint16_t fp = (dec->cur[0] << 8) | dec->cur[1];
828 dec->cur += 2; 1411 dec->cur += 2;
829 1412
830 return newSVnv (ecb_binary16_to_float (fp)); 1413 return newSVnv (ecb_binary16_to_float (fp));
831 } 1414 }
832 1415
833 case 26: 1416 case MISC_FLOAT32:
834 { 1417 {
835 uint32_t fp; 1418 uint32_t fp;
836 WANT (4); 1419 WANT (4);
837 memcpy (&fp, dec->cur, 4); 1420 memcpy (&fp, dec->cur, 4);
838 dec->cur += 4; 1421 dec->cur += 4;
841 fp = ecb_bswap32 (fp); 1424 fp = ecb_bswap32 (fp);
842 1425
843 return newSVnv (ecb_binary32_to_float (fp)); 1426 return newSVnv (ecb_binary32_to_float (fp));
844 } 1427 }
845 1428
846 case 27: 1429 case MISC_FLOAT64:
847 { 1430 {
848 uint64_t fp; 1431 uint64_t fp;
849 WANT (8); 1432 WANT (8);
850 memcpy (&fp, dec->cur, 8); 1433 memcpy (&fp, dec->cur, 8);
851 dec->cur += 8; 1434 dec->cur += 8;
854 fp = ecb_bswap64 (fp); 1437 fp = ecb_bswap64 (fp);
855 1438
856 return newSVnv (ecb_binary64_to_double (fp)); 1439 return newSVnv (ecb_binary64_to_double (fp));
857 } 1440 }
858 1441
859 // 0..19 unassigned 1442 // 0..19 unassigned simple
860 // 24 reserved + unassigned (reserved values are not encodable) 1443 // 24 reserved + unassigned simple (reserved values are not encodable)
1444 // 28-30 unassigned misc
1445 // 31 break code
861 default: 1446 default:
862 ERR ("corrupted CBOR data (reserved/unassigned major 7 value)"); 1447 ERR ("corrupted CBOR data (reserved/unassigned/unexpected major 7 value)");
863 } 1448 }
864 1449
865 break; 1450 break;
866 } 1451 }
867#if 0
868 switch (*dec->cur)
869 {
870 //case '"': ++dec->cur; return decode_str (dec);
871 case '[': ++dec->cur; return decode_av (dec);
872 case '{': ++dec->cur; return decode_hv (dec);
873
874 case '-':
875 case '0': case '1': case '2': case '3': case '4':
876 case '5': case '6': case '7': case '8': case '9':
877 //TODO return decode_num (dec);
878
879 case 't':
880 if (dec->end - dec->cur >= 4 && !memcmp (dec->cur, "true", 4))
881 {
882 dec->cur += 4;
883#if CBOR_SLOW
884 cbor_true = get_bool ("CBOR::XS::true");
885#endif
886 return newSVsv (cbor_true);
887 }
888 else
889 ERR ("'true' expected");
890
891 break;
892
893 case 'f':
894 if (dec->end - dec->cur >= 5 && !memcmp (dec->cur, "false", 5))
895 {
896 dec->cur += 5;
897#if CBOR_SLOW
898 cbor_false = get_bool ("CBOR::XS::false");
899#endif
900 return newSVsv (cbor_false);
901 }
902 else
903 ERR ("'false' expected");
904
905 break;
906
907 case 'n':
908 if (dec->end - dec->cur >= 4 && !memcmp (dec->cur, "null", 4))
909 {
910 dec->cur += 4;
911 return newSVsv (&PL_sv_undef);
912 }
913 else
914 ERR ("'null' expected");
915
916 break;
917
918 default:
919 ERR ("malformed CBOR string, neither array, object, number, string or atom");
920 break;
921 }
922#endif
923 1452
924fail: 1453fail:
925 return &PL_sv_undef; 1454 return &PL_sv_undef;
926} 1455}
927 1456
928static SV * 1457static SV *
929decode_cbor (SV *string, CBOR *cbor, char **offset_return) 1458decode_cbor (SV *string, CBOR *cbor, char **offset_return)
930{ 1459{
931 dec_t dec; 1460 dec_t dec = { 0 };
932 SV *sv; 1461 SV *sv;
1462 STRLEN len;
1463 char *data = SvPVbyte (string, len);
933 1464
934 /* work around bugs in 5.10 where manipulating magic values
935 * makes perl ignore the magic in subsequent accesses.
936 * also make a copy of non-PV values, to get them into a clean
937 * state (SvPV should do that, but it's buggy, see below).
938 */
939 /*SvGETMAGIC (string);*/
940 if (SvMAGICAL (string) || !SvPOK (string))
941 string = sv_2mortal (newSVsv (string));
942
943 SvUPGRADE (string, SVt_PV);
944
945 /* work around a bug in perl 5.10, which causes SvCUR to fail an
946 * assertion with -DDEBUGGING, although SvCUR is documented to
947 * return the xpv_cur field which certainly exists after upgrading.
948 * according to nicholas clark, calling SvPOK fixes this.
949 * But it doesn't fix it, so try another workaround, call SvPV_nolen
950 * and hope for the best.
951 * Damnit, SvPV_nolen still trips over yet another assertion. This
952 * assertion business is seriously broken, try yet another workaround
953 * for the broken -DDEBUGGING.
954 */
955 {
956#ifdef DEBUGGING
957 STRLEN offset = SvOK (string) ? sv_len (string) : 0;
958#else
959 STRLEN offset = SvCUR (string);
960#endif
961
962 if (offset > cbor->max_size && cbor->max_size) 1465 if (len > cbor->max_size && cbor->max_size)
963 croak ("attempted decode of CBOR text of %lu bytes size, but max_size is set to %lu", 1466 croak ("attempted decode of CBOR text of %lu bytes size, but max_size is set to %lu",
964 (unsigned long)SvCUR (string), (unsigned long)cbor->max_size); 1467 (unsigned long)len, (unsigned long)cbor->max_size);
965 }
966
967 sv_utf8_downgrade (string, 0);
968 1468
969 dec.cbor = *cbor; 1469 dec.cbor = *cbor;
970 dec.cur = (U8 *)SvPVX (string); 1470 dec.cur = (U8 *)data;
971 dec.end = (U8 *)SvEND (string); 1471 dec.end = (U8 *)data + len;
972 dec.err = 0;
973 dec.depth = 0;
974
975 if (dec.cbor.cb_object || dec.cbor.cb_sk_object)
976 ;//TODO dec.cbor.flags |= F_HOOK;
977 1472
978 sv = decode_sv (&dec); 1473 sv = decode_sv (&dec);
979 1474
980 if (offset_return) 1475 if (offset_return)
981 *offset_return = dec.cur; 1476 *offset_return = dec.cur;
984 if (dec.cur != dec.end && !dec.err) 1479 if (dec.cur != dec.end && !dec.err)
985 dec.err = "garbage after CBOR object"; 1480 dec.err = "garbage after CBOR object";
986 1481
987 if (dec.err) 1482 if (dec.err)
988 { 1483 {
1484 if (dec.shareable)
1485 {
1486 // need to break cyclic links, which would all be in shareable
1487 int i;
1488 SV **svp;
1489
1490 for (i = av_len (dec.shareable) + 1; i--; )
1491 if ((svp = av_fetch (dec.shareable, i, 0)))
1492 sv_setsv (*svp, &PL_sv_undef);
1493 }
1494
989 SvREFCNT_dec (sv); 1495 SvREFCNT_dec_NN (sv);
1496
1497 if (dec.err_sv)
1498 sv_2mortal (dec.err_sv);
1499
990 croak ("%s, at offset %d (octet 0x%02x)", dec.err, dec.cur - (U8 *)SvPVX (string), (int)(uint8_t)*dec.cur); 1500 croak ("%s, at offset %ld (octet 0x%02x)", dec.err, (long)(dec.cur - (U8 *)data), (int)(uint8_t)*dec.cur);
991 } 1501 }
992 1502
993 sv = sv_2mortal (sv); 1503 sv = sv_2mortal (sv);
994 1504
995 return sv; 1505 return sv;
996} 1506}
997 1507
1508/////////////////////////////////////////////////////////////////////////////
1509// incremental parser
1510
1511#define INCR_DONE(cbor) (AvFILLp (cbor->incr_count) < 0)
1512
1513// returns 0 for notyet, 1 for success or error
1514static int
1515incr_parse (CBOR *self, SV *cborstr)
1516{
1517 STRLEN cur;
1518 SvPV (cborstr, cur);
1519
1520 while (ecb_expect_true (self->incr_need <= cur))
1521 {
1522 // table of integer count bytes
1523 static I8 incr_len[MINOR_MASK + 1] = {
1524 0, 0, 0, 0, 0, 0, 0, 0,
1525 0, 0, 0, 0, 0, 0, 0, 0,
1526 0, 0, 0, 0, 0, 0, 0, 0,
1527 1, 2, 4, 8,-1,-1,-1,-2
1528 };
1529
1530 const U8 *p = SvPVX (cborstr) + self->incr_pos;
1531 U8 m = *p & MINOR_MASK;
1532 IV count = SvIVX (AvARRAY (self->incr_count)[AvFILLp (self->incr_count)]);
1533 I8 ilen = incr_len[m];
1534
1535 self->incr_need = self->incr_pos + 1;
1536
1537 if (ecb_expect_false (ilen < 0))
1538 {
1539 if (m != MINOR_INDEF)
1540 return 1; // error
1541
1542 if (*p == (MAJOR_MISC | MINOR_INDEF))
1543 {
1544 if (count >= 0)
1545 return 1; // error
1546
1547 count = 1;
1548 }
1549 else
1550 {
1551 av_push (self->incr_count, newSViv (-1)); //TODO: nest
1552 count = -1;
1553 }
1554 }
1555 else
1556 {
1557 self->incr_need += ilen;
1558 if (ecb_expect_false (self->incr_need > cur))
1559 return 0;
1560
1561 int major = *p >> MAJOR_SHIFT;
1562
1563 switch (major)
1564 {
1565 case MAJOR_TAG >> MAJOR_SHIFT:
1566 ++count; // tags merely prefix another value
1567 break;
1568
1569 case MAJOR_BYTES >> MAJOR_SHIFT:
1570 case MAJOR_TEXT >> MAJOR_SHIFT:
1571 case MAJOR_ARRAY >> MAJOR_SHIFT:
1572 case MAJOR_MAP >> MAJOR_SHIFT:
1573 {
1574 UV len;
1575
1576 if (ecb_expect_false (ilen))
1577 {
1578 len = 0;
1579
1580 do {
1581 len = (len << 8) | *++p;
1582 } while (--ilen);
1583 }
1584 else
1585 len = m;
1586
1587 switch (major)
1588 {
1589 case MAJOR_BYTES >> MAJOR_SHIFT:
1590 case MAJOR_TEXT >> MAJOR_SHIFT:
1591 self->incr_need += len;
1592 if (ecb_expect_false (self->incr_need > cur))
1593 return 0;
1594
1595 break;
1596
1597 case MAJOR_MAP >> MAJOR_SHIFT:
1598 len <<= 1;
1599 /* FALLTHROUGH */
1600 case MAJOR_ARRAY >> MAJOR_SHIFT:
1601 if (len)
1602 {
1603 av_push (self->incr_count, newSViv (len + 1)); //TODO: nest
1604 count = len + 1;
1605 }
1606 break;
1607 }
1608 }
1609 }
1610 }
1611
1612 self->incr_pos = self->incr_need;
1613
1614 if (count > 0)
1615 {
1616 while (!--count)
1617 {
1618 if (!AvFILLp (self->incr_count))
1619 return 1; // done
1620
1621 SvREFCNT_dec_NN (av_pop (self->incr_count));
1622 count = SvIVX (AvARRAY (self->incr_count)[AvFILLp (self->incr_count)]);
1623 }
1624
1625 SvIVX (AvARRAY (self->incr_count)[AvFILLp (self->incr_count)]) = count;
1626 }
1627 }
1628
1629 return 0;
1630}
1631
1632
998///////////////////////////////////////////////////////////////////////////// 1633/////////////////////////////////////////////////////////////////////////////
999// XS interface functions 1634// XS interface functions
1000 1635
1001MODULE = CBOR::XS PACKAGE = CBOR::XS 1636MODULE = CBOR::XS PACKAGE = CBOR::XS
1002 1637
1003BOOT: 1638BOOT:
1004{ 1639{
1005 cbor_stash = gv_stashpv ("CBOR::XS" , 1); 1640 cbor_stash = gv_stashpv ("CBOR::XS" , 1);
1006 cbor_boolean_stash = gv_stashpv ("CBOR::XS::Boolean", 1); 1641 cbor_tagged_stash = gv_stashpv ("CBOR::XS::Tagged" , 1);
1007 1642
1008 cbor_true = get_bool ("CBOR::XS::true"); 1643 types_boolean_stash = gv_stashpv ("Types::Serialiser::Boolean", 1);
1009 cbor_false = get_bool ("CBOR::XS::false"); 1644 types_error_stash = gv_stashpv ("Types::Serialiser::Error" , 1);
1645
1646 types_true = get_bool ("Types::Serialiser::true" );
1647 types_false = get_bool ("Types::Serialiser::false");
1648 types_error = get_bool ("Types::Serialiser::error");
1649
1650 default_filter = newSVpv ("CBOR::XS::default_filter", 0);
1651
1652 sv_cbor = newSVpv ("CBOR", 0);
1653 SvREADONLY_on (sv_cbor);
1654
1655 assert (("STRLEN must be an unsigned type", 0 <= (STRLEN)-1));
1010} 1656}
1011 1657
1012PROTOTYPES: DISABLE 1658PROTOTYPES: DISABLE
1013 1659
1014void CLONE (...) 1660void CLONE (...)
1015 CODE: 1661 CODE:
1016 cbor_stash = 0; 1662 cbor_stash = 0;
1663 cbor_tagged_stash = 0;
1664 types_error_stash = 0;
1017 cbor_boolean_stash = 0; 1665 types_boolean_stash = 0;
1018 1666
1019void new (char *klass) 1667void new (char *klass)
1020 PPCODE: 1668 PPCODE:
1021{ 1669{
1022 SV *pv = NEWSV (0, sizeof (CBOR)); 1670 SV *pv = NEWSV (0, sizeof (CBOR));
1030 1678
1031void shrink (CBOR *self, int enable = 1) 1679void shrink (CBOR *self, int enable = 1)
1032 ALIAS: 1680 ALIAS:
1033 shrink = F_SHRINK 1681 shrink = F_SHRINK
1034 allow_unknown = F_ALLOW_UNKNOWN 1682 allow_unknown = F_ALLOW_UNKNOWN
1683 allow_sharing = F_ALLOW_SHARING
1684 allow_cycles = F_ALLOW_CYCLES
1685 forbid_objects = F_FORBID_OBJECTS
1686 pack_strings = F_PACK_STRINGS
1687 text_keys = F_TEXT_KEYS
1688 text_strings = F_TEXT_STRINGS
1689 validate_utf8 = F_VALIDATE_UTF8
1035 PPCODE: 1690 PPCODE:
1036{ 1691{
1037 if (enable) 1692 if (enable)
1038 self->flags |= ix; 1693 self->flags |= ix;
1039 else 1694 else
1044 1699
1045void get_shrink (CBOR *self) 1700void get_shrink (CBOR *self)
1046 ALIAS: 1701 ALIAS:
1047 get_shrink = F_SHRINK 1702 get_shrink = F_SHRINK
1048 get_allow_unknown = F_ALLOW_UNKNOWN 1703 get_allow_unknown = F_ALLOW_UNKNOWN
1704 get_allow_sharing = F_ALLOW_SHARING
1705 get_allow_cycles = F_ALLOW_CYCLES
1706 get_forbid_objects = F_FORBID_OBJECTS
1707 get_pack_strings = F_PACK_STRINGS
1708 get_text_keys = F_TEXT_KEYS
1709 get_text_strings = F_TEXT_STRINGS
1710 get_validate_utf8 = F_VALIDATE_UTF8
1049 PPCODE: 1711 PPCODE:
1050 XPUSHs (boolSV (self->flags & ix)); 1712 XPUSHs (boolSV (self->flags & ix));
1051 1713
1052void max_depth (CBOR *self, U32 max_depth = 0x80000000UL) 1714void max_depth (CBOR *self, U32 max_depth = 0x80000000UL)
1053 PPCODE: 1715 PPCODE:
1069 CODE: 1731 CODE:
1070 RETVAL = self->max_size; 1732 RETVAL = self->max_size;
1071 OUTPUT: 1733 OUTPUT:
1072 RETVAL 1734 RETVAL
1073 1735
1074#if 0 //TODO 1736void filter (CBOR *self, SV *filter = 0)
1075
1076void filter_cbor_object (CBOR *self, SV *cb = &PL_sv_undef)
1077 PPCODE: 1737 PPCODE:
1078{
1079 SvREFCNT_dec (self->cb_object); 1738 SvREFCNT_dec (self->filter);
1080 self->cb_object = SvOK (cb) ? newSVsv (cb) : 0; 1739 self->filter = filter ? newSVsv (filter) : filter;
1081
1082 XPUSHs (ST (0)); 1740 XPUSHs (ST (0));
1083}
1084 1741
1085void filter_cbor_single_key_object (CBOR *self, SV *key, SV *cb = &PL_sv_undef) 1742SV *get_filter (CBOR *self)
1086 PPCODE: 1743 CODE:
1087{ 1744 RETVAL = self->filter ? self->filter : NEWSV (0, 0);
1088 if (!self->cb_sk_object) 1745 OUTPUT:
1089 self->cb_sk_object = newHV (); 1746 RETVAL
1090
1091 if (SvOK (cb))
1092 hv_store_ent (self->cb_sk_object, key, newSVsv (cb), 0);
1093 else
1094 {
1095 hv_delete_ent (self->cb_sk_object, key, G_DISCARD, 0);
1096
1097 if (!HvKEYS (self->cb_sk_object))
1098 {
1099 SvREFCNT_dec (self->cb_sk_object);
1100 self->cb_sk_object = 0;
1101 }
1102 }
1103
1104 XPUSHs (ST (0));
1105}
1106
1107#endif
1108 1747
1109void encode (CBOR *self, SV *scalar) 1748void encode (CBOR *self, SV *scalar)
1110 PPCODE: 1749 PPCODE:
1111 PUTBACK; scalar = encode_cbor (scalar, self); SPAGAIN; 1750 PUTBACK; scalar = encode_cbor (scalar, self); SPAGAIN;
1112 XPUSHs (scalar); 1751 XPUSHs (scalar);
1125 EXTEND (SP, 2); 1764 EXTEND (SP, 2);
1126 PUSHs (sv); 1765 PUSHs (sv);
1127 PUSHs (sv_2mortal (newSVuv (offset - SvPVX (cborstr)))); 1766 PUSHs (sv_2mortal (newSVuv (offset - SvPVX (cborstr))));
1128} 1767}
1129 1768
1769void incr_parse (CBOR *self, SV *cborstr)
1770 ALIAS:
1771 incr_parse_multiple = 1
1772 PPCODE:
1773{
1774 if (SvUTF8 (cborstr))
1775 sv_utf8_downgrade (cborstr, 0);
1776
1777 if (!self->incr_count)
1778 {
1779 self->incr_count = newAV ();
1780 self->incr_pos = 0;
1781 self->incr_need = 1;
1782
1783 av_push (self->incr_count, newSViv (1));
1784 }
1785
1786 do
1787 {
1788 if (!incr_parse (self, cborstr))
1789 {
1790 if (self->incr_need > self->max_size && self->max_size)
1791 croak ("attempted decode of CBOR text of %lu bytes size, but max_size is set to %lu",
1792 (unsigned long)self->incr_need, (unsigned long)self->max_size);
1793
1794 break;
1795 }
1796
1797 SV *sv;
1798 char *offset;
1799
1800 PUTBACK; sv = decode_cbor (cborstr, self, &offset); SPAGAIN;
1801 XPUSHs (sv);
1802
1803 sv_chop (cborstr, offset);
1804
1805 av_clear (self->incr_count);
1806 av_push (self->incr_count, newSViv (1));
1807
1808 self->incr_pos = 0;
1809 self->incr_need = self->incr_pos + 1;
1810 }
1811 while (ix);
1812}
1813
1814void incr_reset (CBOR *self)
1815 CODE:
1816{
1817 SvREFCNT_dec (self->incr_count);
1818 self->incr_count = 0;
1819}
1820
1130void DESTROY (CBOR *self) 1821void DESTROY (CBOR *self)
1131 CODE: 1822 PPCODE:
1132 SvREFCNT_dec (self->cb_sk_object); 1823 cbor_free (self);
1133 SvREFCNT_dec (self->cb_object);
1134 1824
1135PROTOTYPES: ENABLE 1825PROTOTYPES: ENABLE
1136 1826
1137void encode_cbor (SV *scalar) 1827void encode_cbor (SV *scalar)
1828 ALIAS:
1829 encode_cbor = 0
1830 encode_cbor_sharing = F_ALLOW_SHARING
1138 PPCODE: 1831 PPCODE:
1139{ 1832{
1140 CBOR cbor; 1833 CBOR cbor;
1141 cbor_init (&cbor); 1834 cbor_init (&cbor);
1835 cbor.flags |= ix;
1142 PUTBACK; scalar = encode_cbor (scalar, &cbor); SPAGAIN; 1836 PUTBACK; scalar = encode_cbor (scalar, &cbor); SPAGAIN;
1143 XPUSHs (scalar); 1837 XPUSHs (scalar);
1144} 1838}
1145 1839
1146void decode_cbor (SV *cborstr) 1840void decode_cbor (SV *cborstr)
1150 cbor_init (&cbor); 1844 cbor_init (&cbor);
1151 PUTBACK; cborstr = decode_cbor (cborstr, &cbor, 0); SPAGAIN; 1845 PUTBACK; cborstr = decode_cbor (cborstr, &cbor, 0); SPAGAIN;
1152 XPUSHs (cborstr); 1846 XPUSHs (cborstr);
1153} 1847}
1154 1848
1849#ifdef __AFL_COMPILER
1850
1851void
1852afl_init ()
1853 CODE:
1854 __AFL_INIT ();
1855
1856int
1857afl_loop (unsigned int count = 10000)
1858 CODE:
1859 RETVAL = __AFL_LOOP (count);
1860 OUTPUT:
1861 RETVAL
1862
1863#endif
1864

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines