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.46 by root, Sun Dec 14 05:57:22 2014 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 = { };
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
600 dec->cur += len; 754 dec->cur += len;
601 755
602 hv_store (hv, key, len, decode_sv (dec), 0); 756 hv_store (hv, key, len, decode_sv (dec), 0);
757
758 return;
603 } 759 }
604 else if (*dec->cur >= 0x60 && *dec->cur <= 0x60 + 27) 760 else if (ecb_expect_true ((U8)(*dec->cur - MAJOR_TEXT) <= LENGTH_EXT8))
605 { 761 {
606 I32 len = decode_uint (dec); 762 I32 len = decode_uint (dec);
607 char *key = (char *)dec->cur; 763 char *key = (char *)dec->cur;
608 764
609 dec->cur += len; 765 dec->cur += len;
610 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
611 hv_store (hv, key, -len, decode_sv (dec), 0); 771 hv_store (hv, key, -len, decode_sv (dec), 0);
772
773 return;
612 } 774 }
613 else 775
614 {
615 SV *k = decode_sv (dec); 776 SV *k = decode_sv (dec);
616 SV *v = decode_sv (dec); 777 SV *v = decode_sv (dec);
617 778
618 hv_store_ent (hv, k, v, 0); 779 hv_store_ent (hv, k, v, 0);
619 SvREFCNT_dec (k); 780 SvREFCNT_dec (k);
620 } 781
782fail:
783 ;
621} 784}
622 785
623static SV * 786static SV *
624decode_hv (dec_t *dec) 787decode_hv (dec_t *dec)
625{ 788{
626 HV *hv = newHV (); 789 HV *hv = newHV ();
627 790
628 DEC_INC_DEPTH; 791 DEC_INC_DEPTH;
629 792
630 if ((*dec->cur & 31) == 31) 793 if (*dec->cur == (MAJOR_MAP | MINOR_INDEF))
631 { 794 {
632 ++dec->cur; 795 ++dec->cur;
633 796
634 for (;;) 797 for (;;)
635 { 798 {
636 WANT (1); 799 WANT (1);
637 800
638 if (*dec->cur == (0xe0 | 31)) 801 if (*dec->cur == (MAJOR_MISC | MINOR_INDEF))
639 { 802 {
640 ++dec->cur; 803 ++dec->cur;
641 break; 804 break;
642 } 805 }
643 806
… …
664static SV * 827static SV *
665decode_str (dec_t *dec, int utf8) 828decode_str (dec_t *dec, int utf8)
666{ 829{
667 SV *sv = 0; 830 SV *sv = 0;
668 831
669 if ((*dec->cur & 31) == 31) 832 if ((*dec->cur & MINOR_MASK) == MINOR_INDEF)
670 { 833 {
834 // indefinite length strings
671 ++dec->cur; 835 ++dec->cur;
672 836
837 U8 major = *dec->cur & MAJOR_MISC;
838
673 sv = newSVpvn ("", 0); 839 sv = newSVpvn ("", 0);
674 840
675 // not very fast, and certainly not robust against illegal input
676 for (;;) 841 for (;;)
677 { 842 {
678 WANT (1); 843 WANT (1);
679 844
680 if (*dec->cur == (0xe0 | 31)) 845 if ((*dec->cur - major) > LENGTH_EXT8)
846 if (*dec->cur == (MAJOR_MISC | MINOR_INDEF))
681 { 847 {
682 ++dec->cur; 848 ++dec->cur;
683 break; 849 break;
684 } 850 }
851 else
852 ERR ("corrupted CBOR data (invalid chunks in indefinite length string)");
685 853
686 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;
687 } 859 }
688 } 860 }
689 else 861 else
690 { 862 {
691 STRLEN len = decode_uint (dec); 863 STRLEN len = decode_uint (dec);
692 864
693 WANT (len); 865 WANT (len);
694 sv = newSVpvn (dec->cur, len); 866 sv = newSVpvn (dec->cur, len);
695 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));
696 } 872 }
697 873
698 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
699 SvUTF8_on (sv); 880 SvUTF8_on (sv);
881 }
700 882
701 return sv; 883 return sv;
702 884
703fail: 885fail:
704 SvREFCNT_dec (sv); 886 SvREFCNT_dec (sv);
… …
706} 888}
707 889
708static SV * 890static SV *
709decode_tagged (dec_t *dec) 891decode_tagged (dec_t *dec)
710{ 892{
893 SV *sv = 0;
711 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:
712 SV *sv = decode_sv (dec); 901 sv = decode_sv (dec);
902 break;
713 903
714 if (tag == CBOR_TAG_MAGIC) 904 case CBOR_TAG_INDIRECTION:
715 return sv; 905 sv = newRV_noinc (decode_sv (dec));
716 else if (tag == CBOR_TAG_PERL_OBJECT) 906 break;
717 {
718 if (!SvROK (sv) || SvTYPE (SvRV (sv)) != SVt_PVAV)
719 ERR ("corrupted CBOR data (non-array perl object)");
720 907
721 AV *av = (AV *)SvRV (sv); 908 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 909 {
730 if (!method) 910 ENTER; SAVETMPS;
731 ERR ("cannot decode perl-object (package does not have a THAW method)");
732
733 dSP;
734 911
735 ENTER; SAVETMPS; PUSHMARK (SP); 912 SAVESPTR (dec->stringref);
736 EXTEND (SP, len + 1); 913 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 914
741 int i; 915 sv = decode_sv (dec);
742 916
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; 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
980 if (!SvROK (sv) || SvTYPE (SvRV (sv)) != SVt_PVAV)
981 ERR ("corrupted CBOR data (non-array perl object)");
982
983 AV *av = (AV *)SvRV (sv);
984 int len = av_len (av) + 1;
985 HV *stash = gv_stashsv (*av_fetch (av, 0, 1), 0);
986
987 if (!stash)
988 ERR ("cannot decode perl-object (package does not exist)");
989
990 GV *method = gv_fetchmethod_autoload (stash, "THAW", 0);
991
992 if (!method)
993 ERR ("cannot decode perl-object (package does not have a THAW method)");
994
995 dSP;
996
997 ENTER; SAVETMPS; PUSHMARK (SP);
998 EXTEND (SP, len + 1);
999 // we re-bless the reference to get overload and other niceties right
1000 PUSHs (*av_fetch (av, 0, 1));
1001 PUSHs (sv_cbor);
1002
1003 int i;
1004
1005 for (i = 1; i < len; ++i)
1006 PUSHs (*av_fetch (av, i, 1));
1007
1008 PUTBACK;
1009 call_sv ((SV *)GvCV (method), G_SCALAR | G_EVAL);
1010 SPAGAIN;
1011
1012 if (SvTRUE (ERRSV))
1013 {
1014 FREETMPS; LEAVE;
753 ERR (SvPVutf8_nolen (sv_2mortal (SvREFCNT_inc (ERRSV)))); 1015 ERR (SvPVutf8_nolen (sv_2mortal (SvREFCNT_inc (ERRSV))));
754 } 1016 }
755 1017
756 SvREFCNT_dec (sv); 1018 SvREFCNT_dec (sv);
757 sv = SvREFCNT_inc (POPs); 1019 sv = SvREFCNT_inc (POPs);
758 1020
759 PUTBACK; 1021 PUTBACK;
760 1022
761 FREETMPS; LEAVE; 1023 FREETMPS; LEAVE;
1024 }
1025 break;
762 1026
763 return sv; 1027 default:
764 } 1028 {
765 else 1029 sv = decode_sv (dec);
766 { 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 {
767 AV *av = newAV (); 1054 AV *av = newAV ();
768 av_push (av, newSVuv (tag)); 1055 av_push (av, newSVuv (tag));
769 av_push (av, sv); 1056 av_push (av, sv);
770 1057
771 HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash 1058 HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash
772 ? cbor_tagged_stash 1059 ? cbor_tagged_stash
773 : gv_stashpv ("CBOR::XS::Tagged" , 1); 1060 : gv_stashpv ("CBOR::XS::Tagged" , 1);
774
775 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;
776 } 1069 }
1070
1071 return sv;
777 1072
778fail: 1073fail:
779 SvREFCNT_dec (sv); 1074 SvREFCNT_dec (sv);
780 return &PL_sv_undef; 1075 return &PL_sv_undef;
781} 1076}
… …
783static SV * 1078static SV *
784decode_sv (dec_t *dec) 1079decode_sv (dec_t *dec)
785{ 1080{
786 WANT (1); 1081 WANT (1);
787 1082
788 switch (*dec->cur >> 5) 1083 switch (*dec->cur >> MAJOR_SHIFT)
789 { 1084 {
790 case 0: // unsigned int 1085 case MAJOR_POS_INT >> MAJOR_SHIFT: return newSVuv (decode_uint (dec));
791 return newSVuv (decode_uint (dec)); 1086 case MAJOR_NEG_INT >> MAJOR_SHIFT: return newSViv (-1 - (IV)decode_uint (dec));
792 case 1: // negative int 1087 case MAJOR_BYTES >> MAJOR_SHIFT: return decode_str (dec, 0);
793 return newSViv (-1 - (IV)decode_uint (dec)); 1088 case MAJOR_TEXT >> MAJOR_SHIFT: return decode_str (dec, 1);
794 case 2: // octet string 1089 case MAJOR_ARRAY >> MAJOR_SHIFT: return decode_av (dec);
795 return decode_str (dec, 0); 1090 case MAJOR_MAP >> MAJOR_SHIFT: return decode_hv (dec);
796 case 3: // utf-8 string 1091 case MAJOR_TAG >> MAJOR_SHIFT: return decode_tagged (dec);
797 return decode_str (dec, 1); 1092
798 case 4: // array 1093 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) 1094 switch (*dec->cur++ & MINOR_MASK)
806 { 1095 {
807 case 20: 1096 case SIMPLE_FALSE:
808#if CBOR_SLOW 1097#if CBOR_SLOW
809 types_false = get_bool ("Types::Serialiser::false"); 1098 types_false = get_bool ("Types::Serialiser::false");
810#endif 1099#endif
811 return newSVsv (types_false); 1100 return newSVsv (types_false);
812 case 21: 1101 case SIMPLE_TRUE:
813#if CBOR_SLOW 1102#if CBOR_SLOW
814 types_true = get_bool ("Types::Serialiser::true"); 1103 types_true = get_bool ("Types::Serialiser::true");
815#endif 1104#endif
816 return newSVsv (types_true); 1105 return newSVsv (types_true);
817 case 22: 1106 case SIMPLE_NULL:
818 return newSVsv (&PL_sv_undef); 1107 return newSVsv (&PL_sv_undef);
819 case 23: 1108 case SIMPLE_UNDEF:
820#if CBOR_SLOW 1109#if CBOR_SLOW
821 types_error = get_bool ("Types::Serialiser::error"); 1110 types_error = get_bool ("Types::Serialiser::error");
822#endif 1111#endif
823 return newSVsv (types_error); 1112 return newSVsv (types_error);
824 1113
825 case 25: 1114 case MISC_FLOAT16:
826 { 1115 {
827 WANT (2); 1116 WANT (2);
828 1117
829 uint16_t fp = (dec->cur[0] << 8) | dec->cur[1]; 1118 uint16_t fp = (dec->cur[0] << 8) | dec->cur[1];
830 dec->cur += 2; 1119 dec->cur += 2;
831 1120
832 return newSVnv (ecb_binary16_to_float (fp)); 1121 return newSVnv (ecb_binary16_to_float (fp));
833 } 1122 }
834 1123
835 case 26: 1124 case MISC_FLOAT32:
836 { 1125 {
837 uint32_t fp; 1126 uint32_t fp;
838 WANT (4); 1127 WANT (4);
839 memcpy (&fp, dec->cur, 4); 1128 memcpy (&fp, dec->cur, 4);
840 dec->cur += 4; 1129 dec->cur += 4;
… …
843 fp = ecb_bswap32 (fp); 1132 fp = ecb_bswap32 (fp);
844 1133
845 return newSVnv (ecb_binary32_to_float (fp)); 1134 return newSVnv (ecb_binary32_to_float (fp));
846 } 1135 }
847 1136
848 case 27: 1137 case MISC_FLOAT64:
849 { 1138 {
850 uint64_t fp; 1139 uint64_t fp;
851 WANT (8); 1140 WANT (8);
852 memcpy (&fp, dec->cur, 8); 1141 memcpy (&fp, dec->cur, 8);
853 dec->cur += 8; 1142 dec->cur += 8;
… …
856 fp = ecb_bswap64 (fp); 1145 fp = ecb_bswap64 (fp);
857 1146
858 return newSVnv (ecb_binary64_to_double (fp)); 1147 return newSVnv (ecb_binary64_to_double (fp));
859 } 1148 }
860 1149
861 // 0..19 unassigned 1150 // 0..19 unassigned simple
862 // 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
863 default: 1154 default:
864 ERR ("corrupted CBOR data (reserved/unassigned major 7 value)"); 1155 ERR ("corrupted CBOR data (reserved/unassigned/unexpected major 7 value)");
865 } 1156 }
866 1157
867 break; 1158 break;
868 } 1159 }
869 1160
… …
872} 1163}
873 1164
874static SV * 1165static SV *
875decode_cbor (SV *string, CBOR *cbor, char **offset_return) 1166decode_cbor (SV *string, CBOR *cbor, char **offset_return)
876{ 1167{
877 dec_t dec; 1168 dec_t dec = { };
878 SV *sv; 1169 SV *sv;
879 STRLEN len; 1170 STRLEN len;
880 char *data = SvPVbyte (string, len); 1171 char *data = SvPVbyte (string, len);
881 1172
882 if (len > cbor->max_size && cbor->max_size) 1173 if (len > cbor->max_size && cbor->max_size)
… …
884 (unsigned long)len, (unsigned long)cbor->max_size); 1175 (unsigned long)len, (unsigned long)cbor->max_size);
885 1176
886 dec.cbor = *cbor; 1177 dec.cbor = *cbor;
887 dec.cur = (U8 *)data; 1178 dec.cur = (U8 *)data;
888 dec.end = (U8 *)data + len; 1179 dec.end = (U8 *)data + len;
889 dec.err = 0;
890 dec.depth = 0;
891 1180
892 sv = decode_sv (&dec); 1181 sv = decode_sv (&dec);
893 1182
894 if (offset_return) 1183 if (offset_return)
895 *offset_return = dec.cur; 1184 *offset_return = dec.cur;
… …
898 if (dec.cur != dec.end && !dec.err) 1187 if (dec.cur != dec.end && !dec.err)
899 dec.err = "garbage after CBOR object"; 1188 dec.err = "garbage after CBOR object";
900 1189
901 if (dec.err) 1190 if (dec.err)
902 { 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
903 SvREFCNT_dec (sv); 1203 SvREFCNT_dec (sv);
904 croak ("%s, at offset %d (octet 0x%02x)", dec.err, dec.cur - (U8 *)data, (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);
905 } 1205 }
906 1206
907 sv = sv_2mortal (sv); 1207 sv = sv_2mortal (sv);
908 1208
909 return sv; 1209 return sv;
910} 1210}
911 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_BYTES >> MAJOR_SHIFT:
1270 case MAJOR_TEXT >> MAJOR_SHIFT:
1271 case MAJOR_ARRAY >> MAJOR_SHIFT:
1272 case MAJOR_MAP >> MAJOR_SHIFT:
1273 {
1274 UV len;
1275
1276 if (ecb_expect_false (ilen))
1277 {
1278 len = 0;
1279
1280 do {
1281 len = (len << 8) | *++p;
1282 } while (--ilen);
1283 }
1284 else
1285 len = m;
1286
1287 switch (major)
1288 {
1289 case MAJOR_BYTES >> MAJOR_SHIFT:
1290 case MAJOR_TEXT >> MAJOR_SHIFT:
1291 self->incr_need += len;
1292 if (ecb_expect_false (self->incr_need > cur))
1293 return 0;
1294
1295 break;
1296
1297 case MAJOR_MAP >> MAJOR_SHIFT:
1298 len <<= 1;
1299 case MAJOR_ARRAY >> MAJOR_SHIFT:
1300 if (len)
1301 {
1302 av_push (self->incr_count, newSViv (len + 1)); //TODO: nest
1303 count = len + 1;
1304 }
1305 break;
1306 }
1307 }
1308 }
1309 }
1310
1311 self->incr_pos = self->incr_need;
1312
1313 if (count > 0)
1314 {
1315 while (!--count)
1316 {
1317 if (!AvFILLp (self->incr_count))
1318 return 1; // done
1319
1320 SvREFCNT_dec_NN (av_pop (self->incr_count));
1321 count = SvIVX (AvARRAY (self->incr_count)[AvFILLp (self->incr_count)]);
1322 }
1323
1324 SvIVX (AvARRAY (self->incr_count)[AvFILLp (self->incr_count)]) = count;
1325 }
1326 }
1327
1328 return 0;
1329}
1330
1331
912///////////////////////////////////////////////////////////////////////////// 1332/////////////////////////////////////////////////////////////////////////////
913// XS interface functions 1333// XS interface functions
914 1334
915MODULE = CBOR::XS PACKAGE = CBOR::XS 1335MODULE = CBOR::XS PACKAGE = CBOR::XS
916 1336
… …
923 types_error_stash = gv_stashpv ("Types::Serialiser::Error" , 1); 1343 types_error_stash = gv_stashpv ("Types::Serialiser::Error" , 1);
924 1344
925 types_true = get_bool ("Types::Serialiser::true" ); 1345 types_true = get_bool ("Types::Serialiser::true" );
926 types_false = get_bool ("Types::Serialiser::false"); 1346 types_false = get_bool ("Types::Serialiser::false");
927 types_error = get_bool ("Types::Serialiser::error"); 1347 types_error = get_bool ("Types::Serialiser::error");
1348
1349 default_filter = newSVpv ("CBOR::XS::default_filter", 0);
928 1350
929 sv_cbor = newSVpv ("CBOR", 0); 1351 sv_cbor = newSVpv ("CBOR", 0);
930 SvREADONLY_on (sv_cbor); 1352 SvREADONLY_on (sv_cbor);
931} 1353}
932 1354
… …
953 1375
954void shrink (CBOR *self, int enable = 1) 1376void shrink (CBOR *self, int enable = 1)
955 ALIAS: 1377 ALIAS:
956 shrink = F_SHRINK 1378 shrink = F_SHRINK
957 allow_unknown = F_ALLOW_UNKNOWN 1379 allow_unknown = F_ALLOW_UNKNOWN
1380 allow_sharing = F_ALLOW_SHARING
1381 allow_cycles = F_ALLOW_CYCLES
1382 pack_strings = F_PACK_STRINGS
1383 validate_utf8 = F_VALIDATE_UTF8
958 PPCODE: 1384 PPCODE:
959{ 1385{
960 if (enable) 1386 if (enable)
961 self->flags |= ix; 1387 self->flags |= ix;
962 else 1388 else
… …
967 1393
968void get_shrink (CBOR *self) 1394void get_shrink (CBOR *self)
969 ALIAS: 1395 ALIAS:
970 get_shrink = F_SHRINK 1396 get_shrink = F_SHRINK
971 get_allow_unknown = F_ALLOW_UNKNOWN 1397 get_allow_unknown = F_ALLOW_UNKNOWN
1398 get_allow_sharing = F_ALLOW_SHARING
1399 get_allow_cycles = F_ALLOW_CYCLES
1400 get_pack_strings = F_PACK_STRINGS
1401 get_validate_utf8 = F_VALIDATE_UTF8
972 PPCODE: 1402 PPCODE:
973 XPUSHs (boolSV (self->flags & ix)); 1403 XPUSHs (boolSV (self->flags & ix));
974 1404
975void max_depth (CBOR *self, U32 max_depth = 0x80000000UL) 1405void max_depth (CBOR *self, U32 max_depth = 0x80000000UL)
976 PPCODE: 1406 PPCODE:
… …
989 XPUSHs (ST (0)); 1419 XPUSHs (ST (0));
990 1420
991int get_max_size (CBOR *self) 1421int get_max_size (CBOR *self)
992 CODE: 1422 CODE:
993 RETVAL = self->max_size; 1423 RETVAL = self->max_size;
1424 OUTPUT:
1425 RETVAL
1426
1427void filter (CBOR *self, SV *filter = 0)
1428 PPCODE:
1429 SvREFCNT_dec (self->filter);
1430 self->filter = filter ? newSVsv (filter) : filter;
1431 XPUSHs (ST (0));
1432
1433SV *get_filter (CBOR *self)
1434 CODE:
1435 RETVAL = self->filter ? self->filter : NEWSV (0, 0);
994 OUTPUT: 1436 OUTPUT:
995 RETVAL 1437 RETVAL
996 1438
997void encode (CBOR *self, SV *scalar) 1439void encode (CBOR *self, SV *scalar)
998 PPCODE: 1440 PPCODE:
… …
1013 EXTEND (SP, 2); 1455 EXTEND (SP, 2);
1014 PUSHs (sv); 1456 PUSHs (sv);
1015 PUSHs (sv_2mortal (newSVuv (offset - SvPVX (cborstr)))); 1457 PUSHs (sv_2mortal (newSVuv (offset - SvPVX (cborstr))));
1016} 1458}
1017 1459
1460void incr_parse (CBOR *self, SV *cborstr)
1461 ALIAS:
1462 incr_parse_multiple = 1
1463 PPCODE:
1464{
1465 if (SvUTF8 (cborstr))
1466 sv_utf8_downgrade (cborstr, 0);
1467
1468 if (!self->incr_count)
1469 {
1470 self->incr_count = newAV ();
1471 self->incr_pos = 0;
1472 self->incr_need = 1;
1473
1474 av_push (self->incr_count, newSViv (1));
1475 }
1476
1477 do
1478 {
1479 if (!incr_parse (self, cborstr))
1480 {
1481 if (self->incr_need > self->max_size && self->max_size)
1482 croak ("attempted decode of CBOR text of %lu bytes size, but max_size is set to %lu",
1483 (unsigned long)self->incr_need, (unsigned long)self->max_size);
1484
1485 break;
1486 }
1487
1488 SV *sv;
1489 char *offset;
1490
1491 PUTBACK; sv = decode_cbor (cborstr, self, &offset); SPAGAIN;
1492 XPUSHs (sv);
1493
1494 sv_chop (cborstr, offset);
1495
1496 av_clear (self->incr_count);
1497 av_push (self->incr_count, newSViv (1));
1498
1499 self->incr_pos = 0;
1500 self->incr_need = self->incr_pos + 1;
1501 }
1502 while (ix);
1503}
1504
1505void incr_reset (CBOR *self)
1506 CODE:
1507{
1508 SvREFCNT_dec (self->incr_count);
1509 self->incr_count = 0;
1510}
1511
1512void DESTROY (CBOR *self)
1513 PPCODE:
1514 cbor_free (self);
1515
1018PROTOTYPES: ENABLE 1516PROTOTYPES: ENABLE
1019 1517
1020void encode_cbor (SV *scalar) 1518void encode_cbor (SV *scalar)
1519 ALIAS:
1520 encode_cbor = 0
1521 encode_cbor_sharing = F_ALLOW_SHARING
1021 PPCODE: 1522 PPCODE:
1022{ 1523{
1023 CBOR cbor; 1524 CBOR cbor;
1024 cbor_init (&cbor); 1525 cbor_init (&cbor);
1526 cbor.flags |= ix;
1025 PUTBACK; scalar = encode_cbor (scalar, &cbor); SPAGAIN; 1527 PUTBACK; scalar = encode_cbor (scalar, &cbor); SPAGAIN;
1026 XPUSHs (scalar); 1528 XPUSHs (scalar);
1027} 1529}
1028 1530
1029void decode_cbor (SV *cborstr) 1531void decode_cbor (SV *cborstr)

Diff Legend

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