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

Comparing CBOR-XS/XS.xs (file contents):
Revision 1.17 by root, Tue Oct 29 22:04:52 2013 UTC vs.
Revision 1.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 {
718 if (!SvROK (sv) || SvTYPE (SvRV (sv)) != SVt_PVAV)
719 ERR ("corrupted CBOR data (non-array perl object)");
720 909
721 AV *av = (AV *)SvRV (sv); 910 case CBOR_TAG_STRINGREF_NAMESPACE:
722 int len = av_len (av) + 1;
723 HV *stash = gv_stashsv (*av_fetch (av, 0, 1), 0);
724
725 if (!stash)
726 ERR ("cannot decode perl-object (package does not exist)");
727
728 GV *method = gv_fetchmethod_autoload (stash, "THAW", 0);
729 911 {
730 if (!method) 912 ENTER; SAVETMPS;
731 ERR ("cannot decode perl-object (package does not have a THAW method)");
732
733 dSP;
734 913
735 ENTER; SAVETMPS; PUSHMARK (SP); 914 SAVESPTR (dec->stringref);
736 EXTEND (SP, len + 1); 915 dec->stringref = (AV *)sv_2mortal ((SV *)newAV ());
737 // we re-bless the reference to get overload and other niceties right
738 PUSHs (*av_fetch (av, 0, 1));
739 PUSHs (sv_cbor);
740 916
741 int i; 917 sv = decode_sv (dec);
742 918
743 for (i = 1; i < len; ++i)
744 PUSHs (*av_fetch (av, i, 1));
745
746 PUTBACK;
747 call_sv ((SV *)GvCV (method), G_SCALAR | G_EVAL);
748 SPAGAIN;
749
750 if (SvTRUE (ERRSV))
751 {
752 FREETMPS; LEAVE; 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
982 if (!SvROK (sv) || SvTYPE (SvRV (sv)) != SVt_PVAV)
983 ERR ("corrupted CBOR data (non-array perl object)");
984
985 AV *av = (AV *)SvRV (sv);
986 int len = av_len (av) + 1;
987 HV *stash = gv_stashsv (*av_fetch (av, 0, 1), 0);
988
989 if (!stash)
990 ERR ("cannot decode perl-object (package does not exist)");
991
992 GV *method = gv_fetchmethod_autoload (stash, "THAW", 0);
993
994 if (!method)
995 ERR ("cannot decode perl-object (package does not have a THAW method)");
996
997 dSP;
998
999 ENTER; SAVETMPS; PUSHMARK (SP);
1000 EXTEND (SP, len + 1);
1001 // we re-bless the reference to get overload and other niceties right
1002 PUSHs (*av_fetch (av, 0, 1));
1003 PUSHs (sv_cbor);
1004
1005 int i;
1006
1007 for (i = 1; i < len; ++i)
1008 PUSHs (*av_fetch (av, i, 1));
1009
1010 PUTBACK;
1011 call_sv ((SV *)GvCV (method), G_SCALAR | G_EVAL);
1012 SPAGAIN;
1013
1014 if (SvTRUE (ERRSV))
1015 {
1016 FREETMPS; LEAVE;
753 ERR (SvPVutf8_nolen (sv_2mortal (SvREFCNT_inc (ERRSV)))); 1017 ERR (SvPVutf8_nolen (sv_2mortal (SvREFCNT_inc (ERRSV))));
754 } 1018 }
755 1019
756 SvREFCNT_dec (sv); 1020 SvREFCNT_dec (sv);
757 sv = SvREFCNT_inc (POPs); 1021 sv = SvREFCNT_inc (POPs);
758 1022
759 PUTBACK; 1023 PUTBACK;
760 1024
761 FREETMPS; LEAVE; 1025 FREETMPS; LEAVE;
1026 }
1027 break;
762 1028
763 return sv; 1029 default:
764 } 1030 {
765 else 1031 sv = decode_sv (dec);
766 { 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 {
767 AV *av = newAV (); 1056 AV *av = newAV ();
768 av_push (av, newSVuv (tag)); 1057 av_push (av, newSVuv (tag));
769 av_push (av, sv); 1058 av_push (av, sv);
770 1059
771 HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash 1060 HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash
772 ? cbor_tagged_stash 1061 ? cbor_tagged_stash
773 : gv_stashpv ("CBOR::XS::Tagged" , 1); 1062 : gv_stashpv ("CBOR::XS::Tagged" , 1);
774
775 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;
776 } 1071 }
1072
1073 return sv;
777 1074
778fail: 1075fail:
779 SvREFCNT_dec (sv); 1076 SvREFCNT_dec (sv);
780 return &PL_sv_undef; 1077 return &PL_sv_undef;
781} 1078}
… …
783static SV * 1080static SV *
784decode_sv (dec_t *dec) 1081decode_sv (dec_t *dec)
785{ 1082{
786 WANT (1); 1083 WANT (1);
787 1084
788 switch (*dec->cur >> 5) 1085 switch (*dec->cur >> MAJOR_SHIFT)
789 { 1086 {
790 case 0: // unsigned int 1087 case MAJOR_POS_INT >> MAJOR_SHIFT: return newSVuv (decode_uint (dec));
791 return newSVuv (decode_uint (dec)); 1088 case MAJOR_NEG_INT >> MAJOR_SHIFT: return newSViv (-1 - (IV)decode_uint (dec));
792 case 1: // negative int 1089 case MAJOR_BYTES >> MAJOR_SHIFT: return decode_str (dec, 0);
793 return newSViv (-1 - (IV)decode_uint (dec)); 1090 case MAJOR_TEXT >> MAJOR_SHIFT: return decode_str (dec, 1);
794 case 2: // octet string 1091 case MAJOR_ARRAY >> MAJOR_SHIFT: return decode_av (dec);
795 return decode_str (dec, 0); 1092 case MAJOR_MAP >> MAJOR_SHIFT: return decode_hv (dec);
796 case 3: // utf-8 string 1093 case MAJOR_TAG >> MAJOR_SHIFT: return decode_tagged (dec);
797 return decode_str (dec, 1); 1094
798 case 4: // array 1095 case MAJOR_MISC >> MAJOR_SHIFT:
799 return decode_av (dec);
800 case 5: // map
801 return decode_hv (dec);
802 case 6: // tag
803 return decode_tagged (dec);
804 case 7: // misc
805 switch (*dec->cur++ & 31) 1096 switch (*dec->cur++ & MINOR_MASK)
806 { 1097 {
807 case 20: 1098 case SIMPLE_FALSE:
808#if CBOR_SLOW 1099#if CBOR_SLOW
809 types_false = get_bool ("Types::Serialiser::false"); 1100 types_false = get_bool ("Types::Serialiser::false");
810#endif 1101#endif
811 return newSVsv (types_false); 1102 return newSVsv (types_false);
812 case 21: 1103 case SIMPLE_TRUE:
813#if CBOR_SLOW 1104#if CBOR_SLOW
814 types_true = get_bool ("Types::Serialiser::true"); 1105 types_true = get_bool ("Types::Serialiser::true");
815#endif 1106#endif
816 return newSVsv (types_true); 1107 return newSVsv (types_true);
817 case 22: 1108 case SIMPLE_NULL:
818 return newSVsv (&PL_sv_undef); 1109 return newSVsv (&PL_sv_undef);
819 case 23: 1110 case SIMPLE_UNDEF:
820#if CBOR_SLOW 1111#if CBOR_SLOW
821 types_error = get_bool ("Types::Serialiser::error"); 1112 types_error = get_bool ("Types::Serialiser::error");
822#endif 1113#endif
823 return newSVsv (types_error); 1114 return newSVsv (types_error);
824 1115
825 case 25: 1116 case MISC_FLOAT16:
826 { 1117 {
827 WANT (2); 1118 WANT (2);
828 1119
829 uint16_t fp = (dec->cur[0] << 8) | dec->cur[1]; 1120 uint16_t fp = (dec->cur[0] << 8) | dec->cur[1];
830 dec->cur += 2; 1121 dec->cur += 2;
831 1122
832 return newSVnv (ecb_binary16_to_float (fp)); 1123 return newSVnv (ecb_binary16_to_float (fp));
833 } 1124 }
834 1125
835 case 26: 1126 case MISC_FLOAT32:
836 { 1127 {
837 uint32_t fp; 1128 uint32_t fp;
838 WANT (4); 1129 WANT (4);
839 memcpy (&fp, dec->cur, 4); 1130 memcpy (&fp, dec->cur, 4);
840 dec->cur += 4; 1131 dec->cur += 4;
… …
843 fp = ecb_bswap32 (fp); 1134 fp = ecb_bswap32 (fp);
844 1135
845 return newSVnv (ecb_binary32_to_float (fp)); 1136 return newSVnv (ecb_binary32_to_float (fp));
846 } 1137 }
847 1138
848 case 27: 1139 case MISC_FLOAT64:
849 { 1140 {
850 uint64_t fp; 1141 uint64_t fp;
851 WANT (8); 1142 WANT (8);
852 memcpy (&fp, dec->cur, 8); 1143 memcpy (&fp, dec->cur, 8);
853 dec->cur += 8; 1144 dec->cur += 8;
… …
856 fp = ecb_bswap64 (fp); 1147 fp = ecb_bswap64 (fp);
857 1148
858 return newSVnv (ecb_binary64_to_double (fp)); 1149 return newSVnv (ecb_binary64_to_double (fp));
859 } 1150 }
860 1151
861 // 0..19 unassigned 1152 // 0..19 unassigned simple
862 // 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
863 default: 1156 default:
864 ERR ("corrupted CBOR data (reserved/unassigned major 7 value)"); 1157 ERR ("corrupted CBOR data (reserved/unassigned/unexpected major 7 value)");
865 } 1158 }
866 1159
867 break; 1160 break;
868 } 1161 }
869 1162
… …
872} 1165}
873 1166
874static SV * 1167static SV *
875decode_cbor (SV *string, CBOR *cbor, char **offset_return) 1168decode_cbor (SV *string, CBOR *cbor, char **offset_return)
876{ 1169{
877 dec_t dec; 1170 dec_t dec = { 0 };
878 SV *sv; 1171 SV *sv;
879 STRLEN len; 1172 STRLEN len;
880 char *data = SvPVbyte (string, len); 1173 char *data = SvPVbyte (string, len);
881 1174
882 if (len > cbor->max_size && cbor->max_size) 1175 if (len > cbor->max_size && cbor->max_size)
… …
884 (unsigned long)len, (unsigned long)cbor->max_size); 1177 (unsigned long)len, (unsigned long)cbor->max_size);
885 1178
886 dec.cbor = *cbor; 1179 dec.cbor = *cbor;
887 dec.cur = (U8 *)data; 1180 dec.cur = (U8 *)data;
888 dec.end = (U8 *)data + len; 1181 dec.end = (U8 *)data + len;
889 dec.err = 0;
890 dec.depth = 0;
891 1182
892 sv = decode_sv (&dec); 1183 sv = decode_sv (&dec);
893 1184
894 if (offset_return) 1185 if (offset_return)
895 *offset_return = dec.cur; 1186 *offset_return = dec.cur;
… …
898 if (dec.cur != dec.end && !dec.err) 1189 if (dec.cur != dec.end && !dec.err)
899 dec.err = "garbage after CBOR object"; 1190 dec.err = "garbage after CBOR object";
900 1191
901 if (dec.err) 1192 if (dec.err)
902 { 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
903 SvREFCNT_dec (sv); 1205 SvREFCNT_dec (sv);
904 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);
905 } 1207 }
906 1208
907 sv = sv_2mortal (sv); 1209 sv = sv_2mortal (sv);
908 1210
909 return sv; 1211 return sv;
910} 1212}
911 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
912///////////////////////////////////////////////////////////////////////////// 1338/////////////////////////////////////////////////////////////////////////////
913// XS interface functions 1339// XS interface functions
914 1340
915MODULE = CBOR::XS PACKAGE = CBOR::XS 1341MODULE = CBOR::XS PACKAGE = CBOR::XS
916 1342
… …
923 types_error_stash = gv_stashpv ("Types::Serialiser::Error" , 1); 1349 types_error_stash = gv_stashpv ("Types::Serialiser::Error" , 1);
924 1350
925 types_true = get_bool ("Types::Serialiser::true" ); 1351 types_true = get_bool ("Types::Serialiser::true" );
926 types_false = get_bool ("Types::Serialiser::false"); 1352 types_false = get_bool ("Types::Serialiser::false");
927 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);
928 1356
929 sv_cbor = newSVpv ("CBOR", 0); 1357 sv_cbor = newSVpv ("CBOR", 0);
930 SvREADONLY_on (sv_cbor); 1358 SvREADONLY_on (sv_cbor);
931} 1359}
932 1360
… …
953 1381
954void shrink (CBOR *self, int enable = 1) 1382void shrink (CBOR *self, int enable = 1)
955 ALIAS: 1383 ALIAS:
956 shrink = F_SHRINK 1384 shrink = F_SHRINK
957 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
958 PPCODE: 1390 PPCODE:
959{ 1391{
960 if (enable) 1392 if (enable)
961 self->flags |= ix; 1393 self->flags |= ix;
962 else 1394 else
… …
967 1399
968void get_shrink (CBOR *self) 1400void get_shrink (CBOR *self)
969 ALIAS: 1401 ALIAS:
970 get_shrink = F_SHRINK 1402 get_shrink = F_SHRINK
971 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
972 PPCODE: 1408 PPCODE:
973 XPUSHs (boolSV (self->flags & ix)); 1409 XPUSHs (boolSV (self->flags & ix));
974 1410
975void max_depth (CBOR *self, U32 max_depth = 0x80000000UL) 1411void max_depth (CBOR *self, U32 max_depth = 0x80000000UL)
976 PPCODE: 1412 PPCODE:
… …
989 XPUSHs (ST (0)); 1425 XPUSHs (ST (0));
990 1426
991int get_max_size (CBOR *self) 1427int get_max_size (CBOR *self)
992 CODE: 1428 CODE:
993 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);
994 OUTPUT: 1442 OUTPUT:
995 RETVAL 1443 RETVAL
996 1444
997void encode (CBOR *self, SV *scalar) 1445void encode (CBOR *self, SV *scalar)
998 PPCODE: 1446 PPCODE:
… …
1013 EXTEND (SP, 2); 1461 EXTEND (SP, 2);
1014 PUSHs (sv); 1462 PUSHs (sv);
1015 PUSHs (sv_2mortal (newSVuv (offset - SvPVX (cborstr)))); 1463 PUSHs (sv_2mortal (newSVuv (offset - SvPVX (cborstr))));
1016} 1464}
1017 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
1018PROTOTYPES: ENABLE 1522PROTOTYPES: ENABLE
1019 1523
1020void encode_cbor (SV *scalar) 1524void encode_cbor (SV *scalar)
1525 ALIAS:
1526 encode_cbor = 0
1527 encode_cbor_sharing = F_ALLOW_SHARING
1021 PPCODE: 1528 PPCODE:
1022{ 1529{
1023 CBOR cbor; 1530 CBOR cbor;
1024 cbor_init (&cbor); 1531 cbor_init (&cbor);
1532 cbor.flags |= ix;
1025 PUTBACK; scalar = encode_cbor (scalar, &cbor); SPAGAIN; 1533 PUTBACK; scalar = encode_cbor (scalar, &cbor); SPAGAIN;
1026 XPUSHs (scalar); 1534 XPUSHs (scalar);
1027} 1535}
1028 1536
1029void decode_cbor (SV *cborstr) 1537void decode_cbor (SV *cborstr)

Diff Legend

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