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

Comparing cvsroot/CBOR-XS/XS.xs (file contents):
Revision 1.20 by root, Wed Nov 20 11:06:42 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
70 CBOR_TAG_STRINGREF = 25, // http://cbor.schmorp.de/stringref
29 CBOR_TAG_PERL_OBJECT = 24, // http://cbor.schmorp.de/perl-object 71 CBOR_TAG_PERL_OBJECT = 26, // http://cbor.schmorp.de/perl-object
30 CBOR_TAG_GENERIC_OBJECT = 25, // http://cbor.schmorp.de/generic-object 72 CBOR_TAG_GENERIC_OBJECT = 27, // http://cbor.schmorp.de/generic-object
31 CBOR_TAG_VALUE_SHAREABLE = 26, // http://cbor.schmorp.de/value-sharing 73 CBOR_TAG_VALUE_SHAREABLE = 28, // http://cbor.schmorp.de/value-sharing
32 CBOR_TAG_VALUE_SHAREDREF = 27, // http://cbor.schmorp.de/value-sharing 74 CBOR_TAG_VALUE_SHAREDREF = 29, // http://cbor.schmorp.de/value-sharing
33 CBOR_TAG_STRINGREF_NAMESPACE = 65537, // http://cbor.schmorp.de/stringref 75 CBOR_TAG_STRINGREF_NAMESPACE = 256, // http://cbor.schmorp.de/stringref
34 CBOR_TAG_STRINGREF = 28, // http://cbor.schmorp.de/stringref
35 CBOR_TAG_INDIRECTION = 22098, // http://cbor.schmorp.de/indirection 76 CBOR_TAG_INDIRECTION = 22098, // http://cbor.schmorp.de/indirection
36 77
37 // rfc7049 78 // rfc7049
38 CBOR_TAG_DATETIME = 0, // rfc4287, utf-8 79 CBOR_TAG_DATETIME = 0, // rfc4287, utf-8
39 CBOR_TAG_TIMESTAMP = 1, // unix timestamp, any 80 CBOR_TAG_TIMESTAMP = 1, // unix timestamp, any
40 CBOR_TAG_POS_BIGNUM = 2, // byte string 81 CBOR_TAG_POS_BIGNUM = 2, // byte string
41 CBOR_TAG_NEG_BIGNUM = 3, // byte string 82 CBOR_TAG_NEG_BIGNUM = 3, // byte string
42 CBOR_TAG_DECIMAL = 4, // decimal fraction, array 83 CBOR_TAG_DECIMAL = 4, // decimal fraction, array
43 CBOR_TAG_BIGFLOAT = 5, // array 84 CBOR_TAG_BIGFLOAT = 5, // array
44 85
45 CBOR_TAG_CONV_B64U = 21, // base64url, any 86 CBOR_TAG_CONV_B64U = 21, // base64url, any
46 CBOR_TAG_CONV_B64 = 22, // base64, any 87 CBOR_TAG_CONV_B64 = 22, // base64, any
47 CBOR_TAG_CONV_HEX = 23, // base16, any 88 CBOR_TAG_CONV_HEX = 23, // base16, any
48 CBOR_TAG_CBOR = 24, // embedded cbor, byte string 89 CBOR_TAG_CBOR = 24, // embedded cbor, byte string
49 90
50 CBOR_TAG_URI = 32, // URI rfc3986, utf-8 91 CBOR_TAG_URI = 32, // URI rfc3986, utf-8
51 CBOR_TAG_B64U = 33, // base64url rfc4648, utf-8 92 CBOR_TAG_B64U = 33, // base64url rfc4648, utf-8
52 CBOR_TAG_B64 = 34, // base6 rfc46484, utf-8 93 CBOR_TAG_B64 = 34, // base6 rfc46484, utf-8
53 CBOR_TAG_REGEX = 35, // regex pcre/ecma262, utf-8 94 CBOR_TAG_REGEX = 35, // regex pcre/ecma262, utf-8
54 CBOR_TAG_MIME = 36, // mime message rfc2045, utf-8 95 CBOR_TAG_MIME = 36, // mime message rfc2045, utf-8
55 96
56 CBOR_TAG_MAGIC = 55799 // self-describe cbor 97 CBOR_TAG_MAGIC = 55799, // self-describe cbor
57}; 98};
58 99
59#define F_SHRINK 0x00000001UL 100#define F_SHRINK 0x00000001UL
60#define F_ALLOW_UNKNOWN 0x00000002UL 101#define F_ALLOW_UNKNOWN 0x00000002UL
61#define F_ALLOW_SHARING 0x00000004UL //TODO 102#define F_ALLOW_SHARING 0x00000004UL
103#define F_ALLOW_CYCLES 0x00000008UL
62#define F_DEDUP_STRINGS 0x00000008UL //TODO 104#define F_PACK_STRINGS 0x00000010UL
63#define F_DEDUP_KEYS 0x00000010UL //TODO 105#define F_VALIDATE_UTF8 0x00000020UL
64 106
65#define INIT_SIZE 32 // initial scalar size to be allocated 107#define INIT_SIZE 32 // initial scalar size to be allocated
66 108
67#define SB do { 109#define SB do {
68#define SE } while (0) 110#define SE } while (0)
… …
80# define CBOR_SLOW 0 122# define CBOR_SLOW 0
81# define CBOR_STASH cbor_stash 123# define CBOR_STASH cbor_stash
82#endif 124#endif
83 125
84static 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::
85static SV *types_true, *types_false, *types_error, *sv_cbor; 127static SV *types_true, *types_false, *types_error, *sv_cbor, *default_filter;
86 128
87typedef struct { 129typedef struct {
88 U32 flags; 130 U32 flags;
89 U32 max_depth; 131 U32 max_depth;
90 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.
91} CBOR; 139} CBOR;
92 140
93ecb_inline void 141ecb_inline void
94cbor_init (CBOR *cbor) 142cbor_init (CBOR *cbor)
95{ 143{
96 Zero (cbor, 1, CBOR); 144 Zero (cbor, 1, CBOR);
97 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);
98} 153}
99 154
100///////////////////////////////////////////////////////////////////////////// 155/////////////////////////////////////////////////////////////////////////////
101// utility functions 156// utility functions
102 157
… …
122 SvPV_shrink_to_cur (sv); 177 SvPV_shrink_to_cur (sv);
123#elif defined (SvPV_renew) 178#elif defined (SvPV_renew)
124 SvPV_renew (sv, SvCUR (sv) + 1); 179 SvPV_renew (sv, SvCUR (sv) + 1);
125#endif 180#endif
126 } 181 }
182}
183
184// minimum length of a string to be registered for stringref
185ecb_inline int
186minimum_string_length (UV idx)
187{
188 return idx > 23
189 ? idx > 0xffU
190 ? idx > 0xffffU
191 ? idx > 0xffffffffU
192 ? 11
193 : 7
194 : 5
195 : 4
196 : 3;
127} 197}
128 198
129///////////////////////////////////////////////////////////////////////////// 199/////////////////////////////////////////////////////////////////////////////
130// encoder 200// encoder
131 201
… …
165static void 235static void
166encode_uint (enc_t *enc, int major, UV len) 236encode_uint (enc_t *enc, int major, UV len)
167{ 237{
168 need (enc, 9); 238 need (enc, 9);
169 239
170 if (len < 24) 240 if (ecb_expect_true (len < LENGTH_EXT1))
171 *enc->cur++ = major | len; 241 *enc->cur++ = major | len;
172 else if (len <= 0xff) 242 else if (ecb_expect_true (len <= 0xffU))
173 { 243 {
174 *enc->cur++ = major | 24; 244 *enc->cur++ = major | LENGTH_EXT1;
175 *enc->cur++ = len; 245 *enc->cur++ = len;
176 } 246 }
177 else if (len <= 0xffff) 247 else if (len <= 0xffffU)
178 { 248 {
179 *enc->cur++ = major | 25; 249 *enc->cur++ = major | LENGTH_EXT2;
180 *enc->cur++ = len >> 8; 250 *enc->cur++ = len >> 8;
181 *enc->cur++ = len; 251 *enc->cur++ = len;
182 } 252 }
183 else if (len <= 0xffffffff) 253 else if (len <= 0xffffffffU)
184 { 254 {
185 *enc->cur++ = major | 26; 255 *enc->cur++ = major | LENGTH_EXT4;
186 *enc->cur++ = len >> 24; 256 *enc->cur++ = len >> 24;
187 *enc->cur++ = len >> 16; 257 *enc->cur++ = len >> 16;
188 *enc->cur++ = len >> 8; 258 *enc->cur++ = len >> 8;
189 *enc->cur++ = len; 259 *enc->cur++ = len;
190 } 260 }
191 else 261 else
192 { 262 {
193 *enc->cur++ = major | 27; 263 *enc->cur++ = major | LENGTH_EXT8;
194 *enc->cur++ = len >> 56; 264 *enc->cur++ = len >> 56;
195 *enc->cur++ = len >> 48; 265 *enc->cur++ = len >> 48;
196 *enc->cur++ = len >> 40; 266 *enc->cur++ = len >> 40;
197 *enc->cur++ = len >> 32; 267 *enc->cur++ = len >> 32;
198 *enc->cur++ = len >> 24; 268 *enc->cur++ = len >> 24;
… …
200 *enc->cur++ = len >> 8; 270 *enc->cur++ = len >> 8;
201 *enc->cur++ = len; 271 *enc->cur++ = len;
202 } 272 }
203} 273}
204 274
205static void 275ecb_inline void
276encode_tag (enc_t *enc, UV tag)
277{
278 encode_uint (enc, MAJOR_TAG, tag);
279}
280
281ecb_inline void
206encode_str (enc_t *enc, int utf8, char *str, STRLEN len) 282encode_str (enc_t *enc, int utf8, char *str, STRLEN len)
207{ 283{
208 encode_uint (enc, utf8 ? 0x60 : 0x40, len); 284 encode_uint (enc, utf8 ? MAJOR_TEXT : MAJOR_BYTES, len);
209 need (enc, len); 285 need (enc, len);
210 memcpy (enc->cur, str, len); 286 memcpy (enc->cur, str, len);
211 enc->cur += len; 287 enc->cur += len;
212} 288}
213 289
214ecb_inline void 290static void
215encode_tag (enc_t *enc, UV tag) 291encode_strref (enc_t *enc, int utf8, char *str, STRLEN len)
216{ 292{
217 encode_uint (enc, 0xc0, tag); 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);
218} 313}
219 314
220static void encode_sv (enc_t *enc, SV *sv); 315static void encode_sv (enc_t *enc, SV *sv);
221 316
222static void 317static void
… …
227 if (enc->depth >= enc->cbor.max_depth) 322 if (enc->depth >= enc->cbor.max_depth)
228 croak (ERR_NESTING_EXCEEDED); 323 croak (ERR_NESTING_EXCEEDED);
229 324
230 ++enc->depth; 325 ++enc->depth;
231 326
232 encode_uint (enc, 0x80, len + 1); 327 encode_uint (enc, MAJOR_ARRAY, len + 1);
233 328
329 if (SvMAGICAL (av))
234 for (i = 0; i <= len; ++i) 330 for (i = 0; i <= len; ++i)
235 { 331 {
236 SV **svp = av_fetch (av, i, 0); 332 SV **svp = av_fetch (av, i, 0);
237 encode_sv (enc, svp ? *svp : &PL_sv_undef); 333 encode_sv (enc, svp ? *svp : &PL_sv_undef);
238 } 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 }
239 341
240 --enc->depth; 342 --enc->depth;
241}
242
243ecb_inline void
244encode_he (enc_t *enc, HE *he)
245{
246 if (HeKLEN (he) == HEf_SVKEY)
247 encode_sv (enc, HeSVKEY (he));
248 else
249 encode_str (enc, HeKUTF8 (he), HeKEY (he), HeKLEN (he));
250} 343}
251 344
252static void 345static void
253encode_hv (enc_t *enc, HV *hv) 346encode_hv (enc_t *enc, HV *hv)
254{ 347{
… …
261 354
262 int pairs = hv_iterinit (hv); 355 int pairs = hv_iterinit (hv);
263 int mg = SvMAGICAL (hv); 356 int mg = SvMAGICAL (hv);
264 357
265 if (mg) 358 if (mg)
266 encode_ch (enc, 0xa0 | 31); 359 encode_ch (enc, MAJOR_MAP | MINOR_INDEF);
267 else 360 else
268 encode_uint (enc, 0xa0, pairs); 361 encode_uint (enc, MAJOR_MAP, pairs);
269 362
270 while ((he = hv_iternext (hv))) 363 while ((he = hv_iternext (hv)))
271 { 364 {
272 if (ecb_expect_false (enc->cbor.flags & (F_DEDUP_STRINGS | F_DEDUP_KEYS)))
273 {
274 SV **svp;
275
276 if (HeKLEN (he) == HEf_SVKEY) 365 if (HeKLEN (he) == HEf_SVKEY)
277 svp = hv_fetch_ent (enc->stringref[!! SvUTF8 (HeSVKEY (he))], HeSVKEY (he) , 1, 0);//TODO return HE :/ 366 encode_sv (enc, HeSVKEY (he));
278 else
279 svp = hv_fetch (enc->stringref[!! HeKUTF8 (he) ], HeKEY (he), HeKLEN (he), 1);
280
281 if (SvOK (*svp))
282 {
283 encode_tag (enc, CBOR_TAG_STRINGREF);
284 encode_uint (enc, 0x00, SvUV (*svp));
285 }
286 else
287 {
288 sv_setuv (*svp, enc->stringref_idx);
289 ++enc->stringref_idx;
290 encode_he (enc, he);
291 }
292 }
293 else 367 else
294 encode_he (enc, he); 368 encode_strref (enc, HeKUTF8 (he), HeKEY (he), HeKLEN (he));
295 369
296 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));
297 } 371 }
298 372
299 if (mg) 373 if (mg)
300 encode_ch (enc, 0xe0 | 31); 374 encode_ch (enc, MAJOR_MISC | MINOR_INDEF);
301 375
302 --enc->depth; 376 --enc->depth;
303} 377}
304 378
305// encode objects, arrays and special \0=false and \1=true values. 379// encode objects, arrays and special \0=false and \1=true values.
306static void 380static void
307encode_rv (enc_t *enc, SV *sv) 381encode_rv (enc_t *enc, SV *sv)
308{ 382{
309 SvGETMAGIC (sv); 383 SvGETMAGIC (sv);
310
311 if (ecb_expect_false (enc->cbor.flags & F_ALLOW_SHARING)
312 && ecb_expect_false (SvREFCNT (sv) > 1))
313 {
314 if (!enc->shareable)
315 enc->shareable = (HV *)sv_2mortal ((SV *)newHV ());
316
317 SV **svp = hv_fetch (enc->shareable, (char *)&sv, sizeof (sv), 1);
318
319 if (SvOK (*svp))
320 {
321 encode_tag (enc, CBOR_TAG_VALUE_SHAREDREF);
322 encode_uint (enc, 0x00, SvUV (*svp));
323 return;
324 }
325 else
326 {
327 sv_setuv (*svp, enc->shareable_idx);
328 ++enc->shareable_idx;
329 encode_tag (enc, CBOR_TAG_VALUE_SHAREABLE);
330 }
331 }
332 384
333 svtype svt = SvTYPE (sv); 385 svtype svt = SvTYPE (sv);
334 386
335 if (ecb_expect_false (SvOBJECT (sv))) 387 if (ecb_expect_false (SvOBJECT (sv)))
336 { 388 {
… …
343 HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash 395 HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash
344 ? cbor_tagged_stash 396 ? cbor_tagged_stash
345 : gv_stashpv ("CBOR::XS::Tagged" , 1); 397 : gv_stashpv ("CBOR::XS::Tagged" , 1);
346 398
347 HV *stash = SvSTASH (sv); 399 HV *stash = SvSTASH (sv);
348 GV *method;
349 400
350 if (stash == boolean_stash) 401 if (stash == boolean_stash)
351 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 }
352 else if (stash == error_stash) 406 else if (stash == error_stash)
353 encode_ch (enc, 0xe0 | 23); 407 {
408 encode_ch (enc, MAJOR_MISC | SIMPLE_UNDEF);
409 return;
410 }
354 else if (stash == tagged_stash) 411 else if (stash == tagged_stash)
355 { 412 {
356 if (svt != SVt_PVAV) 413 if (svt != SVt_PVAV)
357 croak ("encountered CBOR::XS::Tagged object that isn't an array"); 414 croak ("encountered CBOR::XS::Tagged object that isn't an array");
358 415
359 encode_uint (enc, 0xc0, SvUV (*av_fetch ((AV *)sv, 0, 1))); 416 encode_uint (enc, MAJOR_TAG, SvUV (*av_fetch ((AV *)sv, 0, 1)));
360 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))
361 } 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
362 else if ((method = gv_fetchmethod_autoload (stash, "TO_CBOR", 0))) 450 if ((method = gv_fetchmethod_autoload (stash, "TO_CBOR", 0)))
363 { 451 {
364 dSP; 452 dSP;
365 453
366 ENTER; SAVETMPS; PUSHMARK (SP); 454 ENTER; SAVETMPS; PUSHMARK (SP);
367 // 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
… …
399 // catch this surprisingly common error 487 // catch this surprisingly common error
400 if (count == 1 && SvROK (TOPs) && SvRV (TOPs) == sv) 488 if (count == 1 && SvROK (TOPs) && SvRV (TOPs) == sv)
401 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));
402 490
403 encode_tag (enc, CBOR_TAG_PERL_OBJECT); 491 encode_tag (enc, CBOR_TAG_PERL_OBJECT);
404 encode_uint (enc, 0x80, count + 1); 492 encode_uint (enc, MAJOR_ARRAY, count + 1);
405 encode_str (enc, HvNAMEUTF8 (stash), HvNAME (stash), HvNAMELEN (stash)); 493 encode_strref (enc, HvNAMEUTF8 (stash), HvNAME (stash), HvNAMELEN (stash));
406 494
407 while (count) 495 while (count)
408 encode_sv (enc, SP[1 - count--]); 496 encode_sv (enc, SP[1 - count--]);
409 497
410 PUTBACK; 498 PUTBACK;
… …
431{ 519{
432 double nv = SvNVX (sv); 520 double nv = SvNVX (sv);
433 521
434 need (enc, 9); 522 need (enc, 9);
435 523
436 if (ecb_expect_false (nv == (U32)nv)) 524 if (ecb_expect_false (nv == (NV)(U32)nv))
437 encode_uint (enc, 0x00, (U32)nv); 525 encode_uint (enc, MAJOR_POS_INT, (U32)nv);
438 //TODO: maybe I32? 526 //TODO: maybe I32?
439 else if (ecb_expect_false (nv == (float)nv)) 527 else if (ecb_expect_false (nv == (float)nv))
440 { 528 {
441 uint32_t fp = ecb_float_to_binary32 (nv); 529 uint32_t fp = ecb_float_to_binary32 (nv);
442 530
443 *enc->cur++ = 0xe0 | 26; 531 *enc->cur++ = MAJOR_MISC | MISC_FLOAT32;
444 532
445 if (!ecb_big_endian ()) 533 if (!ecb_big_endian ())
446 fp = ecb_bswap32 (fp); 534 fp = ecb_bswap32 (fp);
447 535
448 memcpy (enc->cur, &fp, 4); 536 memcpy (enc->cur, &fp, 4);
… …
450 } 538 }
451 else 539 else
452 { 540 {
453 uint64_t fp = ecb_double_to_binary64 (nv); 541 uint64_t fp = ecb_double_to_binary64 (nv);
454 542
455 *enc->cur++ = 0xe0 | 27; 543 *enc->cur++ = MAJOR_MISC | MISC_FLOAT64;
456 544
457 if (!ecb_big_endian ()) 545 if (!ecb_big_endian ())
458 fp = ecb_bswap64 (fp); 546 fp = ecb_bswap64 (fp);
459 547
460 memcpy (enc->cur, &fp, 8); 548 memcpy (enc->cur, &fp, 8);
… …
469 557
470 if (SvPOKp (sv)) 558 if (SvPOKp (sv))
471 { 559 {
472 STRLEN len; 560 STRLEN len;
473 char *str = SvPV (sv, len); 561 char *str = SvPV (sv, len);
474 encode_str (enc, SvUTF8 (sv), str, len); 562 encode_strref (enc, SvUTF8 (sv), str, len);
475 } 563 }
476 else if (SvNOKp (sv)) 564 else if (SvNOKp (sv))
477 encode_nv (enc, sv); 565 encode_nv (enc, sv);
478 else if (SvIOKp (sv)) 566 else if (SvIOKp (sv))
479 { 567 {
480 if (SvIsUV (sv)) 568 if (SvIsUV (sv))
481 encode_uint (enc, 0x00, SvUVX (sv)); 569 encode_uint (enc, MAJOR_POS_INT, SvUVX (sv));
482 else if (SvIVX (sv) >= 0) 570 else if (SvIVX (sv) >= 0)
483 encode_uint (enc, 0x00, SvIVX (sv)); 571 encode_uint (enc, MAJOR_POS_INT, SvIVX (sv));
484 else 572 else
485 encode_uint (enc, 0x20, -(SvIVX (sv) + 1)); 573 encode_uint (enc, MAJOR_NEG_INT, -(SvIVX (sv) + 1));
486 } 574 }
487 else if (SvROK (sv)) 575 else if (SvROK (sv))
488 encode_rv (enc, SvRV (sv)); 576 encode_rv (enc, SvRV (sv));
489 else if (!SvOK (sv)) 577 else if (!SvOK (sv))
490 encode_ch (enc, 0xe0 | 22); 578 encode_ch (enc, MAJOR_MISC | SIMPLE_NULL);
491 else if (enc->cbor.flags & F_ALLOW_UNKNOWN) 579 else if (enc->cbor.flags & F_ALLOW_UNKNOWN)
492 encode_ch (enc, 0xe0 | 23); 580 encode_ch (enc, MAJOR_MISC | SIMPLE_UNDEF);
493 else 581 else
494 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",
495 SvPV_nolen (sv), (unsigned int)SvFLAGS (sv)); 583 SvPV_nolen (sv), (unsigned int)SvFLAGS (sv));
496} 584}
497 585
498static SV * 586static SV *
499encode_cbor (SV *scalar, CBOR *cbor) 587encode_cbor (SV *scalar, CBOR *cbor)
500{ 588{
501 enc_t enc = { }; 589 enc_t enc = { 0 };
502 590
503 enc.cbor = *cbor; 591 enc.cbor = *cbor;
504 enc.sv = sv_2mortal (NEWSV (0, INIT_SIZE)); 592 enc.sv = sv_2mortal (NEWSV (0, INIT_SIZE));
505 enc.cur = SvPVX (enc.sv); 593 enc.cur = SvPVX (enc.sv);
506 enc.end = SvEND (enc.sv); 594 enc.end = SvEND (enc.sv);
507 595
508 SvPOK_only (enc.sv); 596 SvPOK_only (enc.sv);
509 597
510 if (cbor->flags & (F_DEDUP_STRINGS | F_DEDUP_KEYS)) 598 if (cbor->flags & F_PACK_STRINGS)
511 { 599 {
512 encode_tag (&enc, CBOR_TAG_STRINGREF_NAMESPACE); 600 encode_tag (&enc, CBOR_TAG_STRINGREF_NAMESPACE);
513 enc.stringref[0]= (HV *)sv_2mortal ((SV *)newHV ()); 601 enc.stringref[0]= (HV *)sv_2mortal ((SV *)newHV ());
514 enc.stringref[1]= (HV *)sv_2mortal ((SV *)newHV ()); 602 enc.stringref[1]= (HV *)sv_2mortal ((SV *)newHV ());
515 } 603 }
… …
537 CBOR cbor; 625 CBOR cbor;
538 U32 depth; // recursion depth 626 U32 depth; // recursion depth
539 U32 maxdepth; // recursion depth limit 627 U32 maxdepth; // recursion depth limit
540 AV *shareable; 628 AV *shareable;
541 AV *stringref; 629 AV *stringref;
630 SV *decode_tagged;
542} dec_t; 631} dec_t;
543 632
544#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
545 634
546#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")
… …
549#define DEC_DEC_DEPTH --dec->depth 638#define DEC_DEC_DEPTH --dec->depth
550 639
551static UV 640static UV
552decode_uint (dec_t *dec) 641decode_uint (dec_t *dec)
553{ 642{
554 switch (*dec->cur & 31) 643 U8 m = *dec->cur & MINOR_MASK;
555 { 644 ++dec->cur;
556 case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
557 case 8: case 9: case 10: case 11: case 12: case 13: case 14: case 15:
558 case 16: case 17: case 18: case 19: case 20: case 21: case 22: case 23:
559 return *dec->cur++ & 31;
560 645
561 case 24: 646 if (ecb_expect_true (m < LENGTH_EXT1))
647 return m;
648 else if (ecb_expect_true (m == LENGTH_EXT1))
649 {
562 WANT (2); 650 WANT (1);
563 dec->cur += 2; 651 dec->cur += 1;
564 return dec->cur[-1]; 652 return dec->cur[-1];
565 653 }
566 case 25: 654 else if (ecb_expect_true (m == LENGTH_EXT2))
655 {
567 WANT (3); 656 WANT (2);
568 dec->cur += 3; 657 dec->cur += 2;
569 return (((UV)dec->cur[-2]) << 8) 658 return (((UV)dec->cur[-2]) << 8)
570 | ((UV)dec->cur[-1]); 659 | ((UV)dec->cur[-1]);
571 660 }
572 case 26: 661 else if (ecb_expect_true (m == LENGTH_EXT4))
662 {
573 WANT (5); 663 WANT (4);
574 dec->cur += 5; 664 dec->cur += 4;
575 return (((UV)dec->cur[-4]) << 24) 665 return (((UV)dec->cur[-4]) << 24)
576 | (((UV)dec->cur[-3]) << 16) 666 | (((UV)dec->cur[-3]) << 16)
577 | (((UV)dec->cur[-2]) << 8) 667 | (((UV)dec->cur[-2]) << 8)
578 | ((UV)dec->cur[-1]); 668 | ((UV)dec->cur[-1]);
579 669 }
580 case 27: 670 else if (ecb_expect_true (m == LENGTH_EXT8))
671 {
581 WANT (9); 672 WANT (8);
582 dec->cur += 9; 673 dec->cur += 8;
674
675 return
676#if UVSIZE < 8
677 0
678#else
583 return (((UV)dec->cur[-8]) << 56) 679 (((UV)dec->cur[-8]) << 56)
584 | (((UV)dec->cur[-7]) << 48) 680 | (((UV)dec->cur[-7]) << 48)
585 | (((UV)dec->cur[-6]) << 40) 681 | (((UV)dec->cur[-6]) << 40)
586 | (((UV)dec->cur[-5]) << 32) 682 | (((UV)dec->cur[-5]) << 32)
683#endif
587 | (((UV)dec->cur[-4]) << 24) 684 | (((UV)dec->cur[-4]) << 24)
588 | (((UV)dec->cur[-3]) << 16) 685 | (((UV)dec->cur[-3]) << 16)
589 | (((UV)dec->cur[-2]) << 8) 686 | (((UV)dec->cur[-2]) << 8)
590 | ((UV)dec->cur[-1]); 687 | ((UV)dec->cur[-1]);
591 688 }
592 default: 689 else
593 ERR ("corrupted CBOR data (unsupported integer minor encoding)"); 690 ERR ("corrupted CBOR data (unsupported integer minor encoding)");
594 }
595 691
596fail: 692fail:
597 return 0; 693 return 0;
598} 694}
599 695
… …
604{ 700{
605 AV *av = newAV (); 701 AV *av = newAV ();
606 702
607 DEC_INC_DEPTH; 703 DEC_INC_DEPTH;
608 704
609 if ((*dec->cur & 31) == 31) 705 if (*dec->cur == (MAJOR_ARRAY | MINOR_INDEF))
610 { 706 {
611 ++dec->cur; 707 ++dec->cur;
612 708
613 for (;;) 709 for (;;)
614 { 710 {
615 WANT (1); 711 WANT (1);
616 712
617 if (*dec->cur == (0xe0 | 31)) 713 if (*dec->cur == (MAJOR_MISC | MINOR_INDEF))
618 { 714 {
619 ++dec->cur; 715 ++dec->cur;
620 break; 716 break;
621 } 717 }
622 718
… …
625 } 721 }
626 else 722 else
627 { 723 {
628 int i, len = decode_uint (dec); 724 int i, len = decode_uint (dec);
629 725
726 WANT (len); // complexity check for av_fill - need at least one byte per value, do not allow supersize arrays
630 av_fill (av, len - 1); 727 av_fill (av, len - 1);
631 728
632 for (i = 0; i < len; ++i) 729 for (i = 0; i < len; ++i)
633 AvARRAY (av)[i] = decode_sv (dec); 730 AvARRAY (av)[i] = decode_sv (dec);
634 } 731 }
… …
644 741
645static void 742static void
646decode_he (dec_t *dec, HV *hv) 743decode_he (dec_t *dec, HV *hv)
647{ 744{
648 // for speed reasons, we specialcase single-string 745 // for speed reasons, we specialcase single-string
649 // byte or utf-8 strings as keys. 746 // byte or utf-8 strings as keys, but only when !stringref
650 747
651 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))
652 { 750 {
653 I32 len = decode_uint (dec); 751 I32 len = decode_uint (dec);
654 char *key = (char *)dec->cur; 752 char *key = (char *)dec->cur;
655 753
754 WANT (len);
656 dec->cur += len; 755 dec->cur += len;
657 756
658 if (ecb_expect_false (dec->stringref))
659 av_push (dec->stringref, newSVpvn (key, len));
660
661 hv_store (hv, key, len, decode_sv (dec), 0); 757 hv_store (hv, key, len, decode_sv (dec), 0);
758
759 return;
662 } 760 }
663 else if (*dec->cur >= 0x60 && *dec->cur <= 0x60 + 27) 761 else if (ecb_expect_true ((U8)(*dec->cur - MAJOR_TEXT) <= LENGTH_EXT8))
664 { 762 {
665 I32 len = decode_uint (dec); 763 I32 len = decode_uint (dec);
666 char *key = (char *)dec->cur; 764 char *key = (char *)dec->cur;
667 765
766 WANT (len);
668 dec->cur += len; 767 dec->cur += len;
669 768
670 if (ecb_expect_false (dec->stringref)) 769 if (ecb_expect_false (dec->cbor.flags & F_VALIDATE_UTF8))
671 av_push (dec->stringref, newSVpvn_utf8 (key, len, 1)); 770 if (!is_utf8_string (key, len))
771 ERR ("corrupted CBOR data (invalid UTF-8 in map key)");
672 772
673 hv_store (hv, key, -len, decode_sv (dec), 0); 773 hv_store (hv, key, -len, decode_sv (dec), 0);
774
775 return;
674 } 776 }
675 else 777
676 {
677 SV *k = decode_sv (dec); 778 SV *k = decode_sv (dec);
678 SV *v = decode_sv (dec); 779 SV *v = decode_sv (dec);
679 780
680 hv_store_ent (hv, k, v, 0); 781 hv_store_ent (hv, k, v, 0);
681 SvREFCNT_dec (k); 782 SvREFCNT_dec (k);
682 } 783
784fail:
785 ;
683} 786}
684 787
685static SV * 788static SV *
686decode_hv (dec_t *dec) 789decode_hv (dec_t *dec)
687{ 790{
688 HV *hv = newHV (); 791 HV *hv = newHV ();
689 792
690 DEC_INC_DEPTH; 793 DEC_INC_DEPTH;
691 794
692 if ((*dec->cur & 31) == 31) 795 if (*dec->cur == (MAJOR_MAP | MINOR_INDEF))
693 { 796 {
694 ++dec->cur; 797 ++dec->cur;
695 798
696 for (;;) 799 for (;;)
697 { 800 {
698 WANT (1); 801 WANT (1);
699 802
700 if (*dec->cur == (0xe0 | 31)) 803 if (*dec->cur == (MAJOR_MISC | MINOR_INDEF))
701 { 804 {
702 ++dec->cur; 805 ++dec->cur;
703 break; 806 break;
704 } 807 }
705 808
… …
726static SV * 829static SV *
727decode_str (dec_t *dec, int utf8) 830decode_str (dec_t *dec, int utf8)
728{ 831{
729 SV *sv = 0; 832 SV *sv = 0;
730 833
731 if ((*dec->cur & 31) == 31) 834 if ((*dec->cur & MINOR_MASK) == MINOR_INDEF)
732 { 835 {
836 // indefinite length strings
733 ++dec->cur; 837 ++dec->cur;
734 838
839 U8 major = *dec->cur & MAJOR_MISC;
840
735 sv = newSVpvn ("", 0); 841 sv = newSVpvn ("", 0);
736 842
737 // not very fast, and certainly not robust against illegal input
738 for (;;) 843 for (;;)
739 { 844 {
740 WANT (1); 845 WANT (1);
741 846
742 if (*dec->cur == (0xe0 | 31)) 847 if ((*dec->cur - major) > LENGTH_EXT8)
848 if (*dec->cur == (MAJOR_MISC | MINOR_INDEF))
743 { 849 {
744 ++dec->cur; 850 ++dec->cur;
745 break; 851 break;
746 } 852 }
853 else
854 ERR ("corrupted CBOR data (invalid chunks in indefinite length string)");
747 855
748 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;
749 } 861 }
750 } 862 }
751 else 863 else
752 { 864 {
753 STRLEN len = decode_uint (dec); 865 STRLEN len = decode_uint (dec);
754 866
755 WANT (len); 867 WANT (len);
756 sv = newSVpvn (dec->cur, len); 868 sv = newSVpvn (dec->cur, len);
757 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));
758 } 874 }
759 875
760 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
761 SvUTF8_on (sv); 882 SvUTF8_on (sv);
762 883 }
763 if (ecb_expect_false (dec->stringref))
764 av_push (dec->stringref, SvREFCNT_inc_NN (sv));
765 884
766 return sv; 885 return sv;
767 886
768fail: 887fail:
769 SvREFCNT_dec (sv); 888 SvREFCNT_dec (sv);
… …
801 } 920 }
802 break; 921 break;
803 922
804 case CBOR_TAG_STRINGREF: 923 case CBOR_TAG_STRINGREF:
805 { 924 {
806 if ((*dec->cur >> 5) != 0) 925 if ((*dec->cur >> MAJOR_SHIFT) != (MAJOR_POS_INT >> MAJOR_SHIFT))
807 ERR ("corrupted CBOR data (stringref index not an unsigned integer)"); 926 ERR ("corrupted CBOR data (stringref index not an unsigned integer)");
808 927
809 UV idx = decode_uint (dec); 928 UV idx = decode_uint (dec);
810 929
811 if (!dec->stringref || (int)idx > AvFILLp (dec->stringref)) 930 if (!dec->stringref || (int)idx > AvFILLp (dec->stringref))
… …
818 case CBOR_TAG_VALUE_SHAREABLE: 937 case CBOR_TAG_VALUE_SHAREABLE:
819 { 938 {
820 if (ecb_expect_false (!dec->shareable)) 939 if (ecb_expect_false (!dec->shareable))
821 dec->shareable = (AV *)sv_2mortal ((SV *)newAV ()); 940 dec->shareable = (AV *)sv_2mortal ((SV *)newAV ());
822 941
942 if (dec->cbor.flags & F_ALLOW_CYCLES)
943 {
823 sv = newSV (0); 944 sv = newSV (0);
824 av_push (dec->shareable, SvREFCNT_inc_NN (sv)); 945 av_push (dec->shareable, SvREFCNT_inc_NN (sv));
825 946
826 SV *osv = decode_sv (dec); 947 SV *osv = decode_sv (dec);
827 sv_setsv (sv, osv); 948 sv_setsv (sv, osv);
828 SvREFCNT_dec_NN (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 }
829 } 958 }
830 break; 959 break;
831 960
832 case CBOR_TAG_VALUE_SHAREDREF: 961 case CBOR_TAG_VALUE_SHAREDREF:
833 { 962 {
834 if ((*dec->cur >> 5) != 0) 963 if ((*dec->cur >> MAJOR_SHIFT) != (MAJOR_POS_INT >> MAJOR_SHIFT))
835 ERR ("corrupted CBOR data (sharedref index not an unsigned integer)"); 964 ERR ("corrupted CBOR data (sharedref index not an unsigned integer)");
836 965
837 UV idx = decode_uint (dec); 966 UV idx = decode_uint (dec);
838 967
839 if (!dec->shareable || (int)idx > AvFILLp (dec->shareable)) 968 if (!dec->shareable || (int)idx > AvFILLp (dec->shareable))
840 ERR ("corrupted CBOR data (sharedref index out of bounds)"); 969 ERR ("corrupted CBOR data (sharedref index out of bounds)");
841 970
842 sv = SvREFCNT_inc_NN (AvARRAY (dec->shareable)[idx]); 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");
843 } 975 }
844 break; 976 break;
845 977
846 case CBOR_TAG_PERL_OBJECT: 978 case CBOR_TAG_PERL_OBJECT:
847 { 979 {
… …
896 1028
897 default: 1029 default:
898 { 1030 {
899 sv = decode_sv (dec); 1031 sv = decode_sv (dec);
900 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 {
901 AV *av = newAV (); 1056 AV *av = newAV ();
902 av_push (av, newSVuv (tag)); 1057 av_push (av, newSVuv (tag));
903 av_push (av, sv); 1058 av_push (av, sv);
904 1059
905 HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash 1060 HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash
906 ? cbor_tagged_stash 1061 ? cbor_tagged_stash
907 : gv_stashpv ("CBOR::XS::Tagged" , 1); 1062 : gv_stashpv ("CBOR::XS::Tagged" , 1);
908
909 sv = 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;
910 } 1069 }
911 break; 1070 break;
912 } 1071 }
913 1072
914 return sv; 1073 return sv;
… …
921static SV * 1080static SV *
922decode_sv (dec_t *dec) 1081decode_sv (dec_t *dec)
923{ 1082{
924 WANT (1); 1083 WANT (1);
925 1084
926 switch (*dec->cur >> 5) 1085 switch (*dec->cur >> MAJOR_SHIFT)
927 { 1086 {
928 case 0: // unsigned int 1087 case MAJOR_POS_INT >> MAJOR_SHIFT: return newSVuv (decode_uint (dec));
929 return newSVuv (decode_uint (dec)); 1088 case MAJOR_NEG_INT >> MAJOR_SHIFT: return newSViv (-1 - (IV)decode_uint (dec));
930 case 1: // negative int 1089 case MAJOR_BYTES >> MAJOR_SHIFT: return decode_str (dec, 0);
931 return newSViv (-1 - (IV)decode_uint (dec)); 1090 case MAJOR_TEXT >> MAJOR_SHIFT: return decode_str (dec, 1);
932 case 2: // octet string 1091 case MAJOR_ARRAY >> MAJOR_SHIFT: return decode_av (dec);
933 return decode_str (dec, 0); 1092 case MAJOR_MAP >> MAJOR_SHIFT: return decode_hv (dec);
934 case 3: // utf-8 string 1093 case MAJOR_TAG >> MAJOR_SHIFT: return decode_tagged (dec);
935 return decode_str (dec, 1); 1094
936 case 4: // array 1095 case MAJOR_MISC >> MAJOR_SHIFT:
937 return decode_av (dec);
938 case 5: // map
939 return decode_hv (dec);
940 case 6: // tag
941 return decode_tagged (dec);
942 case 7: // misc
943 switch (*dec->cur++ & 31) 1096 switch (*dec->cur++ & MINOR_MASK)
944 { 1097 {
945 case 20: 1098 case SIMPLE_FALSE:
946#if CBOR_SLOW 1099#if CBOR_SLOW
947 types_false = get_bool ("Types::Serialiser::false"); 1100 types_false = get_bool ("Types::Serialiser::false");
948#endif 1101#endif
949 return newSVsv (types_false); 1102 return newSVsv (types_false);
950 case 21: 1103 case SIMPLE_TRUE:
951#if CBOR_SLOW 1104#if CBOR_SLOW
952 types_true = get_bool ("Types::Serialiser::true"); 1105 types_true = get_bool ("Types::Serialiser::true");
953#endif 1106#endif
954 return newSVsv (types_true); 1107 return newSVsv (types_true);
955 case 22: 1108 case SIMPLE_NULL:
956 return newSVsv (&PL_sv_undef); 1109 return newSVsv (&PL_sv_undef);
957 case 23: 1110 case SIMPLE_UNDEF:
958#if CBOR_SLOW 1111#if CBOR_SLOW
959 types_error = get_bool ("Types::Serialiser::error"); 1112 types_error = get_bool ("Types::Serialiser::error");
960#endif 1113#endif
961 return newSVsv (types_error); 1114 return newSVsv (types_error);
962 1115
963 case 25: 1116 case MISC_FLOAT16:
964 { 1117 {
965 WANT (2); 1118 WANT (2);
966 1119
967 uint16_t fp = (dec->cur[0] << 8) | dec->cur[1]; 1120 uint16_t fp = (dec->cur[0] << 8) | dec->cur[1];
968 dec->cur += 2; 1121 dec->cur += 2;
969 1122
970 return newSVnv (ecb_binary16_to_float (fp)); 1123 return newSVnv (ecb_binary16_to_float (fp));
971 } 1124 }
972 1125
973 case 26: 1126 case MISC_FLOAT32:
974 { 1127 {
975 uint32_t fp; 1128 uint32_t fp;
976 WANT (4); 1129 WANT (4);
977 memcpy (&fp, dec->cur, 4); 1130 memcpy (&fp, dec->cur, 4);
978 dec->cur += 4; 1131 dec->cur += 4;
… …
981 fp = ecb_bswap32 (fp); 1134 fp = ecb_bswap32 (fp);
982 1135
983 return newSVnv (ecb_binary32_to_float (fp)); 1136 return newSVnv (ecb_binary32_to_float (fp));
984 } 1137 }
985 1138
986 case 27: 1139 case MISC_FLOAT64:
987 { 1140 {
988 uint64_t fp; 1141 uint64_t fp;
989 WANT (8); 1142 WANT (8);
990 memcpy (&fp, dec->cur, 8); 1143 memcpy (&fp, dec->cur, 8);
991 dec->cur += 8; 1144 dec->cur += 8;
… …
994 fp = ecb_bswap64 (fp); 1147 fp = ecb_bswap64 (fp);
995 1148
996 return newSVnv (ecb_binary64_to_double (fp)); 1149 return newSVnv (ecb_binary64_to_double (fp));
997 } 1150 }
998 1151
999 // 0..19 unassigned 1152 // 0..19 unassigned simple
1000 // 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
1001 default: 1156 default:
1002 ERR ("corrupted CBOR data (reserved/unassigned major 7 value)"); 1157 ERR ("corrupted CBOR data (reserved/unassigned/unexpected major 7 value)");
1003 } 1158 }
1004 1159
1005 break; 1160 break;
1006 } 1161 }
1007 1162
… …
1010} 1165}
1011 1166
1012static SV * 1167static SV *
1013decode_cbor (SV *string, CBOR *cbor, char **offset_return) 1168decode_cbor (SV *string, CBOR *cbor, char **offset_return)
1014{ 1169{
1015 dec_t dec = { }; 1170 dec_t dec = { 0 };
1016 SV *sv; 1171 SV *sv;
1017 STRLEN len; 1172 STRLEN len;
1018 char *data = SvPVbyte (string, len); 1173 char *data = SvPVbyte (string, len);
1019 1174
1020 if (len > cbor->max_size && cbor->max_size) 1175 if (len > cbor->max_size && cbor->max_size)
… …
1034 if (dec.cur != dec.end && !dec.err) 1189 if (dec.cur != dec.end && !dec.err)
1035 dec.err = "garbage after CBOR object"; 1190 dec.err = "garbage after CBOR object";
1036 1191
1037 if (dec.err) 1192 if (dec.err)
1038 { 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
1039 SvREFCNT_dec (sv); 1205 SvREFCNT_dec (sv);
1040 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);
1041 } 1207 }
1042 1208
1043 sv = sv_2mortal (sv); 1209 sv = sv_2mortal (sv);
1044 1210
1045 return sv; 1211 return sv;
1046} 1212}
1047 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
1048///////////////////////////////////////////////////////////////////////////// 1338/////////////////////////////////////////////////////////////////////////////
1049// XS interface functions 1339// XS interface functions
1050 1340
1051MODULE = CBOR::XS PACKAGE = CBOR::XS 1341MODULE = CBOR::XS PACKAGE = CBOR::XS
1052 1342
… …
1059 types_error_stash = gv_stashpv ("Types::Serialiser::Error" , 1); 1349 types_error_stash = gv_stashpv ("Types::Serialiser::Error" , 1);
1060 1350
1061 types_true = get_bool ("Types::Serialiser::true" ); 1351 types_true = get_bool ("Types::Serialiser::true" );
1062 types_false = get_bool ("Types::Serialiser::false"); 1352 types_false = get_bool ("Types::Serialiser::false");
1063 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);
1064 1356
1065 sv_cbor = newSVpv ("CBOR", 0); 1357 sv_cbor = newSVpv ("CBOR", 0);
1066 SvREADONLY_on (sv_cbor); 1358 SvREADONLY_on (sv_cbor);
1067} 1359}
1068 1360
… …
1090void shrink (CBOR *self, int enable = 1) 1382void shrink (CBOR *self, int enable = 1)
1091 ALIAS: 1383 ALIAS:
1092 shrink = F_SHRINK 1384 shrink = F_SHRINK
1093 allow_unknown = F_ALLOW_UNKNOWN 1385 allow_unknown = F_ALLOW_UNKNOWN
1094 allow_sharing = F_ALLOW_SHARING 1386 allow_sharing = F_ALLOW_SHARING
1095 dedup_keys = F_DEDUP_KEYS 1387 allow_cycles = F_ALLOW_CYCLES
1096 dedup_strings = F_DEDUP_STRINGS 1388 pack_strings = F_PACK_STRINGS
1389 validate_utf8 = F_VALIDATE_UTF8
1097 PPCODE: 1390 PPCODE:
1098{ 1391{
1099 if (enable) 1392 if (enable)
1100 self->flags |= ix; 1393 self->flags |= ix;
1101 else 1394 else
… …
1107void get_shrink (CBOR *self) 1400void get_shrink (CBOR *self)
1108 ALIAS: 1401 ALIAS:
1109 get_shrink = F_SHRINK 1402 get_shrink = F_SHRINK
1110 get_allow_unknown = F_ALLOW_UNKNOWN 1403 get_allow_unknown = F_ALLOW_UNKNOWN
1111 get_allow_sharing = F_ALLOW_SHARING 1404 get_allow_sharing = F_ALLOW_SHARING
1112 get_dedup_keys = F_DEDUP_KEYS 1405 get_allow_cycles = F_ALLOW_CYCLES
1113 get_dedup_strings = F_DEDUP_STRINGS 1406 get_pack_strings = F_PACK_STRINGS
1407 get_validate_utf8 = F_VALIDATE_UTF8
1114 PPCODE: 1408 PPCODE:
1115 XPUSHs (boolSV (self->flags & ix)); 1409 XPUSHs (boolSV (self->flags & ix));
1116 1410
1117void max_depth (CBOR *self, U32 max_depth = 0x80000000UL) 1411void max_depth (CBOR *self, U32 max_depth = 0x80000000UL)
1118 PPCODE: 1412 PPCODE:
… …
1131 XPUSHs (ST (0)); 1425 XPUSHs (ST (0));
1132 1426
1133int get_max_size (CBOR *self) 1427int get_max_size (CBOR *self)
1134 CODE: 1428 CODE:
1135 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);
1136 OUTPUT: 1442 OUTPUT:
1137 RETVAL 1443 RETVAL
1138 1444
1139void encode (CBOR *self, SV *scalar) 1445void encode (CBOR *self, SV *scalar)
1140 PPCODE: 1446 PPCODE:
… …
1155 EXTEND (SP, 2); 1461 EXTEND (SP, 2);
1156 PUSHs (sv); 1462 PUSHs (sv);
1157 PUSHs (sv_2mortal (newSVuv (offset - SvPVX (cborstr)))); 1463 PUSHs (sv_2mortal (newSVuv (offset - SvPVX (cborstr))));
1158} 1464}
1159 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
1160PROTOTYPES: ENABLE 1522PROTOTYPES: ENABLE
1161 1523
1162void encode_cbor (SV *scalar) 1524void encode_cbor (SV *scalar)
1525 ALIAS:
1526 encode_cbor = 0
1527 encode_cbor_sharing = F_ALLOW_SHARING
1163 PPCODE: 1528 PPCODE:
1164{ 1529{
1165 CBOR cbor; 1530 CBOR cbor;
1166 cbor_init (&cbor); 1531 cbor_init (&cbor);
1532 cbor.flags |= ix;
1167 PUTBACK; scalar = encode_cbor (scalar, &cbor); SPAGAIN; 1533 PUTBACK; scalar = encode_cbor (scalar, &cbor); SPAGAIN;
1168 XPUSHs (scalar); 1534 XPUSHs (scalar);
1169} 1535}
1170 1536
1171void decode_cbor (SV *cborstr) 1537void decode_cbor (SV *cborstr)

Diff Legend

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