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.17 by root, Tue Oct 29 22:04:52 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"
13 14
14// compatibility with perl <5.18 15// compatibility with perl <5.18
15#ifndef HvNAMELEN_get 16#ifndef HvNAMELEN_get
16# define HvNAMELEN_get(hv) strlen (HvNAME (hv)) 17# define HvNAMELEN_get(hv) strlen (HvNAME (hv))
… …
19# define HvNAMELEN(hv) HvNAMELEN_get (hv) 20# define HvNAMELEN(hv) HvNAMELEN_get (hv)
20#endif 21#endif
21#ifndef HvNAMEUTF8 22#ifndef HvNAMEUTF8
22# define HvNAMEUTF8(hv) 0 23# define HvNAMEUTF8(hv) 0
23#endif 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};
24 65
25// known tags 66// known tags
26enum cbor_tag 67enum cbor_tag
27{ 68{
28 // inofficial extensions (pending iana registration) 69 // extensions
29 CBOR_TAG_PERL_OBJECT = 256, 70 CBOR_TAG_STRINGREF = 25, // http://cbor.schmorp.de/stringref
30 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
31 77
32 // rfc7049 78 // rfc7049
33 CBOR_TAG_DATETIME = 0, // rfc4287, utf-8 79 CBOR_TAG_DATETIME = 0, // rfc4287, utf-8
34 CBOR_TAG_TIMESTAMP = 1, // unix timestamp, any 80 CBOR_TAG_TIMESTAMP = 1, // unix timestamp, any
35 CBOR_TAG_POS_BIGNUM = 2, // byte string 81 CBOR_TAG_POS_BIGNUM = 2, // byte string
36 CBOR_TAG_NEG_BIGNUM = 3, // byte string 82 CBOR_TAG_NEG_BIGNUM = 3, // byte string
37 CBOR_TAG_DECIMAL = 4, // decimal fraction, array 83 CBOR_TAG_DECIMAL = 4, // decimal fraction, array
38 CBOR_TAG_BIGFLOAT = 5, // array 84 CBOR_TAG_BIGFLOAT = 5, // array
39 85
40 CBOR_TAG_CONV_B64U = 21, // base64url, any 86 CBOR_TAG_CONV_B64U = 21, // base64url, any
41 CBOR_TAG_CONV_B64 = 22, // base64, any 87 CBOR_TAG_CONV_B64 = 22, // base64, any
42 CBOR_TAG_CONV_HEX = 23, // base16, any 88 CBOR_TAG_CONV_HEX = 23, // base16, any
43 CBOR_TAG_CBOR = 24, // embedded cbor, byte string 89 CBOR_TAG_CBOR = 24, // embedded cbor, byte string
44 90
45 CBOR_TAG_URI = 32, // URI rfc3986, utf-8 91 CBOR_TAG_URI = 32, // URI rfc3986, utf-8
46 CBOR_TAG_B64U = 33, // base64url rfc4648, utf-8 92 CBOR_TAG_B64U = 33, // base64url rfc4648, utf-8
47 CBOR_TAG_B64 = 34, // base6 rfc46484, utf-8 93 CBOR_TAG_B64 = 34, // base6 rfc46484, utf-8
48 CBOR_TAG_REGEX = 35, // regex pcre/ecma262, utf-8 94 CBOR_TAG_REGEX = 35, // regex pcre/ecma262, utf-8
49 CBOR_TAG_MIME = 36, // mime message rfc2045, utf-8 95 CBOR_TAG_MIME = 36, // mime message rfc2045, utf-8
50 96
51 CBOR_TAG_MAGIC = 55799 // self-describe cbor 97 CBOR_TAG_MAGIC = 55799, // self-describe cbor
52}; 98};
53 99
54#define F_SHRINK 0x00000200UL 100#define F_SHRINK 0x00000001UL
55#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
56 106
57#define INIT_SIZE 32 // initial scalar size to be allocated 107#define INIT_SIZE 32 // initial scalar size to be allocated
58 108
59#define SB do { 109#define SB do {
60#define SE } while (0) 110#define SE } while (0)
… …
72# define CBOR_SLOW 0 122# define CBOR_SLOW 0
73# define CBOR_STASH cbor_stash 123# define CBOR_STASH cbor_stash
74#endif 124#endif
75 125
76static 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::
77static SV *types_true, *types_false, *types_error, *sv_cbor; 127static SV *types_true, *types_false, *types_error, *sv_cbor, *default_filter;
78 128
79typedef struct { 129typedef struct {
80 U32 flags; 130 U32 flags;
81 U32 max_depth; 131 U32 max_depth;
82 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.
83} CBOR; 139} CBOR;
84 140
85ecb_inline void 141ecb_inline void
86cbor_init (CBOR *cbor) 142cbor_init (CBOR *cbor)
87{ 143{
88 Zero (cbor, 1, CBOR); 144 Zero (cbor, 1, CBOR);
89 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);
90} 153}
91 154
92///////////////////////////////////////////////////////////////////////////// 155/////////////////////////////////////////////////////////////////////////////
93// utility functions 156// utility functions
94 157
… …
116 SvPV_renew (sv, SvCUR (sv) + 1); 179 SvPV_renew (sv, SvCUR (sv) + 1);
117#endif 180#endif
118 } 181 }
119} 182}
120 183
121///////////////////////////////////////////////////////////////////////////// 184// minimum length of a string to be registered for stringref
122// fp hell 185ecb_inline int
123 186minimum_string_length (UV idx)
124//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}
125 198
126///////////////////////////////////////////////////////////////////////////// 199/////////////////////////////////////////////////////////////////////////////
127// encoder 200// encoder
128 201
129// structure used for encoding CBOR 202// structure used for encoding CBOR
… …
132 char *cur; // SvPVX (sv) + current output position 205 char *cur; // SvPVX (sv) + current output position
133 char *end; // SvEND (sv) 206 char *end; // SvEND (sv)
134 SV *sv; // result scalar 207 SV *sv; // result scalar
135 CBOR cbor; 208 CBOR cbor;
136 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;
137} enc_t; 214} enc_t;
138 215
139ecb_inline void 216ecb_inline void
140need (enc_t *enc, STRLEN len) 217need (enc_t *enc, STRLEN len)
141{ 218{
… …
158static void 235static void
159encode_uint (enc_t *enc, int major, UV len) 236encode_uint (enc_t *enc, int major, UV len)
160{ 237{
161 need (enc, 9); 238 need (enc, 9);
162 239
163 if (len < 24) 240 if (ecb_expect_true (len < LENGTH_EXT1))
164 *enc->cur++ = major | len; 241 *enc->cur++ = major | len;
165 else if (len <= 0xff) 242 else if (ecb_expect_true (len <= 0xffU))
166 { 243 {
167 *enc->cur++ = major | 24; 244 *enc->cur++ = major | LENGTH_EXT1;
168 *enc->cur++ = len; 245 *enc->cur++ = len;
169 } 246 }
170 else if (len <= 0xffff) 247 else if (len <= 0xffffU)
171 { 248 {
172 *enc->cur++ = major | 25; 249 *enc->cur++ = major | LENGTH_EXT2;
173 *enc->cur++ = len >> 8; 250 *enc->cur++ = len >> 8;
174 *enc->cur++ = len; 251 *enc->cur++ = len;
175 } 252 }
176 else if (len <= 0xffffffff) 253 else if (len <= 0xffffffffU)
177 { 254 {
178 *enc->cur++ = major | 26; 255 *enc->cur++ = major | LENGTH_EXT4;
179 *enc->cur++ = len >> 24; 256 *enc->cur++ = len >> 24;
180 *enc->cur++ = len >> 16; 257 *enc->cur++ = len >> 16;
181 *enc->cur++ = len >> 8; 258 *enc->cur++ = len >> 8;
182 *enc->cur++ = len; 259 *enc->cur++ = len;
183 } 260 }
184 else 261 else
185 { 262 {
186 *enc->cur++ = major | 27; 263 *enc->cur++ = major | LENGTH_EXT8;
187 *enc->cur++ = len >> 56; 264 *enc->cur++ = len >> 56;
188 *enc->cur++ = len >> 48; 265 *enc->cur++ = len >> 48;
189 *enc->cur++ = len >> 40; 266 *enc->cur++ = len >> 40;
190 *enc->cur++ = len >> 32; 267 *enc->cur++ = len >> 32;
191 *enc->cur++ = len >> 24; 268 *enc->cur++ = len >> 24;
… …
193 *enc->cur++ = len >> 8; 270 *enc->cur++ = len >> 8;
194 *enc->cur++ = len; 271 *enc->cur++ = len;
195 } 272 }
196} 273}
197 274
198static void 275ecb_inline void
276encode_tag (enc_t *enc, UV tag)
277{
278 encode_uint (enc, MAJOR_TAG, tag);
279}
280
281ecb_inline void
199encode_str (enc_t *enc, int utf8, char *str, STRLEN len) 282encode_str (enc_t *enc, int utf8, char *str, STRLEN len)
200{ 283{
201 encode_uint (enc, utf8 ? 0x60 : 0x40, len); 284 encode_uint (enc, utf8 ? MAJOR_TEXT : MAJOR_BYTES, len);
202 need (enc, len); 285 need (enc, len);
203 memcpy (enc->cur, str, len); 286 memcpy (enc->cur, str, len);
204 enc->cur += len; 287 enc->cur += len;
205} 288}
206 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
207static void encode_sv (enc_t *enc, SV *sv); 315static void encode_sv (enc_t *enc, SV *sv);
208 316
209static void 317static void
210encode_av (enc_t *enc, AV *av) 318encode_av (enc_t *enc, AV *av)
211{ 319{
… …
214 if (enc->depth >= enc->cbor.max_depth) 322 if (enc->depth >= enc->cbor.max_depth)
215 croak (ERR_NESTING_EXCEEDED); 323 croak (ERR_NESTING_EXCEEDED);
216 324
217 ++enc->depth; 325 ++enc->depth;
218 326
219 encode_uint (enc, 0x80, len + 1); 327 encode_uint (enc, MAJOR_ARRAY, len + 1);
220 328
329 if (SvMAGICAL (av))
221 for (i = 0; i <= len; ++i) 330 for (i = 0; i <= len; ++i)
222 { 331 {
223 SV **svp = av_fetch (av, i, 0); 332 SV **svp = av_fetch (av, i, 0);
224 encode_sv (enc, svp ? *svp : &PL_sv_undef); 333 encode_sv (enc, svp ? *svp : &PL_sv_undef);
225 } 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 }
226 341
227 --enc->depth; 342 --enc->depth;
228} 343}
229 344
230static void 345static void
… …
239 354
240 int pairs = hv_iterinit (hv); 355 int pairs = hv_iterinit (hv);
241 int mg = SvMAGICAL (hv); 356 int mg = SvMAGICAL (hv);
242 357
243 if (mg) 358 if (mg)
244 encode_ch (enc, 0xa0 | 31); 359 encode_ch (enc, MAJOR_MAP | MINOR_INDEF);
245 else 360 else
246 encode_uint (enc, 0xa0, pairs); 361 encode_uint (enc, MAJOR_MAP, pairs);
247 362
248 while ((he = hv_iternext (hv))) 363 while ((he = hv_iternext (hv)))
249 { 364 {
250 if (HeKLEN (he) == HEf_SVKEY) 365 if (HeKLEN (he) == HEf_SVKEY)
251 encode_sv (enc, HeSVKEY (he)); 366 encode_sv (enc, HeSVKEY (he));
252 else 367 else
253 encode_str (enc, HeKUTF8 (he), HeKEY (he), HeKLEN (he)); 368 encode_strref (enc, HeKUTF8 (he), HeKEY (he), HeKLEN (he));
254 369
255 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));
256 } 371 }
257 372
258 if (mg) 373 if (mg)
259 encode_ch (enc, 0xe0 | 31); 374 encode_ch (enc, MAJOR_MISC | MINOR_INDEF);
260 375
261 --enc->depth; 376 --enc->depth;
262} 377}
263 378
264// encode objects, arrays and special \0=false and \1=true values. 379// encode objects, arrays and special \0=false and \1=true values.
265static void 380static void
266encode_rv (enc_t *enc, SV *sv) 381encode_rv (enc_t *enc, SV *sv)
267{ 382{
268 svtype svt;
269
270 SvGETMAGIC (sv); 383 SvGETMAGIC (sv);
384
271 svt = SvTYPE (sv); 385 svtype svt = SvTYPE (sv);
272 386
273 if (ecb_expect_false (SvOBJECT (sv))) 387 if (ecb_expect_false (SvOBJECT (sv)))
274 { 388 {
275 HV *boolean_stash = !CBOR_SLOW || types_boolean_stash 389 HV *boolean_stash = !CBOR_SLOW || types_boolean_stash
276 ? types_boolean_stash 390 ? types_boolean_stash
… …
281 HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash 395 HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash
282 ? cbor_tagged_stash 396 ? cbor_tagged_stash
283 : gv_stashpv ("CBOR::XS::Tagged" , 1); 397 : gv_stashpv ("CBOR::XS::Tagged" , 1);
284 398
285 HV *stash = SvSTASH (sv); 399 HV *stash = SvSTASH (sv);
286 GV *method;
287 400
288 if (stash == boolean_stash) 401 if (stash == boolean_stash)
289 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 }
290 else if (stash == error_stash) 406 else if (stash == error_stash)
291 encode_ch (enc, 0xe0 | 23); 407 {
408 encode_ch (enc, MAJOR_MISC | SIMPLE_UNDEF);
409 return;
410 }
292 else if (stash == tagged_stash) 411 else if (stash == tagged_stash)
293 { 412 {
294 if (svt != SVt_PVAV) 413 if (svt != SVt_PVAV)
295 croak ("encountered CBOR::XS::Tagged object that isn't an array"); 414 croak ("encountered CBOR::XS::Tagged object that isn't an array");
296 415
297 encode_uint (enc, 0xc0, SvUV (*av_fetch ((AV *)sv, 0, 1))); 416 encode_uint (enc, MAJOR_TAG, SvUV (*av_fetch ((AV *)sv, 0, 1)));
298 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))
299 } 432 {
433 encode_tag (enc, CBOR_TAG_VALUE_SHAREDREF);
434 encode_uint (enc, MAJOR_POS_INT, 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 if (ecb_expect_false (SvOBJECT (sv)))
446 {
447 HV *stash = SvSTASH (sv);
448 GV *method;
449
300 else if ((method = gv_fetchmethod_autoload (stash, "TO_CBOR", 0))) 450 if ((method = gv_fetchmethod_autoload (stash, "TO_CBOR", 0)))
301 { 451 {
302 dSP; 452 dSP;
303 453
304 ENTER; SAVETMPS; PUSHMARK (SP); 454 ENTER; SAVETMPS;
455 PUSHMARK (SP);
305 // 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
306 XPUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash)); 457 XPUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash));
307 458
308 PUTBACK; 459 PUTBACK;
309 // G_SCALAR ensures that return value is 1 460 // G_SCALAR ensures that return value is 1
… …
322 } 473 }
323 else if ((method = gv_fetchmethod_autoload (stash, "FREEZE", 0)) != 0) 474 else if ((method = gv_fetchmethod_autoload (stash, "FREEZE", 0)) != 0)
324 { 475 {
325 dSP; 476 dSP;
326 477
327 ENTER; SAVETMPS; PUSHMARK (SP); 478 ENTER; SAVETMPS;
479 SAVESTACK_POS ();
480 PUSHMARK (SP);
328 EXTEND (SP, 2); 481 EXTEND (SP, 2);
329 // we re-bless the reference to get overload and other niceties right 482 // we re-bless the reference to get overload and other niceties right
330 PUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash)); 483 PUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash));
331 PUSHs (sv_cbor); 484 PUSHs (sv_cbor);
332 485
… …
336 489
337 // catch this surprisingly common error 490 // catch this surprisingly common error
338 if (count == 1 && SvROK (TOPs) && SvRV (TOPs) == sv) 491 if (count == 1 && SvROK (TOPs) && SvRV (TOPs) == sv)
339 croak ("%s::FREEZE(CBOR) method returned same object as was passed instead of a new one", HvNAME (stash)); 492 croak ("%s::FREEZE(CBOR) method returned same object as was passed instead of a new one", HvNAME (stash));
340 493
341 encode_uint (enc, 0xc0, CBOR_TAG_PERL_OBJECT); 494 encode_tag (enc, CBOR_TAG_PERL_OBJECT);
342 encode_uint (enc, 0x80, count + 1); 495 encode_uint (enc, MAJOR_ARRAY, count + 1);
343 encode_str (enc, HvNAMEUTF8 (stash), HvNAME (stash), HvNAMELEN (stash)); 496 encode_strref (enc, HvNAMEUTF8 (stash), HvNAME (stash), HvNAMELEN (stash));
344 497
345 while (count) 498 while (count)
346 encode_sv (enc, SP[1 - count--]); 499 encode_sv (enc, SP[1 - count--]);
347 500
348 PUTBACK; 501 PUTBACK;
… …
355 } 508 }
356 else if (svt == SVt_PVHV) 509 else if (svt == SVt_PVHV)
357 encode_hv (enc, (HV *)sv); 510 encode_hv (enc, (HV *)sv);
358 else if (svt == SVt_PVAV) 511 else if (svt == SVt_PVAV)
359 encode_av (enc, (AV *)sv); 512 encode_av (enc, (AV *)sv);
360 else if (svt < SVt_PVAV)
361 {
362 STRLEN len = 0;
363 char *pv = svt ? SvPV (sv, len) : 0;
364
365 if (len == 1 && *pv == '1')
366 encode_ch (enc, 0xe0 | 21);
367 else if (len == 1 && *pv == '0')
368 encode_ch (enc, 0xe0 | 20);
369 else if (enc->cbor.flags & F_ALLOW_UNKNOWN)
370 encode_ch (enc, 0xe0 | 23);
371 else
372 croak ("cannot encode reference to scalar '%s' unless the scalar is 0 or 1",
373 SvPV_nolen (sv_2mortal (newRV_inc (sv))));
374 }
375 else if (enc->cbor.flags & F_ALLOW_UNKNOWN)
376 encode_ch (enc, 0xe0 | 23);
377 else 513 else
378 croak ("encountered %s, but CBOR can only represent references to arrays or hashes", 514 {
379 SvPV_nolen (sv_2mortal (newRV_inc (sv)))); 515 encode_tag (enc, CBOR_TAG_INDIRECTION);
516 encode_sv (enc, sv);
517 }
380} 518}
381 519
382static void 520static void
383encode_nv (enc_t *enc, SV *sv) 521encode_nv (enc_t *enc, SV *sv)
384{ 522{
385 double nv = SvNVX (sv); 523 double nv = SvNVX (sv);
386 524
387 need (enc, 9); 525 need (enc, 9);
388 526
389 if (ecb_expect_false (nv == (U32)nv)) 527 if (ecb_expect_false (nv == (NV)(U32)nv))
390 encode_uint (enc, 0x00, (U32)nv); 528 encode_uint (enc, MAJOR_POS_INT, (U32)nv);
391 //TODO: maybe I32? 529 //TODO: maybe I32?
392 else if (ecb_expect_false (nv == (float)nv)) 530 else if (ecb_expect_false (nv == (float)nv))
393 { 531 {
394 uint32_t fp = ecb_float_to_binary32 (nv); 532 uint32_t fp = ecb_float_to_binary32 (nv);
395 533
396 *enc->cur++ = 0xe0 | 26; 534 *enc->cur++ = MAJOR_MISC | MISC_FLOAT32;
397 535
398 if (!ecb_big_endian ()) 536 if (!ecb_big_endian ())
399 fp = ecb_bswap32 (fp); 537 fp = ecb_bswap32 (fp);
400 538
401 memcpy (enc->cur, &fp, 4); 539 memcpy (enc->cur, &fp, 4);
… …
403 } 541 }
404 else 542 else
405 { 543 {
406 uint64_t fp = ecb_double_to_binary64 (nv); 544 uint64_t fp = ecb_double_to_binary64 (nv);
407 545
408 *enc->cur++ = 0xe0 | 27; 546 *enc->cur++ = MAJOR_MISC | MISC_FLOAT64;
409 547
410 if (!ecb_big_endian ()) 548 if (!ecb_big_endian ())
411 fp = ecb_bswap64 (fp); 549 fp = ecb_bswap64 (fp);
412 550
413 memcpy (enc->cur, &fp, 8); 551 memcpy (enc->cur, &fp, 8);
… …
422 560
423 if (SvPOKp (sv)) 561 if (SvPOKp (sv))
424 { 562 {
425 STRLEN len; 563 STRLEN len;
426 char *str = SvPV (sv, len); 564 char *str = SvPV (sv, len);
427 encode_str (enc, SvUTF8 (sv), str, len); 565 encode_strref (enc, SvUTF8 (sv), str, len);
428 } 566 }
429 else if (SvNOKp (sv)) 567 else if (SvNOKp (sv))
430 encode_nv (enc, sv); 568 encode_nv (enc, sv);
431 else if (SvIOKp (sv)) 569 else if (SvIOKp (sv))
432 { 570 {
433 if (SvIsUV (sv)) 571 if (SvIsUV (sv))
434 encode_uint (enc, 0x00, SvUVX (sv)); 572 encode_uint (enc, MAJOR_POS_INT, SvUVX (sv));
435 else if (SvIVX (sv) >= 0) 573 else if (SvIVX (sv) >= 0)
436 encode_uint (enc, 0x00, SvIVX (sv)); 574 encode_uint (enc, MAJOR_POS_INT, SvIVX (sv));
437 else 575 else
438 encode_uint (enc, 0x20, -(SvIVX (sv) + 1)); 576 encode_uint (enc, MAJOR_NEG_INT, -(SvIVX (sv) + 1));
439 } 577 }
440 else if (SvROK (sv)) 578 else if (SvROK (sv))
441 encode_rv (enc, SvRV (sv)); 579 encode_rv (enc, SvRV (sv));
442 else if (!SvOK (sv)) 580 else if (!SvOK (sv))
443 encode_ch (enc, 0xe0 | 22); 581 encode_ch (enc, MAJOR_MISC | SIMPLE_NULL);
444 else if (enc->cbor.flags & F_ALLOW_UNKNOWN) 582 else if (enc->cbor.flags & F_ALLOW_UNKNOWN)
445 encode_ch (enc, 0xe0 | 23); 583 encode_ch (enc, MAJOR_MISC | SIMPLE_UNDEF);
446 else 584 else
447 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",
448 SvPV_nolen (sv), (unsigned int)SvFLAGS (sv)); 586 SvPV_nolen (sv), (unsigned int)SvFLAGS (sv));
449} 587}
450 588
451static SV * 589static SV *
452encode_cbor (SV *scalar, CBOR *cbor) 590encode_cbor (SV *scalar, CBOR *cbor)
453{ 591{
454 enc_t enc; 592 enc_t enc = { 0 };
455 593
456 enc.cbor = *cbor; 594 enc.cbor = *cbor;
457 enc.sv = sv_2mortal (NEWSV (0, INIT_SIZE)); 595 enc.sv = sv_2mortal (NEWSV (0, INIT_SIZE));
458 enc.cur = SvPVX (enc.sv); 596 enc.cur = SvPVX (enc.sv);
459 enc.end = SvEND (enc.sv); 597 enc.end = SvEND (enc.sv);
460 enc.depth = 0;
461 598
462 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
463 encode_sv (&enc, scalar); 608 encode_sv (&enc, scalar);
464 609
465 SvCUR_set (enc.sv, enc.cur - SvPVX (enc.sv)); 610 SvCUR_set (enc.sv, enc.cur - SvPVX (enc.sv));
466 *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
467 612
… …
481 U8 *end; // end of input string 626 U8 *end; // end of input string
482 const char *err; // parse error, if != 0 627 const char *err; // parse error, if != 0
483 CBOR cbor; 628 CBOR cbor;
484 U32 depth; // recursion depth 629 U32 depth; // recursion depth
485 U32 maxdepth; // recursion depth limit 630 U32 maxdepth; // recursion depth limit
631 AV *shareable;
632 AV *stringref;
633 SV *decode_tagged;
486} dec_t; 634} dec_t;
487 635
488#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
489 637
490#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")
… …
493#define DEC_DEC_DEPTH --dec->depth 641#define DEC_DEC_DEPTH --dec->depth
494 642
495static UV 643static UV
496decode_uint (dec_t *dec) 644decode_uint (dec_t *dec)
497{ 645{
498 switch (*dec->cur & 31) 646 U8 m = *dec->cur & MINOR_MASK;
499 { 647 ++dec->cur;
500 case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
501 case 8: case 9: case 10: case 11: case 12: case 13: case 14: case 15:
502 case 16: case 17: case 18: case 19: case 20: case 21: case 22: case 23:
503 return *dec->cur++ & 31;
504 648
505 case 24: 649 if (ecb_expect_true (m < LENGTH_EXT1))
650 return m;
651 else if (ecb_expect_true (m == LENGTH_EXT1))
652 {
506 WANT (2); 653 WANT (1);
507 dec->cur += 2; 654 dec->cur += 1;
508 return dec->cur[-1]; 655 return dec->cur[-1];
509 656 }
510 case 25: 657 else if (ecb_expect_true (m == LENGTH_EXT2))
658 {
511 WANT (3); 659 WANT (2);
512 dec->cur += 3; 660 dec->cur += 2;
513 return (((UV)dec->cur[-2]) << 8) 661 return (((UV)dec->cur[-2]) << 8)
514 | ((UV)dec->cur[-1]); 662 | ((UV)dec->cur[-1]);
515 663 }
516 case 26: 664 else if (ecb_expect_true (m == LENGTH_EXT4))
665 {
517 WANT (5); 666 WANT (4);
518 dec->cur += 5; 667 dec->cur += 4;
519 return (((UV)dec->cur[-4]) << 24) 668 return (((UV)dec->cur[-4]) << 24)
520 | (((UV)dec->cur[-3]) << 16) 669 | (((UV)dec->cur[-3]) << 16)
521 | (((UV)dec->cur[-2]) << 8) 670 | (((UV)dec->cur[-2]) << 8)
522 | ((UV)dec->cur[-1]); 671 | ((UV)dec->cur[-1]);
523 672 }
524 case 27: 673 else if (ecb_expect_true (m == LENGTH_EXT8))
674 {
525 WANT (9); 675 WANT (8);
526 dec->cur += 9; 676 dec->cur += 8;
677
678 return
679#if UVSIZE < 8
680 0
681#else
527 return (((UV)dec->cur[-8]) << 56) 682 (((UV)dec->cur[-8]) << 56)
528 | (((UV)dec->cur[-7]) << 48) 683 | (((UV)dec->cur[-7]) << 48)
529 | (((UV)dec->cur[-6]) << 40) 684 | (((UV)dec->cur[-6]) << 40)
530 | (((UV)dec->cur[-5]) << 32) 685 | (((UV)dec->cur[-5]) << 32)
686#endif
531 | (((UV)dec->cur[-4]) << 24) 687 | (((UV)dec->cur[-4]) << 24)
532 | (((UV)dec->cur[-3]) << 16) 688 | (((UV)dec->cur[-3]) << 16)
533 | (((UV)dec->cur[-2]) << 8) 689 | (((UV)dec->cur[-2]) << 8)
534 | ((UV)dec->cur[-1]); 690 | ((UV)dec->cur[-1]);
535 691 }
536 default: 692 else
537 ERR ("corrupted CBOR data (unsupported integer minor encoding)"); 693 ERR ("corrupted CBOR data (unsupported integer minor encoding)");
538 }
539 694
540fail: 695fail:
541 return 0; 696 return 0;
542} 697}
543 698
… …
548{ 703{
549 AV *av = newAV (); 704 AV *av = newAV ();
550 705
551 DEC_INC_DEPTH; 706 DEC_INC_DEPTH;
552 707
553 if ((*dec->cur & 31) == 31) 708 if (*dec->cur == (MAJOR_ARRAY | MINOR_INDEF))
554 { 709 {
555 ++dec->cur; 710 ++dec->cur;
556 711
557 for (;;) 712 for (;;)
558 { 713 {
559 WANT (1); 714 WANT (1);
560 715
561 if (*dec->cur == (0xe0 | 31)) 716 if (*dec->cur == (MAJOR_MISC | MINOR_INDEF))
562 { 717 {
563 ++dec->cur; 718 ++dec->cur;
564 break; 719 break;
565 } 720 }
566 721
… …
569 } 724 }
570 else 725 else
571 { 726 {
572 int i, len = decode_uint (dec); 727 int i, len = decode_uint (dec);
573 728
729 WANT (len); // complexity check for av_fill - need at least one byte per value, do not allow supersize arrays
574 av_fill (av, len - 1); 730 av_fill (av, len - 1);
575 731
576 for (i = 0; i < len; ++i) 732 for (i = 0; i < len; ++i)
577 AvARRAY (av)[i] = decode_sv (dec); 733 AvARRAY (av)[i] = decode_sv (dec);
578 } 734 }
… …
588 744
589static void 745static void
590decode_he (dec_t *dec, HV *hv) 746decode_he (dec_t *dec, HV *hv)
591{ 747{
592 // for speed reasons, we specialcase single-string 748 // for speed reasons, we specialcase single-string
593 // byte or utf-8 strings as keys. 749 // byte or utf-8 strings as keys, but only when !stringref
594 750
595 if (*dec->cur >= 0x40 && *dec->cur <= 0x40 + 27) 751 if (ecb_expect_true (!dec->stringref))
752 if (ecb_expect_true ((U8)(*dec->cur - MAJOR_BYTES) <= LENGTH_EXT8))
596 { 753 {
597 I32 len = decode_uint (dec); 754 I32 len = decode_uint (dec);
598 char *key = (char *)dec->cur; 755 char *key = (char *)dec->cur;
599 756
757 WANT (len);
600 dec->cur += len; 758 dec->cur += len;
601 759
602 hv_store (hv, key, len, decode_sv (dec), 0); 760 hv_store (hv, key, len, decode_sv (dec), 0);
761
762 return;
603 } 763 }
604 else if (*dec->cur >= 0x60 && *dec->cur <= 0x60 + 27) 764 else if (ecb_expect_true ((U8)(*dec->cur - MAJOR_TEXT) <= LENGTH_EXT8))
605 { 765 {
606 I32 len = decode_uint (dec); 766 I32 len = decode_uint (dec);
607 char *key = (char *)dec->cur; 767 char *key = (char *)dec->cur;
608 768
769 WANT (len);
609 dec->cur += len; 770 dec->cur += len;
610 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
611 hv_store (hv, key, -len, decode_sv (dec), 0); 776 hv_store (hv, key, -len, decode_sv (dec), 0);
777
778 return;
612 } 779 }
613 else 780
614 {
615 SV *k = decode_sv (dec); 781 SV *k = decode_sv (dec);
616 SV *v = decode_sv (dec); 782 SV *v = decode_sv (dec);
617 783
618 hv_store_ent (hv, k, v, 0); 784 hv_store_ent (hv, k, v, 0);
619 SvREFCNT_dec (k); 785 SvREFCNT_dec (k);
620 } 786
787fail:
788 ;
621} 789}
622 790
623static SV * 791static SV *
624decode_hv (dec_t *dec) 792decode_hv (dec_t *dec)
625{ 793{
626 HV *hv = newHV (); 794 HV *hv = newHV ();
627 795
628 DEC_INC_DEPTH; 796 DEC_INC_DEPTH;
629 797
630 if ((*dec->cur & 31) == 31) 798 if (*dec->cur == (MAJOR_MAP | MINOR_INDEF))
631 { 799 {
632 ++dec->cur; 800 ++dec->cur;
633 801
634 for (;;) 802 for (;;)
635 { 803 {
636 WANT (1); 804 WANT (1);
637 805
638 if (*dec->cur == (0xe0 | 31)) 806 if (*dec->cur == (MAJOR_MISC | MINOR_INDEF))
639 { 807 {
640 ++dec->cur; 808 ++dec->cur;
641 break; 809 break;
642 } 810 }
643 811
… …
664static SV * 832static SV *
665decode_str (dec_t *dec, int utf8) 833decode_str (dec_t *dec, int utf8)
666{ 834{
667 SV *sv = 0; 835 SV *sv = 0;
668 836
669 if ((*dec->cur & 31) == 31) 837 if ((*dec->cur & MINOR_MASK) == MINOR_INDEF)
670 { 838 {
839 // indefinite length strings
671 ++dec->cur; 840 ++dec->cur;
672 841
842 U8 major = *dec->cur & MAJOR_MISC;
843
673 sv = newSVpvn ("", 0); 844 sv = newSVpvn ("", 0);
674 845
675 // not very fast, and certainly not robust against illegal input
676 for (;;) 846 for (;;)
677 { 847 {
678 WANT (1); 848 WANT (1);
679 849
680 if (*dec->cur == (0xe0 | 31)) 850 if ((*dec->cur - major) > LENGTH_EXT8)
851 if (*dec->cur == (MAJOR_MISC | MINOR_INDEF))
681 { 852 {
682 ++dec->cur; 853 ++dec->cur;
683 break; 854 break;
684 } 855 }
856 else
857 ERR ("corrupted CBOR data (invalid chunks in indefinite length string)");
685 858
686 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;
687 } 864 }
688 } 865 }
689 else 866 else
690 { 867 {
691 STRLEN len = decode_uint (dec); 868 STRLEN len = decode_uint (dec);
692 869
693 WANT (len); 870 WANT (len);
694 sv = newSVpvn (dec->cur, len); 871 sv = newSVpvn (dec->cur, len);
695 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));
696 } 877 }
697 878
698 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
699 SvUTF8_on (sv); 885 SvUTF8_on (sv);
886 }
700 887
701 return sv; 888 return sv;
702 889
703fail: 890fail:
704 SvREFCNT_dec (sv); 891 SvREFCNT_dec (sv);
… …
706} 893}
707 894
708static SV * 895static SV *
709decode_tagged (dec_t *dec) 896decode_tagged (dec_t *dec)
710{ 897{
898 SV *sv = 0;
711 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:
712 SV *sv = decode_sv (dec); 906 sv = decode_sv (dec);
907 break;
713 908
714 if (tag == CBOR_TAG_MAGIC) 909 case CBOR_TAG_INDIRECTION:
715 return sv; 910 sv = newRV_noinc (decode_sv (dec));
716 else if (tag == CBOR_TAG_PERL_OBJECT) 911 break;
717 {
718 if (!SvROK (sv) || SvTYPE (SvRV (sv)) != SVt_PVAV)
719 ERR ("corrupted CBOR data (non-array perl object)");
720 912
721 AV *av = (AV *)SvRV (sv); 913 case CBOR_TAG_STRINGREF_NAMESPACE:
722 int len = av_len (av) + 1;
723 HV *stash = gv_stashsv (*av_fetch (av, 0, 1), 0);
724
725 if (!stash)
726 ERR ("cannot decode perl-object (package does not exist)");
727
728 GV *method = gv_fetchmethod_autoload (stash, "THAW", 0);
729 914 {
730 if (!method) 915 ENTER; SAVETMPS;
731 ERR ("cannot decode perl-object (package does not have a THAW method)");
732
733 dSP;
734 916
735 ENTER; SAVETMPS; PUSHMARK (SP); 917 SAVESPTR (dec->stringref);
736 EXTEND (SP, len + 1); 918 dec->stringref = (AV *)sv_2mortal ((SV *)newAV ());
737 // we re-bless the reference to get overload and other niceties right
738 PUSHs (*av_fetch (av, 0, 1));
739 PUSHs (sv_cbor);
740 919
741 int i; 920 sv = decode_sv (dec);
742 921
743 for (i = 1; i < len; ++i)
744 PUSHs (*av_fetch (av, i, 1));
745
746 PUTBACK;
747 call_sv ((SV *)GvCV (method), G_SCALAR | G_EVAL);
748 SPAGAIN;
749
750 if (SvTRUE (ERRSV))
751 {
752 FREETMPS; LEAVE; 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
985 if (!SvROK (sv) || SvTYPE (SvRV (sv)) != SVt_PVAV)
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;
753 ERR (SvPVutf8_nolen (sv_2mortal (SvREFCNT_inc (ERRSV)))); 1021 ERR (SvPVutf8_nolen (sv_2mortal (SvREFCNT_inc (ERRSV))));
754 } 1022 }
755 1023
756 SvREFCNT_dec (sv); 1024 SvREFCNT_dec (sv);
757 sv = SvREFCNT_inc (POPs); 1025 sv = SvREFCNT_inc (POPs);
758 1026
759 PUTBACK; 1027 PUTBACK;
760 1028
761 FREETMPS; LEAVE; 1029 FREETMPS; LEAVE;
1030 }
1031 break;
762 1032
763 return sv; 1033 default:
764 } 1034 {
765 else 1035 sv = decode_sv (dec);
766 { 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 {
767 AV *av = newAV (); 1062 AV *av = newAV ();
768 av_push (av, newSVuv (tag)); 1063 av_push (av, newSVuv (tag));
769 av_push (av, sv); 1064 av_push (av, sv);
770 1065
771 HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash 1066 HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash
772 ? cbor_tagged_stash 1067 ? cbor_tagged_stash
773 : gv_stashpv ("CBOR::XS::Tagged" , 1); 1068 : gv_stashpv ("CBOR::XS::Tagged" , 1);
774
775 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;
776 } 1077 }
1078
1079 return sv;
777 1080
778fail: 1081fail:
779 SvREFCNT_dec (sv); 1082 SvREFCNT_dec (sv);
780 return &PL_sv_undef; 1083 return &PL_sv_undef;
781} 1084}
… …
783static SV * 1086static SV *
784decode_sv (dec_t *dec) 1087decode_sv (dec_t *dec)
785{ 1088{
786 WANT (1); 1089 WANT (1);
787 1090
788 switch (*dec->cur >> 5) 1091 switch (*dec->cur >> MAJOR_SHIFT)
789 { 1092 {
790 case 0: // unsigned int 1093 case MAJOR_POS_INT >> MAJOR_SHIFT: return newSVuv (decode_uint (dec));
791 return newSVuv (decode_uint (dec)); 1094 case MAJOR_NEG_INT >> MAJOR_SHIFT: return newSViv (-1 - (IV)decode_uint (dec));
792 case 1: // negative int 1095 case MAJOR_BYTES >> MAJOR_SHIFT: return decode_str (dec, 0);
793 return newSViv (-1 - (IV)decode_uint (dec)); 1096 case MAJOR_TEXT >> MAJOR_SHIFT: return decode_str (dec, 1);
794 case 2: // octet string 1097 case MAJOR_ARRAY >> MAJOR_SHIFT: return decode_av (dec);
795 return decode_str (dec, 0); 1098 case MAJOR_MAP >> MAJOR_SHIFT: return decode_hv (dec);
796 case 3: // utf-8 string 1099 case MAJOR_TAG >> MAJOR_SHIFT: return decode_tagged (dec);
797 return decode_str (dec, 1); 1100
798 case 4: // array 1101 case MAJOR_MISC >> MAJOR_SHIFT:
799 return decode_av (dec);
800 case 5: // map
801 return decode_hv (dec);
802 case 6: // tag
803 return decode_tagged (dec);
804 case 7: // misc
805 switch (*dec->cur++ & 31) 1102 switch (*dec->cur++ & MINOR_MASK)
806 { 1103 {
807 case 20: 1104 case SIMPLE_FALSE:
808#if CBOR_SLOW 1105#if CBOR_SLOW
809 types_false = get_bool ("Types::Serialiser::false"); 1106 types_false = get_bool ("Types::Serialiser::false");
810#endif 1107#endif
811 return newSVsv (types_false); 1108 return newSVsv (types_false);
812 case 21: 1109 case SIMPLE_TRUE:
813#if CBOR_SLOW 1110#if CBOR_SLOW
814 types_true = get_bool ("Types::Serialiser::true"); 1111 types_true = get_bool ("Types::Serialiser::true");
815#endif 1112#endif
816 return newSVsv (types_true); 1113 return newSVsv (types_true);
817 case 22: 1114 case SIMPLE_NULL:
818 return newSVsv (&PL_sv_undef); 1115 return newSVsv (&PL_sv_undef);
819 case 23: 1116 case SIMPLE_UNDEF:
820#if CBOR_SLOW 1117#if CBOR_SLOW
821 types_error = get_bool ("Types::Serialiser::error"); 1118 types_error = get_bool ("Types::Serialiser::error");
822#endif 1119#endif
823 return newSVsv (types_error); 1120 return newSVsv (types_error);
824 1121
825 case 25: 1122 case MISC_FLOAT16:
826 { 1123 {
827 WANT (2); 1124 WANT (2);
828 1125
829 uint16_t fp = (dec->cur[0] << 8) | dec->cur[1]; 1126 uint16_t fp = (dec->cur[0] << 8) | dec->cur[1];
830 dec->cur += 2; 1127 dec->cur += 2;
831 1128
832 return newSVnv (ecb_binary16_to_float (fp)); 1129 return newSVnv (ecb_binary16_to_float (fp));
833 } 1130 }
834 1131
835 case 26: 1132 case MISC_FLOAT32:
836 { 1133 {
837 uint32_t fp; 1134 uint32_t fp;
838 WANT (4); 1135 WANT (4);
839 memcpy (&fp, dec->cur, 4); 1136 memcpy (&fp, dec->cur, 4);
840 dec->cur += 4; 1137 dec->cur += 4;
… …
843 fp = ecb_bswap32 (fp); 1140 fp = ecb_bswap32 (fp);
844 1141
845 return newSVnv (ecb_binary32_to_float (fp)); 1142 return newSVnv (ecb_binary32_to_float (fp));
846 } 1143 }
847 1144
848 case 27: 1145 case MISC_FLOAT64:
849 { 1146 {
850 uint64_t fp; 1147 uint64_t fp;
851 WANT (8); 1148 WANT (8);
852 memcpy (&fp, dec->cur, 8); 1149 memcpy (&fp, dec->cur, 8);
853 dec->cur += 8; 1150 dec->cur += 8;
… …
856 fp = ecb_bswap64 (fp); 1153 fp = ecb_bswap64 (fp);
857 1154
858 return newSVnv (ecb_binary64_to_double (fp)); 1155 return newSVnv (ecb_binary64_to_double (fp));
859 } 1156 }
860 1157
861 // 0..19 unassigned 1158 // 0..19 unassigned simple
862 // 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
863 default: 1162 default:
864 ERR ("corrupted CBOR data (reserved/unassigned major 7 value)"); 1163 ERR ("corrupted CBOR data (reserved/unassigned/unexpected major 7 value)");
865 } 1164 }
866 1165
867 break; 1166 break;
868 } 1167 }
869 1168
… …
872} 1171}
873 1172
874static SV * 1173static SV *
875decode_cbor (SV *string, CBOR *cbor, char **offset_return) 1174decode_cbor (SV *string, CBOR *cbor, char **offset_return)
876{ 1175{
877 dec_t dec; 1176 dec_t dec = { 0 };
878 SV *sv; 1177 SV *sv;
879 STRLEN len; 1178 STRLEN len;
880 char *data = SvPVbyte (string, len); 1179 char *data = SvPVbyte (string, len);
881 1180
882 if (len > cbor->max_size && cbor->max_size) 1181 if (len > cbor->max_size && cbor->max_size)
… …
884 (unsigned long)len, (unsigned long)cbor->max_size); 1183 (unsigned long)len, (unsigned long)cbor->max_size);
885 1184
886 dec.cbor = *cbor; 1185 dec.cbor = *cbor;
887 dec.cur = (U8 *)data; 1186 dec.cur = (U8 *)data;
888 dec.end = (U8 *)data + len; 1187 dec.end = (U8 *)data + len;
889 dec.err = 0;
890 dec.depth = 0;
891 1188
892 sv = decode_sv (&dec); 1189 sv = decode_sv (&dec);
893 1190
894 if (offset_return) 1191 if (offset_return)
895 *offset_return = dec.cur; 1192 *offset_return = dec.cur;
… …
898 if (dec.cur != dec.end && !dec.err) 1195 if (dec.cur != dec.end && !dec.err)
899 dec.err = "garbage after CBOR object"; 1196 dec.err = "garbage after CBOR object";
900 1197
901 if (dec.err) 1198 if (dec.err)
902 { 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
903 SvREFCNT_dec (sv); 1211 SvREFCNT_dec (sv);
904 croak ("%s, at offset %d (octet 0x%02x)", dec.err, dec.cur - (U8 *)data, (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);
905 } 1213 }
906 1214
907 sv = sv_2mortal (sv); 1215 sv = sv_2mortal (sv);
908 1216
909 return sv; 1217 return sv;
910} 1218}
911 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
912///////////////////////////////////////////////////////////////////////////// 1344/////////////////////////////////////////////////////////////////////////////
913// XS interface functions 1345// XS interface functions
914 1346
915MODULE = CBOR::XS PACKAGE = CBOR::XS 1347MODULE = CBOR::XS PACKAGE = CBOR::XS
916 1348
… …
923 types_error_stash = gv_stashpv ("Types::Serialiser::Error" , 1); 1355 types_error_stash = gv_stashpv ("Types::Serialiser::Error" , 1);
924 1356
925 types_true = get_bool ("Types::Serialiser::true" ); 1357 types_true = get_bool ("Types::Serialiser::true" );
926 types_false = get_bool ("Types::Serialiser::false"); 1358 types_false = get_bool ("Types::Serialiser::false");
927 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);
928 1362
929 sv_cbor = newSVpv ("CBOR", 0); 1363 sv_cbor = newSVpv ("CBOR", 0);
930 SvREADONLY_on (sv_cbor); 1364 SvREADONLY_on (sv_cbor);
931} 1365}
932 1366
… …
953 1387
954void shrink (CBOR *self, int enable = 1) 1388void shrink (CBOR *self, int enable = 1)
955 ALIAS: 1389 ALIAS:
956 shrink = F_SHRINK 1390 shrink = F_SHRINK
957 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
958 PPCODE: 1396 PPCODE:
959{ 1397{
960 if (enable) 1398 if (enable)
961 self->flags |= ix; 1399 self->flags |= ix;
962 else 1400 else
… …
967 1405
968void get_shrink (CBOR *self) 1406void get_shrink (CBOR *self)
969 ALIAS: 1407 ALIAS:
970 get_shrink = F_SHRINK 1408 get_shrink = F_SHRINK
971 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
972 PPCODE: 1414 PPCODE:
973 XPUSHs (boolSV (self->flags & ix)); 1415 XPUSHs (boolSV (self->flags & ix));
974 1416
975void max_depth (CBOR *self, U32 max_depth = 0x80000000UL) 1417void max_depth (CBOR *self, U32 max_depth = 0x80000000UL)
976 PPCODE: 1418 PPCODE:
… …
989 XPUSHs (ST (0)); 1431 XPUSHs (ST (0));
990 1432
991int get_max_size (CBOR *self) 1433int get_max_size (CBOR *self)
992 CODE: 1434 CODE:
993 RETVAL = self->max_size; 1435 RETVAL = self->max_size;
1436 OUTPUT:
1437 RETVAL
1438
1439void filter (CBOR *self, SV *filter = 0)
1440 PPCODE:
1441 SvREFCNT_dec (self->filter);
1442 self->filter = filter ? newSVsv (filter) : filter;
1443 XPUSHs (ST (0));
1444
1445SV *get_filter (CBOR *self)
1446 CODE:
1447 RETVAL = self->filter ? self->filter : NEWSV (0, 0);
994 OUTPUT: 1448 OUTPUT:
995 RETVAL 1449 RETVAL
996 1450
997void encode (CBOR *self, SV *scalar) 1451void encode (CBOR *self, SV *scalar)
998 PPCODE: 1452 PPCODE:
… …
1013 EXTEND (SP, 2); 1467 EXTEND (SP, 2);
1014 PUSHs (sv); 1468 PUSHs (sv);
1015 PUSHs (sv_2mortal (newSVuv (offset - SvPVX (cborstr)))); 1469 PUSHs (sv_2mortal (newSVuv (offset - SvPVX (cborstr))));
1016} 1470}
1017 1471
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}
1523
1524void DESTROY (CBOR *self)
1525 PPCODE:
1526 cbor_free (self);
1527
1018PROTOTYPES: ENABLE 1528PROTOTYPES: ENABLE
1019 1529
1020void encode_cbor (SV *scalar) 1530void encode_cbor (SV *scalar)
1531 ALIAS:
1532 encode_cbor = 0
1533 encode_cbor_sharing = F_ALLOW_SHARING
1021 PPCODE: 1534 PPCODE:
1022{ 1535{
1023 CBOR cbor; 1536 CBOR cbor;
1024 cbor_init (&cbor); 1537 cbor_init (&cbor);
1538 cbor.flags |= ix;
1025 PUTBACK; scalar = encode_cbor (scalar, &cbor); SPAGAIN; 1539 PUTBACK; scalar = encode_cbor (scalar, &cbor); SPAGAIN;
1026 XPUSHs (scalar); 1540 XPUSHs (scalar);
1027} 1541}
1028 1542
1029void decode_cbor (SV *cborstr) 1543void decode_cbor (SV *cborstr)

Diff Legend

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