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.16 by root, Tue Oct 29 20:59:16 2013 UTC vs.
Revision 1.49 by root, Mon Feb 8 04:11:11 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; PUSHMARK (SP);
305 // we re-bless the reference to get overload and other niceties right 455 // we re-bless the reference to get overload and other niceties right
… …
336 486
337 // catch this surprisingly common error 487 // catch this surprisingly common error
338 if (count == 1 && SvROK (TOPs) && SvRV (TOPs) == sv) 488 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)); 489 croak ("%s::FREEZE(CBOR) method returned same object as was passed instead of a new one", HvNAME (stash));
340 490
341 encode_uint (enc, 0xc0, CBOR_TAG_PERL_OBJECT); 491 encode_tag (enc, CBOR_TAG_PERL_OBJECT);
342 encode_uint (enc, 0x80, count + 1); 492 encode_uint (enc, MAJOR_ARRAY, count + 1);
343 encode_str (enc, HvNAMEUTF8 (stash), HvNAME (stash), HvNAMELEN (stash)); 493 encode_strref (enc, HvNAMEUTF8 (stash), HvNAME (stash), HvNAMELEN (stash));
344 494
345 while (count) 495 while (count)
346 encode_sv (enc, SP[1 - count--]); 496 encode_sv (enc, SP[1 - count--]);
347 497
348 PUTBACK; 498 PUTBACK;
… …
355 } 505 }
356 else if (svt == SVt_PVHV) 506 else if (svt == SVt_PVHV)
357 encode_hv (enc, (HV *)sv); 507 encode_hv (enc, (HV *)sv);
358 else if (svt == SVt_PVAV) 508 else if (svt == SVt_PVAV)
359 encode_av (enc, (AV *)sv); 509 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 510 else
378 croak ("encountered %s, but CBOR can only represent references to arrays or hashes", 511 {
379 SvPV_nolen (sv_2mortal (newRV_inc (sv)))); 512 encode_tag (enc, CBOR_TAG_INDIRECTION);
513 encode_sv (enc, sv);
514 }
380} 515}
381 516
382static void 517static void
383encode_nv (enc_t *enc, SV *sv) 518encode_nv (enc_t *enc, SV *sv)
384{ 519{
385 double nv = SvNVX (sv); 520 double nv = SvNVX (sv);
386 521
387 need (enc, 9); 522 need (enc, 9);
388 523
389 if (ecb_expect_false (nv == (U32)nv)) 524 if (ecb_expect_false (nv == (NV)(U32)nv))
390 encode_uint (enc, 0x00, (U32)nv); 525 encode_uint (enc, MAJOR_POS_INT, (U32)nv);
391 //TODO: maybe I32? 526 //TODO: maybe I32?
392 else if (ecb_expect_false (nv == (float)nv)) 527 else if (ecb_expect_false (nv == (float)nv))
393 { 528 {
394 uint32_t fp = ecb_float_to_binary32 (nv); 529 uint32_t fp = ecb_float_to_binary32 (nv);
395 530
396 *enc->cur++ = 0xe0 | 26; 531 *enc->cur++ = MAJOR_MISC | MISC_FLOAT32;
397 532
398 if (!ecb_big_endian ()) 533 if (!ecb_big_endian ())
399 fp = ecb_bswap32 (fp); 534 fp = ecb_bswap32 (fp);
400 535
401 memcpy (enc->cur, &fp, 4); 536 memcpy (enc->cur, &fp, 4);
… …
403 } 538 }
404 else 539 else
405 { 540 {
406 uint64_t fp = ecb_double_to_binary64 (nv); 541 uint64_t fp = ecb_double_to_binary64 (nv);
407 542
408 *enc->cur++ = 0xe0 | 27; 543 *enc->cur++ = MAJOR_MISC | MISC_FLOAT64;
409 544
410 if (!ecb_big_endian ()) 545 if (!ecb_big_endian ())
411 fp = ecb_bswap64 (fp); 546 fp = ecb_bswap64 (fp);
412 547
413 memcpy (enc->cur, &fp, 8); 548 memcpy (enc->cur, &fp, 8);
… …
422 557
423 if (SvPOKp (sv)) 558 if (SvPOKp (sv))
424 { 559 {
425 STRLEN len; 560 STRLEN len;
426 char *str = SvPV (sv, len); 561 char *str = SvPV (sv, len);
427 encode_str (enc, SvUTF8 (sv), str, len); 562 encode_strref (enc, SvUTF8 (sv), str, len);
428 } 563 }
429 else if (SvNOKp (sv)) 564 else if (SvNOKp (sv))
430 encode_nv (enc, sv); 565 encode_nv (enc, sv);
431 else if (SvIOKp (sv)) 566 else if (SvIOKp (sv))
432 { 567 {
433 if (SvIsUV (sv)) 568 if (SvIsUV (sv))
434 encode_uint (enc, 0x00, SvUVX (sv)); 569 encode_uint (enc, MAJOR_POS_INT, SvUVX (sv));
435 else if (SvIVX (sv) >= 0) 570 else if (SvIVX (sv) >= 0)
436 encode_uint (enc, 0x00, SvIVX (sv)); 571 encode_uint (enc, MAJOR_POS_INT, SvIVX (sv));
437 else 572 else
438 encode_uint (enc, 0x20, -(SvIVX (sv) + 1)); 573 encode_uint (enc, MAJOR_NEG_INT, -(SvIVX (sv) + 1));
439 } 574 }
440 else if (SvROK (sv)) 575 else if (SvROK (sv))
441 encode_rv (enc, SvRV (sv)); 576 encode_rv (enc, SvRV (sv));
442 else if (!SvOK (sv)) 577 else if (!SvOK (sv))
443 encode_ch (enc, 0xe0 | 22); 578 encode_ch (enc, MAJOR_MISC | SIMPLE_NULL);
444 else if (enc->cbor.flags & F_ALLOW_UNKNOWN) 579 else if (enc->cbor.flags & F_ALLOW_UNKNOWN)
445 encode_ch (enc, 0xe0 | 23); 580 encode_ch (enc, MAJOR_MISC | SIMPLE_UNDEF);
446 else 581 else
447 croak ("encountered perl type (%s,0x%x) that CBOR cannot handle, check your input data", 582 croak ("encountered perl type (%s,0x%x) that CBOR cannot handle, check your input data",
448 SvPV_nolen (sv), (unsigned int)SvFLAGS (sv)); 583 SvPV_nolen (sv), (unsigned int)SvFLAGS (sv));
449} 584}
450 585
451static SV * 586static SV *
452encode_cbor (SV *scalar, CBOR *cbor) 587encode_cbor (SV *scalar, CBOR *cbor)
453{ 588{
454 enc_t enc; 589 enc_t enc = { 0 };
455 590
456 enc.cbor = *cbor; 591 enc.cbor = *cbor;
457 enc.sv = sv_2mortal (NEWSV (0, INIT_SIZE)); 592 enc.sv = sv_2mortal (NEWSV (0, INIT_SIZE));
458 enc.cur = SvPVX (enc.sv); 593 enc.cur = SvPVX (enc.sv);
459 enc.end = SvEND (enc.sv); 594 enc.end = SvEND (enc.sv);
460 enc.depth = 0;
461 595
462 SvPOK_only (enc.sv); 596 SvPOK_only (enc.sv);
597
598 if (cbor->flags & F_PACK_STRINGS)
599 {
600 encode_tag (&enc, CBOR_TAG_STRINGREF_NAMESPACE);
601 enc.stringref[0]= (HV *)sv_2mortal ((SV *)newHV ());
602 enc.stringref[1]= (HV *)sv_2mortal ((SV *)newHV ());
603 }
604
463 encode_sv (&enc, scalar); 605 encode_sv (&enc, scalar);
464 606
465 SvCUR_set (enc.sv, enc.cur - SvPVX (enc.sv)); 607 SvCUR_set (enc.sv, enc.cur - SvPVX (enc.sv));
466 *SvEND (enc.sv) = 0; // many xs functions expect a trailing 0 for text strings 608 *SvEND (enc.sv) = 0; // many xs functions expect a trailing 0 for text strings
467 609
… …
481 U8 *end; // end of input string 623 U8 *end; // end of input string
482 const char *err; // parse error, if != 0 624 const char *err; // parse error, if != 0
483 CBOR cbor; 625 CBOR cbor;
484 U32 depth; // recursion depth 626 U32 depth; // recursion depth
485 U32 maxdepth; // recursion depth limit 627 U32 maxdepth; // recursion depth limit
628 AV *shareable;
629 AV *stringref;
630 SV *decode_tagged;
486} dec_t; 631} dec_t;
487 632
488#define ERR(reason) SB if (!dec->err) dec->err = reason; goto fail; SE 633#define ERR(reason) SB if (!dec->err) dec->err = reason; goto fail; SE
489 634
490#define WANT(len) if (ecb_expect_false (dec->cur + len > dec->end)) ERR ("unexpected end of CBOR data") 635#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 638#define DEC_DEC_DEPTH --dec->depth
494 639
495static UV 640static UV
496decode_uint (dec_t *dec) 641decode_uint (dec_t *dec)
497{ 642{
498 switch (*dec->cur & 31) 643 U8 m = *dec->cur & MINOR_MASK;
499 { 644 ++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 645
505 case 24: 646 if (ecb_expect_true (m < LENGTH_EXT1))
647 return m;
648 else if (ecb_expect_true (m == LENGTH_EXT1))
649 {
506 WANT (2); 650 WANT (1);
507 dec->cur += 2; 651 dec->cur += 1;
508 return dec->cur[-1]; 652 return dec->cur[-1];
509 653 }
510 case 25: 654 else if (ecb_expect_true (m == LENGTH_EXT2))
655 {
511 WANT (3); 656 WANT (2);
512 dec->cur += 3; 657 dec->cur += 2;
513 return (((UV)dec->cur[-2]) << 8) 658 return (((UV)dec->cur[-2]) << 8)
514 | ((UV)dec->cur[-1]); 659 | ((UV)dec->cur[-1]);
515 660 }
516 case 26: 661 else if (ecb_expect_true (m == LENGTH_EXT4))
662 {
517 WANT (5); 663 WANT (4);
518 dec->cur += 5; 664 dec->cur += 4;
519 return (((UV)dec->cur[-4]) << 24) 665 return (((UV)dec->cur[-4]) << 24)
520 | (((UV)dec->cur[-3]) << 16) 666 | (((UV)dec->cur[-3]) << 16)
521 | (((UV)dec->cur[-2]) << 8) 667 | (((UV)dec->cur[-2]) << 8)
522 | ((UV)dec->cur[-1]); 668 | ((UV)dec->cur[-1]);
523 669 }
524 case 27: 670 else if (ecb_expect_true (m == LENGTH_EXT8))
671 {
525 WANT (9); 672 WANT (8);
526 dec->cur += 9; 673 dec->cur += 8;
674
675 return
676#if UVSIZE < 8
677 0
678#else
527 return (((UV)dec->cur[-8]) << 56) 679 (((UV)dec->cur[-8]) << 56)
528 | (((UV)dec->cur[-7]) << 48) 680 | (((UV)dec->cur[-7]) << 48)
529 | (((UV)dec->cur[-6]) << 40) 681 | (((UV)dec->cur[-6]) << 40)
530 | (((UV)dec->cur[-5]) << 32) 682 | (((UV)dec->cur[-5]) << 32)
683#endif
531 | (((UV)dec->cur[-4]) << 24) 684 | (((UV)dec->cur[-4]) << 24)
532 | (((UV)dec->cur[-3]) << 16) 685 | (((UV)dec->cur[-3]) << 16)
533 | (((UV)dec->cur[-2]) << 8) 686 | (((UV)dec->cur[-2]) << 8)
534 | ((UV)dec->cur[-1]); 687 | ((UV)dec->cur[-1]);
535 688 }
536 default: 689 else
537 ERR ("corrupted CBOR data (unsupported integer minor encoding)"); 690 ERR ("corrupted CBOR data (unsupported integer minor encoding)");
538 }
539 691
540fail: 692fail:
541 return 0; 693 return 0;
542} 694}
543 695
… …
548{ 700{
549 AV *av = newAV (); 701 AV *av = newAV ();
550 702
551 DEC_INC_DEPTH; 703 DEC_INC_DEPTH;
552 704
553 if ((*dec->cur & 31) == 31) 705 if (*dec->cur == (MAJOR_ARRAY | MINOR_INDEF))
554 { 706 {
555 ++dec->cur; 707 ++dec->cur;
556 708
557 for (;;) 709 for (;;)
558 { 710 {
559 WANT (1); 711 WANT (1);
560 712
561 if (*dec->cur == (0xe0 | 31)) 713 if (*dec->cur == (MAJOR_MISC | MINOR_INDEF))
562 { 714 {
563 ++dec->cur; 715 ++dec->cur;
564 break; 716 break;
565 } 717 }
566 718
… …
569 } 721 }
570 else 722 else
571 { 723 {
572 int i, len = decode_uint (dec); 724 int i, len = decode_uint (dec);
573 725
726 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); 727 av_fill (av, len - 1);
575 728
576 for (i = 0; i < len; ++i) 729 for (i = 0; i < len; ++i)
577 AvARRAY (av)[i] = decode_sv (dec); 730 AvARRAY (av)[i] = decode_sv (dec);
578 } 731 }
… …
588 741
589static void 742static void
590decode_he (dec_t *dec, HV *hv) 743decode_he (dec_t *dec, HV *hv)
591{ 744{
592 // for speed reasons, we specialcase single-string 745 // for speed reasons, we specialcase single-string
593 // byte or utf-8 strings as keys. 746 // byte or utf-8 strings as keys, but only when !stringref
594 747
595 if (*dec->cur >= 0x40 && *dec->cur <= 0x40 + 27) 748 if (ecb_expect_true (!dec->stringref))
749 if (ecb_expect_true ((U8)(*dec->cur - MAJOR_BYTES) <= LENGTH_EXT8))
596 { 750 {
597 I32 len = decode_uint (dec); 751 I32 len = decode_uint (dec);
598 char *key = (char *)dec->cur; 752 char *key = (char *)dec->cur;
599 753
754 WANT (len);
600 dec->cur += len; 755 dec->cur += len;
601 756
602 hv_store (hv, key, len, decode_sv (dec), 0); 757 hv_store (hv, key, len, decode_sv (dec), 0);
758
759 return;
603 } 760 }
604 else if (*dec->cur >= 0x60 && *dec->cur <= 0x60 + 27) 761 else if (ecb_expect_true ((U8)(*dec->cur - MAJOR_TEXT) <= LENGTH_EXT8))
605 { 762 {
606 I32 len = decode_uint (dec); 763 I32 len = decode_uint (dec);
607 char *key = (char *)dec->cur; 764 char *key = (char *)dec->cur;
608 765
766 WANT (len);
609 dec->cur += len; 767 dec->cur += len;
610 768
769 if (ecb_expect_false (dec->cbor.flags & F_VALIDATE_UTF8))
770 if (!is_utf8_string (key, len))
771 ERR ("corrupted CBOR data (invalid UTF-8 in map key)");
772
611 hv_store (hv, key, -len, decode_sv (dec), 0); 773 hv_store (hv, key, -len, decode_sv (dec), 0);
774
775 return;
612 } 776 }
613 else 777
614 {
615 SV *k = decode_sv (dec); 778 SV *k = decode_sv (dec);
616 SV *v = decode_sv (dec); 779 SV *v = decode_sv (dec);
617 780
618 hv_store_ent (hv, k, v, 0); 781 hv_store_ent (hv, k, v, 0);
619 SvREFCNT_dec (k); 782 SvREFCNT_dec (k);
620 } 783
784fail:
785 ;
621} 786}
622 787
623static SV * 788static SV *
624decode_hv (dec_t *dec) 789decode_hv (dec_t *dec)
625{ 790{
626 HV *hv = newHV (); 791 HV *hv = newHV ();
627 792
628 DEC_INC_DEPTH; 793 DEC_INC_DEPTH;
629 794
630 if ((*dec->cur & 31) == 31) 795 if (*dec->cur == (MAJOR_MAP | MINOR_INDEF))
631 { 796 {
632 ++dec->cur; 797 ++dec->cur;
633 798
634 for (;;) 799 for (;;)
635 { 800 {
636 WANT (1); 801 WANT (1);
637 802
638 if (*dec->cur == (0xe0 | 31)) 803 if (*dec->cur == (MAJOR_MISC | MINOR_INDEF))
639 { 804 {
640 ++dec->cur; 805 ++dec->cur;
641 break; 806 break;
642 } 807 }
643 808
… …
664static SV * 829static SV *
665decode_str (dec_t *dec, int utf8) 830decode_str (dec_t *dec, int utf8)
666{ 831{
667 SV *sv = 0; 832 SV *sv = 0;
668 833
669 if ((*dec->cur & 31) == 31) 834 if ((*dec->cur & MINOR_MASK) == MINOR_INDEF)
670 { 835 {
836 // indefinite length strings
671 ++dec->cur; 837 ++dec->cur;
672 838
839 U8 major = *dec->cur & MAJOR_MISC;
840
673 sv = newSVpvn ("", 0); 841 sv = newSVpvn ("", 0);
674 842
675 // not very fast, and certainly not robust against illegal input
676 for (;;) 843 for (;;)
677 { 844 {
678 WANT (1); 845 WANT (1);
679 846
680 if (*dec->cur == (0xe0 | 31)) 847 if ((*dec->cur - major) > LENGTH_EXT8)
848 if (*dec->cur == (MAJOR_MISC | MINOR_INDEF))
681 { 849 {
682 ++dec->cur; 850 ++dec->cur;
683 break; 851 break;
684 } 852 }
853 else
854 ERR ("corrupted CBOR data (invalid chunks in indefinite length string)");
685 855
686 sv_catsv (sv, decode_sv (dec)); 856 STRLEN len = decode_uint (dec);
857
858 WANT (len);
859 sv_catpvn (sv, dec->cur, len);
860 dec->cur += len;
687 } 861 }
688 } 862 }
689 else 863 else
690 { 864 {
691 STRLEN len = decode_uint (dec); 865 STRLEN len = decode_uint (dec);
692 866
693 WANT (len); 867 WANT (len);
694 sv = newSVpvn (dec->cur, len); 868 sv = newSVpvn (dec->cur, len);
695 dec->cur += len; 869 dec->cur += len;
870
871 if (ecb_expect_false (dec->stringref)
872 && SvCUR (sv) >= minimum_string_length (AvFILLp (dec->stringref) + 1))
873 av_push (dec->stringref, SvREFCNT_inc_NN (sv));
696 } 874 }
697 875
698 if (utf8) 876 if (utf8)
877 {
878 if (ecb_expect_false (dec->cbor.flags & F_VALIDATE_UTF8))
879 if (!is_utf8_string (SvPVX (sv), SvCUR (sv)))
880 ERR ("corrupted CBOR data (invalid UTF-8 in text string)");
881
699 SvUTF8_on (sv); 882 SvUTF8_on (sv);
883 }
700 884
701 return sv; 885 return sv;
702 886
703fail: 887fail:
704 SvREFCNT_dec (sv); 888 SvREFCNT_dec (sv);
… …
706} 890}
707 891
708static SV * 892static SV *
709decode_tagged (dec_t *dec) 893decode_tagged (dec_t *dec)
710{ 894{
895 SV *sv = 0;
711 UV tag = decode_uint (dec); 896 UV tag = decode_uint (dec);
897
898 WANT (1);
899
900 switch (tag)
901 {
902 case CBOR_TAG_MAGIC:
712 SV *sv = decode_sv (dec); 903 sv = decode_sv (dec);
904 break;
713 905
714 if (tag == CBOR_TAG_MAGIC) 906 case CBOR_TAG_INDIRECTION:
715 return sv; 907 sv = newRV_noinc (decode_sv (dec));
716 else if (tag == CBOR_TAG_PERL_OBJECT) 908 break;
717 { 909
910 case CBOR_TAG_STRINGREF_NAMESPACE:
911 {
912 ENTER; SAVETMPS;
913
914 SAVESPTR (dec->stringref);
915 dec->stringref = (AV *)sv_2mortal ((SV *)newAV ());
916
917 sv = decode_sv (dec);
918
919 FREETMPS; LEAVE;
920 }
921 break;
922
923 case CBOR_TAG_STRINGREF:
924 {
925 if ((*dec->cur >> MAJOR_SHIFT) != (MAJOR_POS_INT >> MAJOR_SHIFT))
926 ERR ("corrupted CBOR data (stringref index not an unsigned integer)");
927
928 UV idx = decode_uint (dec);
929
930 if (!dec->stringref || (int)idx > AvFILLp (dec->stringref))
931 ERR ("corrupted CBOR data (stringref index out of bounds or outside namespace)");
932
933 sv = newSVsv (AvARRAY (dec->stringref)[idx]);
934 }
935 break;
936
937 case CBOR_TAG_VALUE_SHAREABLE:
938 {
939 if (ecb_expect_false (!dec->shareable))
940 dec->shareable = (AV *)sv_2mortal ((SV *)newAV ());
941
942 if (dec->cbor.flags & F_ALLOW_CYCLES)
943 {
944 sv = newSV (0);
945 av_push (dec->shareable, SvREFCNT_inc_NN (sv));
946
947 SV *osv = decode_sv (dec);
948 sv_setsv (sv, osv);
949 SvREFCNT_dec_NN (osv);
950 }
951 else
952 {
953 av_push (dec->shareable, &PL_sv_undef);
954 int idx = AvFILLp (dec->shareable);
955 sv = decode_sv (dec);
956 av_store (dec->shareable, idx, SvREFCNT_inc_NN (sv));
957 }
958 }
959 break;
960
961 case CBOR_TAG_VALUE_SHAREDREF:
962 {
963 if ((*dec->cur >> MAJOR_SHIFT) != (MAJOR_POS_INT >> MAJOR_SHIFT))
964 ERR ("corrupted CBOR data (sharedref index not an unsigned integer)");
965
966 UV idx = decode_uint (dec);
967
968 if (!dec->shareable || (int)idx > AvFILLp (dec->shareable))
969 ERR ("corrupted CBOR data (sharedref index out of bounds)");
970
971 sv = SvREFCNT_inc_NN (AvARRAY (dec->shareable)[idx]);
972
973 if (sv == &PL_sv_undef)
974 ERR ("cyclic CBOR data structure found, but allow_cycles is not enabled");
975 }
976 break;
977
978 case CBOR_TAG_PERL_OBJECT:
979 {
980 sv = decode_sv (dec);
981
718 if (!SvROK (sv) || SvTYPE (SvRV (sv)) != SVt_PVAV) 982 if (!SvROK (sv) || SvTYPE (SvRV (sv)) != SVt_PVAV)
719 ERR ("corrupted CBOR data (non-array perl object)"); 983 ERR ("corrupted CBOR data (non-array perl object)");
720 984
721 AV *av = (AV *)SvRV (sv); 985 AV *av = (AV *)SvRV (sv);
722 int len = av_len (av) + 1; 986 int len = av_len (av) + 1;
723 HV *stash = gv_stashsv (*av_fetch (av, 0, 1), 0); 987 HV *stash = gv_stashsv (*av_fetch (av, 0, 1), 0);
724 988
725 if (!stash) 989 if (!stash)
726 ERR ("cannot decode perl-object (package does not exist)"); 990 ERR ("cannot decode perl-object (package does not exist)");
727 991
728 GV *method = gv_fetchmethod_autoload (stash, "THAW", 0); 992 GV *method = gv_fetchmethod_autoload (stash, "THAW", 0);
729 993
730 if (!method) 994 if (!method)
731 ERR ("cannot decode perl-object (package does not have a THAW method)"); 995 ERR ("cannot decode perl-object (package does not have a THAW method)");
732 996
733 dSP; 997 dSP;
734 998
735 ENTER; SAVETMPS; PUSHMARK (SP); 999 ENTER; SAVETMPS; PUSHMARK (SP);
736 EXTEND (SP, len + 1); 1000 EXTEND (SP, len + 1);
737 // we re-bless the reference to get overload and other niceties right 1001 // we re-bless the reference to get overload and other niceties right
738 PUSHs (*av_fetch (av, 0, 1)); 1002 PUSHs (*av_fetch (av, 0, 1));
739 PUSHs (sv_cbor); 1003 PUSHs (sv_cbor);
740 1004
741 int i; 1005 int i;
742 1006
743 for (i = 1; i < len; ++i) 1007 for (i = 1; i < len; ++i)
744 PUSHs (*av_fetch (av, i, 1)); 1008 PUSHs (*av_fetch (av, i, 1));
745 1009
746 PUTBACK; 1010 PUTBACK;
747 call_sv ((SV *)GvCV (method), G_SCALAR); 1011 call_sv ((SV *)GvCV (method), G_SCALAR | G_EVAL);
748 SPAGAIN; 1012 SPAGAIN;
749 1013
1014 if (SvTRUE (ERRSV))
1015 {
1016 FREETMPS; LEAVE;
1017 ERR (SvPVutf8_nolen (sv_2mortal (SvREFCNT_inc (ERRSV))));
1018 }
1019
750 SvREFCNT_dec (sv); 1020 SvREFCNT_dec (sv);
751 sv = SvREFCNT_inc (POPs); 1021 sv = SvREFCNT_inc (POPs);
752 1022
753 PUTBACK; 1023 PUTBACK;
754 1024
755 FREETMPS; LEAVE; 1025 FREETMPS; LEAVE;
1026 }
1027 break;
756 1028
757 return sv; 1029 default:
758 } 1030 {
759 else 1031 sv = decode_sv (dec);
760 { 1032
1033 dSP;
1034 ENTER; SAVETMPS; PUSHMARK (SP);
1035 EXTEND (SP, 2);
1036 PUSHs (newSVuv (tag));
1037 PUSHs (sv);
1038
1039 PUTBACK;
1040 int count = call_sv (dec->cbor.filter ? dec->cbor.filter : default_filter, G_ARRAY | G_EVAL);
1041 SPAGAIN;
1042
1043 if (SvTRUE (ERRSV))
1044 {
1045 FREETMPS; LEAVE;
1046 ERR (SvPVutf8_nolen (sv_2mortal (SvREFCNT_inc (ERRSV))));
1047 }
1048
1049 if (count)
1050 {
1051 SvREFCNT_dec (sv);
1052 sv = SvREFCNT_inc (POPs);
1053 }
1054 else
1055 {
761 AV *av = newAV (); 1056 AV *av = newAV ();
762 av_push (av, newSVuv (tag)); 1057 av_push (av, newSVuv (tag));
763 av_push (av, sv); 1058 av_push (av, sv);
764 1059
765 HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash 1060 HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash
766 ? cbor_tagged_stash 1061 ? cbor_tagged_stash
767 : gv_stashpv ("CBOR::XS::Tagged" , 1); 1062 : gv_stashpv ("CBOR::XS::Tagged" , 1);
768
769 return sv_bless (newRV_noinc ((SV *)av), tagged_stash); 1063 sv = sv_bless (newRV_noinc ((SV *)av), tagged_stash);
1064 }
1065
1066 PUTBACK;
1067
1068 FREETMPS; LEAVE;
1069 }
1070 break;
770 } 1071 }
1072
1073 return sv;
771 1074
772fail: 1075fail:
773 SvREFCNT_dec (sv); 1076 SvREFCNT_dec (sv);
774 return &PL_sv_undef; 1077 return &PL_sv_undef;
775} 1078}
… …
777static SV * 1080static SV *
778decode_sv (dec_t *dec) 1081decode_sv (dec_t *dec)
779{ 1082{
780 WANT (1); 1083 WANT (1);
781 1084
782 switch (*dec->cur >> 5) 1085 switch (*dec->cur >> MAJOR_SHIFT)
783 { 1086 {
784 case 0: // unsigned int 1087 case MAJOR_POS_INT >> MAJOR_SHIFT: return newSVuv (decode_uint (dec));
785 return newSVuv (decode_uint (dec)); 1088 case MAJOR_NEG_INT >> MAJOR_SHIFT: return newSViv (-1 - (IV)decode_uint (dec));
786 case 1: // negative int 1089 case MAJOR_BYTES >> MAJOR_SHIFT: return decode_str (dec, 0);
787 return newSViv (-1 - (IV)decode_uint (dec)); 1090 case MAJOR_TEXT >> MAJOR_SHIFT: return decode_str (dec, 1);
788 case 2: // octet string 1091 case MAJOR_ARRAY >> MAJOR_SHIFT: return decode_av (dec);
789 return decode_str (dec, 0); 1092 case MAJOR_MAP >> MAJOR_SHIFT: return decode_hv (dec);
790 case 3: // utf-8 string 1093 case MAJOR_TAG >> MAJOR_SHIFT: return decode_tagged (dec);
791 return decode_str (dec, 1); 1094
792 case 4: // array 1095 case MAJOR_MISC >> MAJOR_SHIFT:
793 return decode_av (dec);
794 case 5: // map
795 return decode_hv (dec);
796 case 6: // tag
797 return decode_tagged (dec);
798 case 7: // misc
799 switch (*dec->cur++ & 31) 1096 switch (*dec->cur++ & MINOR_MASK)
800 { 1097 {
801 case 20: 1098 case SIMPLE_FALSE:
802#if CBOR_SLOW 1099#if CBOR_SLOW
803 types_false = get_bool ("Types::Serialiser::false"); 1100 types_false = get_bool ("Types::Serialiser::false");
804#endif 1101#endif
805 return newSVsv (types_false); 1102 return newSVsv (types_false);
806 case 21: 1103 case SIMPLE_TRUE:
807#if CBOR_SLOW 1104#if CBOR_SLOW
808 types_true = get_bool ("Types::Serialiser::true"); 1105 types_true = get_bool ("Types::Serialiser::true");
809#endif 1106#endif
810 return newSVsv (types_true); 1107 return newSVsv (types_true);
811 case 22: 1108 case SIMPLE_NULL:
812 return newSVsv (&PL_sv_undef); 1109 return newSVsv (&PL_sv_undef);
813 case 23: 1110 case SIMPLE_UNDEF:
814#if CBOR_SLOW 1111#if CBOR_SLOW
815 types_error = get_bool ("Types::Serialiser::error"); 1112 types_error = get_bool ("Types::Serialiser::error");
816#endif 1113#endif
817 return newSVsv (types_error); 1114 return newSVsv (types_error);
818 1115
819 case 25: 1116 case MISC_FLOAT16:
820 { 1117 {
821 WANT (2); 1118 WANT (2);
822 1119
823 uint16_t fp = (dec->cur[0] << 8) | dec->cur[1]; 1120 uint16_t fp = (dec->cur[0] << 8) | dec->cur[1];
824 dec->cur += 2; 1121 dec->cur += 2;
825 1122
826 return newSVnv (ecb_binary16_to_float (fp)); 1123 return newSVnv (ecb_binary16_to_float (fp));
827 } 1124 }
828 1125
829 case 26: 1126 case MISC_FLOAT32:
830 { 1127 {
831 uint32_t fp; 1128 uint32_t fp;
832 WANT (4); 1129 WANT (4);
833 memcpy (&fp, dec->cur, 4); 1130 memcpy (&fp, dec->cur, 4);
834 dec->cur += 4; 1131 dec->cur += 4;
… …
837 fp = ecb_bswap32 (fp); 1134 fp = ecb_bswap32 (fp);
838 1135
839 return newSVnv (ecb_binary32_to_float (fp)); 1136 return newSVnv (ecb_binary32_to_float (fp));
840 } 1137 }
841 1138
842 case 27: 1139 case MISC_FLOAT64:
843 { 1140 {
844 uint64_t fp; 1141 uint64_t fp;
845 WANT (8); 1142 WANT (8);
846 memcpy (&fp, dec->cur, 8); 1143 memcpy (&fp, dec->cur, 8);
847 dec->cur += 8; 1144 dec->cur += 8;
… …
850 fp = ecb_bswap64 (fp); 1147 fp = ecb_bswap64 (fp);
851 1148
852 return newSVnv (ecb_binary64_to_double (fp)); 1149 return newSVnv (ecb_binary64_to_double (fp));
853 } 1150 }
854 1151
855 // 0..19 unassigned 1152 // 0..19 unassigned simple
856 // 24 reserved + unassigned (reserved values are not encodable) 1153 // 24 reserved + unassigned simple (reserved values are not encodable)
1154 // 28-30 unassigned misc
1155 // 31 break code
857 default: 1156 default:
858 ERR ("corrupted CBOR data (reserved/unassigned major 7 value)"); 1157 ERR ("corrupted CBOR data (reserved/unassigned/unexpected major 7 value)");
859 } 1158 }
860 1159
861 break; 1160 break;
862 } 1161 }
863 1162
… …
866} 1165}
867 1166
868static SV * 1167static SV *
869decode_cbor (SV *string, CBOR *cbor, char **offset_return) 1168decode_cbor (SV *string, CBOR *cbor, char **offset_return)
870{ 1169{
871 dec_t dec; 1170 dec_t dec = { 0 };
872 SV *sv; 1171 SV *sv;
873 STRLEN len; 1172 STRLEN len;
874 char *data = SvPVbyte (string, len); 1173 char *data = SvPVbyte (string, len);
875 1174
876 if (len > cbor->max_size && cbor->max_size) 1175 if (len > cbor->max_size && cbor->max_size)
… …
878 (unsigned long)len, (unsigned long)cbor->max_size); 1177 (unsigned long)len, (unsigned long)cbor->max_size);
879 1178
880 dec.cbor = *cbor; 1179 dec.cbor = *cbor;
881 dec.cur = (U8 *)data; 1180 dec.cur = (U8 *)data;
882 dec.end = (U8 *)data + len; 1181 dec.end = (U8 *)data + len;
883 dec.err = 0;
884 dec.depth = 0;
885 1182
886 sv = decode_sv (&dec); 1183 sv = decode_sv (&dec);
887 1184
888 if (offset_return) 1185 if (offset_return)
889 *offset_return = dec.cur; 1186 *offset_return = dec.cur;
… …
892 if (dec.cur != dec.end && !dec.err) 1189 if (dec.cur != dec.end && !dec.err)
893 dec.err = "garbage after CBOR object"; 1190 dec.err = "garbage after CBOR object";
894 1191
895 if (dec.err) 1192 if (dec.err)
896 { 1193 {
1194 if (dec.shareable)
1195 {
1196 // need to break cyclic links, which whould all be in shareable
1197 int i;
1198 SV **svp;
1199
1200 for (i = av_len (dec.shareable) + 1; i--; )
1201 if ((svp = av_fetch (dec.shareable, i, 0)))
1202 sv_setsv (*svp, &PL_sv_undef);
1203 }
1204
897 SvREFCNT_dec (sv); 1205 SvREFCNT_dec (sv);
898 croak ("%s, at offset %d (octet 0x%02x)", dec.err, dec.cur - (U8 *)data, (int)(uint8_t)*dec.cur); 1206 croak ("%s, at offset %d (octet 0x%02x)", dec.err, dec.cur - (U8 *)data, (int)(uint8_t)*dec.cur);
899 } 1207 }
900 1208
901 sv = sv_2mortal (sv); 1209 sv = sv_2mortal (sv);
902 1210
903 return sv; 1211 return sv;
904} 1212}
905 1213
1214/////////////////////////////////////////////////////////////////////////////
1215// incremental parser
1216
1217#define INCR_DONE(cbor) (AvFILLp (cbor->incr_count) < 0)
1218
1219// returns 0 for notyet, 1 for success or error
1220static int
1221incr_parse (CBOR *self, SV *cborstr)
1222{
1223 STRLEN cur;
1224 SvPV (cborstr, cur);
1225
1226 while (ecb_expect_true (self->incr_need <= cur))
1227 {
1228 // table of integer count bytes
1229 static I8 incr_len[MINOR_MASK + 1] = {
1230 0, 0, 0, 0, 0, 0, 0, 0,
1231 0, 0, 0, 0, 0, 0, 0, 0,
1232 0, 0, 0, 0, 0, 0, 0, 0,
1233 1, 2, 4, 8,-1,-1,-1,-2
1234 };
1235
1236 const U8 *p = SvPVX (cborstr) + self->incr_pos;
1237 U8 m = *p & MINOR_MASK;
1238 IV count = SvIVX (AvARRAY (self->incr_count)[AvFILLp (self->incr_count)]);
1239 I8 ilen = incr_len[m];
1240
1241 self->incr_need = self->incr_pos + 1;
1242
1243 if (ecb_expect_false (ilen < 0))
1244 {
1245 if (m != MINOR_INDEF)
1246 return 1; // error
1247
1248 if (*p == (MAJOR_MISC | MINOR_INDEF))
1249 {
1250 if (count >= 0)
1251 return 1; // error
1252
1253 count = 1;
1254 }
1255 else
1256 {
1257 av_push (self->incr_count, newSViv (-1)); //TODO: nest
1258 count = -1;
1259 }
1260 }
1261 else
1262 {
1263 self->incr_need += ilen;
1264 if (ecb_expect_false (self->incr_need > cur))
1265 return 0;
1266
1267 int major = *p >> MAJOR_SHIFT;
1268
1269 switch (major)
1270 {
1271 case MAJOR_TAG >> MAJOR_SHIFT:
1272 ++count; // tags merely prefix another value
1273 break;
1274
1275 case MAJOR_BYTES >> MAJOR_SHIFT:
1276 case MAJOR_TEXT >> MAJOR_SHIFT:
1277 case MAJOR_ARRAY >> MAJOR_SHIFT:
1278 case MAJOR_MAP >> MAJOR_SHIFT:
1279 {
1280 UV len;
1281
1282 if (ecb_expect_false (ilen))
1283 {
1284 len = 0;
1285
1286 do {
1287 len = (len << 8) | *++p;
1288 } while (--ilen);
1289 }
1290 else
1291 len = m;
1292
1293 switch (major)
1294 {
1295 case MAJOR_BYTES >> MAJOR_SHIFT:
1296 case MAJOR_TEXT >> MAJOR_SHIFT:
1297 self->incr_need += len;
1298 if (ecb_expect_false (self->incr_need > cur))
1299 return 0;
1300
1301 break;
1302
1303 case MAJOR_MAP >> MAJOR_SHIFT:
1304 len <<= 1;
1305 case MAJOR_ARRAY >> MAJOR_SHIFT:
1306 if (len)
1307 {
1308 av_push (self->incr_count, newSViv (len + 1)); //TODO: nest
1309 count = len + 1;
1310 }
1311 break;
1312 }
1313 }
1314 }
1315 }
1316
1317 self->incr_pos = self->incr_need;
1318
1319 if (count > 0)
1320 {
1321 while (!--count)
1322 {
1323 if (!AvFILLp (self->incr_count))
1324 return 1; // done
1325
1326 SvREFCNT_dec_NN (av_pop (self->incr_count));
1327 count = SvIVX (AvARRAY (self->incr_count)[AvFILLp (self->incr_count)]);
1328 }
1329
1330 SvIVX (AvARRAY (self->incr_count)[AvFILLp (self->incr_count)]) = count;
1331 }
1332 }
1333
1334 return 0;
1335}
1336
1337
906///////////////////////////////////////////////////////////////////////////// 1338/////////////////////////////////////////////////////////////////////////////
907// XS interface functions 1339// XS interface functions
908 1340
909MODULE = CBOR::XS PACKAGE = CBOR::XS 1341MODULE = CBOR::XS PACKAGE = CBOR::XS
910 1342
… …
917 types_error_stash = gv_stashpv ("Types::Serialiser::Error" , 1); 1349 types_error_stash = gv_stashpv ("Types::Serialiser::Error" , 1);
918 1350
919 types_true = get_bool ("Types::Serialiser::true" ); 1351 types_true = get_bool ("Types::Serialiser::true" );
920 types_false = get_bool ("Types::Serialiser::false"); 1352 types_false = get_bool ("Types::Serialiser::false");
921 types_error = get_bool ("Types::Serialiser::error"); 1353 types_error = get_bool ("Types::Serialiser::error");
1354
1355 default_filter = newSVpv ("CBOR::XS::default_filter", 0);
922 1356
923 sv_cbor = newSVpv ("CBOR", 0); 1357 sv_cbor = newSVpv ("CBOR", 0);
924 SvREADONLY_on (sv_cbor); 1358 SvREADONLY_on (sv_cbor);
925} 1359}
926 1360
… …
947 1381
948void shrink (CBOR *self, int enable = 1) 1382void shrink (CBOR *self, int enable = 1)
949 ALIAS: 1383 ALIAS:
950 shrink = F_SHRINK 1384 shrink = F_SHRINK
951 allow_unknown = F_ALLOW_UNKNOWN 1385 allow_unknown = F_ALLOW_UNKNOWN
1386 allow_sharing = F_ALLOW_SHARING
1387 allow_cycles = F_ALLOW_CYCLES
1388 pack_strings = F_PACK_STRINGS
1389 validate_utf8 = F_VALIDATE_UTF8
952 PPCODE: 1390 PPCODE:
953{ 1391{
954 if (enable) 1392 if (enable)
955 self->flags |= ix; 1393 self->flags |= ix;
956 else 1394 else
… …
961 1399
962void get_shrink (CBOR *self) 1400void get_shrink (CBOR *self)
963 ALIAS: 1401 ALIAS:
964 get_shrink = F_SHRINK 1402 get_shrink = F_SHRINK
965 get_allow_unknown = F_ALLOW_UNKNOWN 1403 get_allow_unknown = F_ALLOW_UNKNOWN
1404 get_allow_sharing = F_ALLOW_SHARING
1405 get_allow_cycles = F_ALLOW_CYCLES
1406 get_pack_strings = F_PACK_STRINGS
1407 get_validate_utf8 = F_VALIDATE_UTF8
966 PPCODE: 1408 PPCODE:
967 XPUSHs (boolSV (self->flags & ix)); 1409 XPUSHs (boolSV (self->flags & ix));
968 1410
969void max_depth (CBOR *self, U32 max_depth = 0x80000000UL) 1411void max_depth (CBOR *self, U32 max_depth = 0x80000000UL)
970 PPCODE: 1412 PPCODE:
… …
983 XPUSHs (ST (0)); 1425 XPUSHs (ST (0));
984 1426
985int get_max_size (CBOR *self) 1427int get_max_size (CBOR *self)
986 CODE: 1428 CODE:
987 RETVAL = self->max_size; 1429 RETVAL = self->max_size;
1430 OUTPUT:
1431 RETVAL
1432
1433void filter (CBOR *self, SV *filter = 0)
1434 PPCODE:
1435 SvREFCNT_dec (self->filter);
1436 self->filter = filter ? newSVsv (filter) : filter;
1437 XPUSHs (ST (0));
1438
1439SV *get_filter (CBOR *self)
1440 CODE:
1441 RETVAL = self->filter ? self->filter : NEWSV (0, 0);
988 OUTPUT: 1442 OUTPUT:
989 RETVAL 1443 RETVAL
990 1444
991void encode (CBOR *self, SV *scalar) 1445void encode (CBOR *self, SV *scalar)
992 PPCODE: 1446 PPCODE:
… …
1007 EXTEND (SP, 2); 1461 EXTEND (SP, 2);
1008 PUSHs (sv); 1462 PUSHs (sv);
1009 PUSHs (sv_2mortal (newSVuv (offset - SvPVX (cborstr)))); 1463 PUSHs (sv_2mortal (newSVuv (offset - SvPVX (cborstr))));
1010} 1464}
1011 1465
1466void incr_parse (CBOR *self, SV *cborstr)
1467 ALIAS:
1468 incr_parse_multiple = 1
1469 PPCODE:
1470{
1471 if (SvUTF8 (cborstr))
1472 sv_utf8_downgrade (cborstr, 0);
1473
1474 if (!self->incr_count)
1475 {
1476 self->incr_count = newAV ();
1477 self->incr_pos = 0;
1478 self->incr_need = 1;
1479
1480 av_push (self->incr_count, newSViv (1));
1481 }
1482
1483 do
1484 {
1485 if (!incr_parse (self, cborstr))
1486 {
1487 if (self->incr_need > self->max_size && self->max_size)
1488 croak ("attempted decode of CBOR text of %lu bytes size, but max_size is set to %lu",
1489 (unsigned long)self->incr_need, (unsigned long)self->max_size);
1490
1491 break;
1492 }
1493
1494 SV *sv;
1495 char *offset;
1496
1497 PUTBACK; sv = decode_cbor (cborstr, self, &offset); SPAGAIN;
1498 XPUSHs (sv);
1499
1500 sv_chop (cborstr, offset);
1501
1502 av_clear (self->incr_count);
1503 av_push (self->incr_count, newSViv (1));
1504
1505 self->incr_pos = 0;
1506 self->incr_need = self->incr_pos + 1;
1507 }
1508 while (ix);
1509}
1510
1511void incr_reset (CBOR *self)
1512 CODE:
1513{
1514 SvREFCNT_dec (self->incr_count);
1515 self->incr_count = 0;
1516}
1517
1518void DESTROY (CBOR *self)
1519 PPCODE:
1520 cbor_free (self);
1521
1012PROTOTYPES: ENABLE 1522PROTOTYPES: ENABLE
1013 1523
1014void encode_cbor (SV *scalar) 1524void encode_cbor (SV *scalar)
1525 ALIAS:
1526 encode_cbor = 0
1527 encode_cbor_sharing = F_ALLOW_SHARING
1015 PPCODE: 1528 PPCODE:
1016{ 1529{
1017 CBOR cbor; 1530 CBOR cbor;
1018 cbor_init (&cbor); 1531 cbor_init (&cbor);
1532 cbor.flags |= ix;
1019 PUTBACK; scalar = encode_cbor (scalar, &cbor); SPAGAIN; 1533 PUTBACK; scalar = encode_cbor (scalar, &cbor); SPAGAIN;
1020 XPUSHs (scalar); 1534 XPUSHs (scalar);
1021} 1535}
1022 1536
1023void decode_cbor (SV *cborstr) 1537void decode_cbor (SV *cborstr)

Diff Legend

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