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.15 by root, Tue Oct 29 18:37:31 2013 UTC vs.
Revision 1.48 by root, Sun Sep 20 23:25:53 2015 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 }
… …
584 SvREFCNT_dec (av); 737 SvREFCNT_dec (av);
585 DEC_DEC_DEPTH; 738 DEC_DEC_DEPTH;
586 return &PL_sv_undef; 739 return &PL_sv_undef;
587} 740}
588 741
742static void
743decode_he (dec_t *dec, HV *hv)
744{
745 // for speed reasons, we specialcase single-string
746 // byte or utf-8 strings as keys, but only when !stringref
747
748 if (ecb_expect_true (!dec->stringref))
749 if (ecb_expect_true ((U8)(*dec->cur - MAJOR_BYTES) <= LENGTH_EXT8))
750 {
751 I32 len = decode_uint (dec);
752 char *key = (char *)dec->cur;
753
754 dec->cur += len;
755
756 hv_store (hv, key, len, decode_sv (dec), 0);
757
758 return;
759 }
760 else if (ecb_expect_true ((U8)(*dec->cur - MAJOR_TEXT) <= LENGTH_EXT8))
761 {
762 I32 len = decode_uint (dec);
763 char *key = (char *)dec->cur;
764
765 dec->cur += len;
766
767 if (ecb_expect_false (dec->cbor.flags & F_VALIDATE_UTF8))
768 if (!is_utf8_string (key, len))
769 ERR ("corrupted CBOR data (invalid UTF-8 in map key)");
770
771 hv_store (hv, key, -len, decode_sv (dec), 0);
772
773 return;
774 }
775
776 SV *k = decode_sv (dec);
777 SV *v = decode_sv (dec);
778
779 hv_store_ent (hv, k, v, 0);
780 SvREFCNT_dec (k);
781
782fail:
783 ;
784}
785
589static SV * 786static SV *
590decode_hv (dec_t *dec) 787decode_hv (dec_t *dec)
591{ 788{
592 HV *hv = newHV (); 789 HV *hv = newHV ();
593 790
594 DEC_INC_DEPTH; 791 DEC_INC_DEPTH;
595 792
596 if ((*dec->cur & 31) == 31) 793 if (*dec->cur == (MAJOR_MAP | MINOR_INDEF))
597 { 794 {
598 ++dec->cur; 795 ++dec->cur;
599 796
600 for (;;) 797 for (;;)
601 { 798 {
602 WANT (1); 799 WANT (1);
603 800
604 if (*dec->cur == (0xe0 | 31)) 801 if (*dec->cur == (MAJOR_MISC | MINOR_INDEF))
605 { 802 {
606 ++dec->cur; 803 ++dec->cur;
607 break; 804 break;
608 } 805 }
609 806
610 SV *k = decode_sv (dec); 807 decode_he (dec, hv);
611 SV *v = decode_sv (dec);
612
613 hv_store_ent (hv, k, v, 0);
614 SvREFCNT_dec (k);
615 } 808 }
616 } 809 }
617 else 810 else
618 { 811 {
619 int len = decode_uint (dec); 812 int pairs = decode_uint (dec);
620 813
621 while (len--) 814 while (pairs--)
622 { 815 decode_he (dec, hv);
623 SV *k = decode_sv (dec);
624 SV *v = decode_sv (dec);
625
626 hv_store_ent (hv, k, v, 0);
627 SvREFCNT_dec (k);
628 }
629 } 816 }
630 817
631 DEC_DEC_DEPTH; 818 DEC_DEC_DEPTH;
632 return newRV_noinc ((SV *)hv); 819 return newRV_noinc ((SV *)hv);
633 820
… …
640static SV * 827static SV *
641decode_str (dec_t *dec, int utf8) 828decode_str (dec_t *dec, int utf8)
642{ 829{
643 SV *sv = 0; 830 SV *sv = 0;
644 831
645 if ((*dec->cur & 31) == 31) 832 if ((*dec->cur & MINOR_MASK) == MINOR_INDEF)
646 { 833 {
834 // indefinite length strings
647 ++dec->cur; 835 ++dec->cur;
648 836
837 U8 major = *dec->cur & MAJOR_MISC;
838
649 sv = newSVpvn ("", 0); 839 sv = newSVpvn ("", 0);
650 840
651 // not very fast, and certainly not robust against illegal input
652 for (;;) 841 for (;;)
653 { 842 {
654 WANT (1); 843 WANT (1);
655 844
656 if (*dec->cur == (0xe0 | 31)) 845 if ((*dec->cur - major) > LENGTH_EXT8)
846 if (*dec->cur == (MAJOR_MISC | MINOR_INDEF))
657 { 847 {
658 ++dec->cur; 848 ++dec->cur;
659 break; 849 break;
660 } 850 }
851 else
852 ERR ("corrupted CBOR data (invalid chunks in indefinite length string)");
661 853
662 sv_catsv (sv, decode_sv (dec)); 854 STRLEN len = decode_uint (dec);
855
856 WANT (len);
857 sv_catpvn (sv, dec->cur, len);
858 dec->cur += len;
663 } 859 }
664 } 860 }
665 else 861 else
666 { 862 {
667 STRLEN len = decode_uint (dec); 863 STRLEN len = decode_uint (dec);
668 864
669 WANT (len); 865 WANT (len);
670 sv = newSVpvn (dec->cur, len); 866 sv = newSVpvn (dec->cur, len);
671 dec->cur += len; 867 dec->cur += len;
868
869 if (ecb_expect_false (dec->stringref)
870 && SvCUR (sv) >= minimum_string_length (AvFILLp (dec->stringref) + 1))
871 av_push (dec->stringref, SvREFCNT_inc_NN (sv));
672 } 872 }
673 873
674 if (utf8) 874 if (utf8)
875 {
876 if (ecb_expect_false (dec->cbor.flags & F_VALIDATE_UTF8))
877 if (!is_utf8_string (SvPVX (sv), SvCUR (sv)))
878 ERR ("corrupted CBOR data (invalid UTF-8 in text string)");
879
675 SvUTF8_on (sv); 880 SvUTF8_on (sv);
881 }
676 882
677 return sv; 883 return sv;
678 884
679fail: 885fail:
680 SvREFCNT_dec (sv); 886 SvREFCNT_dec (sv);
… …
682} 888}
683 889
684static SV * 890static SV *
685decode_tagged (dec_t *dec) 891decode_tagged (dec_t *dec)
686{ 892{
893 SV *sv = 0;
687 UV tag = decode_uint (dec); 894 UV tag = decode_uint (dec);
895
896 WANT (1);
897
898 switch (tag)
899 {
900 case CBOR_TAG_MAGIC:
688 SV *sv = decode_sv (dec); 901 sv = decode_sv (dec);
902 break;
689 903
690 if (tag == CBOR_TAG_MAGIC) 904 case CBOR_TAG_INDIRECTION:
691 return sv; 905 sv = newRV_noinc (decode_sv (dec));
692 else if (tag == CBOR_TAG_PERL_OBJECT) 906 break;
693 { 907
908 case CBOR_TAG_STRINGREF_NAMESPACE:
909 {
910 ENTER; SAVETMPS;
911
912 SAVESPTR (dec->stringref);
913 dec->stringref = (AV *)sv_2mortal ((SV *)newAV ());
914
915 sv = decode_sv (dec);
916
917 FREETMPS; LEAVE;
918 }
919 break;
920
921 case CBOR_TAG_STRINGREF:
922 {
923 if ((*dec->cur >> MAJOR_SHIFT) != (MAJOR_POS_INT >> MAJOR_SHIFT))
924 ERR ("corrupted CBOR data (stringref index not an unsigned integer)");
925
926 UV idx = decode_uint (dec);
927
928 if (!dec->stringref || (int)idx > AvFILLp (dec->stringref))
929 ERR ("corrupted CBOR data (stringref index out of bounds or outside namespace)");
930
931 sv = newSVsv (AvARRAY (dec->stringref)[idx]);
932 }
933 break;
934
935 case CBOR_TAG_VALUE_SHAREABLE:
936 {
937 if (ecb_expect_false (!dec->shareable))
938 dec->shareable = (AV *)sv_2mortal ((SV *)newAV ());
939
940 if (dec->cbor.flags & F_ALLOW_CYCLES)
941 {
942 sv = newSV (0);
943 av_push (dec->shareable, SvREFCNT_inc_NN (sv));
944
945 SV *osv = decode_sv (dec);
946 sv_setsv (sv, osv);
947 SvREFCNT_dec_NN (osv);
948 }
949 else
950 {
951 av_push (dec->shareable, &PL_sv_undef);
952 int idx = AvFILLp (dec->shareable);
953 sv = decode_sv (dec);
954 av_store (dec->shareable, idx, SvREFCNT_inc_NN (sv));
955 }
956 }
957 break;
958
959 case CBOR_TAG_VALUE_SHAREDREF:
960 {
961 if ((*dec->cur >> MAJOR_SHIFT) != (MAJOR_POS_INT >> MAJOR_SHIFT))
962 ERR ("corrupted CBOR data (sharedref index not an unsigned integer)");
963
964 UV idx = decode_uint (dec);
965
966 if (!dec->shareable || (int)idx > AvFILLp (dec->shareable))
967 ERR ("corrupted CBOR data (sharedref index out of bounds)");
968
969 sv = SvREFCNT_inc_NN (AvARRAY (dec->shareable)[idx]);
970
971 if (sv == &PL_sv_undef)
972 ERR ("cyclic CBOR data structure found, but allow_cycles is not enabled");
973 }
974 break;
975
976 case CBOR_TAG_PERL_OBJECT:
977 {
978 sv = decode_sv (dec);
979
694 if (!SvROK (sv) || SvTYPE (SvRV (sv)) != SVt_PVAV) 980 if (!SvROK (sv) || SvTYPE (SvRV (sv)) != SVt_PVAV)
695 ERR ("corrupted CBOR data (non-array perl object)"); 981 ERR ("corrupted CBOR data (non-array perl object)");
696 982
697 AV *av = (AV *)SvRV (sv); 983 AV *av = (AV *)SvRV (sv);
698 int len = av_len (av) + 1; 984 int len = av_len (av) + 1;
699 HV *stash = gv_stashsv (*av_fetch (av, 0, 1), 0); 985 HV *stash = gv_stashsv (*av_fetch (av, 0, 1), 0);
700 986
701 if (!stash) 987 if (!stash)
702 ERR ("cannot decode perl-object (package does not exist)"); 988 ERR ("cannot decode perl-object (package does not exist)");
703 989
704 GV *method = gv_fetchmethod_autoload (stash, "THAW", 0); 990 GV *method = gv_fetchmethod_autoload (stash, "THAW", 0);
705 991
706 if (!method) 992 if (!method)
707 ERR ("cannot decode perl-object (package does not have a THAW method)"); 993 ERR ("cannot decode perl-object (package does not have a THAW method)");
708 994
709 dSP; 995 dSP;
710 996
711 ENTER; SAVETMPS; PUSHMARK (SP); 997 ENTER; SAVETMPS; PUSHMARK (SP);
712 EXTEND (SP, len + 1); 998 EXTEND (SP, len + 1);
713 // we re-bless the reference to get overload and other niceties right 999 // we re-bless the reference to get overload and other niceties right
714 PUSHs (*av_fetch (av, 0, 1)); 1000 PUSHs (*av_fetch (av, 0, 1));
715 PUSHs (sv_cbor); 1001 PUSHs (sv_cbor);
716 1002
717 int i; 1003 int i;
718 1004
719 for (i = 1; i < len; ++i) 1005 for (i = 1; i < len; ++i)
720 PUSHs (*av_fetch (av, i, 1)); 1006 PUSHs (*av_fetch (av, i, 1));
721 1007
722 PUTBACK; 1008 PUTBACK;
723 call_sv ((SV *)GvCV (method), G_SCALAR); 1009 call_sv ((SV *)GvCV (method), G_SCALAR | G_EVAL);
724 SPAGAIN; 1010 SPAGAIN;
725 1011
1012 if (SvTRUE (ERRSV))
1013 {
1014 FREETMPS; LEAVE;
1015 ERR (SvPVutf8_nolen (sv_2mortal (SvREFCNT_inc (ERRSV))));
1016 }
1017
726 SvREFCNT_dec (sv); 1018 SvREFCNT_dec (sv);
727 sv = SvREFCNT_inc (POPs); 1019 sv = SvREFCNT_inc (POPs);
728 1020
729 PUTBACK; 1021 PUTBACK;
730 1022
731 FREETMPS; LEAVE; 1023 FREETMPS; LEAVE;
1024 }
1025 break;
732 1026
733 return sv; 1027 default:
734 } 1028 {
735 else 1029 sv = decode_sv (dec);
736 { 1030
1031 dSP;
1032 ENTER; SAVETMPS; PUSHMARK (SP);
1033 EXTEND (SP, 2);
1034 PUSHs (newSVuv (tag));
1035 PUSHs (sv);
1036
1037 PUTBACK;
1038 int count = call_sv (dec->cbor.filter ? dec->cbor.filter : default_filter, G_ARRAY | G_EVAL);
1039 SPAGAIN;
1040
1041 if (SvTRUE (ERRSV))
1042 {
1043 FREETMPS; LEAVE;
1044 ERR (SvPVutf8_nolen (sv_2mortal (SvREFCNT_inc (ERRSV))));
1045 }
1046
1047 if (count)
1048 {
1049 SvREFCNT_dec (sv);
1050 sv = SvREFCNT_inc (POPs);
1051 }
1052 else
1053 {
737 AV *av = newAV (); 1054 AV *av = newAV ();
738 av_push (av, newSVuv (tag)); 1055 av_push (av, newSVuv (tag));
739 av_push (av, sv); 1056 av_push (av, sv);
740 1057
741 HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash 1058 HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash
742 ? cbor_tagged_stash 1059 ? cbor_tagged_stash
743 : gv_stashpv ("CBOR::XS::Tagged" , 1); 1060 : gv_stashpv ("CBOR::XS::Tagged" , 1);
744
745 return sv_bless (newRV_noinc ((SV *)av), tagged_stash); 1061 sv = sv_bless (newRV_noinc ((SV *)av), tagged_stash);
1062 }
1063
1064 PUTBACK;
1065
1066 FREETMPS; LEAVE;
1067 }
1068 break;
746 } 1069 }
1070
1071 return sv;
747 1072
748fail: 1073fail:
749 SvREFCNT_dec (sv); 1074 SvREFCNT_dec (sv);
750 return &PL_sv_undef; 1075 return &PL_sv_undef;
751} 1076}
… …
753static SV * 1078static SV *
754decode_sv (dec_t *dec) 1079decode_sv (dec_t *dec)
755{ 1080{
756 WANT (1); 1081 WANT (1);
757 1082
758 switch (*dec->cur >> 5) 1083 switch (*dec->cur >> MAJOR_SHIFT)
759 { 1084 {
760 case 0: // unsigned int 1085 case MAJOR_POS_INT >> MAJOR_SHIFT: return newSVuv (decode_uint (dec));
761 return newSVuv (decode_uint (dec)); 1086 case MAJOR_NEG_INT >> MAJOR_SHIFT: return newSViv (-1 - (IV)decode_uint (dec));
762 case 1: // negative int 1087 case MAJOR_BYTES >> MAJOR_SHIFT: return decode_str (dec, 0);
763 return newSViv (-1 - (IV)decode_uint (dec)); 1088 case MAJOR_TEXT >> MAJOR_SHIFT: return decode_str (dec, 1);
764 case 2: // octet string 1089 case MAJOR_ARRAY >> MAJOR_SHIFT: return decode_av (dec);
765 return decode_str (dec, 0); 1090 case MAJOR_MAP >> MAJOR_SHIFT: return decode_hv (dec);
766 case 3: // utf-8 string 1091 case MAJOR_TAG >> MAJOR_SHIFT: return decode_tagged (dec);
767 return decode_str (dec, 1); 1092
768 case 4: // array 1093 case MAJOR_MISC >> MAJOR_SHIFT:
769 return decode_av (dec);
770 case 5: // map
771 return decode_hv (dec);
772 case 6: // tag
773 return decode_tagged (dec);
774 case 7: // misc
775 switch (*dec->cur++ & 31) 1094 switch (*dec->cur++ & MINOR_MASK)
776 { 1095 {
777 case 20: 1096 case SIMPLE_FALSE:
778#if CBOR_SLOW 1097#if CBOR_SLOW
779 types_false = get_bool ("Types::Serialiser::false"); 1098 types_false = get_bool ("Types::Serialiser::false");
780#endif 1099#endif
781 return newSVsv (types_false); 1100 return newSVsv (types_false);
782 case 21: 1101 case SIMPLE_TRUE:
783#if CBOR_SLOW 1102#if CBOR_SLOW
784 types_true = get_bool ("Types::Serialiser::true"); 1103 types_true = get_bool ("Types::Serialiser::true");
785#endif 1104#endif
786 return newSVsv (types_true); 1105 return newSVsv (types_true);
787 case 22: 1106 case SIMPLE_NULL:
788 return newSVsv (&PL_sv_undef); 1107 return newSVsv (&PL_sv_undef);
789 case 23: 1108 case SIMPLE_UNDEF:
790#if CBOR_SLOW 1109#if CBOR_SLOW
791 types_error = get_bool ("Types::Serialiser::error"); 1110 types_error = get_bool ("Types::Serialiser::error");
792#endif 1111#endif
793 return newSVsv (types_error); 1112 return newSVsv (types_error);
794 1113
795 case 25: 1114 case MISC_FLOAT16:
796 { 1115 {
797 WANT (2); 1116 WANT (2);
798 1117
799 uint16_t fp = (dec->cur[0] << 8) | dec->cur[1]; 1118 uint16_t fp = (dec->cur[0] << 8) | dec->cur[1];
800 dec->cur += 2; 1119 dec->cur += 2;
801 1120
802 return newSVnv (ecb_binary16_to_float (fp)); 1121 return newSVnv (ecb_binary16_to_float (fp));
803 } 1122 }
804 1123
805 case 26: 1124 case MISC_FLOAT32:
806 { 1125 {
807 uint32_t fp; 1126 uint32_t fp;
808 WANT (4); 1127 WANT (4);
809 memcpy (&fp, dec->cur, 4); 1128 memcpy (&fp, dec->cur, 4);
810 dec->cur += 4; 1129 dec->cur += 4;
… …
813 fp = ecb_bswap32 (fp); 1132 fp = ecb_bswap32 (fp);
814 1133
815 return newSVnv (ecb_binary32_to_float (fp)); 1134 return newSVnv (ecb_binary32_to_float (fp));
816 } 1135 }
817 1136
818 case 27: 1137 case MISC_FLOAT64:
819 { 1138 {
820 uint64_t fp; 1139 uint64_t fp;
821 WANT (8); 1140 WANT (8);
822 memcpy (&fp, dec->cur, 8); 1141 memcpy (&fp, dec->cur, 8);
823 dec->cur += 8; 1142 dec->cur += 8;
… …
826 fp = ecb_bswap64 (fp); 1145 fp = ecb_bswap64 (fp);
827 1146
828 return newSVnv (ecb_binary64_to_double (fp)); 1147 return newSVnv (ecb_binary64_to_double (fp));
829 } 1148 }
830 1149
831 // 0..19 unassigned 1150 // 0..19 unassigned simple
832 // 24 reserved + unassigned (reserved values are not encodable) 1151 // 24 reserved + unassigned simple (reserved values are not encodable)
1152 // 28-30 unassigned misc
1153 // 31 break code
833 default: 1154 default:
834 ERR ("corrupted CBOR data (reserved/unassigned major 7 value)"); 1155 ERR ("corrupted CBOR data (reserved/unassigned/unexpected major 7 value)");
835 } 1156 }
836 1157
837 break; 1158 break;
838 } 1159 }
839 1160
… …
842} 1163}
843 1164
844static SV * 1165static SV *
845decode_cbor (SV *string, CBOR *cbor, char **offset_return) 1166decode_cbor (SV *string, CBOR *cbor, char **offset_return)
846{ 1167{
847 dec_t dec; 1168 dec_t dec = { 0 };
848 SV *sv; 1169 SV *sv;
1170 STRLEN len;
1171 char *data = SvPVbyte (string, len);
849 1172
850 /* work around bugs in 5.10 where manipulating magic values
851 * makes perl ignore the magic in subsequent accesses.
852 * also make a copy of non-PV values, to get them into a clean
853 * state (SvPV should do that, but it's buggy, see below).
854 */
855 /*SvGETMAGIC (string);*/
856 if (SvMAGICAL (string) || !SvPOK (string))
857 string = sv_2mortal (newSVsv (string));
858
859 SvUPGRADE (string, SVt_PV);
860
861 /* work around a bug in perl 5.10, which causes SvCUR to fail an
862 * assertion with -DDEBUGGING, although SvCUR is documented to
863 * return the xpv_cur field which certainly exists after upgrading.
864 * according to nicholas clark, calling SvPOK fixes this.
865 * But it doesn't fix it, so try another workaround, call SvPV_nolen
866 * and hope for the best.
867 * Damnit, SvPV_nolen still trips over yet another assertion. This
868 * assertion business is seriously broken, try yet another workaround
869 * for the broken -DDEBUGGING.
870 */
871 {
872#ifdef DEBUGGING
873 STRLEN offset = SvOK (string) ? sv_len (string) : 0;
874#else
875 STRLEN offset = SvCUR (string);
876#endif
877
878 if (offset > cbor->max_size && cbor->max_size) 1173 if (len > cbor->max_size && cbor->max_size)
879 croak ("attempted decode of CBOR text of %lu bytes size, but max_size is set to %lu", 1174 croak ("attempted decode of CBOR text of %lu bytes size, but max_size is set to %lu",
880 (unsigned long)SvCUR (string), (unsigned long)cbor->max_size); 1175 (unsigned long)len, (unsigned long)cbor->max_size);
881 }
882
883 sv_utf8_downgrade (string, 0);
884 1176
885 dec.cbor = *cbor; 1177 dec.cbor = *cbor;
886 dec.cur = (U8 *)SvPVX (string); 1178 dec.cur = (U8 *)data;
887 dec.end = (U8 *)SvEND (string); 1179 dec.end = (U8 *)data + len;
888 dec.err = 0;
889 dec.depth = 0;
890 1180
891 sv = decode_sv (&dec); 1181 sv = decode_sv (&dec);
892 1182
893 if (offset_return) 1183 if (offset_return)
894 *offset_return = dec.cur; 1184 *offset_return = dec.cur;
… …
897 if (dec.cur != dec.end && !dec.err) 1187 if (dec.cur != dec.end && !dec.err)
898 dec.err = "garbage after CBOR object"; 1188 dec.err = "garbage after CBOR object";
899 1189
900 if (dec.err) 1190 if (dec.err)
901 { 1191 {
1192 if (dec.shareable)
1193 {
1194 // need to break cyclic links, which whould all be in shareable
1195 int i;
1196 SV **svp;
1197
1198 for (i = av_len (dec.shareable) + 1; i--; )
1199 if ((svp = av_fetch (dec.shareable, i, 0)))
1200 sv_setsv (*svp, &PL_sv_undef);
1201 }
1202
902 SvREFCNT_dec (sv); 1203 SvREFCNT_dec (sv);
903 croak ("%s, at offset %d (octet 0x%02x)", dec.err, dec.cur - (U8 *)SvPVX (string), (int)(uint8_t)*dec.cur); 1204 croak ("%s, at offset %d (octet 0x%02x)", dec.err, dec.cur - (U8 *)data, (int)(uint8_t)*dec.cur);
904 } 1205 }
905 1206
906 sv = sv_2mortal (sv); 1207 sv = sv_2mortal (sv);
907 1208
908 return sv; 1209 return sv;
909} 1210}
910 1211
1212/////////////////////////////////////////////////////////////////////////////
1213// incremental parser
1214
1215#define INCR_DONE(cbor) (AvFILLp (cbor->incr_count) < 0)
1216
1217// returns 0 for notyet, 1 for success or error
1218static int
1219incr_parse (CBOR *self, SV *cborstr)
1220{
1221 STRLEN cur;
1222 SvPV (cborstr, cur);
1223
1224 while (ecb_expect_true (self->incr_need <= cur))
1225 {
1226 // table of integer count bytes
1227 static I8 incr_len[MINOR_MASK + 1] = {
1228 0, 0, 0, 0, 0, 0, 0, 0,
1229 0, 0, 0, 0, 0, 0, 0, 0,
1230 0, 0, 0, 0, 0, 0, 0, 0,
1231 1, 2, 4, 8,-1,-1,-1,-2
1232 };
1233
1234 const U8 *p = SvPVX (cborstr) + self->incr_pos;
1235 U8 m = *p & MINOR_MASK;
1236 IV count = SvIVX (AvARRAY (self->incr_count)[AvFILLp (self->incr_count)]);
1237 I8 ilen = incr_len[m];
1238
1239 self->incr_need = self->incr_pos + 1;
1240
1241 if (ecb_expect_false (ilen < 0))
1242 {
1243 if (m != MINOR_INDEF)
1244 return 1; // error
1245
1246 if (*p == (MAJOR_MISC | MINOR_INDEF))
1247 {
1248 if (count >= 0)
1249 return 1; // error
1250
1251 count = 1;
1252 }
1253 else
1254 {
1255 av_push (self->incr_count, newSViv (-1)); //TODO: nest
1256 count = -1;
1257 }
1258 }
1259 else
1260 {
1261 self->incr_need += ilen;
1262 if (ecb_expect_false (self->incr_need > cur))
1263 return 0;
1264
1265 int major = *p >> MAJOR_SHIFT;
1266
1267 switch (major)
1268 {
1269 case MAJOR_TAG >> MAJOR_SHIFT:
1270 ++count; // tags merely prefix another value
1271 break;
1272
1273 case MAJOR_BYTES >> MAJOR_SHIFT:
1274 case MAJOR_TEXT >> MAJOR_SHIFT:
1275 case MAJOR_ARRAY >> MAJOR_SHIFT:
1276 case MAJOR_MAP >> MAJOR_SHIFT:
1277 {
1278 UV len;
1279
1280 if (ecb_expect_false (ilen))
1281 {
1282 len = 0;
1283
1284 do {
1285 len = (len << 8) | *++p;
1286 } while (--ilen);
1287 }
1288 else
1289 len = m;
1290
1291 switch (major)
1292 {
1293 case MAJOR_BYTES >> MAJOR_SHIFT:
1294 case MAJOR_TEXT >> MAJOR_SHIFT:
1295 self->incr_need += len;
1296 if (ecb_expect_false (self->incr_need > cur))
1297 return 0;
1298
1299 break;
1300
1301 case MAJOR_MAP >> MAJOR_SHIFT:
1302 len <<= 1;
1303 case MAJOR_ARRAY >> MAJOR_SHIFT:
1304 if (len)
1305 {
1306 av_push (self->incr_count, newSViv (len + 1)); //TODO: nest
1307 count = len + 1;
1308 }
1309 break;
1310 }
1311 }
1312 }
1313 }
1314
1315 self->incr_pos = self->incr_need;
1316
1317 if (count > 0)
1318 {
1319 while (!--count)
1320 {
1321 if (!AvFILLp (self->incr_count))
1322 return 1; // done
1323
1324 SvREFCNT_dec_NN (av_pop (self->incr_count));
1325 count = SvIVX (AvARRAY (self->incr_count)[AvFILLp (self->incr_count)]);
1326 }
1327
1328 SvIVX (AvARRAY (self->incr_count)[AvFILLp (self->incr_count)]) = count;
1329 }
1330 }
1331
1332 return 0;
1333}
1334
1335
911///////////////////////////////////////////////////////////////////////////// 1336/////////////////////////////////////////////////////////////////////////////
912// XS interface functions 1337// XS interface functions
913 1338
914MODULE = CBOR::XS PACKAGE = CBOR::XS 1339MODULE = CBOR::XS PACKAGE = CBOR::XS
915 1340
… …
922 types_error_stash = gv_stashpv ("Types::Serialiser::Error" , 1); 1347 types_error_stash = gv_stashpv ("Types::Serialiser::Error" , 1);
923 1348
924 types_true = get_bool ("Types::Serialiser::true" ); 1349 types_true = get_bool ("Types::Serialiser::true" );
925 types_false = get_bool ("Types::Serialiser::false"); 1350 types_false = get_bool ("Types::Serialiser::false");
926 types_error = get_bool ("Types::Serialiser::error"); 1351 types_error = get_bool ("Types::Serialiser::error");
1352
1353 default_filter = newSVpv ("CBOR::XS::default_filter", 0);
927 1354
928 sv_cbor = newSVpv ("CBOR", 0); 1355 sv_cbor = newSVpv ("CBOR", 0);
929 SvREADONLY_on (sv_cbor); 1356 SvREADONLY_on (sv_cbor);
930} 1357}
931 1358
… …
952 1379
953void shrink (CBOR *self, int enable = 1) 1380void shrink (CBOR *self, int enable = 1)
954 ALIAS: 1381 ALIAS:
955 shrink = F_SHRINK 1382 shrink = F_SHRINK
956 allow_unknown = F_ALLOW_UNKNOWN 1383 allow_unknown = F_ALLOW_UNKNOWN
1384 allow_sharing = F_ALLOW_SHARING
1385 allow_cycles = F_ALLOW_CYCLES
1386 pack_strings = F_PACK_STRINGS
1387 validate_utf8 = F_VALIDATE_UTF8
957 PPCODE: 1388 PPCODE:
958{ 1389{
959 if (enable) 1390 if (enable)
960 self->flags |= ix; 1391 self->flags |= ix;
961 else 1392 else
… …
966 1397
967void get_shrink (CBOR *self) 1398void get_shrink (CBOR *self)
968 ALIAS: 1399 ALIAS:
969 get_shrink = F_SHRINK 1400 get_shrink = F_SHRINK
970 get_allow_unknown = F_ALLOW_UNKNOWN 1401 get_allow_unknown = F_ALLOW_UNKNOWN
1402 get_allow_sharing = F_ALLOW_SHARING
1403 get_allow_cycles = F_ALLOW_CYCLES
1404 get_pack_strings = F_PACK_STRINGS
1405 get_validate_utf8 = F_VALIDATE_UTF8
971 PPCODE: 1406 PPCODE:
972 XPUSHs (boolSV (self->flags & ix)); 1407 XPUSHs (boolSV (self->flags & ix));
973 1408
974void max_depth (CBOR *self, U32 max_depth = 0x80000000UL) 1409void max_depth (CBOR *self, U32 max_depth = 0x80000000UL)
975 PPCODE: 1410 PPCODE:
… …
988 XPUSHs (ST (0)); 1423 XPUSHs (ST (0));
989 1424
990int get_max_size (CBOR *self) 1425int get_max_size (CBOR *self)
991 CODE: 1426 CODE:
992 RETVAL = self->max_size; 1427 RETVAL = self->max_size;
1428 OUTPUT:
1429 RETVAL
1430
1431void filter (CBOR *self, SV *filter = 0)
1432 PPCODE:
1433 SvREFCNT_dec (self->filter);
1434 self->filter = filter ? newSVsv (filter) : filter;
1435 XPUSHs (ST (0));
1436
1437SV *get_filter (CBOR *self)
1438 CODE:
1439 RETVAL = self->filter ? self->filter : NEWSV (0, 0);
993 OUTPUT: 1440 OUTPUT:
994 RETVAL 1441 RETVAL
995 1442
996void encode (CBOR *self, SV *scalar) 1443void encode (CBOR *self, SV *scalar)
997 PPCODE: 1444 PPCODE:
… …
1012 EXTEND (SP, 2); 1459 EXTEND (SP, 2);
1013 PUSHs (sv); 1460 PUSHs (sv);
1014 PUSHs (sv_2mortal (newSVuv (offset - SvPVX (cborstr)))); 1461 PUSHs (sv_2mortal (newSVuv (offset - SvPVX (cborstr))));
1015} 1462}
1016 1463
1464void incr_parse (CBOR *self, SV *cborstr)
1465 ALIAS:
1466 incr_parse_multiple = 1
1467 PPCODE:
1468{
1469 if (SvUTF8 (cborstr))
1470 sv_utf8_downgrade (cborstr, 0);
1471
1472 if (!self->incr_count)
1473 {
1474 self->incr_count = newAV ();
1475 self->incr_pos = 0;
1476 self->incr_need = 1;
1477
1478 av_push (self->incr_count, newSViv (1));
1479 }
1480
1481 do
1482 {
1483 if (!incr_parse (self, cborstr))
1484 {
1485 if (self->incr_need > self->max_size && self->max_size)
1486 croak ("attempted decode of CBOR text of %lu bytes size, but max_size is set to %lu",
1487 (unsigned long)self->incr_need, (unsigned long)self->max_size);
1488
1489 break;
1490 }
1491
1492 SV *sv;
1493 char *offset;
1494
1495 PUTBACK; sv = decode_cbor (cborstr, self, &offset); SPAGAIN;
1496 XPUSHs (sv);
1497
1498 sv_chop (cborstr, offset);
1499
1500 av_clear (self->incr_count);
1501 av_push (self->incr_count, newSViv (1));
1502
1503 self->incr_pos = 0;
1504 self->incr_need = self->incr_pos + 1;
1505 }
1506 while (ix);
1507}
1508
1509void incr_reset (CBOR *self)
1510 CODE:
1511{
1512 SvREFCNT_dec (self->incr_count);
1513 self->incr_count = 0;
1514}
1515
1516void DESTROY (CBOR *self)
1517 PPCODE:
1518 cbor_free (self);
1519
1017PROTOTYPES: ENABLE 1520PROTOTYPES: ENABLE
1018 1521
1019void encode_cbor (SV *scalar) 1522void encode_cbor (SV *scalar)
1523 ALIAS:
1524 encode_cbor = 0
1525 encode_cbor_sharing = F_ALLOW_SHARING
1020 PPCODE: 1526 PPCODE:
1021{ 1527{
1022 CBOR cbor; 1528 CBOR cbor;
1023 cbor_init (&cbor); 1529 cbor_init (&cbor);
1530 cbor.flags |= ix;
1024 PUTBACK; scalar = encode_cbor (scalar, &cbor); SPAGAIN; 1531 PUTBACK; scalar = encode_cbor (scalar, &cbor); SPAGAIN;
1025 XPUSHs (scalar); 1532 XPUSHs (scalar);
1026} 1533}
1027 1534
1028void decode_cbor (SV *cborstr) 1535void decode_cbor (SV *cborstr)

Diff Legend

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