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.33 by root, Sat Nov 30 15:23:59 2013 UTC vs.
Revision 1.62 by root, Sat Nov 26 02:11:52 2016 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
14// compatibility with perl <5.18 16// compatibility with perl <5.18
15#ifndef HvNAMELEN_get 17#ifndef HvNAMELEN_get
16# define HvNAMELEN_get(hv) strlen (HvNAME (hv)) 18# define HvNAMELEN_get(hv) strlen (HvNAME (hv))
… …
23#endif 25#endif
24#ifndef SvREFCNT_dec_NN 26#ifndef SvREFCNT_dec_NN
25# define SvREFCNT_dec_NN(sv) SvREFCNT_dec (sv) 27# define SvREFCNT_dec_NN(sv) SvREFCNT_dec (sv)
26#endif 28#endif
27 29
30// known major and minor types
31enum cbor_type
32{
33 MAJOR_SHIFT = 5,
34 MINOR_MASK = 0x1f,
35
36 MAJOR_POS_INT = 0 << MAJOR_SHIFT,
37 MAJOR_NEG_INT = 1 << MAJOR_SHIFT,
38 MAJOR_BYTES = 2 << MAJOR_SHIFT,
39 MAJOR_TEXT = 3 << MAJOR_SHIFT,
40 MAJOR_ARRAY = 4 << MAJOR_SHIFT,
41 MAJOR_MAP = 5 << MAJOR_SHIFT,
42 MAJOR_TAG = 6 << MAJOR_SHIFT,
43 MAJOR_MISC = 7 << MAJOR_SHIFT,
44
45 // INT/STRING/ARRAY/MAP subtypes
46 LENGTH_EXT1 = 24,
47 LENGTH_EXT2 = 25,
48 LENGTH_EXT4 = 26,
49 LENGTH_EXT8 = 27,
50
51 // SIMPLE types (effectively MISC subtypes)
52 SIMPLE_FALSE = 20,
53 SIMPLE_TRUE = 21,
54 SIMPLE_NULL = 22,
55 SIMPLE_UNDEF = 23,
56
57 // MISC subtype (unused)
58 MISC_EXT1 = 24,
59 MISC_FLOAT16 = 25,
60 MISC_FLOAT32 = 26,
61 MISC_FLOAT64 = 27,
62
63 // BYTES/TEXT/ARRAY/MAP
64 MINOR_INDEF = 31,
65};
66
28// known tags 67// known tags
29enum cbor_tag 68enum cbor_tag
30{ 69{
31 // extensions 70 // extensions
32 CBOR_TAG_STRINGREF = 25, // http://cbor.schmorp.de/stringref 71 CBOR_TAG_STRINGREF = 25, // http://cbor.schmorp.de/stringref
33 CBOR_TAG_PERL_OBJECT = 26, // http://cbor.schmorp.de/perl-object 72 CBOR_TAG_PERL_OBJECT = 26, // http://cbor.schmorp.de/perl-object
34 CBOR_TAG_GENERIC_OBJECT = 27, // http://cbor.schmorp.de/generic-object 73 CBOR_TAG_GENERIC_OBJECT = 27, // http://cbor.schmorp.de/generic-object
35 CBOR_TAG_VALUE_SHAREABLE = 28, // http://cbor.schmorp.de/value-sharing 74 CBOR_TAG_VALUE_SHAREABLE = 28, // http://cbor.schmorp.de/value-sharing
36 CBOR_TAG_VALUE_SHAREDREF = 29, // http://cbor.schmorp.de/value-sharing 75 CBOR_TAG_VALUE_SHAREDREF = 29, // http://cbor.schmorp.de/value-sharing
37 CBOR_TAG_STRINGREF_NAMESPACE = 256, // http://cbor.schmorp.de/stringref 76 CBOR_TAG_STRINGREF_NAMESPACE = 256, // http://cbor.schmorp.de/stringref
38 CBOR_TAG_INDIRECTION = 22098, // http://cbor.schmorp.de/indirection 77 CBOR_TAG_INDIRECTION = 22098, // http://cbor.schmorp.de/indirection
39 78
40 // rfc7049 79 // rfc7049
41 CBOR_TAG_DATETIME = 0, // rfc4287, utf-8 80 CBOR_TAG_DATETIME = 0, // rfc4287, utf-8
42 CBOR_TAG_TIMESTAMP = 1, // unix timestamp, any 81 CBOR_TAG_TIMESTAMP = 1, // unix timestamp, any
43 CBOR_TAG_POS_BIGNUM = 2, // byte string 82 CBOR_TAG_POS_BIGNUM = 2, // byte string
44 CBOR_TAG_NEG_BIGNUM = 3, // byte string 83 CBOR_TAG_NEG_BIGNUM = 3, // byte string
45 CBOR_TAG_DECIMAL = 4, // decimal fraction, array 84 CBOR_TAG_DECIMAL = 4, // decimal fraction, array
46 CBOR_TAG_BIGFLOAT = 5, // array 85 CBOR_TAG_BIGFLOAT = 5, // array
47 86
48 CBOR_TAG_CONV_B64U = 21, // base64url, any 87 CBOR_TAG_CONV_B64U = 21, // base64url, any
49 CBOR_TAG_CONV_B64 = 22, // base64, any 88 CBOR_TAG_CONV_B64 = 22, // base64, any
50 CBOR_TAG_CONV_HEX = 23, // base16, any 89 CBOR_TAG_CONV_HEX = 23, // base16, any
51 CBOR_TAG_CBOR = 24, // embedded cbor, byte string 90 CBOR_TAG_CBOR = 24, // embedded cbor, byte string
52 91
53 CBOR_TAG_URI = 32, // URI rfc3986, utf-8 92 CBOR_TAG_URI = 32, // URI rfc3986, utf-8
54 CBOR_TAG_B64U = 33, // base64url rfc4648, utf-8 93 CBOR_TAG_B64U = 33, // base64url rfc4648, utf-8
55 CBOR_TAG_B64 = 34, // base6 rfc46484, utf-8 94 CBOR_TAG_B64 = 34, // base6 rfc46484, utf-8
56 CBOR_TAG_REGEX = 35, // regex pcre/ecma262, utf-8 95 CBOR_TAG_REGEX = 35, // regex pcre/ecma262, utf-8
57 CBOR_TAG_MIME = 36, // mime message rfc2045, utf-8 96 CBOR_TAG_MIME = 36, // mime message rfc2045, utf-8
58 97
59 CBOR_TAG_MAGIC = 55799 // self-describe cbor 98 CBOR_TAG_MAGIC = 55799, // self-describe cbor
60}; 99};
61 100
62#define F_SHRINK 0x00000001UL 101#define F_SHRINK 0x00000001UL
63#define F_ALLOW_UNKNOWN 0x00000002UL 102#define F_ALLOW_UNKNOWN 0x00000002UL
64#define F_ALLOW_SHARING 0x00000004UL 103#define F_ALLOW_SHARING 0x00000004UL
104#define F_ALLOW_CYCLES 0x00000008UL
105#define F_FORBID_OBJECTS 0x00000010UL
65#define F_PACK_STRINGS 0x00000008UL 106#define F_PACK_STRINGS 0x00000020UL
107#define F_TEXT_KEYS 0x00000040UL
108#define F_TEXT_STRINGS 0x00000080UL
109#define F_VALIDATE_UTF8 0x00000100UL
66 110
67#define INIT_SIZE 32 // initial scalar size to be allocated 111#define INIT_SIZE 32 // initial scalar size to be allocated
68 112
69#define SB do { 113#define SB do {
70#define SE } while (0) 114#define SE } while (0)
… …
89typedef struct { 133typedef struct {
90 U32 flags; 134 U32 flags;
91 U32 max_depth; 135 U32 max_depth;
92 STRLEN max_size; 136 STRLEN max_size;
93 SV *filter; 137 SV *filter;
138
139 // for the incremental parser
140 STRLEN incr_pos; // the current offset into the text
141 STRLEN incr_need; // minimum bytes needed to decode
142 AV *incr_count; // for every nesting level, the number of outstanding values, or -1 for indef.
94} CBOR; 143} CBOR;
95 144
96ecb_inline void 145ecb_inline void
97cbor_init (CBOR *cbor) 146cbor_init (CBOR *cbor)
98{ 147{
… …
102 151
103ecb_inline void 152ecb_inline void
104cbor_free (CBOR *cbor) 153cbor_free (CBOR *cbor)
105{ 154{
106 SvREFCNT_dec (cbor->filter); 155 SvREFCNT_dec (cbor->filter);
156 SvREFCNT_dec (cbor->incr_count);
107} 157}
108 158
109///////////////////////////////////////////////////////////////////////////// 159/////////////////////////////////////////////////////////////////////////////
110// utility functions 160// utility functions
111 161
… …
137 187
138// minimum length of a string to be registered for stringref 188// minimum length of a string to be registered for stringref
139ecb_inline int 189ecb_inline int
140minimum_string_length (UV idx) 190minimum_string_length (UV idx)
141{ 191{
142 return idx > 23 192 return idx <= 23 ? 3
143 ? idx > 0xffU 193 : idx <= 0xffU ? 4
144 ? idx > 0xffffU 194 : idx <= 0xffffU ? 5
145 ? idx > 0xffffffffU 195 : idx <= 0xffffffffU ? 7
146 ? 11 196 : 11;
147 : 7
148 : 5
149 : 4
150 : 3;
151} 197}
152 198
153///////////////////////////////////////////////////////////////////////////// 199/////////////////////////////////////////////////////////////////////////////
154// encoder 200// encoder
155 201
… …
168} enc_t; 214} enc_t;
169 215
170ecb_inline void 216ecb_inline void
171need (enc_t *enc, STRLEN len) 217need (enc_t *enc, STRLEN len)
172{ 218{
173 if (ecb_expect_false (enc->cur + len >= enc->end)) 219 if (ecb_expect_false ((uintptr_t)(enc->end - enc->cur) < len))
174 { 220 {
175 STRLEN cur = enc->cur - (char *)SvPVX (enc->sv); 221 STRLEN cur = enc->cur - (char *)SvPVX (enc->sv);
176 SvGROW (enc->sv, cur + (len < (cur >> 2) ? cur >> 2 : len) + 1); 222 SvGROW (enc->sv, cur + (len < (cur >> 2) ? cur >> 2 : len) + 1);
177 enc->cur = SvPVX (enc->sv) + cur; 223 enc->cur = SvPVX (enc->sv) + cur;
178 enc->end = SvPVX (enc->sv) + SvLEN (enc->sv) - 1; 224 enc->end = SvPVX (enc->sv) + SvLEN (enc->sv) - 1;
… …
189static void 235static void
190encode_uint (enc_t *enc, int major, UV len) 236encode_uint (enc_t *enc, int major, UV len)
191{ 237{
192 need (enc, 9); 238 need (enc, 9);
193 239
194 if (ecb_expect_true (len < 24)) 240 if (ecb_expect_true (len < LENGTH_EXT1))
195 *enc->cur++ = major | len; 241 *enc->cur++ = major | len;
196 else if (ecb_expect_true (len <= 0xff)) 242 else if (ecb_expect_true (len <= 0xffU))
197 { 243 {
198 *enc->cur++ = major | 24; 244 *enc->cur++ = major | LENGTH_EXT1;
199 *enc->cur++ = len; 245 *enc->cur++ = len;
200 } 246 }
201 else if (len <= 0xffff) 247 else if (len <= 0xffffU)
202 { 248 {
203 *enc->cur++ = major | 25; 249 *enc->cur++ = major | LENGTH_EXT2;
204 *enc->cur++ = len >> 8; 250 *enc->cur++ = len >> 8;
205 *enc->cur++ = len; 251 *enc->cur++ = len;
206 } 252 }
207 else if (len <= 0xffffffff) 253 else if (len <= 0xffffffffU)
208 { 254 {
209 *enc->cur++ = major | 26; 255 *enc->cur++ = major | LENGTH_EXT4;
210 *enc->cur++ = len >> 24; 256 *enc->cur++ = len >> 24;
211 *enc->cur++ = len >> 16; 257 *enc->cur++ = len >> 16;
212 *enc->cur++ = len >> 8; 258 *enc->cur++ = len >> 8;
213 *enc->cur++ = len; 259 *enc->cur++ = len;
214 } 260 }
215 else 261 else
216 { 262 {
217 *enc->cur++ = major | 27; 263 *enc->cur++ = major | LENGTH_EXT8;
218 *enc->cur++ = len >> 56; 264 *enc->cur++ = len >> 56;
219 *enc->cur++ = len >> 48; 265 *enc->cur++ = len >> 48;
220 *enc->cur++ = len >> 40; 266 *enc->cur++ = len >> 40;
221 *enc->cur++ = len >> 32; 267 *enc->cur++ = len >> 32;
222 *enc->cur++ = len >> 24; 268 *enc->cur++ = len >> 24;
… …
227} 273}
228 274
229ecb_inline void 275ecb_inline void
230encode_tag (enc_t *enc, UV tag) 276encode_tag (enc_t *enc, UV tag)
231{ 277{
232 encode_uint (enc, 0xc0, tag); 278 encode_uint (enc, MAJOR_TAG, tag);
279}
280
281// exceptional (hopefully) slow path for byte strings that need to be utf8-encoded
282ecb_noinline static void
283encode_str_utf8 (enc_t *enc, int utf8, char *str, STRLEN len)
284{
285 STRLEN ulen = len;
286 U8 *p, *pend = (U8 *)str + len;
287
288 for (p = (U8 *)str; p < pend; ++p)
289 ulen += *p >> 7; // count set high bits
290
291 encode_uint (enc, MAJOR_TEXT, ulen);
292
293 need (enc, ulen);
294 for (p = (U8 *)str; p < pend; ++p)
295 if (*p < 0x80)
296 *enc->cur++ = *p;
297 else
298 {
299 *enc->cur++ = 0xc0 + (*p >> 6);
300 *enc->cur++ = 0x80 + (*p & 63);
301 }
233} 302}
234 303
235ecb_inline void 304ecb_inline void
236encode_str (enc_t *enc, int utf8, char *str, STRLEN len) 305encode_str (enc_t *enc, int upgrade_utf8, int utf8, char *str, STRLEN len)
237{ 306{
238 encode_uint (enc, utf8 ? 0x60 : 0x40, len); 307 if (ecb_expect_false (upgrade_utf8))
308 if (!utf8)
309 {
310 encode_str_utf8 (enc, utf8, str, len);
311 return;
312 }
313
314 encode_uint (enc, utf8 ? MAJOR_TEXT : MAJOR_BYTES, len);
239 need (enc, len); 315 need (enc, len);
240 memcpy (enc->cur, str, len); 316 memcpy (enc->cur, str, len);
241 enc->cur += len; 317 enc->cur += len;
242} 318}
243 319
244static void 320ecb_inline void
245encode_strref (enc_t *enc, int utf8, char *str, STRLEN len) 321encode_strref (enc_t *enc, int upgrade_utf8, int utf8, char *str, STRLEN len)
246{ 322{
247 if (ecb_expect_false (enc->cbor.flags & F_PACK_STRINGS)) 323 if (ecb_expect_false (enc->cbor.flags & F_PACK_STRINGS))
248 { 324 {
249 SV **svp = hv_fetch (enc->stringref[!!utf8], str, len, 1); 325 SV **svp = hv_fetch (enc->stringref[!!utf8], str, len, 1);
250 326
251 if (SvOK (*svp)) 327 if (SvOK (*svp))
252 { 328 {
253 // already registered, use stringref 329 // already registered, use stringref
254 encode_tag (enc, CBOR_TAG_STRINGREF); 330 encode_tag (enc, CBOR_TAG_STRINGREF);
255 encode_uint (enc, 0x00, SvUV (*svp)); 331 encode_uint (enc, MAJOR_POS_INT, SvUV (*svp));
256 return; 332 return;
257 } 333 }
258 else if (len >= minimum_string_length (enc->stringref_idx)) 334 else if (len >= minimum_string_length (enc->stringref_idx))
259 { 335 {
260 // register only 336 // register only
261 sv_setuv (*svp, enc->stringref_idx); 337 sv_setuv (*svp, enc->stringref_idx);
262 ++enc->stringref_idx; 338 ++enc->stringref_idx;
263 } 339 }
264 } 340 }
265 341
266 encode_str (enc, utf8, str, len); 342 encode_str (enc, upgrade_utf8, utf8, str, len);
267} 343}
268 344
269static void encode_sv (enc_t *enc, SV *sv); 345static void encode_sv (enc_t *enc, SV *sv);
270 346
271static void 347static void
… …
276 if (enc->depth >= enc->cbor.max_depth) 352 if (enc->depth >= enc->cbor.max_depth)
277 croak (ERR_NESTING_EXCEEDED); 353 croak (ERR_NESTING_EXCEEDED);
278 354
279 ++enc->depth; 355 ++enc->depth;
280 356
281 encode_uint (enc, 0x80, len + 1); 357 encode_uint (enc, MAJOR_ARRAY, len + 1);
282 358
359 if (SvMAGICAL (av))
283 for (i = 0; i <= len; ++i) 360 for (i = 0; i <= len; ++i)
284 { 361 {
285 SV **svp = av_fetch (av, i, 0); 362 SV **svp = av_fetch (av, i, 0);
286 encode_sv (enc, svp ? *svp : &PL_sv_undef); 363 encode_sv (enc, svp ? *svp : &PL_sv_undef);
287 } 364 }
365 else
366 for (i = 0; i <= len; ++i)
367 {
368 SV *sv = AvARRAY (av)[i];
369 encode_sv (enc, sv ? sv : &PL_sv_undef);
370 }
288 371
289 --enc->depth; 372 --enc->depth;
290} 373}
291 374
292static void 375static void
… …
301 384
302 int pairs = hv_iterinit (hv); 385 int pairs = hv_iterinit (hv);
303 int mg = SvMAGICAL (hv); 386 int mg = SvMAGICAL (hv);
304 387
305 if (mg) 388 if (mg)
306 encode_ch (enc, 0xa0 | 31); 389 encode_ch (enc, MAJOR_MAP | MINOR_INDEF);
307 else 390 else
308 encode_uint (enc, 0xa0, pairs); 391 encode_uint (enc, MAJOR_MAP, pairs);
309 392
310 while ((he = hv_iternext (hv))) 393 while ((he = hv_iternext (hv)))
311 { 394 {
312 if (HeKLEN (he) == HEf_SVKEY) 395 if (HeKLEN (he) == HEf_SVKEY)
313 encode_sv (enc, HeSVKEY (he)); 396 encode_sv (enc, HeSVKEY (he));
314 else 397 else
315 encode_strref (enc, HeKUTF8 (he), HeKEY (he), HeKLEN (he)); 398 encode_strref (enc, enc->cbor.flags & (F_TEXT_KEYS | F_TEXT_STRINGS), HeKUTF8 (he), HeKEY (he), HeKLEN (he));
316 399
317 encode_sv (enc, ecb_expect_false (mg) ? hv_iterval (hv, he) : HeVAL (he)); 400 encode_sv (enc, ecb_expect_false (mg) ? hv_iterval (hv, he) : HeVAL (he));
318 } 401 }
319 402
320 if (mg) 403 if (mg)
321 encode_ch (enc, 0xe0 | 31); 404 encode_ch (enc, MAJOR_MISC | MINOR_INDEF);
322 405
323 --enc->depth; 406 --enc->depth;
324} 407}
325 408
326// encode objects, arrays and special \0=false and \1=true values. 409// encode objects, arrays and special \0=false and \1=true values.
… …
342 HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash 425 HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash
343 ? cbor_tagged_stash 426 ? cbor_tagged_stash
344 : gv_stashpv ("CBOR::XS::Tagged" , 1); 427 : gv_stashpv ("CBOR::XS::Tagged" , 1);
345 428
346 HV *stash = SvSTASH (sv); 429 HV *stash = SvSTASH (sv);
347 GV *method;
348 430
349 if (stash == boolean_stash) 431 if (stash == boolean_stash)
350 encode_ch (enc, SvIV (sv) ? 0xe0 | 21 : 0xe0 | 20); 432 {
433 encode_ch (enc, SvIV (sv) ? MAJOR_MISC | SIMPLE_TRUE : MAJOR_MISC | SIMPLE_FALSE);
434 return;
435 }
351 else if (stash == error_stash) 436 else if (stash == error_stash)
352 encode_ch (enc, 0xe0 | 23); 437 {
438 encode_ch (enc, MAJOR_MISC | SIMPLE_UNDEF);
439 return;
440 }
353 else if (stash == tagged_stash) 441 else if (stash == tagged_stash)
354 { 442 {
355 if (svt != SVt_PVAV) 443 if (svt != SVt_PVAV)
356 croak ("encountered CBOR::XS::Tagged object that isn't an array"); 444 croak ("encountered CBOR::XS::Tagged object that isn't an array");
357 445
358 encode_uint (enc, 0xc0, SvUV (*av_fetch ((AV *)sv, 0, 1))); 446 encode_uint (enc, MAJOR_TAG, SvUV (*av_fetch ((AV *)sv, 0, 1)));
359 encode_sv (enc, *av_fetch ((AV *)sv, 1, 1)); 447 encode_sv (enc, *av_fetch ((AV *)sv, 1, 1));
448
449 return;
450 }
451 }
452
453 if (ecb_expect_false (SvREFCNT (sv) > 1)
454 && ecb_expect_false (enc->cbor.flags & F_ALLOW_SHARING))
455 {
456 if (!enc->shareable)
457 enc->shareable = (HV *)sv_2mortal ((SV *)newHV ());
458
459 SV **svp = hv_fetch (enc->shareable, (char *)&sv, sizeof (sv), 1);
460
461 if (SvOK (*svp))
360 } 462 {
463 encode_tag (enc, CBOR_TAG_VALUE_SHAREDREF);
464 encode_uint (enc, MAJOR_POS_INT, SvUV (*svp));
465 return;
466 }
467 else
468 {
469 sv_setuv (*svp, enc->shareable_idx);
470 ++enc->shareable_idx;
471 encode_tag (enc, CBOR_TAG_VALUE_SHAREABLE);
472 }
473 }
474
475 if (ecb_expect_false (SvOBJECT (sv)))
476 {
477 HV *stash = SvSTASH (sv);
478 GV *method;
479
480 if (enc->cbor.flags & F_FORBID_OBJECTS)
481 croak ("encountered object '%s', but forbid_objects is enabled",
482 SvPV_nolen (sv_2mortal (newRV_inc (sv))));
361 else if ((method = gv_fetchmethod_autoload (stash, "TO_CBOR", 0))) 483 else if ((method = gv_fetchmethod_autoload (stash, "TO_CBOR", 0)))
362 { 484 {
363 dSP; 485 dSP;
364 486
365 ENTER; SAVETMPS; PUSHMARK (SP); 487 ENTER; SAVETMPS;
488 PUSHMARK (SP);
366 // we re-bless the reference to get overload and other niceties right 489 // we re-bless the reference to get overload and other niceties right
367 XPUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash)); 490 XPUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash));
368 491
369 PUTBACK; 492 PUTBACK;
370 // G_SCALAR ensures that return value is 1 493 // G_SCALAR ensures that return value is 1
… …
383 } 506 }
384 else if ((method = gv_fetchmethod_autoload (stash, "FREEZE", 0)) != 0) 507 else if ((method = gv_fetchmethod_autoload (stash, "FREEZE", 0)) != 0)
385 { 508 {
386 dSP; 509 dSP;
387 510
388 ENTER; SAVETMPS; PUSHMARK (SP); 511 ENTER; SAVETMPS;
512 SAVESTACK_POS ();
513 PUSHMARK (SP);
389 EXTEND (SP, 2); 514 EXTEND (SP, 2);
390 // we re-bless the reference to get overload and other niceties right 515 // we re-bless the reference to get overload and other niceties right
391 PUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash)); 516 PUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash));
392 PUSHs (sv_cbor); 517 PUSHs (sv_cbor);
393 518
… …
398 // catch this surprisingly common error 523 // catch this surprisingly common error
399 if (count == 1 && SvROK (TOPs) && SvRV (TOPs) == sv) 524 if (count == 1 && SvROK (TOPs) && SvRV (TOPs) == sv)
400 croak ("%s::FREEZE(CBOR) method returned same object as was passed instead of a new one", HvNAME (stash)); 525 croak ("%s::FREEZE(CBOR) method returned same object as was passed instead of a new one", HvNAME (stash));
401 526
402 encode_tag (enc, CBOR_TAG_PERL_OBJECT); 527 encode_tag (enc, CBOR_TAG_PERL_OBJECT);
403 encode_uint (enc, 0x80, count + 1); 528 encode_uint (enc, MAJOR_ARRAY, count + 1);
404 encode_strref (enc, HvNAMEUTF8 (stash), HvNAME (stash), HvNAMELEN (stash)); 529 encode_strref (enc, 0, HvNAMEUTF8 (stash), HvNAME (stash), HvNAMELEN (stash));
405 530
406 while (count) 531 while (count)
407 encode_sv (enc, SP[1 - count--]); 532 encode_sv (enc, SP[1 - count--]);
408 533
409 PUTBACK; 534 PUTBACK;
… …
418 encode_hv (enc, (HV *)sv); 543 encode_hv (enc, (HV *)sv);
419 else if (svt == SVt_PVAV) 544 else if (svt == SVt_PVAV)
420 encode_av (enc, (AV *)sv); 545 encode_av (enc, (AV *)sv);
421 else 546 else
422 { 547 {
423 if (ecb_expect_false (SvREFCNT (sv) > 1)
424 && ecb_expect_false (enc->cbor.flags & F_ALLOW_SHARING))
425 {
426 if (!enc->shareable)
427 enc->shareable = (HV *)sv_2mortal ((SV *)newHV ());
428
429 SV **svp = hv_fetch (enc->shareable, (char *)&sv, sizeof (sv), 1);
430
431 if (SvOK (*svp))
432 {
433 encode_tag (enc, CBOR_TAG_VALUE_SHAREDREF);
434 encode_uint (enc, 0x00, SvUV (*svp));
435 return;
436 }
437 else
438 {
439 sv_setuv (*svp, enc->shareable_idx);
440 ++enc->shareable_idx;
441 encode_tag (enc, CBOR_TAG_VALUE_SHAREABLE);
442 }
443 }
444
445 encode_tag (enc, CBOR_TAG_INDIRECTION); 548 encode_tag (enc, CBOR_TAG_INDIRECTION);
446 encode_sv (enc, sv); 549 encode_sv (enc, sv);
447 } 550 }
448} 551}
449 552
… …
452{ 555{
453 double nv = SvNVX (sv); 556 double nv = SvNVX (sv);
454 557
455 need (enc, 9); 558 need (enc, 9);
456 559
457 if (ecb_expect_false (nv == (U32)nv)) 560 if (ecb_expect_false (nv == (NV)(U32)nv))
458 encode_uint (enc, 0x00, (U32)nv); 561 encode_uint (enc, MAJOR_POS_INT, (U32)nv);
459 //TODO: maybe I32? 562 //TODO: maybe I32?
460 else if (ecb_expect_false (nv == (float)nv)) 563 else if (ecb_expect_false (nv == (float)nv))
461 { 564 {
462 uint32_t fp = ecb_float_to_binary32 (nv); 565 uint32_t fp = ecb_float_to_binary32 (nv);
463 566
464 *enc->cur++ = 0xe0 | 26; 567 *enc->cur++ = MAJOR_MISC | MISC_FLOAT32;
465 568
466 if (!ecb_big_endian ()) 569 if (!ecb_big_endian ())
467 fp = ecb_bswap32 (fp); 570 fp = ecb_bswap32 (fp);
468 571
469 memcpy (enc->cur, &fp, 4); 572 memcpy (enc->cur, &fp, 4);
… …
471 } 574 }
472 else 575 else
473 { 576 {
474 uint64_t fp = ecb_double_to_binary64 (nv); 577 uint64_t fp = ecb_double_to_binary64 (nv);
475 578
476 *enc->cur++ = 0xe0 | 27; 579 *enc->cur++ = MAJOR_MISC | MISC_FLOAT64;
477 580
478 if (!ecb_big_endian ()) 581 if (!ecb_big_endian ())
479 fp = ecb_bswap64 (fp); 582 fp = ecb_bswap64 (fp);
480 583
481 memcpy (enc->cur, &fp, 8); 584 memcpy (enc->cur, &fp, 8);
… …
490 593
491 if (SvPOKp (sv)) 594 if (SvPOKp (sv))
492 { 595 {
493 STRLEN len; 596 STRLEN len;
494 char *str = SvPV (sv, len); 597 char *str = SvPV (sv, len);
495 encode_strref (enc, SvUTF8 (sv), str, len); 598 encode_strref (enc, enc->cbor.flags & F_TEXT_STRINGS, SvUTF8 (sv), str, len);
496 } 599 }
497 else if (SvNOKp (sv)) 600 else if (SvNOKp (sv))
498 encode_nv (enc, sv); 601 encode_nv (enc, sv);
499 else if (SvIOKp (sv)) 602 else if (SvIOKp (sv))
500 { 603 {
501 if (SvIsUV (sv)) 604 if (SvIsUV (sv))
502 encode_uint (enc, 0x00, SvUVX (sv)); 605 encode_uint (enc, MAJOR_POS_INT, SvUVX (sv));
503 else if (SvIVX (sv) >= 0) 606 else if (SvIVX (sv) >= 0)
504 encode_uint (enc, 0x00, SvIVX (sv)); 607 encode_uint (enc, MAJOR_POS_INT, SvIVX (sv));
505 else 608 else
506 encode_uint (enc, 0x20, -(SvIVX (sv) + 1)); 609 encode_uint (enc, MAJOR_NEG_INT, -(SvIVX (sv) + 1));
507 } 610 }
508 else if (SvROK (sv)) 611 else if (SvROK (sv))
509 encode_rv (enc, SvRV (sv)); 612 encode_rv (enc, SvRV (sv));
510 else if (!SvOK (sv)) 613 else if (!SvOK (sv))
511 encode_ch (enc, 0xe0 | 22); 614 encode_ch (enc, MAJOR_MISC | SIMPLE_NULL);
512 else if (enc->cbor.flags & F_ALLOW_UNKNOWN) 615 else if (enc->cbor.flags & F_ALLOW_UNKNOWN)
513 encode_ch (enc, 0xe0 | 23); 616 encode_ch (enc, MAJOR_MISC | SIMPLE_UNDEF);
514 else 617 else
515 croak ("encountered perl type (%s,0x%x) that CBOR cannot handle, check your input data", 618 croak ("encountered perl type (%s,0x%x) that CBOR cannot handle, check your input data",
516 SvPV_nolen (sv), (unsigned int)SvFLAGS (sv)); 619 SvPV_nolen (sv), (unsigned int)SvFLAGS (sv));
517} 620}
518 621
519static SV * 622static SV *
520encode_cbor (SV *scalar, CBOR *cbor) 623encode_cbor (SV *scalar, CBOR *cbor)
521{ 624{
522 enc_t enc = { }; 625 enc_t enc = { 0 };
523 626
524 enc.cbor = *cbor; 627 enc.cbor = *cbor;
525 enc.sv = sv_2mortal (NEWSV (0, INIT_SIZE)); 628 enc.sv = sv_2mortal (NEWSV (0, INIT_SIZE));
526 enc.cur = SvPVX (enc.sv); 629 enc.cur = SvPVX (enc.sv);
527 enc.end = SvEND (enc.sv); 630 enc.end = SvEND (enc.sv);
… …
559 U32 depth; // recursion depth 662 U32 depth; // recursion depth
560 U32 maxdepth; // recursion depth limit 663 U32 maxdepth; // recursion depth limit
561 AV *shareable; 664 AV *shareable;
562 AV *stringref; 665 AV *stringref;
563 SV *decode_tagged; 666 SV *decode_tagged;
667 SV *err_sv; // optional sv for error, needs to be freed
564} dec_t; 668} dec_t;
565 669
566#define ERR(reason) SB if (!dec->err) dec->err = reason; goto fail; SE 670// set dec->err to ERRSV
671ecb_cold static void
672err_errsv (dec_t *dec)
673{
674 if (!dec->err)
675 {
676 dec->err_sv = newSVsv (ERRSV);
567 677
568#define WANT(len) if (ecb_expect_false (dec->cur + len > dec->end)) ERR ("unexpected end of CBOR data") 678 // chop off the trailing \n
679 SvCUR_set (dec->err_sv, SvCUR (dec->err_sv) - 1);
680 *SvEND (dec->err_sv) = 0;
569 681
682 dec->err = SvPVutf8_nolen (dec->err_sv);
683 }
684}
685
686// the following functions are used to reduce code size and help the compiler to optimise
687ecb_cold static void
688err_set (dec_t *dec, const char *reason)
689{
690 if (!dec->err)
691 dec->err = reason;
692}
693
694ecb_cold static void
695err_unexpected_end (dec_t *dec)
696{
697 err_set (dec, "unexpected end of CBOR data");
698}
699
700ecb_cold static void
701err_nesting_exceeded (dec_t *dec)
702{
703 err_set (dec, ERR_NESTING_EXCEEDED);
704}
705
706#define ERR_DO(do) SB do; goto fail; SE
707#define ERR(reason) ERR_DO (err_set (dec, reason))
708#define ERR_ERRSV ERR_DO (err_errsv (dec))
709
710#define WANT(len) if (ecb_expect_false ((uintptr_t)(dec->end - dec->cur) < (STRLEN)len)) ERR_DO (err_unexpected_end (dec))
711
570#define DEC_INC_DEPTH if (++dec->depth > dec->cbor.max_depth) ERR (ERR_NESTING_EXCEEDED) 712#define DEC_INC_DEPTH if (ecb_expect_false (++dec->depth > dec->cbor.max_depth)) ERR (ERR_NESTING_EXCEEDED)
571#define DEC_DEC_DEPTH --dec->depth 713#define DEC_DEC_DEPTH --dec->depth
572 714
573static UV 715static UV
574decode_uint (dec_t *dec) 716decode_uint (dec_t *dec)
575{ 717{
576 switch (*dec->cur & 31) 718 U8 m = *dec->cur & MINOR_MASK;
577 { 719 ++dec->cur;
578 case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
579 case 8: case 9: case 10: case 11: case 12: case 13: case 14: case 15:
580 case 16: case 17: case 18: case 19: case 20: case 21: case 22: case 23:
581 return *dec->cur++ & 31;
582 720
583 case 24: 721 if (ecb_expect_true (m < LENGTH_EXT1))
722 return m;
723 else if (ecb_expect_true (m == LENGTH_EXT1))
724 {
584 WANT (2); 725 WANT (1);
585 dec->cur += 2; 726 dec->cur += 1;
586 return dec->cur[-1]; 727 return dec->cur[-1];
587 728 }
588 case 25: 729 else if (ecb_expect_true (m == LENGTH_EXT2))
730 {
589 WANT (3); 731 WANT (2);
590 dec->cur += 3; 732 dec->cur += 2;
591 return (((UV)dec->cur[-2]) << 8) 733 return (((UV)dec->cur[-2]) << 8)
592 | ((UV)dec->cur[-1]); 734 | ((UV)dec->cur[-1]);
593 735 }
594 case 26: 736 else if (ecb_expect_true (m == LENGTH_EXT4))
737 {
595 WANT (5); 738 WANT (4);
596 dec->cur += 5; 739 dec->cur += 4;
597 return (((UV)dec->cur[-4]) << 24) 740 return (((UV)dec->cur[-4]) << 24)
598 | (((UV)dec->cur[-3]) << 16) 741 | (((UV)dec->cur[-3]) << 16)
599 | (((UV)dec->cur[-2]) << 8) 742 | (((UV)dec->cur[-2]) << 8)
600 | ((UV)dec->cur[-1]); 743 | ((UV)dec->cur[-1]);
601 744 }
602 case 27: 745 else if (ecb_expect_true (m == LENGTH_EXT8))
746 {
603 WANT (9); 747 WANT (8);
604 dec->cur += 9; 748 dec->cur += 8;
749
750 return
751#if UVSIZE < 8
752 0
753#else
605 return (((UV)dec->cur[-8]) << 56) 754 (((UV)dec->cur[-8]) << 56)
606 | (((UV)dec->cur[-7]) << 48) 755 | (((UV)dec->cur[-7]) << 48)
607 | (((UV)dec->cur[-6]) << 40) 756 | (((UV)dec->cur[-6]) << 40)
608 | (((UV)dec->cur[-5]) << 32) 757 | (((UV)dec->cur[-5]) << 32)
758#endif
609 | (((UV)dec->cur[-4]) << 24) 759 | (((UV)dec->cur[-4]) << 24)
610 | (((UV)dec->cur[-3]) << 16) 760 | (((UV)dec->cur[-3]) << 16)
611 | (((UV)dec->cur[-2]) << 8) 761 | (((UV)dec->cur[-2]) << 8)
612 | ((UV)dec->cur[-1]); 762 | ((UV)dec->cur[-1]);
613 763 }
614 default: 764 else
615 ERR ("corrupted CBOR data (unsupported integer minor encoding)"); 765 ERR ("corrupted CBOR data (unsupported integer minor encoding)");
616 }
617 766
618fail: 767fail:
619 return 0; 768 return 0;
620} 769}
621 770
… …
626{ 775{
627 AV *av = newAV (); 776 AV *av = newAV ();
628 777
629 DEC_INC_DEPTH; 778 DEC_INC_DEPTH;
630 779
631 if ((*dec->cur & 31) == 31) 780 if (*dec->cur == (MAJOR_ARRAY | MINOR_INDEF))
632 { 781 {
633 ++dec->cur; 782 ++dec->cur;
634 783
635 for (;;) 784 for (;;)
636 { 785 {
637 WANT (1); 786 WANT (1);
638 787
639 if (*dec->cur == (0xe0 | 31)) 788 if (*dec->cur == (MAJOR_MISC | MINOR_INDEF))
640 { 789 {
641 ++dec->cur; 790 ++dec->cur;
642 break; 791 break;
643 } 792 }
644 793
645 av_push (av, decode_sv (dec)); 794 av_push (av, decode_sv (dec));
646 } 795 }
647 } 796 }
648 else 797 else
649 { 798 {
650 int i, len = decode_uint (dec); 799 UV i, len = decode_uint (dec);
651 800
801 WANT (len); // complexity check for av_fill - need at least one byte per value, do not allow supersize arrays
652 av_fill (av, len - 1); 802 av_fill (av, len - 1);
653 803
654 for (i = 0; i < len; ++i) 804 for (i = 0; i < len; ++i)
655 AvARRAY (av)[i] = decode_sv (dec); 805 AvARRAY (av)[i] = decode_sv (dec);
656 } 806 }
… …
669{ 819{
670 // for speed reasons, we specialcase single-string 820 // for speed reasons, we specialcase single-string
671 // byte or utf-8 strings as keys, but only when !stringref 821 // byte or utf-8 strings as keys, but only when !stringref
672 822
673 if (ecb_expect_true (!dec->stringref)) 823 if (ecb_expect_true (!dec->stringref))
674 if (*dec->cur >= 0x40 && *dec->cur <= 0x40 + 27) 824 if (ecb_expect_true ((U8)(*dec->cur - MAJOR_BYTES) <= LENGTH_EXT8))
675 { 825 {
676 I32 len = decode_uint (dec); 826 STRLEN len = decode_uint (dec);
677 char *key = (char *)dec->cur; 827 char *key = (char *)dec->cur;
678 828
829 WANT (len);
679 dec->cur += len; 830 dec->cur += len;
680 831
681 if (ecb_expect_false (dec->stringref))
682 av_push (dec->stringref, newSVpvn (key, len));
683
684 hv_store (hv, key, len, decode_sv (dec), 0); 832 hv_store (hv, key, len, decode_sv (dec), 0);
685 833
686 return; 834 return;
687 } 835 }
688 else if (*dec->cur >= 0x60 && *dec->cur <= 0x60 + 27) 836 else if (ecb_expect_true ((U8)(*dec->cur - MAJOR_TEXT) <= LENGTH_EXT8))
689 { 837 {
690 I32 len = decode_uint (dec); 838 STRLEN len = decode_uint (dec);
691 char *key = (char *)dec->cur; 839 char *key = (char *)dec->cur;
692 840
841 WANT (len);
693 dec->cur += len; 842 dec->cur += len;
694 843
695 if (ecb_expect_false (dec->stringref)) 844 if (ecb_expect_false (dec->cbor.flags & F_VALIDATE_UTF8))
696 av_push (dec->stringref, newSVpvn_utf8 (key, len, 1)); 845 if (!is_utf8_string (key, len))
846 ERR ("corrupted CBOR data (invalid UTF-8 in map key)");
697 847
698 hv_store (hv, key, -len, decode_sv (dec), 0); 848 hv_store (hv, key, -len, decode_sv (dec), 0);
699 849
700 return; 850 return;
701 } 851 }
702 852
703 SV *k = decode_sv (dec); 853 SV *k = decode_sv (dec);
704 SV *v = decode_sv (dec); 854 SV *v = decode_sv (dec);
705 855
856 // we leak memory if uncaught exceptions are thrown by random magical
857 // methods, and this is hopefully the only place where it can happen,
858 // so if there is a chance of an exception, take the very slow path.
859 // since catching exceptions is "undocumented/internal/forbidden" by
860 // the new p5p powers, we need to call out to a perl function :/
861 if (ecb_expect_false (SvAMAGIC (k)))
862 {
863 dSP;
864
865 ENTER; SAVETMPS;
866 PUSHMARK (SP);
867 EXTEND (SP, 3);
868 PUSHs (sv_2mortal (newRV_inc ((SV *)hv)));
869 PUSHs (sv_2mortal (k));
870 PUSHs (sv_2mortal (v));
871
872 PUTBACK;
873 call_pv ("CBOR::XS::_hv_store", G_VOID | G_DISCARD | G_EVAL);
874 SPAGAIN;
875
876 FREETMPS; LEAVE;
877
878 if (SvTRUE (ERRSV))
879 ERR_ERRSV;
880
881 return;
882 }
883
706 hv_store_ent (hv, k, v, 0); 884 hv_store_ent (hv, k, v, 0);
707 SvREFCNT_dec (k); 885 SvREFCNT_dec (k);
886
887fail:
888 ;
708} 889}
709 890
710static SV * 891static SV *
711decode_hv (dec_t *dec) 892decode_hv (dec_t *dec)
712{ 893{
713 HV *hv = newHV (); 894 HV *hv = newHV ();
714 895
715 DEC_INC_DEPTH; 896 DEC_INC_DEPTH;
716 897
717 if ((*dec->cur & 31) == 31) 898 if (*dec->cur == (MAJOR_MAP | MINOR_INDEF))
718 { 899 {
719 ++dec->cur; 900 ++dec->cur;
720 901
721 for (;;) 902 for (;;)
722 { 903 {
723 WANT (1); 904 WANT (1);
724 905
725 if (*dec->cur == (0xe0 | 31)) 906 if (*dec->cur == (MAJOR_MISC | MINOR_INDEF))
726 { 907 {
727 ++dec->cur; 908 ++dec->cur;
728 break; 909 break;
729 } 910 }
730 911
731 decode_he (dec, hv); 912 decode_he (dec, hv);
732 } 913 }
733 } 914 }
734 else 915 else
735 { 916 {
736 int pairs = decode_uint (dec); 917 UV pairs = decode_uint (dec);
918
919 WANT (pairs); // complexity check - need at least one byte per value, do not allow supersize hashes
737 920
738 while (pairs--) 921 while (pairs--)
739 decode_he (dec, hv); 922 decode_he (dec, hv);
740 } 923 }
741 924
… …
751static SV * 934static SV *
752decode_str (dec_t *dec, int utf8) 935decode_str (dec_t *dec, int utf8)
753{ 936{
754 SV *sv = 0; 937 SV *sv = 0;
755 938
756 if ((*dec->cur & 31) == 31) 939 if ((*dec->cur & MINOR_MASK) == MINOR_INDEF)
757 { 940 {
758 // indefinite length strings 941 // indefinite length strings
759 ++dec->cur; 942 ++dec->cur;
760 943
761 unsigned char major = *dec->cur & 0xe0; 944 U8 major = *dec->cur & MAJOR_MISC;
762 945
763 sv = newSVpvn ("", 0); 946 sv = newSVpvn ("", 0);
764 947
765 for (;;) 948 for (;;)
766 { 949 {
767 WANT (1); 950 WANT (1);
768 951
769 if ((*dec->cur ^ major) >= 31) 952 if ((*dec->cur - major) > LENGTH_EXT8)
770 if (*dec->cur == (0xe0 | 31)) 953 if (*dec->cur == (MAJOR_MISC | MINOR_INDEF))
771 { 954 {
772 ++dec->cur; 955 ++dec->cur;
773 break; 956 break;
774 } 957 }
775 else 958 else
… …
794 && SvCUR (sv) >= minimum_string_length (AvFILLp (dec->stringref) + 1)) 977 && SvCUR (sv) >= minimum_string_length (AvFILLp (dec->stringref) + 1))
795 av_push (dec->stringref, SvREFCNT_inc_NN (sv)); 978 av_push (dec->stringref, SvREFCNT_inc_NN (sv));
796 } 979 }
797 980
798 if (utf8) 981 if (utf8)
982 {
983 if (ecb_expect_false (dec->cbor.flags & F_VALIDATE_UTF8))
984 if (!is_utf8_string (SvPVX (sv), SvCUR (sv)))
985 ERR ("corrupted CBOR data (invalid UTF-8 in text string)");
986
799 SvUTF8_on (sv); 987 SvUTF8_on (sv);
988 }
800 989
801 return sv; 990 return sv;
802 991
803fail: 992fail:
804 SvREFCNT_dec (sv); 993 SvREFCNT_dec (sv);
… …
823 sv = newRV_noinc (decode_sv (dec)); 1012 sv = newRV_noinc (decode_sv (dec));
824 break; 1013 break;
825 1014
826 case CBOR_TAG_STRINGREF_NAMESPACE: 1015 case CBOR_TAG_STRINGREF_NAMESPACE:
827 { 1016 {
1017 // do nmot use SAVETMPS/FREETMPS, as these will
1018 // erase mortalised caches, e.g. "shareable"
828 ENTER; SAVETMPS; 1019 ENTER;
829 1020
830 SAVESPTR (dec->stringref); 1021 SAVESPTR (dec->stringref);
831 dec->stringref = (AV *)sv_2mortal ((SV *)newAV ()); 1022 dec->stringref = (AV *)sv_2mortal ((SV *)newAV ());
832 1023
833 sv = decode_sv (dec); 1024 sv = decode_sv (dec);
834 1025
835 FREETMPS; LEAVE; 1026 LEAVE;
836 } 1027 }
837 break; 1028 break;
838 1029
839 case CBOR_TAG_STRINGREF: 1030 case CBOR_TAG_STRINGREF:
840 { 1031 {
841 if ((*dec->cur >> 5) != 0) 1032 if ((*dec->cur >> MAJOR_SHIFT) != (MAJOR_POS_INT >> MAJOR_SHIFT))
842 ERR ("corrupted CBOR data (stringref index not an unsigned integer)"); 1033 ERR ("corrupted CBOR data (stringref index not an unsigned integer)");
843 1034
844 UV idx = decode_uint (dec); 1035 UV idx = decode_uint (dec);
845 1036
846 if (!dec->stringref || (int)idx > AvFILLp (dec->stringref)) 1037 if (!dec->stringref || (int)idx > AvFILLp (dec->stringref))
… …
853 case CBOR_TAG_VALUE_SHAREABLE: 1044 case CBOR_TAG_VALUE_SHAREABLE:
854 { 1045 {
855 if (ecb_expect_false (!dec->shareable)) 1046 if (ecb_expect_false (!dec->shareable))
856 dec->shareable = (AV *)sv_2mortal ((SV *)newAV ()); 1047 dec->shareable = (AV *)sv_2mortal ((SV *)newAV ());
857 1048
1049 if (dec->cbor.flags & F_ALLOW_CYCLES)
1050 {
858 sv = newSV (0); 1051 sv = newSV (0);
859 av_push (dec->shareable, SvREFCNT_inc_NN (sv)); 1052 av_push (dec->shareable, SvREFCNT_inc_NN (sv));
860 1053
861 SV *osv = decode_sv (dec); 1054 SV *osv = decode_sv (dec);
862 sv_setsv (sv, osv); 1055 sv_setsv (sv, osv);
863 SvREFCNT_dec_NN (osv); 1056 SvREFCNT_dec_NN (osv);
1057 }
1058 else
1059 {
1060 av_push (dec->shareable, &PL_sv_undef);
1061 int idx = AvFILLp (dec->shareable);
1062 sv = decode_sv (dec);
1063 av_store (dec->shareable, idx, SvREFCNT_inc_NN (sv));
1064 }
864 } 1065 }
865 break; 1066 break;
866 1067
867 case CBOR_TAG_VALUE_SHAREDREF: 1068 case CBOR_TAG_VALUE_SHAREDREF:
868 { 1069 {
869 if ((*dec->cur >> 5) != 0) 1070 if ((*dec->cur >> MAJOR_SHIFT) != (MAJOR_POS_INT >> MAJOR_SHIFT))
870 ERR ("corrupted CBOR data (sharedref index not an unsigned integer)"); 1071 ERR ("corrupted CBOR data (sharedref index not an unsigned integer)");
871 1072
872 UV idx = decode_uint (dec); 1073 UV idx = decode_uint (dec);
873 1074
874 if (!dec->shareable || (int)idx > AvFILLp (dec->shareable)) 1075 if (!dec->shareable || (int)idx > AvFILLp (dec->shareable))
875 ERR ("corrupted CBOR data (sharedref index out of bounds)"); 1076 ERR ("corrupted CBOR data (sharedref index out of bounds)");
876 1077
877 sv = SvREFCNT_inc_NN (AvARRAY (dec->shareable)[idx]); 1078 sv = SvREFCNT_inc_NN (AvARRAY (dec->shareable)[idx]);
1079
1080 if (sv == &PL_sv_undef)
1081 ERR ("cyclic CBOR data structure found, but allow_cycles is not enabled");
878 } 1082 }
879 break; 1083 break;
880 1084
881 case CBOR_TAG_PERL_OBJECT: 1085 case CBOR_TAG_PERL_OBJECT:
882 { 1086 {
1087 if (dec->cbor.flags & F_FORBID_OBJECTS)
1088 goto filter;
1089
883 sv = decode_sv (dec); 1090 sv = decode_sv (dec);
884 1091
885 if (!SvROK (sv) || SvTYPE (SvRV (sv)) != SVt_PVAV) 1092 if (!SvROK (sv) || SvTYPE (SvRV (sv)) != SVt_PVAV)
886 ERR ("corrupted CBOR data (non-array perl object)"); 1093 ERR ("corrupted CBOR data (non-array perl object)");
887 1094
… …
897 if (!method) 1104 if (!method)
898 ERR ("cannot decode perl-object (package does not have a THAW method)"); 1105 ERR ("cannot decode perl-object (package does not have a THAW method)");
899 1106
900 dSP; 1107 dSP;
901 1108
902 ENTER; SAVETMPS; PUSHMARK (SP); 1109 ENTER; SAVETMPS;
1110 PUSHMARK (SP);
903 EXTEND (SP, len + 1); 1111 EXTEND (SP, len + 1);
904 // we re-bless the reference to get overload and other niceties right 1112 // we re-bless the reference to get overload and other niceties right
905 PUSHs (*av_fetch (av, 0, 1)); 1113 PUSHs (*av_fetch (av, 0, 1));
906 PUSHs (sv_cbor); 1114 PUSHs (sv_cbor);
907 1115
… …
915 SPAGAIN; 1123 SPAGAIN;
916 1124
917 if (SvTRUE (ERRSV)) 1125 if (SvTRUE (ERRSV))
918 { 1126 {
919 FREETMPS; LEAVE; 1127 FREETMPS; LEAVE;
920 ERR (SvPVutf8_nolen (sv_2mortal (SvREFCNT_inc (ERRSV)))); 1128 ERR_ERRSV;
921 } 1129 }
922 1130
923 SvREFCNT_dec (sv); 1131 SvREFCNT_dec (sv);
924 sv = SvREFCNT_inc (POPs); 1132 sv = SvREFCNT_inc (POPs);
925 1133
… …
928 FREETMPS; LEAVE; 1136 FREETMPS; LEAVE;
929 } 1137 }
930 break; 1138 break;
931 1139
932 default: 1140 default:
1141 filter:
933 { 1142 {
1143 SV *tag_sv = newSVuv (tag);
1144
934 sv = decode_sv (dec); 1145 sv = decode_sv (dec);
935 1146
936 dSP; 1147 dSP;
937 ENTER; SAVETMPS; PUSHMARK (SP); 1148 ENTER; SAVETMPS;
1149 SAVESTACK_POS ();
1150 PUSHMARK (SP);
938 EXTEND (SP, 2); 1151 EXTEND (SP, 2);
939 PUSHs (newSVuv (tag)); 1152 PUSHs (tag_sv);
940 PUSHs (sv); 1153 PUSHs (sv);
941 1154
942 PUTBACK; 1155 PUTBACK;
943 int count = call_sv (dec->cbor.filter ? dec->cbor.filter : default_filter, G_ARRAY | G_EVAL); 1156 int count = call_sv (dec->cbor.filter ? dec->cbor.filter : default_filter, G_ARRAY | G_EVAL);
944 SPAGAIN; 1157 SPAGAIN;
945 1158
946 if (SvTRUE (ERRSV)) 1159 if (SvTRUE (ERRSV))
947 { 1160 {
1161 SvREFCNT_dec (tag_sv);
948 FREETMPS; LEAVE; 1162 FREETMPS; LEAVE;
949 ERR (SvPVutf8_nolen (sv_2mortal (SvREFCNT_inc (ERRSV)))); 1163 ERR_ERRSV;
950 } 1164 }
951 1165
952 if (count) 1166 if (count)
953 { 1167 {
1168 SvREFCNT_dec (tag_sv);
954 SvREFCNT_dec (sv); 1169 SvREFCNT_dec (sv);
955 sv = SvREFCNT_inc (POPs); 1170 sv = SvREFCNT_inc (POPs);
956 } 1171 }
957 else 1172 else
958 { 1173 {
959 AV *av = newAV (); 1174 AV *av = newAV ();
960 av_push (av, newSVuv (tag)); 1175 av_push (av, tag_sv);
961 av_push (av, sv); 1176 av_push (av, sv);
962 1177
963 HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash 1178 HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash
964 ? cbor_tagged_stash 1179 ? cbor_tagged_stash
965 : gv_stashpv ("CBOR::XS::Tagged" , 1); 1180 : gv_stashpv ("CBOR::XS::Tagged" , 1);
… …
983static SV * 1198static SV *
984decode_sv (dec_t *dec) 1199decode_sv (dec_t *dec)
985{ 1200{
986 WANT (1); 1201 WANT (1);
987 1202
988 switch (*dec->cur >> 5) 1203 switch (*dec->cur >> MAJOR_SHIFT)
989 { 1204 {
990 case 0: // unsigned int 1205 case MAJOR_POS_INT >> MAJOR_SHIFT: return newSVuv (decode_uint (dec));
991 return newSVuv (decode_uint (dec)); 1206 case MAJOR_NEG_INT >> MAJOR_SHIFT: return newSViv (-1 - (IV)decode_uint (dec));
992 case 1: // negative int 1207 case MAJOR_BYTES >> MAJOR_SHIFT: return decode_str (dec, 0);
993 return newSViv (-1 - (IV)decode_uint (dec)); 1208 case MAJOR_TEXT >> MAJOR_SHIFT: return decode_str (dec, 1);
994 case 2: // octet string 1209 case MAJOR_ARRAY >> MAJOR_SHIFT: return decode_av (dec);
995 return decode_str (dec, 0); 1210 case MAJOR_MAP >> MAJOR_SHIFT: return decode_hv (dec);
996 case 3: // utf-8 string 1211 case MAJOR_TAG >> MAJOR_SHIFT: return decode_tagged (dec);
997 return decode_str (dec, 1); 1212
998 case 4: // array 1213 case MAJOR_MISC >> MAJOR_SHIFT:
999 return decode_av (dec);
1000 case 5: // map
1001 return decode_hv (dec);
1002 case 6: // tag
1003 return decode_tagged (dec);
1004 case 7: // misc
1005 switch (*dec->cur++ & 31) 1214 switch (*dec->cur++ & MINOR_MASK)
1006 { 1215 {
1007 case 20: 1216 case SIMPLE_FALSE:
1008#if CBOR_SLOW 1217#if CBOR_SLOW
1009 types_false = get_bool ("Types::Serialiser::false"); 1218 types_false = get_bool ("Types::Serialiser::false");
1010#endif 1219#endif
1011 return newSVsv (types_false); 1220 return newSVsv (types_false);
1012 case 21: 1221 case SIMPLE_TRUE:
1013#if CBOR_SLOW 1222#if CBOR_SLOW
1014 types_true = get_bool ("Types::Serialiser::true"); 1223 types_true = get_bool ("Types::Serialiser::true");
1015#endif 1224#endif
1016 return newSVsv (types_true); 1225 return newSVsv (types_true);
1017 case 22: 1226 case SIMPLE_NULL:
1018 return newSVsv (&PL_sv_undef); 1227 return newSVsv (&PL_sv_undef);
1019 case 23: 1228 case SIMPLE_UNDEF:
1020#if CBOR_SLOW 1229#if CBOR_SLOW
1021 types_error = get_bool ("Types::Serialiser::error"); 1230 types_error = get_bool ("Types::Serialiser::error");
1022#endif 1231#endif
1023 return newSVsv (types_error); 1232 return newSVsv (types_error);
1024 1233
1025 case 25: 1234 case MISC_FLOAT16:
1026 { 1235 {
1027 WANT (2); 1236 WANT (2);
1028 1237
1029 uint16_t fp = (dec->cur[0] << 8) | dec->cur[1]; 1238 uint16_t fp = (dec->cur[0] << 8) | dec->cur[1];
1030 dec->cur += 2; 1239 dec->cur += 2;
1031 1240
1032 return newSVnv (ecb_binary16_to_float (fp)); 1241 return newSVnv (ecb_binary16_to_float (fp));
1033 } 1242 }
1034 1243
1035 case 26: 1244 case MISC_FLOAT32:
1036 { 1245 {
1037 uint32_t fp; 1246 uint32_t fp;
1038 WANT (4); 1247 WANT (4);
1039 memcpy (&fp, dec->cur, 4); 1248 memcpy (&fp, dec->cur, 4);
1040 dec->cur += 4; 1249 dec->cur += 4;
… …
1043 fp = ecb_bswap32 (fp); 1252 fp = ecb_bswap32 (fp);
1044 1253
1045 return newSVnv (ecb_binary32_to_float (fp)); 1254 return newSVnv (ecb_binary32_to_float (fp));
1046 } 1255 }
1047 1256
1048 case 27: 1257 case MISC_FLOAT64:
1049 { 1258 {
1050 uint64_t fp; 1259 uint64_t fp;
1051 WANT (8); 1260 WANT (8);
1052 memcpy (&fp, dec->cur, 8); 1261 memcpy (&fp, dec->cur, 8);
1053 dec->cur += 8; 1262 dec->cur += 8;
… …
1056 fp = ecb_bswap64 (fp); 1265 fp = ecb_bswap64 (fp);
1057 1266
1058 return newSVnv (ecb_binary64_to_double (fp)); 1267 return newSVnv (ecb_binary64_to_double (fp));
1059 } 1268 }
1060 1269
1061 // 0..19 unassigned 1270 // 0..19 unassigned simple
1062 // 24 reserved + unassigned (reserved values are not encodable) 1271 // 24 reserved + unassigned simple (reserved values are not encodable)
1272 // 28-30 unassigned misc
1273 // 31 break code
1063 default: 1274 default:
1064 ERR ("corrupted CBOR data (reserved/unassigned major 7 value)"); 1275 ERR ("corrupted CBOR data (reserved/unassigned/unexpected major 7 value)");
1065 } 1276 }
1066 1277
1067 break; 1278 break;
1068 } 1279 }
1069 1280
… …
1072} 1283}
1073 1284
1074static SV * 1285static SV *
1075decode_cbor (SV *string, CBOR *cbor, char **offset_return) 1286decode_cbor (SV *string, CBOR *cbor, char **offset_return)
1076{ 1287{
1077 dec_t dec = { }; 1288 dec_t dec = { 0 };
1078 SV *sv; 1289 SV *sv;
1079 STRLEN len; 1290 STRLEN len;
1080 char *data = SvPVbyte (string, len); 1291 char *data = SvPVbyte (string, len);
1081 1292
1082 if (len > cbor->max_size && cbor->max_size) 1293 if (len > cbor->max_size && cbor->max_size)
… …
1096 if (dec.cur != dec.end && !dec.err) 1307 if (dec.cur != dec.end && !dec.err)
1097 dec.err = "garbage after CBOR object"; 1308 dec.err = "garbage after CBOR object";
1098 1309
1099 if (dec.err) 1310 if (dec.err)
1100 { 1311 {
1312 if (dec.shareable)
1313 {
1314 // need to break cyclic links, which would all be in shareable
1315 int i;
1316 SV **svp;
1317
1318 for (i = av_len (dec.shareable) + 1; i--; )
1319 if ((svp = av_fetch (dec.shareable, i, 0)))
1320 sv_setsv (*svp, &PL_sv_undef);
1321 }
1322
1101 SvREFCNT_dec (sv); 1323 SvREFCNT_dec (sv);
1324
1325 if (dec.err_sv)
1326 sv_2mortal (dec.err_sv);
1327
1102 croak ("%s, at offset %d (octet 0x%02x)", dec.err, dec.cur - (U8 *)data, (int)(uint8_t)*dec.cur); 1328 croak ("%s, at offset %d (octet 0x%02x)", dec.err, dec.cur - (U8 *)data, (int)(uint8_t)*dec.cur);
1103 } 1329 }
1104 1330
1105 sv = sv_2mortal (sv); 1331 sv = sv_2mortal (sv);
1106 1332
1107 return sv; 1333 return sv;
1108} 1334}
1109 1335
1336/////////////////////////////////////////////////////////////////////////////
1337// incremental parser
1338
1339#define INCR_DONE(cbor) (AvFILLp (cbor->incr_count) < 0)
1340
1341// returns 0 for notyet, 1 for success or error
1342static int
1343incr_parse (CBOR *self, SV *cborstr)
1344{
1345 STRLEN cur;
1346 SvPV (cborstr, cur);
1347
1348 while (ecb_expect_true (self->incr_need <= cur))
1349 {
1350 // table of integer count bytes
1351 static I8 incr_len[MINOR_MASK + 1] = {
1352 0, 0, 0, 0, 0, 0, 0, 0,
1353 0, 0, 0, 0, 0, 0, 0, 0,
1354 0, 0, 0, 0, 0, 0, 0, 0,
1355 1, 2, 4, 8,-1,-1,-1,-2
1356 };
1357
1358 const U8 *p = SvPVX (cborstr) + self->incr_pos;
1359 U8 m = *p & MINOR_MASK;
1360 IV count = SvIVX (AvARRAY (self->incr_count)[AvFILLp (self->incr_count)]);
1361 I8 ilen = incr_len[m];
1362
1363 self->incr_need = self->incr_pos + 1;
1364
1365 if (ecb_expect_false (ilen < 0))
1366 {
1367 if (m != MINOR_INDEF)
1368 return 1; // error
1369
1370 if (*p == (MAJOR_MISC | MINOR_INDEF))
1371 {
1372 if (count >= 0)
1373 return 1; // error
1374
1375 count = 1;
1376 }
1377 else
1378 {
1379 av_push (self->incr_count, newSViv (-1)); //TODO: nest
1380 count = -1;
1381 }
1382 }
1383 else
1384 {
1385 self->incr_need += ilen;
1386 if (ecb_expect_false (self->incr_need > cur))
1387 return 0;
1388
1389 int major = *p >> MAJOR_SHIFT;
1390
1391 switch (major)
1392 {
1393 case MAJOR_TAG >> MAJOR_SHIFT:
1394 ++count; // tags merely prefix another value
1395 break;
1396
1397 case MAJOR_BYTES >> MAJOR_SHIFT:
1398 case MAJOR_TEXT >> MAJOR_SHIFT:
1399 case MAJOR_ARRAY >> MAJOR_SHIFT:
1400 case MAJOR_MAP >> MAJOR_SHIFT:
1401 {
1402 UV len;
1403
1404 if (ecb_expect_false (ilen))
1405 {
1406 len = 0;
1407
1408 do {
1409 len = (len << 8) | *++p;
1410 } while (--ilen);
1411 }
1412 else
1413 len = m;
1414
1415 switch (major)
1416 {
1417 case MAJOR_BYTES >> MAJOR_SHIFT:
1418 case MAJOR_TEXT >> MAJOR_SHIFT:
1419 self->incr_need += len;
1420 if (ecb_expect_false (self->incr_need > cur))
1421 return 0;
1422
1423 break;
1424
1425 case MAJOR_MAP >> MAJOR_SHIFT:
1426 len <<= 1;
1427 case MAJOR_ARRAY >> MAJOR_SHIFT:
1428 if (len)
1429 {
1430 av_push (self->incr_count, newSViv (len + 1)); //TODO: nest
1431 count = len + 1;
1432 }
1433 break;
1434 }
1435 }
1436 }
1437 }
1438
1439 self->incr_pos = self->incr_need;
1440
1441 if (count > 0)
1442 {
1443 while (!--count)
1444 {
1445 if (!AvFILLp (self->incr_count))
1446 return 1; // done
1447
1448 SvREFCNT_dec_NN (av_pop (self->incr_count));
1449 count = SvIVX (AvARRAY (self->incr_count)[AvFILLp (self->incr_count)]);
1450 }
1451
1452 SvIVX (AvARRAY (self->incr_count)[AvFILLp (self->incr_count)]) = count;
1453 }
1454 }
1455
1456 return 0;
1457}
1458
1459
1110///////////////////////////////////////////////////////////////////////////// 1460/////////////////////////////////////////////////////////////////////////////
1111// XS interface functions 1461// XS interface functions
1112 1462
1113MODULE = CBOR::XS PACKAGE = CBOR::XS 1463MODULE = CBOR::XS PACKAGE = CBOR::XS
1114 1464
… …
1126 1476
1127 default_filter = newSVpv ("CBOR::XS::default_filter", 0); 1477 default_filter = newSVpv ("CBOR::XS::default_filter", 0);
1128 1478
1129 sv_cbor = newSVpv ("CBOR", 0); 1479 sv_cbor = newSVpv ("CBOR", 0);
1130 SvREADONLY_on (sv_cbor); 1480 SvREADONLY_on (sv_cbor);
1481
1482 assert (("STRLEN must be an unsigned type", 0 <= (STRLEN)-1));
1131} 1483}
1132 1484
1133PROTOTYPES: DISABLE 1485PROTOTYPES: DISABLE
1134 1486
1135void CLONE (...) 1487void CLONE (...)
… …
1154void shrink (CBOR *self, int enable = 1) 1506void shrink (CBOR *self, int enable = 1)
1155 ALIAS: 1507 ALIAS:
1156 shrink = F_SHRINK 1508 shrink = F_SHRINK
1157 allow_unknown = F_ALLOW_UNKNOWN 1509 allow_unknown = F_ALLOW_UNKNOWN
1158 allow_sharing = F_ALLOW_SHARING 1510 allow_sharing = F_ALLOW_SHARING
1511 allow_cycles = F_ALLOW_CYCLES
1512 forbid_objects = F_FORBID_OBJECTS
1159 pack_strings = F_PACK_STRINGS 1513 pack_strings = F_PACK_STRINGS
1514 text_keys = F_TEXT_KEYS
1515 text_strings = F_TEXT_STRINGS
1516 validate_utf8 = F_VALIDATE_UTF8
1160 PPCODE: 1517 PPCODE:
1161{ 1518{
1162 if (enable) 1519 if (enable)
1163 self->flags |= ix; 1520 self->flags |= ix;
1164 else 1521 else
… …
1170void get_shrink (CBOR *self) 1527void get_shrink (CBOR *self)
1171 ALIAS: 1528 ALIAS:
1172 get_shrink = F_SHRINK 1529 get_shrink = F_SHRINK
1173 get_allow_unknown = F_ALLOW_UNKNOWN 1530 get_allow_unknown = F_ALLOW_UNKNOWN
1174 get_allow_sharing = F_ALLOW_SHARING 1531 get_allow_sharing = F_ALLOW_SHARING
1532 get_allow_cycles = F_ALLOW_CYCLES
1533 get_forbid_objects = F_FORBID_OBJECTS
1175 get_pack_strings = F_PACK_STRINGS 1534 get_pack_strings = F_PACK_STRINGS
1535 get_text_keys = F_TEXT_KEYS
1536 get_text_strings = F_TEXT_STRINGS
1537 get_validate_utf8 = F_VALIDATE_UTF8
1176 PPCODE: 1538 PPCODE:
1177 XPUSHs (boolSV (self->flags & ix)); 1539 XPUSHs (boolSV (self->flags & ix));
1178 1540
1179void max_depth (CBOR *self, U32 max_depth = 0x80000000UL) 1541void max_depth (CBOR *self, U32 max_depth = 0x80000000UL)
1180 PPCODE: 1542 PPCODE:
… …
1229 EXTEND (SP, 2); 1591 EXTEND (SP, 2);
1230 PUSHs (sv); 1592 PUSHs (sv);
1231 PUSHs (sv_2mortal (newSVuv (offset - SvPVX (cborstr)))); 1593 PUSHs (sv_2mortal (newSVuv (offset - SvPVX (cborstr))));
1232} 1594}
1233 1595
1596void incr_parse (CBOR *self, SV *cborstr)
1597 ALIAS:
1598 incr_parse_multiple = 1
1599 PPCODE:
1600{
1601 if (SvUTF8 (cborstr))
1602 sv_utf8_downgrade (cborstr, 0);
1603
1604 if (!self->incr_count)
1605 {
1606 self->incr_count = newAV ();
1607 self->incr_pos = 0;
1608 self->incr_need = 1;
1609
1610 av_push (self->incr_count, newSViv (1));
1611 }
1612
1613 do
1614 {
1615 if (!incr_parse (self, cborstr))
1616 {
1617 if (self->incr_need > self->max_size && self->max_size)
1618 croak ("attempted decode of CBOR text of %lu bytes size, but max_size is set to %lu",
1619 (unsigned long)self->incr_need, (unsigned long)self->max_size);
1620
1621 break;
1622 }
1623
1624 SV *sv;
1625 char *offset;
1626
1627 PUTBACK; sv = decode_cbor (cborstr, self, &offset); SPAGAIN;
1628 XPUSHs (sv);
1629
1630 sv_chop (cborstr, offset);
1631
1632 av_clear (self->incr_count);
1633 av_push (self->incr_count, newSViv (1));
1634
1635 self->incr_pos = 0;
1636 self->incr_need = self->incr_pos + 1;
1637 }
1638 while (ix);
1639}
1640
1641void incr_reset (CBOR *self)
1642 CODE:
1643{
1644 SvREFCNT_dec (self->incr_count);
1645 self->incr_count = 0;
1646}
1647
1234void DESTROY (CBOR *self) 1648void DESTROY (CBOR *self)
1235 PPCODE: 1649 PPCODE:
1236 cbor_free (self); 1650 cbor_free (self);
1237 1651
1238PROTOTYPES: ENABLE 1652PROTOTYPES: ENABLE
1239 1653
1240void encode_cbor (SV *scalar) 1654void encode_cbor (SV *scalar)
1655 ALIAS:
1656 encode_cbor = 0
1657 encode_cbor_sharing = F_ALLOW_SHARING
1241 PPCODE: 1658 PPCODE:
1242{ 1659{
1243 CBOR cbor; 1660 CBOR cbor;
1244 cbor_init (&cbor); 1661 cbor_init (&cbor);
1662 cbor.flags |= ix;
1245 PUTBACK; scalar = encode_cbor (scalar, &cbor); SPAGAIN; 1663 PUTBACK; scalar = encode_cbor (scalar, &cbor); SPAGAIN;
1246 XPUSHs (scalar); 1664 XPUSHs (scalar);
1247} 1665}
1248 1666
1249void decode_cbor (SV *cborstr) 1667void decode_cbor (SV *cborstr)

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines