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.10 by root, Sun Oct 27 20:40:25 2013 UTC vs.
Revision 1.50 by root, Thu Feb 25 02:29:22 2016 UTC

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 11
12#define ECB_NO_THREADS 1
12#include "ecb.h" 13#include "ecb.h"
14
15// compatibility with perl <5.18
16#ifndef HvNAMELEN_get
17# define HvNAMELEN_get(hv) strlen (HvNAME (hv))
18#endif
19#ifndef HvNAMELEN
20# define HvNAMELEN(hv) HvNAMELEN_get (hv)
21#endif
22#ifndef HvNAMEUTF8
23# define HvNAMEUTF8(hv) 0
24#endif
25#ifndef SvREFCNT_dec_NN
26# define SvREFCNT_dec_NN(sv) SvREFCNT_dec (sv)
27#endif
28
29// known major and minor types
30enum cbor_type
31{
32 MAJOR_SHIFT = 5,
33 MINOR_MASK = 0x1f,
34
35 MAJOR_POS_INT = 0 << MAJOR_SHIFT,
36 MAJOR_NEG_INT = 1 << MAJOR_SHIFT,
37 MAJOR_BYTES = 2 << MAJOR_SHIFT,
38 MAJOR_TEXT = 3 << MAJOR_SHIFT,
39 MAJOR_ARRAY = 4 << MAJOR_SHIFT,
40 MAJOR_MAP = 5 << MAJOR_SHIFT,
41 MAJOR_TAG = 6 << MAJOR_SHIFT,
42 MAJOR_MISC = 7 << MAJOR_SHIFT,
43
44 // INT/STRING/ARRAY/MAP subtypes
45 LENGTH_EXT1 = 24,
46 LENGTH_EXT2 = 25,
47 LENGTH_EXT4 = 26,
48 LENGTH_EXT8 = 27,
49
50 // SIMPLE types (effectively MISC subtypes)
51 SIMPLE_FALSE = 20,
52 SIMPLE_TRUE = 21,
53 SIMPLE_NULL = 22,
54 SIMPLE_UNDEF = 23,
55
56 // MISC subtype (unused)
57 MISC_EXT1 = 24,
58 MISC_FLOAT16 = 25,
59 MISC_FLOAT32 = 26,
60 MISC_FLOAT64 = 27,
61
62 // BYTES/TEXT/ARRAY/MAP
63 MINOR_INDEF = 31,
64};
13 65
14// known tags 66// known tags
15enum cbor_tag 67enum cbor_tag
16{ 68{
17 // inofficial extensions (pending iana registration) 69 // extensions
18 CBOR_TAG_PERL_OBJECT = 256, 70 CBOR_TAG_STRINGREF = 25, // http://cbor.schmorp.de/stringref
19 CBOR_TAG_GENERIC_OBJECT = 257, 71 CBOR_TAG_PERL_OBJECT = 26, // http://cbor.schmorp.de/perl-object
72 CBOR_TAG_GENERIC_OBJECT = 27, // http://cbor.schmorp.de/generic-object
73 CBOR_TAG_VALUE_SHAREABLE = 28, // http://cbor.schmorp.de/value-sharing
74 CBOR_TAG_VALUE_SHAREDREF = 29, // http://cbor.schmorp.de/value-sharing
75 CBOR_TAG_STRINGREF_NAMESPACE = 256, // http://cbor.schmorp.de/stringref
76 CBOR_TAG_INDIRECTION = 22098, // http://cbor.schmorp.de/indirection
20 77
21 // rfc7049 78 // rfc7049
22 CBOR_TAG_DATETIME = 0, // rfc4287, utf-8 79 CBOR_TAG_DATETIME = 0, // rfc4287, utf-8
23 CBOR_TAG_TIMESTAMP = 1, // unix timestamp, any 80 CBOR_TAG_TIMESTAMP = 1, // unix timestamp, any
24 CBOR_TAG_POS_BIGNUM = 2, // byte string 81 CBOR_TAG_POS_BIGNUM = 2, // byte string
25 CBOR_TAG_NEG_BIGNUM = 3, // byte string 82 CBOR_TAG_NEG_BIGNUM = 3, // byte string
26 CBOR_TAG_DECIMAL = 4, // decimal fraction, array 83 CBOR_TAG_DECIMAL = 4, // decimal fraction, array
27 CBOR_TAG_BIGFLOAT = 5, // array 84 CBOR_TAG_BIGFLOAT = 5, // array
28 85
29 CBOR_TAG_CONV_B64U = 21, // base64url, any 86 CBOR_TAG_CONV_B64U = 21, // base64url, any
30 CBOR_TAG_CONV_B64 = 22, // base64, any 87 CBOR_TAG_CONV_B64 = 22, // base64, any
31 CBOR_TAG_CONV_HEX = 23, // base16, any 88 CBOR_TAG_CONV_HEX = 23, // base16, any
32 CBOR_TAG_CBOR = 24, // embedded cbor, byte string 89 CBOR_TAG_CBOR = 24, // embedded cbor, byte string
33 90
34 CBOR_TAG_URI = 32, // URI rfc3986, utf-8 91 CBOR_TAG_URI = 32, // URI rfc3986, utf-8
35 CBOR_TAG_B64U = 33, // base64url rfc4648, utf-8 92 CBOR_TAG_B64U = 33, // base64url rfc4648, utf-8
36 CBOR_TAG_B64 = 34, // base6 rfc46484, utf-8 93 CBOR_TAG_B64 = 34, // base6 rfc46484, utf-8
37 CBOR_TAG_REGEX = 35, // regex pcre/ecma262, utf-8 94 CBOR_TAG_REGEX = 35, // regex pcre/ecma262, utf-8
38 CBOR_TAG_MIME = 36, // mime message rfc2045, utf-8 95 CBOR_TAG_MIME = 36, // mime message rfc2045, utf-8
39 96
40 CBOR_TAG_MAGIC = 55799 // self-describe cbor 97 CBOR_TAG_MAGIC = 55799, // self-describe cbor
41}; 98};
42 99
43#define F_SHRINK 0x00000200UL 100#define F_SHRINK 0x00000001UL
44#define F_ALLOW_UNKNOWN 0x00002000UL 101#define F_ALLOW_UNKNOWN 0x00000002UL
102#define F_ALLOW_SHARING 0x00000004UL
103#define F_ALLOW_CYCLES 0x00000008UL
104#define F_PACK_STRINGS 0x00000010UL
105#define F_VALIDATE_UTF8 0x00000020UL
45 106
46#define INIT_SIZE 32 // initial scalar size to be allocated 107#define INIT_SIZE 32 // initial scalar size to be allocated
47 108
48#define SB do { 109#define SB do {
49#define SE } while (0) 110#define SE } while (0)
61# define CBOR_SLOW 0 122# define CBOR_SLOW 0
62# define CBOR_STASH cbor_stash 123# define CBOR_STASH cbor_stash
63#endif 124#endif
64 125
65static HV *cbor_stash, *types_boolean_stash, *types_error_stash, *cbor_tagged_stash; // CBOR::XS:: 126static HV *cbor_stash, *types_boolean_stash, *types_error_stash, *cbor_tagged_stash; // CBOR::XS::
66static SV *types_true, *types_false, *types_error; 127static SV *types_true, *types_false, *types_error, *sv_cbor, *default_filter;
67 128
68typedef struct { 129typedef struct {
69 U32 flags; 130 U32 flags;
70 U32 max_depth; 131 U32 max_depth;
71 STRLEN max_size; 132 STRLEN max_size;
133 SV *filter;
134
135 // for the incremental parser
136 STRLEN incr_pos; // the current offset into the text
137 STRLEN incr_need; // minimum bytes needed to decode
138 AV *incr_count; // for every nesting level, the number of outstanding values, or -1 for indef.
72} CBOR; 139} CBOR;
73 140
74ecb_inline void 141ecb_inline void
75cbor_init (CBOR *cbor) 142cbor_init (CBOR *cbor)
76{ 143{
77 Zero (cbor, 1, CBOR); 144 Zero (cbor, 1, CBOR);
78 cbor->max_depth = 512; 145 cbor->max_depth = 512;
146}
147
148ecb_inline void
149cbor_free (CBOR *cbor)
150{
151 SvREFCNT_dec (cbor->filter);
152 SvREFCNT_dec (cbor->incr_count);
79} 153}
80 154
81///////////////////////////////////////////////////////////////////////////// 155/////////////////////////////////////////////////////////////////////////////
82// utility functions 156// utility functions
83 157
105 SvPV_renew (sv, SvCUR (sv) + 1); 179 SvPV_renew (sv, SvCUR (sv) + 1);
106#endif 180#endif
107 } 181 }
108} 182}
109 183
110///////////////////////////////////////////////////////////////////////////// 184// minimum length of a string to be registered for stringref
111// fp hell 185ecb_inline int
112 186minimum_string_length (UV idx)
113//TODO 187{
188 return idx > 23
189 ? idx > 0xffU
190 ? idx > 0xffffU
191 ? idx > 0xffffffffU
192 ? 11
193 : 7
194 : 5
195 : 4
196 : 3;
197}
114 198
115///////////////////////////////////////////////////////////////////////////// 199/////////////////////////////////////////////////////////////////////////////
116// encoder 200// encoder
117 201
118// structure used for encoding CBOR 202// structure used for encoding CBOR
121 char *cur; // SvPVX (sv) + current output position 205 char *cur; // SvPVX (sv) + current output position
122 char *end; // SvEND (sv) 206 char *end; // SvEND (sv)
123 SV *sv; // result scalar 207 SV *sv; // result scalar
124 CBOR cbor; 208 CBOR cbor;
125 U32 depth; // recursion level 209 U32 depth; // recursion level
210 HV *stringref[2]; // string => index, or 0 ([0] = bytes, [1] = utf-8)
211 UV stringref_idx;
212 HV *shareable; // ptr => index, or 0
213 UV shareable_idx;
126} enc_t; 214} enc_t;
127 215
128ecb_inline void 216ecb_inline void
129need (enc_t *enc, STRLEN len) 217need (enc_t *enc, STRLEN len)
130{ 218{
147static void 235static void
148encode_uint (enc_t *enc, int major, UV len) 236encode_uint (enc_t *enc, int major, UV len)
149{ 237{
150 need (enc, 9); 238 need (enc, 9);
151 239
152 if (len < 24) 240 if (ecb_expect_true (len < LENGTH_EXT1))
153 *enc->cur++ = major | len; 241 *enc->cur++ = major | len;
154 else if (len <= 0xff) 242 else if (ecb_expect_true (len <= 0xffU))
155 { 243 {
156 *enc->cur++ = major | 24; 244 *enc->cur++ = major | LENGTH_EXT1;
157 *enc->cur++ = len; 245 *enc->cur++ = len;
158 } 246 }
159 else if (len <= 0xffff) 247 else if (len <= 0xffffU)
160 { 248 {
161 *enc->cur++ = major | 25; 249 *enc->cur++ = major | LENGTH_EXT2;
162 *enc->cur++ = len >> 8; 250 *enc->cur++ = len >> 8;
163 *enc->cur++ = len; 251 *enc->cur++ = len;
164 } 252 }
165 else if (len <= 0xffffffff) 253 else if (len <= 0xffffffffU)
166 { 254 {
167 *enc->cur++ = major | 26; 255 *enc->cur++ = major | LENGTH_EXT4;
168 *enc->cur++ = len >> 24; 256 *enc->cur++ = len >> 24;
169 *enc->cur++ = len >> 16; 257 *enc->cur++ = len >> 16;
170 *enc->cur++ = len >> 8; 258 *enc->cur++ = len >> 8;
171 *enc->cur++ = len; 259 *enc->cur++ = len;
172 } 260 }
173 else 261 else
174 { 262 {
175 *enc->cur++ = major | 27; 263 *enc->cur++ = major | LENGTH_EXT8;
176 *enc->cur++ = len >> 56; 264 *enc->cur++ = len >> 56;
177 *enc->cur++ = len >> 48; 265 *enc->cur++ = len >> 48;
178 *enc->cur++ = len >> 40; 266 *enc->cur++ = len >> 40;
179 *enc->cur++ = len >> 32; 267 *enc->cur++ = len >> 32;
180 *enc->cur++ = len >> 24; 268 *enc->cur++ = len >> 24;
182 *enc->cur++ = len >> 8; 270 *enc->cur++ = len >> 8;
183 *enc->cur++ = len; 271 *enc->cur++ = len;
184 } 272 }
185} 273}
186 274
187static void 275ecb_inline void
276encode_tag (enc_t *enc, UV tag)
277{
278 encode_uint (enc, MAJOR_TAG, tag);
279}
280
281ecb_inline void
188encode_str (enc_t *enc, int utf8, char *str, STRLEN len) 282encode_str (enc_t *enc, int utf8, char *str, STRLEN len)
189{ 283{
190 encode_uint (enc, utf8 ? 0x60 : 0x40, len); 284 encode_uint (enc, utf8 ? MAJOR_TEXT : MAJOR_BYTES, len);
191 need (enc, len); 285 need (enc, len);
192 memcpy (enc->cur, str, len); 286 memcpy (enc->cur, str, len);
193 enc->cur += len; 287 enc->cur += len;
194} 288}
195 289
290static void
291encode_strref (enc_t *enc, int utf8, char *str, STRLEN len)
292{
293 if (ecb_expect_false (enc->cbor.flags & F_PACK_STRINGS))
294 {
295 SV **svp = hv_fetch (enc->stringref[!!utf8], str, len, 1);
296
297 if (SvOK (*svp))
298 {
299 // already registered, use stringref
300 encode_tag (enc, CBOR_TAG_STRINGREF);
301 encode_uint (enc, MAJOR_POS_INT, SvUV (*svp));
302 return;
303 }
304 else if (len >= minimum_string_length (enc->stringref_idx))
305 {
306 // register only
307 sv_setuv (*svp, enc->stringref_idx);
308 ++enc->stringref_idx;
309 }
310 }
311
312 encode_str (enc, utf8, str, len);
313}
314
196static void encode_sv (enc_t *enc, SV *sv); 315static void encode_sv (enc_t *enc, SV *sv);
197 316
198static void 317static void
199encode_av (enc_t *enc, AV *av) 318encode_av (enc_t *enc, AV *av)
200{ 319{
203 if (enc->depth >= enc->cbor.max_depth) 322 if (enc->depth >= enc->cbor.max_depth)
204 croak (ERR_NESTING_EXCEEDED); 323 croak (ERR_NESTING_EXCEEDED);
205 324
206 ++enc->depth; 325 ++enc->depth;
207 326
208 encode_uint (enc, 0x80, len + 1); 327 encode_uint (enc, MAJOR_ARRAY, len + 1);
209 328
329 if (SvMAGICAL (av))
210 for (i = 0; i <= len; ++i) 330 for (i = 0; i <= len; ++i)
211 { 331 {
212 SV **svp = av_fetch (av, i, 0); 332 SV **svp = av_fetch (av, i, 0);
213 encode_sv (enc, svp ? *svp : &PL_sv_undef); 333 encode_sv (enc, svp ? *svp : &PL_sv_undef);
214 } 334 }
335 else
336 for (i = 0; i <= len; ++i)
337 {
338 SV *sv = AvARRAY (av)[i];
339 encode_sv (enc, sv ? sv : &PL_sv_undef);
340 }
215 341
216 --enc->depth; 342 --enc->depth;
217} 343}
218 344
219static void 345static void
228 354
229 int pairs = hv_iterinit (hv); 355 int pairs = hv_iterinit (hv);
230 int mg = SvMAGICAL (hv); 356 int mg = SvMAGICAL (hv);
231 357
232 if (mg) 358 if (mg)
233 encode_ch (enc, 0xa0 | 31); 359 encode_ch (enc, MAJOR_MAP | MINOR_INDEF);
234 else 360 else
235 encode_uint (enc, 0xa0, pairs); 361 encode_uint (enc, MAJOR_MAP, pairs);
236 362
237 while ((he = hv_iternext (hv))) 363 while ((he = hv_iternext (hv)))
238 { 364 {
239 if (HeKLEN (he) == HEf_SVKEY) 365 if (HeKLEN (he) == HEf_SVKEY)
240 encode_sv (enc, HeSVKEY (he)); 366 encode_sv (enc, HeSVKEY (he));
241 else 367 else
242 encode_str (enc, HeKUTF8 (he), HeKEY (he), HeKLEN (he)); 368 encode_strref (enc, HeKUTF8 (he), HeKEY (he), HeKLEN (he));
243 369
244 encode_sv (enc, ecb_expect_false (mg) ? hv_iterval (hv, he) : HeVAL (he)); 370 encode_sv (enc, ecb_expect_false (mg) ? hv_iterval (hv, he) : HeVAL (he));
245 } 371 }
246 372
247 if (mg) 373 if (mg)
248 encode_ch (enc, 0xe0 | 31); 374 encode_ch (enc, MAJOR_MISC | MINOR_INDEF);
249 375
250 --enc->depth; 376 --enc->depth;
251} 377}
252 378
253// encode objects, arrays and special \0=false and \1=true values. 379// encode objects, arrays and special \0=false and \1=true values.
254static void 380static void
255encode_rv (enc_t *enc, SV *sv) 381encode_rv (enc_t *enc, SV *sv)
256{ 382{
257 svtype svt;
258
259 SvGETMAGIC (sv); 383 SvGETMAGIC (sv);
384
260 svt = SvTYPE (sv); 385 svtype svt = SvTYPE (sv);
261 386
262 if (ecb_expect_false (SvOBJECT (sv))) 387 if (ecb_expect_false (SvOBJECT (sv)))
263 { 388 {
264 HV *boolean_stash = !CBOR_SLOW || types_boolean_stash 389 HV *boolean_stash = !CBOR_SLOW || types_boolean_stash
265 ? types_boolean_stash 390 ? types_boolean_stash
269 : gv_stashpv ("Types::Serialiser::Error", 1); 394 : gv_stashpv ("Types::Serialiser::Error", 1);
270 HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash 395 HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash
271 ? cbor_tagged_stash 396 ? cbor_tagged_stash
272 : gv_stashpv ("CBOR::XS::Tagged" , 1); 397 : gv_stashpv ("CBOR::XS::Tagged" , 1);
273 398
399 HV *stash = SvSTASH (sv);
400
274 if (SvSTASH (sv) == boolean_stash) 401 if (stash == boolean_stash)
275 encode_ch (enc, SvIV (sv) ? 0xe0 | 21 : 0xe0 | 20); 402 {
403 encode_ch (enc, SvIV (sv) ? MAJOR_MISC | SIMPLE_TRUE : MAJOR_MISC | SIMPLE_FALSE);
404 return;
405 }
276 else if (SvSTASH (sv) == error_stash) 406 else if (stash == error_stash)
277 encode_ch (enc, 0xe0 | 23); 407 {
408 encode_ch (enc, MAJOR_MISC | SIMPLE_UNDEF);
409 return;
410 }
278 else if (SvSTASH (sv) == tagged_stash) 411 else if (stash == tagged_stash)
279 { 412 {
280 if (svt != SVt_PVAV) 413 if (svt != SVt_PVAV)
281 croak ("encountered CBOR::XS::Tagged object that isn't an array"); 414 croak ("encountered CBOR::XS::Tagged object that isn't an array");
282 415
283 encode_uint (enc, 0xc0, SvUV (*av_fetch ((AV *)sv, 0, 1))); 416 encode_uint (enc, MAJOR_TAG, SvUV (*av_fetch ((AV *)sv, 0, 1)));
284 encode_sv (enc, *av_fetch ((AV *)sv, 1, 1)); 417 encode_sv (enc, *av_fetch ((AV *)sv, 1, 1));
418
419 return;
420 }
421 }
422
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, MAJOR_POS_INT, SvUV (*svp));
435 return;
285 } 436 }
286 else 437 else
287 { 438 {
439 sv_setuv (*svp, enc->shareable_idx);
440 ++enc->shareable_idx;
441 encode_tag (enc, CBOR_TAG_VALUE_SHAREABLE);
442 }
443 }
444
445 if (ecb_expect_false (SvOBJECT (sv)))
446 {
447 HV *stash = SvSTASH (sv);
448 GV *method;
449
450 if ((method = gv_fetchmethod_autoload (stash, "TO_CBOR", 0)))
451 {
452 dSP;
453
454 ENTER; SAVETMPS;
455 PUSHMARK (SP);
288 // we re-bless the reference to get overload and other niceties right 456 // we re-bless the reference to get overload and other niceties right
289 GV *to_cbor = gv_fetchmethod_autoload (SvSTASH (sv), "TO_CBOR", 0);
290
291 if (to_cbor)
292 {
293 dSP;
294
295 ENTER; SAVETMPS; PUSHMARK (SP);
296 XPUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), SvSTASH (sv))); 457 XPUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash));
297 458
298 // calling with G_SCALAR ensures that we always get a 1 return value
299 PUTBACK; 459 PUTBACK;
460 // G_SCALAR ensures that return value is 1
300 call_sv ((SV *)GvCV (to_cbor), G_SCALAR); 461 call_sv ((SV *)GvCV (method), G_SCALAR);
301 SPAGAIN; 462 SPAGAIN;
302 463
303 // catch this surprisingly common error 464 // catch this surprisingly common error
304 if (SvROK (TOPs) && SvRV (TOPs) == sv) 465 if (SvROK (TOPs) && SvRV (TOPs) == sv)
305 croak ("%s::TO_CBOR method returned same object as was passed instead of a new one", HvNAME (SvSTASH (sv))); 466 croak ("%s::TO_CBOR method returned same object as was passed instead of a new one", HvNAME (stash));
306 467
307 sv = POPs; 468 encode_sv (enc, POPs);
469
308 PUTBACK; 470 PUTBACK;
309 471
310 encode_sv (enc, sv);
311
312 FREETMPS; LEAVE; 472 FREETMPS; LEAVE;
313 } 473 }
474 else if ((method = gv_fetchmethod_autoload (stash, "FREEZE", 0)) != 0)
475 {
476 dSP;
477
478 ENTER; SAVETMPS;
479 SAVESTACK_POS ();
480 PUSHMARK (SP);
481 EXTEND (SP, 2);
482 // we re-bless the reference to get overload and other niceties right
483 PUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash));
484 PUSHs (sv_cbor);
485
486 PUTBACK;
487 int count = call_sv ((SV *)GvCV (method), G_ARRAY);
488 SPAGAIN;
489
490 // catch this surprisingly common error
491 if (count == 1 && SvROK (TOPs) && SvRV (TOPs) == sv)
492 croak ("%s::FREEZE(CBOR) method returned same object as was passed instead of a new one", HvNAME (stash));
493
494 encode_tag (enc, CBOR_TAG_PERL_OBJECT);
495 encode_uint (enc, MAJOR_ARRAY, count + 1);
496 encode_strref (enc, HvNAMEUTF8 (stash), HvNAME (stash), HvNAMELEN (stash));
497
498 while (count)
499 encode_sv (enc, SP[1 - count--]);
500
501 PUTBACK;
502
503 FREETMPS; LEAVE;
504 }
314 else 505 else
315 croak ("encountered object '%s', but no TO_CBOR method available on it", 506 croak ("encountered object '%s', but no TO_CBOR or FREEZE methods available on it",
316 SvPV_nolen (sv_2mortal (newRV_inc (sv)))); 507 SvPV_nolen (sv_2mortal (newRV_inc (sv))));
317 }
318 } 508 }
319 else if (svt == SVt_PVHV) 509 else if (svt == SVt_PVHV)
320 encode_hv (enc, (HV *)sv); 510 encode_hv (enc, (HV *)sv);
321 else if (svt == SVt_PVAV) 511 else if (svt == SVt_PVAV)
322 encode_av (enc, (AV *)sv); 512 encode_av (enc, (AV *)sv);
323 else if (svt < SVt_PVAV)
324 {
325 STRLEN len = 0;
326 char *pv = svt ? SvPV (sv, len) : 0;
327
328 if (len == 1 && *pv == '1')
329 encode_ch (enc, 0xe0 | 21);
330 else if (len == 1 && *pv == '0')
331 encode_ch (enc, 0xe0 | 20);
332 else if (enc->cbor.flags & F_ALLOW_UNKNOWN)
333 encode_ch (enc, 0xe0 | 23);
334 else
335 croak ("cannot encode reference to scalar '%s' unless the scalar is 0 or 1",
336 SvPV_nolen (sv_2mortal (newRV_inc (sv))));
337 }
338 else if (enc->cbor.flags & F_ALLOW_UNKNOWN)
339 encode_ch (enc, 0xe0 | 23);
340 else 513 else
341 croak ("encountered %s, but CBOR can only represent references to arrays or hashes", 514 {
342 SvPV_nolen (sv_2mortal (newRV_inc (sv)))); 515 encode_tag (enc, CBOR_TAG_INDIRECTION);
516 encode_sv (enc, sv);
517 }
343} 518}
344 519
345static void 520static void
346encode_nv (enc_t *enc, SV *sv) 521encode_nv (enc_t *enc, SV *sv)
347{ 522{
348 double nv = SvNVX (sv); 523 double nv = SvNVX (sv);
349 524
350 need (enc, 9); 525 need (enc, 9);
351 526
352 if (ecb_expect_false (nv == (U32)nv)) 527 if (ecb_expect_false (nv == (NV)(U32)nv))
353 encode_uint (enc, 0x00, (U32)nv); 528 encode_uint (enc, MAJOR_POS_INT, (U32)nv);
354 //TODO: maybe I32? 529 //TODO: maybe I32?
355 else if (ecb_expect_false (nv == (float)nv)) 530 else if (ecb_expect_false (nv == (float)nv))
356 { 531 {
357 uint32_t fp = ecb_float_to_binary32 (nv); 532 uint32_t fp = ecb_float_to_binary32 (nv);
358 533
359 *enc->cur++ = 0xe0 | 26; 534 *enc->cur++ = MAJOR_MISC | MISC_FLOAT32;
360 535
361 if (!ecb_big_endian ()) 536 if (!ecb_big_endian ())
362 fp = ecb_bswap32 (fp); 537 fp = ecb_bswap32 (fp);
363 538
364 memcpy (enc->cur, &fp, 4); 539 memcpy (enc->cur, &fp, 4);
366 } 541 }
367 else 542 else
368 { 543 {
369 uint64_t fp = ecb_double_to_binary64 (nv); 544 uint64_t fp = ecb_double_to_binary64 (nv);
370 545
371 *enc->cur++ = 0xe0 | 27; 546 *enc->cur++ = MAJOR_MISC | MISC_FLOAT64;
372 547
373 if (!ecb_big_endian ()) 548 if (!ecb_big_endian ())
374 fp = ecb_bswap64 (fp); 549 fp = ecb_bswap64 (fp);
375 550
376 memcpy (enc->cur, &fp, 8); 551 memcpy (enc->cur, &fp, 8);
385 560
386 if (SvPOKp (sv)) 561 if (SvPOKp (sv))
387 { 562 {
388 STRLEN len; 563 STRLEN len;
389 char *str = SvPV (sv, len); 564 char *str = SvPV (sv, len);
390 encode_str (enc, SvUTF8 (sv), str, len); 565 encode_strref (enc, SvUTF8 (sv), str, len);
391 } 566 }
392 else if (SvNOKp (sv)) 567 else if (SvNOKp (sv))
393 encode_nv (enc, sv); 568 encode_nv (enc, sv);
394 else if (SvIOKp (sv)) 569 else if (SvIOKp (sv))
395 { 570 {
396 if (SvIsUV (sv)) 571 if (SvIsUV (sv))
397 encode_uint (enc, 0x00, SvUVX (sv)); 572 encode_uint (enc, MAJOR_POS_INT, SvUVX (sv));
398 else if (SvIVX (sv) >= 0) 573 else if (SvIVX (sv) >= 0)
399 encode_uint (enc, 0x00, SvIVX (sv)); 574 encode_uint (enc, MAJOR_POS_INT, SvIVX (sv));
400 else 575 else
401 encode_uint (enc, 0x20, -(SvIVX (sv) + 1)); 576 encode_uint (enc, MAJOR_NEG_INT, -(SvIVX (sv) + 1));
402 } 577 }
403 else if (SvROK (sv)) 578 else if (SvROK (sv))
404 encode_rv (enc, SvRV (sv)); 579 encode_rv (enc, SvRV (sv));
405 else if (!SvOK (sv)) 580 else if (!SvOK (sv))
406 encode_ch (enc, 0xe0 | 22); 581 encode_ch (enc, MAJOR_MISC | SIMPLE_NULL);
407 else if (enc->cbor.flags & F_ALLOW_UNKNOWN) 582 else if (enc->cbor.flags & F_ALLOW_UNKNOWN)
408 encode_ch (enc, 0xe0 | 23); 583 encode_ch (enc, MAJOR_MISC | SIMPLE_UNDEF);
409 else 584 else
410 croak ("encountered perl type (%s,0x%x) that CBOR cannot handle, check your input data", 585 croak ("encountered perl type (%s,0x%x) that CBOR cannot handle, check your input data",
411 SvPV_nolen (sv), (unsigned int)SvFLAGS (sv)); 586 SvPV_nolen (sv), (unsigned int)SvFLAGS (sv));
412} 587}
413 588
414static SV * 589static SV *
415encode_cbor (SV *scalar, CBOR *cbor) 590encode_cbor (SV *scalar, CBOR *cbor)
416{ 591{
417 enc_t enc; 592 enc_t enc = { 0 };
418 593
419 enc.cbor = *cbor; 594 enc.cbor = *cbor;
420 enc.sv = sv_2mortal (NEWSV (0, INIT_SIZE)); 595 enc.sv = sv_2mortal (NEWSV (0, INIT_SIZE));
421 enc.cur = SvPVX (enc.sv); 596 enc.cur = SvPVX (enc.sv);
422 enc.end = SvEND (enc.sv); 597 enc.end = SvEND (enc.sv);
423 enc.depth = 0;
424 598
425 SvPOK_only (enc.sv); 599 SvPOK_only (enc.sv);
600
601 if (cbor->flags & F_PACK_STRINGS)
602 {
603 encode_tag (&enc, CBOR_TAG_STRINGREF_NAMESPACE);
604 enc.stringref[0]= (HV *)sv_2mortal ((SV *)newHV ());
605 enc.stringref[1]= (HV *)sv_2mortal ((SV *)newHV ());
606 }
607
426 encode_sv (&enc, scalar); 608 encode_sv (&enc, scalar);
427 609
428 SvCUR_set (enc.sv, enc.cur - SvPVX (enc.sv)); 610 SvCUR_set (enc.sv, enc.cur - SvPVX (enc.sv));
429 *SvEND (enc.sv) = 0; // many xs functions expect a trailing 0 for text strings 611 *SvEND (enc.sv) = 0; // many xs functions expect a trailing 0 for text strings
430 612
444 U8 *end; // end of input string 626 U8 *end; // end of input string
445 const char *err; // parse error, if != 0 627 const char *err; // parse error, if != 0
446 CBOR cbor; 628 CBOR cbor;
447 U32 depth; // recursion depth 629 U32 depth; // recursion depth
448 U32 maxdepth; // recursion depth limit 630 U32 maxdepth; // recursion depth limit
631 AV *shareable;
632 AV *stringref;
633 SV *decode_tagged;
449} dec_t; 634} dec_t;
450 635
451#define ERR(reason) SB if (!dec->err) dec->err = reason; goto fail; SE 636#define ERR(reason) SB if (!dec->err) dec->err = reason; goto fail; SE
452 637
453#define WANT(len) if (ecb_expect_false (dec->cur + len > dec->end)) ERR ("unexpected end of CBOR data") 638#define WANT(len) if (ecb_expect_false (dec->cur + len > dec->end)) ERR ("unexpected end of CBOR data")
456#define DEC_DEC_DEPTH --dec->depth 641#define DEC_DEC_DEPTH --dec->depth
457 642
458static UV 643static UV
459decode_uint (dec_t *dec) 644decode_uint (dec_t *dec)
460{ 645{
461 switch (*dec->cur & 31) 646 U8 m = *dec->cur & MINOR_MASK;
462 { 647 ++dec->cur;
463 case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
464 case 8: case 9: case 10: case 11: case 12: case 13: case 14: case 15:
465 case 16: case 17: case 18: case 19: case 20: case 21: case 22: case 23:
466 return *dec->cur++ & 31;
467 648
468 case 24: 649 if (ecb_expect_true (m < LENGTH_EXT1))
650 return m;
651 else if (ecb_expect_true (m == LENGTH_EXT1))
652 {
469 WANT (2); 653 WANT (1);
470 dec->cur += 2; 654 dec->cur += 1;
471 return dec->cur[-1]; 655 return dec->cur[-1];
472 656 }
473 case 25: 657 else if (ecb_expect_true (m == LENGTH_EXT2))
658 {
474 WANT (3); 659 WANT (2);
475 dec->cur += 3; 660 dec->cur += 2;
476 return (((UV)dec->cur[-2]) << 8) 661 return (((UV)dec->cur[-2]) << 8)
477 | ((UV)dec->cur[-1]); 662 | ((UV)dec->cur[-1]);
478 663 }
479 case 26: 664 else if (ecb_expect_true (m == LENGTH_EXT4))
665 {
480 WANT (5); 666 WANT (4);
481 dec->cur += 5; 667 dec->cur += 4;
482 return (((UV)dec->cur[-4]) << 24) 668 return (((UV)dec->cur[-4]) << 24)
483 | (((UV)dec->cur[-3]) << 16) 669 | (((UV)dec->cur[-3]) << 16)
484 | (((UV)dec->cur[-2]) << 8) 670 | (((UV)dec->cur[-2]) << 8)
485 | ((UV)dec->cur[-1]); 671 | ((UV)dec->cur[-1]);
486 672 }
487 case 27: 673 else if (ecb_expect_true (m == LENGTH_EXT8))
674 {
488 WANT (9); 675 WANT (8);
489 dec->cur += 9; 676 dec->cur += 8;
677
678 return
679#if UVSIZE < 8
680 0
681#else
490 return (((UV)dec->cur[-8]) << 56) 682 (((UV)dec->cur[-8]) << 56)
491 | (((UV)dec->cur[-7]) << 48) 683 | (((UV)dec->cur[-7]) << 48)
492 | (((UV)dec->cur[-6]) << 40) 684 | (((UV)dec->cur[-6]) << 40)
493 | (((UV)dec->cur[-5]) << 32) 685 | (((UV)dec->cur[-5]) << 32)
686#endif
494 | (((UV)dec->cur[-4]) << 24) 687 | (((UV)dec->cur[-4]) << 24)
495 | (((UV)dec->cur[-3]) << 16) 688 | (((UV)dec->cur[-3]) << 16)
496 | (((UV)dec->cur[-2]) << 8) 689 | (((UV)dec->cur[-2]) << 8)
497 | ((UV)dec->cur[-1]); 690 | ((UV)dec->cur[-1]);
498 691 }
499 default: 692 else
500 ERR ("corrupted CBOR data (unsupported integer minor encoding)"); 693 ERR ("corrupted CBOR data (unsupported integer minor encoding)");
501 }
502 694
503fail: 695fail:
504 return 0; 696 return 0;
505} 697}
506 698
511{ 703{
512 AV *av = newAV (); 704 AV *av = newAV ();
513 705
514 DEC_INC_DEPTH; 706 DEC_INC_DEPTH;
515 707
516 if ((*dec->cur & 31) == 31) 708 if (*dec->cur == (MAJOR_ARRAY | MINOR_INDEF))
517 { 709 {
518 ++dec->cur; 710 ++dec->cur;
519 711
520 for (;;) 712 for (;;)
521 { 713 {
522 WANT (1); 714 WANT (1);
523 715
524 if (*dec->cur == (0xe0 | 31)) 716 if (*dec->cur == (MAJOR_MISC | MINOR_INDEF))
525 { 717 {
526 ++dec->cur; 718 ++dec->cur;
527 break; 719 break;
528 } 720 }
529 721
532 } 724 }
533 else 725 else
534 { 726 {
535 int i, len = decode_uint (dec); 727 int i, len = decode_uint (dec);
536 728
729 WANT (len); // complexity check for av_fill - need at least one byte per value, do not allow supersize arrays
537 av_fill (av, len - 1); 730 av_fill (av, len - 1);
538 731
539 for (i = 0; i < len; ++i) 732 for (i = 0; i < len; ++i)
540 AvARRAY (av)[i] = decode_sv (dec); 733 AvARRAY (av)[i] = decode_sv (dec);
541 } 734 }
547 SvREFCNT_dec (av); 740 SvREFCNT_dec (av);
548 DEC_DEC_DEPTH; 741 DEC_DEC_DEPTH;
549 return &PL_sv_undef; 742 return &PL_sv_undef;
550} 743}
551 744
745static void
746decode_he (dec_t *dec, HV *hv)
747{
748 // for speed reasons, we specialcase single-string
749 // byte or utf-8 strings as keys, but only when !stringref
750
751 if (ecb_expect_true (!dec->stringref))
752 if (ecb_expect_true ((U8)(*dec->cur - MAJOR_BYTES) <= LENGTH_EXT8))
753 {
754 I32 len = decode_uint (dec);
755 char *key = (char *)dec->cur;
756
757 WANT (len);
758 dec->cur += len;
759
760 hv_store (hv, key, len, decode_sv (dec), 0);
761
762 return;
763 }
764 else if (ecb_expect_true ((U8)(*dec->cur - MAJOR_TEXT) <= LENGTH_EXT8))
765 {
766 I32 len = decode_uint (dec);
767 char *key = (char *)dec->cur;
768
769 WANT (len);
770 dec->cur += len;
771
772 if (ecb_expect_false (dec->cbor.flags & F_VALIDATE_UTF8))
773 if (!is_utf8_string (key, len))
774 ERR ("corrupted CBOR data (invalid UTF-8 in map key)");
775
776 hv_store (hv, key, -len, decode_sv (dec), 0);
777
778 return;
779 }
780
781 SV *k = decode_sv (dec);
782 SV *v = decode_sv (dec);
783
784 hv_store_ent (hv, k, v, 0);
785 SvREFCNT_dec (k);
786
787fail:
788 ;
789}
790
552static SV * 791static SV *
553decode_hv (dec_t *dec) 792decode_hv (dec_t *dec)
554{ 793{
555 HV *hv = newHV (); 794 HV *hv = newHV ();
556 795
557 DEC_INC_DEPTH; 796 DEC_INC_DEPTH;
558 797
559 if ((*dec->cur & 31) == 31) 798 if (*dec->cur == (MAJOR_MAP | MINOR_INDEF))
560 { 799 {
561 ++dec->cur; 800 ++dec->cur;
562 801
563 for (;;) 802 for (;;)
564 { 803 {
565 WANT (1); 804 WANT (1);
566 805
567 if (*dec->cur == (0xe0 | 31)) 806 if (*dec->cur == (MAJOR_MISC | MINOR_INDEF))
568 { 807 {
569 ++dec->cur; 808 ++dec->cur;
570 break; 809 break;
571 } 810 }
572 811
573 SV *k = decode_sv (dec); 812 decode_he (dec, hv);
574 SV *v = decode_sv (dec);
575
576 hv_store_ent (hv, k, v, 0);
577 } 813 }
578 } 814 }
579 else 815 else
580 { 816 {
581 int len = decode_uint (dec); 817 int pairs = decode_uint (dec);
582 818
583 while (len--) 819 while (pairs--)
584 { 820 decode_he (dec, hv);
585 SV *k = decode_sv (dec);
586 SV *v = decode_sv (dec);
587
588 hv_store_ent (hv, k, v, 0);
589 }
590 } 821 }
591 822
592 DEC_DEC_DEPTH; 823 DEC_DEC_DEPTH;
593 return newRV_noinc ((SV *)hv); 824 return newRV_noinc ((SV *)hv);
594 825
601static SV * 832static SV *
602decode_str (dec_t *dec, int utf8) 833decode_str (dec_t *dec, int utf8)
603{ 834{
604 SV *sv = 0; 835 SV *sv = 0;
605 836
606 if ((*dec->cur & 31) == 31) 837 if ((*dec->cur & MINOR_MASK) == MINOR_INDEF)
607 { 838 {
839 // indefinite length strings
608 ++dec->cur; 840 ++dec->cur;
609 841
842 U8 major = *dec->cur & MAJOR_MISC;
843
610 sv = newSVpvn ("", 0); 844 sv = newSVpvn ("", 0);
611 845
612 // not very fast, and certainly not robust against illegal input
613 for (;;) 846 for (;;)
614 { 847 {
615 WANT (1); 848 WANT (1);
616 849
617 if (*dec->cur == (0xe0 | 31)) 850 if ((*dec->cur - major) > LENGTH_EXT8)
851 if (*dec->cur == (MAJOR_MISC | MINOR_INDEF))
618 { 852 {
619 ++dec->cur; 853 ++dec->cur;
620 break; 854 break;
621 } 855 }
856 else
857 ERR ("corrupted CBOR data (invalid chunks in indefinite length string)");
622 858
623 sv_catsv (sv, decode_sv (dec)); 859 STRLEN len = decode_uint (dec);
860
861 WANT (len);
862 sv_catpvn (sv, dec->cur, len);
863 dec->cur += len;
624 } 864 }
625 } 865 }
626 else 866 else
627 { 867 {
628 STRLEN len = decode_uint (dec); 868 STRLEN len = decode_uint (dec);
629 869
630 WANT (len); 870 WANT (len);
631 sv = newSVpvn (dec->cur, len); 871 sv = newSVpvn (dec->cur, len);
632 dec->cur += len; 872 dec->cur += len;
873
874 if (ecb_expect_false (dec->stringref)
875 && SvCUR (sv) >= minimum_string_length (AvFILLp (dec->stringref) + 1))
876 av_push (dec->stringref, SvREFCNT_inc_NN (sv));
633 } 877 }
634 878
635 if (utf8) 879 if (utf8)
880 {
881 if (ecb_expect_false (dec->cbor.flags & F_VALIDATE_UTF8))
882 if (!is_utf8_string (SvPVX (sv), SvCUR (sv)))
883 ERR ("corrupted CBOR data (invalid UTF-8 in text string)");
884
636 SvUTF8_on (sv); 885 SvUTF8_on (sv);
886 }
637 887
638 return sv; 888 return sv;
639 889
640fail: 890fail:
641 SvREFCNT_dec (sv); 891 SvREFCNT_dec (sv);
643} 893}
644 894
645static SV * 895static SV *
646decode_tagged (dec_t *dec) 896decode_tagged (dec_t *dec)
647{ 897{
898 SV *sv = 0;
648 UV tag = decode_uint (dec); 899 UV tag = decode_uint (dec);
900
901 WANT (1);
902
903 switch (tag)
904 {
905 case CBOR_TAG_MAGIC:
649 SV *sv = decode_sv (dec); 906 sv = decode_sv (dec);
907 break;
650 908
651 if (tag == CBOR_TAG_MAGIC) 909 case CBOR_TAG_INDIRECTION:
652 return sv; 910 sv = newRV_noinc (decode_sv (dec));
911 break;
653 912
654 if (tag == CBOR_TAG_PERL_OBJECT) 913 case CBOR_TAG_STRINGREF_NAMESPACE:
655 { 914 {
915 ENTER; SAVETMPS;
916
917 SAVESPTR (dec->stringref);
918 dec->stringref = (AV *)sv_2mortal ((SV *)newAV ());
919
920 sv = decode_sv (dec);
921
922 FREETMPS; LEAVE;
923 }
924 break;
925
926 case CBOR_TAG_STRINGREF:
927 {
928 if ((*dec->cur >> MAJOR_SHIFT) != (MAJOR_POS_INT >> MAJOR_SHIFT))
929 ERR ("corrupted CBOR data (stringref index not an unsigned integer)");
930
931 UV idx = decode_uint (dec);
932
933 if (!dec->stringref || (int)idx > AvFILLp (dec->stringref))
934 ERR ("corrupted CBOR data (stringref index out of bounds or outside namespace)");
935
936 sv = newSVsv (AvARRAY (dec->stringref)[idx]);
937 }
938 break;
939
940 case CBOR_TAG_VALUE_SHAREABLE:
941 {
942 if (ecb_expect_false (!dec->shareable))
943 dec->shareable = (AV *)sv_2mortal ((SV *)newAV ());
944
945 if (dec->cbor.flags & F_ALLOW_CYCLES)
946 {
947 sv = newSV (0);
948 av_push (dec->shareable, SvREFCNT_inc_NN (sv));
949
950 SV *osv = decode_sv (dec);
951 sv_setsv (sv, osv);
952 SvREFCNT_dec_NN (osv);
953 }
954 else
955 {
956 av_push (dec->shareable, &PL_sv_undef);
957 int idx = AvFILLp (dec->shareable);
958 sv = decode_sv (dec);
959 av_store (dec->shareable, idx, SvREFCNT_inc_NN (sv));
960 }
961 }
962 break;
963
964 case CBOR_TAG_VALUE_SHAREDREF:
965 {
966 if ((*dec->cur >> MAJOR_SHIFT) != (MAJOR_POS_INT >> MAJOR_SHIFT))
967 ERR ("corrupted CBOR data (sharedref index not an unsigned integer)");
968
969 UV idx = decode_uint (dec);
970
971 if (!dec->shareable || (int)idx > AvFILLp (dec->shareable))
972 ERR ("corrupted CBOR data (sharedref index out of bounds)");
973
974 sv = SvREFCNT_inc_NN (AvARRAY (dec->shareable)[idx]);
975
976 if (sv == &PL_sv_undef)
977 ERR ("cyclic CBOR data structure found, but allow_cycles is not enabled");
978 }
979 break;
980
981 case CBOR_TAG_PERL_OBJECT:
982 {
983 sv = decode_sv (dec);
984
656 if (!SvROK (sv) || SvTYPE (SvRV (sv)) != SVt_PVAV) 985 if (!SvROK (sv) || SvTYPE (SvRV (sv)) != SVt_PVAV)
657 ERR ("corrupted CBOR data (non-array perl object)"); 986 ERR ("corrupted CBOR data (non-array perl object)");
987
988 AV *av = (AV *)SvRV (sv);
989 int len = av_len (av) + 1;
990 HV *stash = gv_stashsv (*av_fetch (av, 0, 1), 0);
991
992 if (!stash)
993 ERR ("cannot decode perl-object (package does not exist)");
994
995 GV *method = gv_fetchmethod_autoload (stash, "THAW", 0);
996
997 if (!method)
998 ERR ("cannot decode perl-object (package does not have a THAW method)");
999
1000 dSP;
1001
1002 ENTER; SAVETMPS;
1003 PUSHMARK (SP);
1004 EXTEND (SP, len + 1);
1005 // we re-bless the reference to get overload and other niceties right
1006 PUSHs (*av_fetch (av, 0, 1));
1007 PUSHs (sv_cbor);
1008
1009 int i;
1010
1011 for (i = 1; i < len; ++i)
1012 PUSHs (*av_fetch (av, i, 1));
1013
1014 PUTBACK;
1015 call_sv ((SV *)GvCV (method), G_SCALAR | G_EVAL);
1016 SPAGAIN;
1017
1018 if (SvTRUE (ERRSV))
1019 {
1020 FREETMPS; LEAVE;
1021 ERR (SvPVutf8_nolen (sv_2mortal (SvREFCNT_inc (ERRSV))));
1022 }
1023
1024 SvREFCNT_dec (sv);
1025 sv = SvREFCNT_inc (POPs);
1026
1027 PUTBACK;
1028
1029 FREETMPS; LEAVE;
658 1030 }
659 // TODO 1031 break;
660 }
661 1032
1033 default:
1034 {
1035 sv = decode_sv (dec);
1036
1037 dSP;
1038 ENTER; SAVETMPS;
1039 SAVESTACK_POS ();
1040 PUSHMARK (SP);
1041 EXTEND (SP, 2);
1042 PUSHs (newSVuv (tag));
1043 PUSHs (sv);
1044
1045 PUTBACK;
1046 int count = call_sv (dec->cbor.filter ? dec->cbor.filter : default_filter, G_ARRAY | G_EVAL);
1047 SPAGAIN;
1048
1049 if (SvTRUE (ERRSV))
1050 {
1051 FREETMPS; LEAVE;
1052 ERR (SvPVutf8_nolen (sv_2mortal (SvREFCNT_inc (ERRSV))));
1053 }
1054
1055 if (count)
1056 {
1057 SvREFCNT_dec (sv);
1058 sv = SvREFCNT_inc (POPs);
1059 }
1060 else
1061 {
662 AV *av = newAV (); 1062 AV *av = newAV ();
663 av_push (av, newSVuv (tag)); 1063 av_push (av, newSVuv (tag));
664 av_push (av, sv); 1064 av_push (av, sv);
665 1065
666 HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash 1066 HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash
667 ? cbor_tagged_stash 1067 ? cbor_tagged_stash
668 : gv_stashpv ("CBOR::XS::Tagged" , 1); 1068 : gv_stashpv ("CBOR::XS::Tagged" , 1);
669
670 return sv_bless (newRV_noinc ((SV *)av), tagged_stash); 1069 sv = sv_bless (newRV_noinc ((SV *)av), tagged_stash);
1070 }
1071
1072 PUTBACK;
1073
1074 FREETMPS; LEAVE;
1075 }
1076 break;
1077 }
1078
1079 return sv;
671 1080
672fail: 1081fail:
673 SvREFCNT_dec (sv); 1082 SvREFCNT_dec (sv);
674 return &PL_sv_undef; 1083 return &PL_sv_undef;
675} 1084}
677static SV * 1086static SV *
678decode_sv (dec_t *dec) 1087decode_sv (dec_t *dec)
679{ 1088{
680 WANT (1); 1089 WANT (1);
681 1090
682 switch (*dec->cur >> 5) 1091 switch (*dec->cur >> MAJOR_SHIFT)
683 { 1092 {
684 case 0: // unsigned int 1093 case MAJOR_POS_INT >> MAJOR_SHIFT: return newSVuv (decode_uint (dec));
685 return newSVuv (decode_uint (dec)); 1094 case MAJOR_NEG_INT >> MAJOR_SHIFT: return newSViv (-1 - (IV)decode_uint (dec));
686 case 1: // negative int 1095 case MAJOR_BYTES >> MAJOR_SHIFT: return decode_str (dec, 0);
687 return newSViv (-1 - (IV)decode_uint (dec)); 1096 case MAJOR_TEXT >> MAJOR_SHIFT: return decode_str (dec, 1);
688 case 2: // octet string 1097 case MAJOR_ARRAY >> MAJOR_SHIFT: return decode_av (dec);
689 return decode_str (dec, 0); 1098 case MAJOR_MAP >> MAJOR_SHIFT: return decode_hv (dec);
690 case 3: // utf-8 string 1099 case MAJOR_TAG >> MAJOR_SHIFT: return decode_tagged (dec);
691 return decode_str (dec, 1); 1100
692 case 4: // array 1101 case MAJOR_MISC >> MAJOR_SHIFT:
693 return decode_av (dec);
694 case 5: // map
695 return decode_hv (dec);
696 case 6: // tag
697 return decode_tagged (dec);
698 case 7: // misc
699 switch (*dec->cur++ & 31) 1102 switch (*dec->cur++ & MINOR_MASK)
700 { 1103 {
701 case 20: 1104 case SIMPLE_FALSE:
702#if CBOR_SLOW 1105#if CBOR_SLOW
703 types_false = get_bool ("Types::Serialiser::false"); 1106 types_false = get_bool ("Types::Serialiser::false");
704#endif 1107#endif
705 return newSVsv (types_false); 1108 return newSVsv (types_false);
706 case 21: 1109 case SIMPLE_TRUE:
707#if CBOR_SLOW 1110#if CBOR_SLOW
708 types_true = get_bool ("Types::Serialiser::true"); 1111 types_true = get_bool ("Types::Serialiser::true");
709#endif 1112#endif
710 return newSVsv (types_true); 1113 return newSVsv (types_true);
711 case 22: 1114 case SIMPLE_NULL:
712 return newSVsv (&PL_sv_undef); 1115 return newSVsv (&PL_sv_undef);
713 case 23: 1116 case SIMPLE_UNDEF:
714#if CBOR_SLOW 1117#if CBOR_SLOW
715 types_error = get_bool ("Types::Serialiser::error"); 1118 types_error = get_bool ("Types::Serialiser::error");
716#endif 1119#endif
717 return newSVsv (types_error); 1120 return newSVsv (types_error);
718 1121
719 case 25: 1122 case MISC_FLOAT16:
720 { 1123 {
721 WANT (2); 1124 WANT (2);
722 1125
723 uint16_t fp = (dec->cur[0] << 8) | dec->cur[1]; 1126 uint16_t fp = (dec->cur[0] << 8) | dec->cur[1];
724 dec->cur += 2; 1127 dec->cur += 2;
725 1128
726 return newSVnv (ecb_binary16_to_float (fp)); 1129 return newSVnv (ecb_binary16_to_float (fp));
727 } 1130 }
728 1131
729 case 26: 1132 case MISC_FLOAT32:
730 { 1133 {
731 uint32_t fp; 1134 uint32_t fp;
732 WANT (4); 1135 WANT (4);
733 memcpy (&fp, dec->cur, 4); 1136 memcpy (&fp, dec->cur, 4);
734 dec->cur += 4; 1137 dec->cur += 4;
737 fp = ecb_bswap32 (fp); 1140 fp = ecb_bswap32 (fp);
738 1141
739 return newSVnv (ecb_binary32_to_float (fp)); 1142 return newSVnv (ecb_binary32_to_float (fp));
740 } 1143 }
741 1144
742 case 27: 1145 case MISC_FLOAT64:
743 { 1146 {
744 uint64_t fp; 1147 uint64_t fp;
745 WANT (8); 1148 WANT (8);
746 memcpy (&fp, dec->cur, 8); 1149 memcpy (&fp, dec->cur, 8);
747 dec->cur += 8; 1150 dec->cur += 8;
750 fp = ecb_bswap64 (fp); 1153 fp = ecb_bswap64 (fp);
751 1154
752 return newSVnv (ecb_binary64_to_double (fp)); 1155 return newSVnv (ecb_binary64_to_double (fp));
753 } 1156 }
754 1157
755 // 0..19 unassigned 1158 // 0..19 unassigned simple
756 // 24 reserved + unassigned (reserved values are not encodable) 1159 // 24 reserved + unassigned simple (reserved values are not encodable)
1160 // 28-30 unassigned misc
1161 // 31 break code
757 default: 1162 default:
758 ERR ("corrupted CBOR data (reserved/unassigned major 7 value)"); 1163 ERR ("corrupted CBOR data (reserved/unassigned/unexpected major 7 value)");
759 } 1164 }
760 1165
761 break; 1166 break;
762 } 1167 }
763 1168
766} 1171}
767 1172
768static SV * 1173static SV *
769decode_cbor (SV *string, CBOR *cbor, char **offset_return) 1174decode_cbor (SV *string, CBOR *cbor, char **offset_return)
770{ 1175{
771 dec_t dec; 1176 dec_t dec = { 0 };
772 SV *sv; 1177 SV *sv;
1178 STRLEN len;
1179 char *data = SvPVbyte (string, len);
773 1180
774 /* work around bugs in 5.10 where manipulating magic values
775 * makes perl ignore the magic in subsequent accesses.
776 * also make a copy of non-PV values, to get them into a clean
777 * state (SvPV should do that, but it's buggy, see below).
778 */
779 /*SvGETMAGIC (string);*/
780 if (SvMAGICAL (string) || !SvPOK (string))
781 string = sv_2mortal (newSVsv (string));
782
783 SvUPGRADE (string, SVt_PV);
784
785 /* work around a bug in perl 5.10, which causes SvCUR to fail an
786 * assertion with -DDEBUGGING, although SvCUR is documented to
787 * return the xpv_cur field which certainly exists after upgrading.
788 * according to nicholas clark, calling SvPOK fixes this.
789 * But it doesn't fix it, so try another workaround, call SvPV_nolen
790 * and hope for the best.
791 * Damnit, SvPV_nolen still trips over yet another assertion. This
792 * assertion business is seriously broken, try yet another workaround
793 * for the broken -DDEBUGGING.
794 */
795 {
796#ifdef DEBUGGING
797 STRLEN offset = SvOK (string) ? sv_len (string) : 0;
798#else
799 STRLEN offset = SvCUR (string);
800#endif
801
802 if (offset > cbor->max_size && cbor->max_size) 1181 if (len > cbor->max_size && cbor->max_size)
803 croak ("attempted decode of CBOR text of %lu bytes size, but max_size is set to %lu", 1182 croak ("attempted decode of CBOR text of %lu bytes size, but max_size is set to %lu",
804 (unsigned long)SvCUR (string), (unsigned long)cbor->max_size); 1183 (unsigned long)len, (unsigned long)cbor->max_size);
805 }
806
807 sv_utf8_downgrade (string, 0);
808 1184
809 dec.cbor = *cbor; 1185 dec.cbor = *cbor;
810 dec.cur = (U8 *)SvPVX (string); 1186 dec.cur = (U8 *)data;
811 dec.end = (U8 *)SvEND (string); 1187 dec.end = (U8 *)data + len;
812 dec.err = 0;
813 dec.depth = 0;
814 1188
815 sv = decode_sv (&dec); 1189 sv = decode_sv (&dec);
816 1190
817 if (offset_return) 1191 if (offset_return)
818 *offset_return = dec.cur; 1192 *offset_return = dec.cur;
821 if (dec.cur != dec.end && !dec.err) 1195 if (dec.cur != dec.end && !dec.err)
822 dec.err = "garbage after CBOR object"; 1196 dec.err = "garbage after CBOR object";
823 1197
824 if (dec.err) 1198 if (dec.err)
825 { 1199 {
1200 if (dec.shareable)
1201 {
1202 // need to break cyclic links, which whould all be in shareable
1203 int i;
1204 SV **svp;
1205
1206 for (i = av_len (dec.shareable) + 1; i--; )
1207 if ((svp = av_fetch (dec.shareable, i, 0)))
1208 sv_setsv (*svp, &PL_sv_undef);
1209 }
1210
826 SvREFCNT_dec (sv); 1211 SvREFCNT_dec (sv);
827 croak ("%s, at offset %d (octet 0x%02x)", dec.err, dec.cur - (U8 *)SvPVX (string), (int)(uint8_t)*dec.cur); 1212 croak ("%s, at offset %d (octet 0x%02x)", dec.err, dec.cur - (U8 *)data, (int)(uint8_t)*dec.cur);
828 } 1213 }
829 1214
830 sv = sv_2mortal (sv); 1215 sv = sv_2mortal (sv);
831 1216
832 return sv; 1217 return sv;
833} 1218}
834 1219
1220/////////////////////////////////////////////////////////////////////////////
1221// incremental parser
1222
1223#define INCR_DONE(cbor) (AvFILLp (cbor->incr_count) < 0)
1224
1225// returns 0 for notyet, 1 for success or error
1226static int
1227incr_parse (CBOR *self, SV *cborstr)
1228{
1229 STRLEN cur;
1230 SvPV (cborstr, cur);
1231
1232 while (ecb_expect_true (self->incr_need <= cur))
1233 {
1234 // table of integer count bytes
1235 static I8 incr_len[MINOR_MASK + 1] = {
1236 0, 0, 0, 0, 0, 0, 0, 0,
1237 0, 0, 0, 0, 0, 0, 0, 0,
1238 0, 0, 0, 0, 0, 0, 0, 0,
1239 1, 2, 4, 8,-1,-1,-1,-2
1240 };
1241
1242 const U8 *p = SvPVX (cborstr) + self->incr_pos;
1243 U8 m = *p & MINOR_MASK;
1244 IV count = SvIVX (AvARRAY (self->incr_count)[AvFILLp (self->incr_count)]);
1245 I8 ilen = incr_len[m];
1246
1247 self->incr_need = self->incr_pos + 1;
1248
1249 if (ecb_expect_false (ilen < 0))
1250 {
1251 if (m != MINOR_INDEF)
1252 return 1; // error
1253
1254 if (*p == (MAJOR_MISC | MINOR_INDEF))
1255 {
1256 if (count >= 0)
1257 return 1; // error
1258
1259 count = 1;
1260 }
1261 else
1262 {
1263 av_push (self->incr_count, newSViv (-1)); //TODO: nest
1264 count = -1;
1265 }
1266 }
1267 else
1268 {
1269 self->incr_need += ilen;
1270 if (ecb_expect_false (self->incr_need > cur))
1271 return 0;
1272
1273 int major = *p >> MAJOR_SHIFT;
1274
1275 switch (major)
1276 {
1277 case MAJOR_TAG >> MAJOR_SHIFT:
1278 ++count; // tags merely prefix another value
1279 break;
1280
1281 case MAJOR_BYTES >> MAJOR_SHIFT:
1282 case MAJOR_TEXT >> MAJOR_SHIFT:
1283 case MAJOR_ARRAY >> MAJOR_SHIFT:
1284 case MAJOR_MAP >> MAJOR_SHIFT:
1285 {
1286 UV len;
1287
1288 if (ecb_expect_false (ilen))
1289 {
1290 len = 0;
1291
1292 do {
1293 len = (len << 8) | *++p;
1294 } while (--ilen);
1295 }
1296 else
1297 len = m;
1298
1299 switch (major)
1300 {
1301 case MAJOR_BYTES >> MAJOR_SHIFT:
1302 case MAJOR_TEXT >> MAJOR_SHIFT:
1303 self->incr_need += len;
1304 if (ecb_expect_false (self->incr_need > cur))
1305 return 0;
1306
1307 break;
1308
1309 case MAJOR_MAP >> MAJOR_SHIFT:
1310 len <<= 1;
1311 case MAJOR_ARRAY >> MAJOR_SHIFT:
1312 if (len)
1313 {
1314 av_push (self->incr_count, newSViv (len + 1)); //TODO: nest
1315 count = len + 1;
1316 }
1317 break;
1318 }
1319 }
1320 }
1321 }
1322
1323 self->incr_pos = self->incr_need;
1324
1325 if (count > 0)
1326 {
1327 while (!--count)
1328 {
1329 if (!AvFILLp (self->incr_count))
1330 return 1; // done
1331
1332 SvREFCNT_dec_NN (av_pop (self->incr_count));
1333 count = SvIVX (AvARRAY (self->incr_count)[AvFILLp (self->incr_count)]);
1334 }
1335
1336 SvIVX (AvARRAY (self->incr_count)[AvFILLp (self->incr_count)]) = count;
1337 }
1338 }
1339
1340 return 0;
1341}
1342
1343
835///////////////////////////////////////////////////////////////////////////// 1344/////////////////////////////////////////////////////////////////////////////
836// XS interface functions 1345// XS interface functions
837 1346
838MODULE = CBOR::XS PACKAGE = CBOR::XS 1347MODULE = CBOR::XS PACKAGE = CBOR::XS
839 1348
846 types_error_stash = gv_stashpv ("Types::Serialiser::Error" , 1); 1355 types_error_stash = gv_stashpv ("Types::Serialiser::Error" , 1);
847 1356
848 types_true = get_bool ("Types::Serialiser::true" ); 1357 types_true = get_bool ("Types::Serialiser::true" );
849 types_false = get_bool ("Types::Serialiser::false"); 1358 types_false = get_bool ("Types::Serialiser::false");
850 types_error = get_bool ("Types::Serialiser::error"); 1359 types_error = get_bool ("Types::Serialiser::error");
1360
1361 default_filter = newSVpv ("CBOR::XS::default_filter", 0);
1362
1363 sv_cbor = newSVpv ("CBOR", 0);
1364 SvREADONLY_on (sv_cbor);
851} 1365}
852 1366
853PROTOTYPES: DISABLE 1367PROTOTYPES: DISABLE
854 1368
855void CLONE (...) 1369void CLONE (...)
873 1387
874void shrink (CBOR *self, int enable = 1) 1388void shrink (CBOR *self, int enable = 1)
875 ALIAS: 1389 ALIAS:
876 shrink = F_SHRINK 1390 shrink = F_SHRINK
877 allow_unknown = F_ALLOW_UNKNOWN 1391 allow_unknown = F_ALLOW_UNKNOWN
1392 allow_sharing = F_ALLOW_SHARING
1393 allow_cycles = F_ALLOW_CYCLES
1394 pack_strings = F_PACK_STRINGS
1395 validate_utf8 = F_VALIDATE_UTF8
878 PPCODE: 1396 PPCODE:
879{ 1397{
880 if (enable) 1398 if (enable)
881 self->flags |= ix; 1399 self->flags |= ix;
882 else 1400 else
887 1405
888void get_shrink (CBOR *self) 1406void get_shrink (CBOR *self)
889 ALIAS: 1407 ALIAS:
890 get_shrink = F_SHRINK 1408 get_shrink = F_SHRINK
891 get_allow_unknown = F_ALLOW_UNKNOWN 1409 get_allow_unknown = F_ALLOW_UNKNOWN
1410 get_allow_sharing = F_ALLOW_SHARING
1411 get_allow_cycles = F_ALLOW_CYCLES
1412 get_pack_strings = F_PACK_STRINGS
1413 get_validate_utf8 = F_VALIDATE_UTF8
892 PPCODE: 1414 PPCODE:
893 XPUSHs (boolSV (self->flags & ix)); 1415 XPUSHs (boolSV (self->flags & ix));
894 1416
895void max_depth (CBOR *self, U32 max_depth = 0x80000000UL) 1417void max_depth (CBOR *self, U32 max_depth = 0x80000000UL)
896 PPCODE: 1418 PPCODE:
912 CODE: 1434 CODE:
913 RETVAL = self->max_size; 1435 RETVAL = self->max_size;
914 OUTPUT: 1436 OUTPUT:
915 RETVAL 1437 RETVAL
916 1438
917#if 0 //TODO 1439void filter (CBOR *self, SV *filter = 0)
918
919void filter_cbor_object (CBOR *self, SV *cb = &PL_sv_undef)
920 PPCODE: 1440 PPCODE:
921{
922 SvREFCNT_dec (self->cb_object); 1441 SvREFCNT_dec (self->filter);
923 self->cb_object = SvOK (cb) ? newSVsv (cb) : 0; 1442 self->filter = filter ? newSVsv (filter) : filter;
924
925 XPUSHs (ST (0)); 1443 XPUSHs (ST (0));
926}
927 1444
928void filter_cbor_single_key_object (CBOR *self, SV *key, SV *cb = &PL_sv_undef) 1445SV *get_filter (CBOR *self)
929 PPCODE: 1446 CODE:
930{ 1447 RETVAL = self->filter ? self->filter : NEWSV (0, 0);
931 if (!self->cb_sk_object) 1448 OUTPUT:
932 self->cb_sk_object = newHV (); 1449 RETVAL
933
934 if (SvOK (cb))
935 hv_store_ent (self->cb_sk_object, key, newSVsv (cb), 0);
936 else
937 {
938 hv_delete_ent (self->cb_sk_object, key, G_DISCARD, 0);
939
940 if (!HvKEYS (self->cb_sk_object))
941 {
942 SvREFCNT_dec (self->cb_sk_object);
943 self->cb_sk_object = 0;
944 }
945 }
946
947 XPUSHs (ST (0));
948}
949
950#endif
951 1450
952void encode (CBOR *self, SV *scalar) 1451void encode (CBOR *self, SV *scalar)
953 PPCODE: 1452 PPCODE:
954 PUTBACK; scalar = encode_cbor (scalar, self); SPAGAIN; 1453 PUTBACK; scalar = encode_cbor (scalar, self); SPAGAIN;
955 XPUSHs (scalar); 1454 XPUSHs (scalar);
968 EXTEND (SP, 2); 1467 EXTEND (SP, 2);
969 PUSHs (sv); 1468 PUSHs (sv);
970 PUSHs (sv_2mortal (newSVuv (offset - SvPVX (cborstr)))); 1469 PUSHs (sv_2mortal (newSVuv (offset - SvPVX (cborstr))));
971} 1470}
972 1471
973#if 0 1472void incr_parse (CBOR *self, SV *cborstr)
1473 ALIAS:
1474 incr_parse_multiple = 1
1475 PPCODE:
1476{
1477 if (SvUTF8 (cborstr))
1478 sv_utf8_downgrade (cborstr, 0);
1479
1480 if (!self->incr_count)
1481 {
1482 self->incr_count = newAV ();
1483 self->incr_pos = 0;
1484 self->incr_need = 1;
1485
1486 av_push (self->incr_count, newSViv (1));
1487 }
1488
1489 do
1490 {
1491 if (!incr_parse (self, cborstr))
1492 {
1493 if (self->incr_need > self->max_size && self->max_size)
1494 croak ("attempted decode of CBOR text of %lu bytes size, but max_size is set to %lu",
1495 (unsigned long)self->incr_need, (unsigned long)self->max_size);
1496
1497 break;
1498 }
1499
1500 SV *sv;
1501 char *offset;
1502
1503 PUTBACK; sv = decode_cbor (cborstr, self, &offset); SPAGAIN;
1504 XPUSHs (sv);
1505
1506 sv_chop (cborstr, offset);
1507
1508 av_clear (self->incr_count);
1509 av_push (self->incr_count, newSViv (1));
1510
1511 self->incr_pos = 0;
1512 self->incr_need = self->incr_pos + 1;
1513 }
1514 while (ix);
1515}
1516
1517void incr_reset (CBOR *self)
1518 CODE:
1519{
1520 SvREFCNT_dec (self->incr_count);
1521 self->incr_count = 0;
1522}
974 1523
975void DESTROY (CBOR *self) 1524void DESTROY (CBOR *self)
976 CODE: 1525 PPCODE:
977 SvREFCNT_dec (self->cb_sk_object); 1526 cbor_free (self);
978 SvREFCNT_dec (self->cb_object);
979
980#endif
981 1527
982PROTOTYPES: ENABLE 1528PROTOTYPES: ENABLE
983 1529
984void encode_cbor (SV *scalar) 1530void encode_cbor (SV *scalar)
1531 ALIAS:
1532 encode_cbor = 0
1533 encode_cbor_sharing = F_ALLOW_SHARING
985 PPCODE: 1534 PPCODE:
986{ 1535{
987 CBOR cbor; 1536 CBOR cbor;
988 cbor_init (&cbor); 1537 cbor_init (&cbor);
1538 cbor.flags |= ix;
989 PUTBACK; scalar = encode_cbor (scalar, &cbor); SPAGAIN; 1539 PUTBACK; scalar = encode_cbor (scalar, &cbor); SPAGAIN;
990 XPUSHs (scalar); 1540 XPUSHs (scalar);
991} 1541}
992 1542
993void decode_cbor (SV *cborstr) 1543void decode_cbor (SV *cborstr)

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines