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.39 by root, Sun Dec 1 14:45:03 2013 UTC vs.
Revision 1.62 by root, Sat Nov 26 02:11:52 2016 UTC

… …
6#include <string.h> 6#include <string.h>
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#include <inttypes.h>
11 12
13#define ECB_NO_THREADS 1
12#include "ecb.h" 14#include "ecb.h"
13 15
14// compatibility with perl <5.18 16// compatibility with perl <5.18
15#ifndef HvNAMELEN_get 17#ifndef HvNAMELEN_get
16# define HvNAMELEN_get(hv) strlen (HvNAME (hv)) 18# define HvNAMELEN_get(hv) strlen (HvNAME (hv))
… …
98 100
99#define F_SHRINK 0x00000001UL 101#define F_SHRINK 0x00000001UL
100#define F_ALLOW_UNKNOWN 0x00000002UL 102#define F_ALLOW_UNKNOWN 0x00000002UL
101#define F_ALLOW_SHARING 0x00000004UL 103#define F_ALLOW_SHARING 0x00000004UL
102#define F_ALLOW_CYCLES 0x00000008UL 104#define F_ALLOW_CYCLES 0x00000008UL
105#define F_FORBID_OBJECTS 0x00000010UL
103#define F_PACK_STRINGS 0x00000010UL 106#define F_PACK_STRINGS 0x00000020UL
107#define F_TEXT_KEYS 0x00000040UL
108#define F_TEXT_STRINGS 0x00000080UL
104#define F_VALIDATE_UTF8 0x00000020UL 109#define F_VALIDATE_UTF8 0x00000100UL
105 110
106#define INIT_SIZE 32 // initial scalar size to be allocated 111#define INIT_SIZE 32 // initial scalar size to be allocated
107 112
108#define SB do { 113#define SB do {
109#define SE } while (0) 114#define SE } while (0)
… …
128typedef struct { 133typedef struct {
129 U32 flags; 134 U32 flags;
130 U32 max_depth; 135 U32 max_depth;
131 STRLEN max_size; 136 STRLEN max_size;
132 SV *filter; 137 SV *filter;
138
139 // for the incremental parser
140 STRLEN incr_pos; // the current offset into the text
141 STRLEN incr_need; // minimum bytes needed to decode
142 AV *incr_count; // for every nesting level, the number of outstanding values, or -1 for indef.
133} CBOR; 143} CBOR;
134 144
135ecb_inline void 145ecb_inline void
136cbor_init (CBOR *cbor) 146cbor_init (CBOR *cbor)
137{ 147{
… …
141 151
142ecb_inline void 152ecb_inline void
143cbor_free (CBOR *cbor) 153cbor_free (CBOR *cbor)
144{ 154{
145 SvREFCNT_dec (cbor->filter); 155 SvREFCNT_dec (cbor->filter);
156 SvREFCNT_dec (cbor->incr_count);
146} 157}
147 158
148///////////////////////////////////////////////////////////////////////////// 159/////////////////////////////////////////////////////////////////////////////
149// utility functions 160// utility functions
150 161
… …
176 187
177// minimum length of a string to be registered for stringref 188// minimum length of a string to be registered for stringref
178ecb_inline int 189ecb_inline int
179minimum_string_length (UV idx) 190minimum_string_length (UV idx)
180{ 191{
181 return idx > 23 192 return idx <= 23 ? 3
182 ? idx > 0xffU 193 : idx <= 0xffU ? 4
183 ? idx > 0xffffU 194 : idx <= 0xffffU ? 5
184 ? idx > 0xffffffffU 195 : idx <= 0xffffffffU ? 7
185 ? 11 196 : 11;
186 : 7
187 : 5
188 : 4
189 : 3;
190} 197}
191 198
192///////////////////////////////////////////////////////////////////////////// 199/////////////////////////////////////////////////////////////////////////////
193// encoder 200// encoder
194 201
… …
207} enc_t; 214} enc_t;
208 215
209ecb_inline void 216ecb_inline void
210need (enc_t *enc, STRLEN len) 217need (enc_t *enc, STRLEN len)
211{ 218{
212 if (ecb_expect_false (enc->cur + len >= enc->end)) 219 if (ecb_expect_false ((uintptr_t)(enc->end - enc->cur) < len))
213 { 220 {
214 STRLEN cur = enc->cur - (char *)SvPVX (enc->sv); 221 STRLEN cur = enc->cur - (char *)SvPVX (enc->sv);
215 SvGROW (enc->sv, cur + (len < (cur >> 2) ? cur >> 2 : len) + 1); 222 SvGROW (enc->sv, cur + (len < (cur >> 2) ? cur >> 2 : len) + 1);
216 enc->cur = SvPVX (enc->sv) + cur; 223 enc->cur = SvPVX (enc->sv) + cur;
217 enc->end = SvPVX (enc->sv) + SvLEN (enc->sv) - 1; 224 enc->end = SvPVX (enc->sv) + SvLEN (enc->sv) - 1;
… …
269encode_tag (enc_t *enc, UV tag) 276encode_tag (enc_t *enc, UV tag)
270{ 277{
271 encode_uint (enc, MAJOR_TAG, tag); 278 encode_uint (enc, MAJOR_TAG, tag);
272} 279}
273 280
281// exceptional (hopefully) slow path for byte strings that need to be utf8-encoded
282ecb_noinline static void
283encode_str_utf8 (enc_t *enc, int utf8, char *str, STRLEN len)
284{
285 STRLEN ulen = len;
286 U8 *p, *pend = (U8 *)str + len;
287
288 for (p = (U8 *)str; p < pend; ++p)
289 ulen += *p >> 7; // count set high bits
290
291 encode_uint (enc, MAJOR_TEXT, ulen);
292
293 need (enc, ulen);
294 for (p = (U8 *)str; p < pend; ++p)
295 if (*p < 0x80)
296 *enc->cur++ = *p;
297 else
298 {
299 *enc->cur++ = 0xc0 + (*p >> 6);
300 *enc->cur++ = 0x80 + (*p & 63);
301 }
302}
303
274ecb_inline void 304ecb_inline void
275encode_str (enc_t *enc, int utf8, char *str, STRLEN len) 305encode_str (enc_t *enc, int upgrade_utf8, int utf8, char *str, STRLEN len)
276{ 306{
307 if (ecb_expect_false (upgrade_utf8))
308 if (!utf8)
309 {
310 encode_str_utf8 (enc, utf8, str, len);
311 return;
312 }
313
277 encode_uint (enc, utf8 ? MAJOR_TEXT : MAJOR_BYTES, len); 314 encode_uint (enc, utf8 ? MAJOR_TEXT : MAJOR_BYTES, len);
278 need (enc, len); 315 need (enc, len);
279 memcpy (enc->cur, str, len); 316 memcpy (enc->cur, str, len);
280 enc->cur += len; 317 enc->cur += len;
281} 318}
282 319
283static void 320ecb_inline void
284encode_strref (enc_t *enc, int utf8, char *str, STRLEN len) 321encode_strref (enc_t *enc, int upgrade_utf8, int utf8, char *str, STRLEN len)
285{ 322{
286 if (ecb_expect_false (enc->cbor.flags & F_PACK_STRINGS)) 323 if (ecb_expect_false (enc->cbor.flags & F_PACK_STRINGS))
287 { 324 {
288 SV **svp = hv_fetch (enc->stringref[!!utf8], str, len, 1); 325 SV **svp = hv_fetch (enc->stringref[!!utf8], str, len, 1);
289 326
… …
300 sv_setuv (*svp, enc->stringref_idx); 337 sv_setuv (*svp, enc->stringref_idx);
301 ++enc->stringref_idx; 338 ++enc->stringref_idx;
302 } 339 }
303 } 340 }
304 341
305 encode_str (enc, utf8, str, len); 342 encode_str (enc, upgrade_utf8, utf8, str, len);
306} 343}
307 344
308static void encode_sv (enc_t *enc, SV *sv); 345static void encode_sv (enc_t *enc, SV *sv);
309 346
310static void 347static void
… …
317 354
318 ++enc->depth; 355 ++enc->depth;
319 356
320 encode_uint (enc, MAJOR_ARRAY, len + 1); 357 encode_uint (enc, MAJOR_ARRAY, len + 1);
321 358
359 if (SvMAGICAL (av))
322 for (i = 0; i <= len; ++i) 360 for (i = 0; i <= len; ++i)
323 { 361 {
324 SV **svp = av_fetch (av, i, 0); 362 SV **svp = av_fetch (av, i, 0);
325 encode_sv (enc, svp ? *svp : &PL_sv_undef); 363 encode_sv (enc, svp ? *svp : &PL_sv_undef);
326 } 364 }
365 else
366 for (i = 0; i <= len; ++i)
367 {
368 SV *sv = AvARRAY (av)[i];
369 encode_sv (enc, sv ? sv : &PL_sv_undef);
370 }
327 371
328 --enc->depth; 372 --enc->depth;
329} 373}
330 374
331static void 375static void
… …
349 while ((he = hv_iternext (hv))) 393 while ((he = hv_iternext (hv)))
350 { 394 {
351 if (HeKLEN (he) == HEf_SVKEY) 395 if (HeKLEN (he) == HEf_SVKEY)
352 encode_sv (enc, HeSVKEY (he)); 396 encode_sv (enc, HeSVKEY (he));
353 else 397 else
354 encode_strref (enc, HeKUTF8 (he), HeKEY (he), HeKLEN (he)); 398 encode_strref (enc, enc->cbor.flags & (F_TEXT_KEYS | F_TEXT_STRINGS), HeKUTF8 (he), HeKEY (he), HeKLEN (he));
355 399
356 encode_sv (enc, ecb_expect_false (mg) ? hv_iterval (hv, he) : HeVAL (he)); 400 encode_sv (enc, ecb_expect_false (mg) ? hv_iterval (hv, he) : HeVAL (he));
357 } 401 }
358 402
359 if (mg) 403 if (mg)
… …
431 if (ecb_expect_false (SvOBJECT (sv))) 475 if (ecb_expect_false (SvOBJECT (sv)))
432 { 476 {
433 HV *stash = SvSTASH (sv); 477 HV *stash = SvSTASH (sv);
434 GV *method; 478 GV *method;
435 479
480 if (enc->cbor.flags & F_FORBID_OBJECTS)
481 croak ("encountered object '%s', but forbid_objects is enabled",
482 SvPV_nolen (sv_2mortal (newRV_inc (sv))));
436 if ((method = gv_fetchmethod_autoload (stash, "TO_CBOR", 0))) 483 else if ((method = gv_fetchmethod_autoload (stash, "TO_CBOR", 0)))
437 { 484 {
438 dSP; 485 dSP;
439 486
440 ENTER; SAVETMPS; PUSHMARK (SP); 487 ENTER; SAVETMPS;
488 PUSHMARK (SP);
441 // we re-bless the reference to get overload and other niceties right 489 // we re-bless the reference to get overload and other niceties right
442 XPUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash)); 490 XPUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash));
443 491
444 PUTBACK; 492 PUTBACK;
445 // G_SCALAR ensures that return value is 1 493 // G_SCALAR ensures that return value is 1
… …
458 } 506 }
459 else if ((method = gv_fetchmethod_autoload (stash, "FREEZE", 0)) != 0) 507 else if ((method = gv_fetchmethod_autoload (stash, "FREEZE", 0)) != 0)
460 { 508 {
461 dSP; 509 dSP;
462 510
463 ENTER; SAVETMPS; PUSHMARK (SP); 511 ENTER; SAVETMPS;
512 SAVESTACK_POS ();
513 PUSHMARK (SP);
464 EXTEND (SP, 2); 514 EXTEND (SP, 2);
465 // we re-bless the reference to get overload and other niceties right 515 // we re-bless the reference to get overload and other niceties right
466 PUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash)); 516 PUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash));
467 PUSHs (sv_cbor); 517 PUSHs (sv_cbor);
468 518
… …
474 if (count == 1 && SvROK (TOPs) && SvRV (TOPs) == sv) 524 if (count == 1 && SvROK (TOPs) && SvRV (TOPs) == sv)
475 croak ("%s::FREEZE(CBOR) method returned same object as was passed instead of a new one", HvNAME (stash)); 525 croak ("%s::FREEZE(CBOR) method returned same object as was passed instead of a new one", HvNAME (stash));
476 526
477 encode_tag (enc, CBOR_TAG_PERL_OBJECT); 527 encode_tag (enc, CBOR_TAG_PERL_OBJECT);
478 encode_uint (enc, MAJOR_ARRAY, count + 1); 528 encode_uint (enc, MAJOR_ARRAY, count + 1);
479 encode_strref (enc, HvNAMEUTF8 (stash), HvNAME (stash), HvNAMELEN (stash)); 529 encode_strref (enc, 0, HvNAMEUTF8 (stash), HvNAME (stash), HvNAMELEN (stash));
480 530
481 while (count) 531 while (count)
482 encode_sv (enc, SP[1 - count--]); 532 encode_sv (enc, SP[1 - count--]);
483 533
484 PUTBACK; 534 PUTBACK;
… …
543 593
544 if (SvPOKp (sv)) 594 if (SvPOKp (sv))
545 { 595 {
546 STRLEN len; 596 STRLEN len;
547 char *str = SvPV (sv, len); 597 char *str = SvPV (sv, len);
548 encode_strref (enc, SvUTF8 (sv), str, len); 598 encode_strref (enc, enc->cbor.flags & F_TEXT_STRINGS, SvUTF8 (sv), str, len);
549 } 599 }
550 else if (SvNOKp (sv)) 600 else if (SvNOKp (sv))
551 encode_nv (enc, sv); 601 encode_nv (enc, sv);
552 else if (SvIOKp (sv)) 602 else if (SvIOKp (sv))
553 { 603 {
… …
570} 620}
571 621
572static SV * 622static SV *
573encode_cbor (SV *scalar, CBOR *cbor) 623encode_cbor (SV *scalar, CBOR *cbor)
574{ 624{
575 enc_t enc = { }; 625 enc_t enc = { 0 };
576 626
577 enc.cbor = *cbor; 627 enc.cbor = *cbor;
578 enc.sv = sv_2mortal (NEWSV (0, INIT_SIZE)); 628 enc.sv = sv_2mortal (NEWSV (0, INIT_SIZE));
579 enc.cur = SvPVX (enc.sv); 629 enc.cur = SvPVX (enc.sv);
580 enc.end = SvEND (enc.sv); 630 enc.end = SvEND (enc.sv);
… …
612 U32 depth; // recursion depth 662 U32 depth; // recursion depth
613 U32 maxdepth; // recursion depth limit 663 U32 maxdepth; // recursion depth limit
614 AV *shareable; 664 AV *shareable;
615 AV *stringref; 665 AV *stringref;
616 SV *decode_tagged; 666 SV *decode_tagged;
667 SV *err_sv; // optional sv for error, needs to be freed
617} dec_t; 668} dec_t;
618 669
619#define ERR(reason) SB if (!dec->err) dec->err = reason; goto fail; SE 670// set dec->err to ERRSV
671ecb_cold static void
672err_errsv (dec_t *dec)
673{
674 if (!dec->err)
675 {
676 dec->err_sv = newSVsv (ERRSV);
620 677
621#define WANT(len) if (ecb_expect_false (dec->cur + len > dec->end)) ERR ("unexpected end of CBOR data") 678 // chop off the trailing \n
679 SvCUR_set (dec->err_sv, SvCUR (dec->err_sv) - 1);
680 *SvEND (dec->err_sv) = 0;
622 681
682 dec->err = SvPVutf8_nolen (dec->err_sv);
683 }
684}
685
686// the following functions are used to reduce code size and help the compiler to optimise
687ecb_cold static void
688err_set (dec_t *dec, const char *reason)
689{
690 if (!dec->err)
691 dec->err = reason;
692}
693
694ecb_cold static void
695err_unexpected_end (dec_t *dec)
696{
697 err_set (dec, "unexpected end of CBOR data");
698}
699
700ecb_cold static void
701err_nesting_exceeded (dec_t *dec)
702{
703 err_set (dec, ERR_NESTING_EXCEEDED);
704}
705
706#define ERR_DO(do) SB do; goto fail; SE
707#define ERR(reason) ERR_DO (err_set (dec, reason))
708#define ERR_ERRSV ERR_DO (err_errsv (dec))
709
710#define WANT(len) if (ecb_expect_false ((uintptr_t)(dec->end - dec->cur) < (STRLEN)len)) ERR_DO (err_unexpected_end (dec))
711
623#define DEC_INC_DEPTH if (++dec->depth > dec->cbor.max_depth) ERR (ERR_NESTING_EXCEEDED) 712#define DEC_INC_DEPTH if (ecb_expect_false (++dec->depth > dec->cbor.max_depth)) ERR (ERR_NESTING_EXCEEDED)
624#define DEC_DEC_DEPTH --dec->depth 713#define DEC_DEC_DEPTH --dec->depth
625 714
626static UV 715static UV
627decode_uint (dec_t *dec) 716decode_uint (dec_t *dec)
628{ 717{
… …
705 av_push (av, decode_sv (dec)); 794 av_push (av, decode_sv (dec));
706 } 795 }
707 } 796 }
708 else 797 else
709 { 798 {
710 int i, len = decode_uint (dec); 799 UV i, len = decode_uint (dec);
711 800
712 WANT (len); // complexity check for av_fill - need at least one byte per value, do not allow supersize arrays 801 WANT (len); // complexity check for av_fill - need at least one byte per value, do not allow supersize arrays
713 av_fill (av, len - 1); 802 av_fill (av, len - 1);
714 803
715 for (i = 0; i < len; ++i) 804 for (i = 0; i < len; ++i)
… …
730{ 819{
731 // for speed reasons, we specialcase single-string 820 // for speed reasons, we specialcase single-string
732 // byte or utf-8 strings as keys, but only when !stringref 821 // byte or utf-8 strings as keys, but only when !stringref
733 822
734 if (ecb_expect_true (!dec->stringref)) 823 if (ecb_expect_true (!dec->stringref))
735 if (ecb_expect_true ((*dec->cur - MAJOR_BYTES) <= LENGTH_EXT8)) 824 if (ecb_expect_true ((U8)(*dec->cur - MAJOR_BYTES) <= LENGTH_EXT8))
736 { 825 {
737 I32 len = decode_uint (dec); 826 STRLEN len = decode_uint (dec);
738 char *key = (char *)dec->cur; 827 char *key = (char *)dec->cur;
739 828
829 WANT (len);
740 dec->cur += len; 830 dec->cur += len;
741 831
742 hv_store (hv, key, len, decode_sv (dec), 0); 832 hv_store (hv, key, len, decode_sv (dec), 0);
743 833
744 return; 834 return;
745 } 835 }
746 else if (ecb_expect_true ((*dec->cur - MAJOR_TEXT) <= LENGTH_EXT8)) 836 else if (ecb_expect_true ((U8)(*dec->cur - MAJOR_TEXT) <= LENGTH_EXT8))
747 { 837 {
748 I32 len = decode_uint (dec); 838 STRLEN len = decode_uint (dec);
749 char *key = (char *)dec->cur; 839 char *key = (char *)dec->cur;
750 840
841 WANT (len);
751 dec->cur += len; 842 dec->cur += len;
752 843
753 if (ecb_expect_false (dec->cbor.flags & F_VALIDATE_UTF8)) 844 if (ecb_expect_false (dec->cbor.flags & F_VALIDATE_UTF8))
754 if (!is_utf8_string (key, len)) 845 if (!is_utf8_string (key, len))
755 ERR ("corrupted CBOR data (invalid UTF-8 in map key)"); 846 ERR ("corrupted CBOR data (invalid UTF-8 in map key)");
… …
759 return; 850 return;
760 } 851 }
761 852
762 SV *k = decode_sv (dec); 853 SV *k = decode_sv (dec);
763 SV *v = decode_sv (dec); 854 SV *v = decode_sv (dec);
855
856 // we leak memory if uncaught exceptions are thrown by random magical
857 // methods, and this is hopefully the only place where it can happen,
858 // so if there is a chance of an exception, take the very slow path.
859 // since catching exceptions is "undocumented/internal/forbidden" by
860 // the new p5p powers, we need to call out to a perl function :/
861 if (ecb_expect_false (SvAMAGIC (k)))
862 {
863 dSP;
864
865 ENTER; SAVETMPS;
866 PUSHMARK (SP);
867 EXTEND (SP, 3);
868 PUSHs (sv_2mortal (newRV_inc ((SV *)hv)));
869 PUSHs (sv_2mortal (k));
870 PUSHs (sv_2mortal (v));
871
872 PUTBACK;
873 call_pv ("CBOR::XS::_hv_store", G_VOID | G_DISCARD | G_EVAL);
874 SPAGAIN;
875
876 FREETMPS; LEAVE;
877
878 if (SvTRUE (ERRSV))
879 ERR_ERRSV;
880
881 return;
882 }
764 883
765 hv_store_ent (hv, k, v, 0); 884 hv_store_ent (hv, k, v, 0);
766 SvREFCNT_dec (k); 885 SvREFCNT_dec (k);
767 886
768fail: 887fail:
… …
793 decode_he (dec, hv); 912 decode_he (dec, hv);
794 } 913 }
795 } 914 }
796 else 915 else
797 { 916 {
798 int pairs = decode_uint (dec); 917 UV pairs = decode_uint (dec);
918
919 WANT (pairs); // complexity check - need at least one byte per value, do not allow supersize hashes
799 920
800 while (pairs--) 921 while (pairs--)
801 decode_he (dec, hv); 922 decode_he (dec, hv);
802 } 923 }
803 924
… …
891 sv = newRV_noinc (decode_sv (dec)); 1012 sv = newRV_noinc (decode_sv (dec));
892 break; 1013 break;
893 1014
894 case CBOR_TAG_STRINGREF_NAMESPACE: 1015 case CBOR_TAG_STRINGREF_NAMESPACE:
895 { 1016 {
1017 // do nmot use SAVETMPS/FREETMPS, as these will
1018 // erase mortalised caches, e.g. "shareable"
896 ENTER; SAVETMPS; 1019 ENTER;
897 1020
898 SAVESPTR (dec->stringref); 1021 SAVESPTR (dec->stringref);
899 dec->stringref = (AV *)sv_2mortal ((SV *)newAV ()); 1022 dec->stringref = (AV *)sv_2mortal ((SV *)newAV ());
900 1023
901 sv = decode_sv (dec); 1024 sv = decode_sv (dec);
902 1025
903 FREETMPS; LEAVE; 1026 LEAVE;
904 } 1027 }
905 break; 1028 break;
906 1029
907 case CBOR_TAG_STRINGREF: 1030 case CBOR_TAG_STRINGREF:
908 { 1031 {
… …
959 } 1082 }
960 break; 1083 break;
961 1084
962 case CBOR_TAG_PERL_OBJECT: 1085 case CBOR_TAG_PERL_OBJECT:
963 { 1086 {
1087 if (dec->cbor.flags & F_FORBID_OBJECTS)
1088 goto filter;
1089
964 sv = decode_sv (dec); 1090 sv = decode_sv (dec);
965 1091
966 if (!SvROK (sv) || SvTYPE (SvRV (sv)) != SVt_PVAV) 1092 if (!SvROK (sv) || SvTYPE (SvRV (sv)) != SVt_PVAV)
967 ERR ("corrupted CBOR data (non-array perl object)"); 1093 ERR ("corrupted CBOR data (non-array perl object)");
968 1094
… …
978 if (!method) 1104 if (!method)
979 ERR ("cannot decode perl-object (package does not have a THAW method)"); 1105 ERR ("cannot decode perl-object (package does not have a THAW method)");
980 1106
981 dSP; 1107 dSP;
982 1108
983 ENTER; SAVETMPS; PUSHMARK (SP); 1109 ENTER; SAVETMPS;
1110 PUSHMARK (SP);
984 EXTEND (SP, len + 1); 1111 EXTEND (SP, len + 1);
985 // we re-bless the reference to get overload and other niceties right 1112 // we re-bless the reference to get overload and other niceties right
986 PUSHs (*av_fetch (av, 0, 1)); 1113 PUSHs (*av_fetch (av, 0, 1));
987 PUSHs (sv_cbor); 1114 PUSHs (sv_cbor);
988 1115
… …
996 SPAGAIN; 1123 SPAGAIN;
997 1124
998 if (SvTRUE (ERRSV)) 1125 if (SvTRUE (ERRSV))
999 { 1126 {
1000 FREETMPS; LEAVE; 1127 FREETMPS; LEAVE;
1001 ERR (SvPVutf8_nolen (sv_2mortal (SvREFCNT_inc (ERRSV)))); 1128 ERR_ERRSV;
1002 } 1129 }
1003 1130
1004 SvREFCNT_dec (sv); 1131 SvREFCNT_dec (sv);
1005 sv = SvREFCNT_inc (POPs); 1132 sv = SvREFCNT_inc (POPs);
1006 1133
… …
1009 FREETMPS; LEAVE; 1136 FREETMPS; LEAVE;
1010 } 1137 }
1011 break; 1138 break;
1012 1139
1013 default: 1140 default:
1141 filter:
1014 { 1142 {
1143 SV *tag_sv = newSVuv (tag);
1144
1015 sv = decode_sv (dec); 1145 sv = decode_sv (dec);
1016 1146
1017 dSP; 1147 dSP;
1018 ENTER; SAVETMPS; PUSHMARK (SP); 1148 ENTER; SAVETMPS;
1149 SAVESTACK_POS ();
1150 PUSHMARK (SP);
1019 EXTEND (SP, 2); 1151 EXTEND (SP, 2);
1020 PUSHs (newSVuv (tag)); 1152 PUSHs (tag_sv);
1021 PUSHs (sv); 1153 PUSHs (sv);
1022 1154
1023 PUTBACK; 1155 PUTBACK;
1024 int count = call_sv (dec->cbor.filter ? dec->cbor.filter : default_filter, G_ARRAY | G_EVAL); 1156 int count = call_sv (dec->cbor.filter ? dec->cbor.filter : default_filter, G_ARRAY | G_EVAL);
1025 SPAGAIN; 1157 SPAGAIN;
1026 1158
1027 if (SvTRUE (ERRSV)) 1159 if (SvTRUE (ERRSV))
1028 { 1160 {
1161 SvREFCNT_dec (tag_sv);
1029 FREETMPS; LEAVE; 1162 FREETMPS; LEAVE;
1030 ERR (SvPVutf8_nolen (sv_2mortal (SvREFCNT_inc (ERRSV)))); 1163 ERR_ERRSV;
1031 } 1164 }
1032 1165
1033 if (count) 1166 if (count)
1034 { 1167 {
1168 SvREFCNT_dec (tag_sv);
1035 SvREFCNT_dec (sv); 1169 SvREFCNT_dec (sv);
1036 sv = SvREFCNT_inc (POPs); 1170 sv = SvREFCNT_inc (POPs);
1037 } 1171 }
1038 else 1172 else
1039 { 1173 {
1040 AV *av = newAV (); 1174 AV *av = newAV ();
1041 av_push (av, newSVuv (tag)); 1175 av_push (av, tag_sv);
1042 av_push (av, sv); 1176 av_push (av, sv);
1043 1177
1044 HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash 1178 HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash
1045 ? cbor_tagged_stash 1179 ? cbor_tagged_stash
1046 : gv_stashpv ("CBOR::XS::Tagged" , 1); 1180 : gv_stashpv ("CBOR::XS::Tagged" , 1);
… …
1132 1266
1133 return newSVnv (ecb_binary64_to_double (fp)); 1267 return newSVnv (ecb_binary64_to_double (fp));
1134 } 1268 }
1135 1269
1136 // 0..19 unassigned simple 1270 // 0..19 unassigned simple
1137 // 24 reserved + unassigned (reserved values are not encodable) 1271 // 24 reserved + unassigned simple (reserved values are not encodable)
1272 // 28-30 unassigned misc
1273 // 31 break code
1138 default: 1274 default:
1139 ERR ("corrupted CBOR data (reserved/unassigned major 7 value)"); 1275 ERR ("corrupted CBOR data (reserved/unassigned/unexpected major 7 value)");
1140 } 1276 }
1141 1277
1142 break; 1278 break;
1143 } 1279 }
1144 1280
… …
1147} 1283}
1148 1284
1149static SV * 1285static SV *
1150decode_cbor (SV *string, CBOR *cbor, char **offset_return) 1286decode_cbor (SV *string, CBOR *cbor, char **offset_return)
1151{ 1287{
1152 dec_t dec = { }; 1288 dec_t dec = { 0 };
1153 SV *sv; 1289 SV *sv;
1154 STRLEN len; 1290 STRLEN len;
1155 char *data = SvPVbyte (string, len); 1291 char *data = SvPVbyte (string, len);
1156 1292
1157 if (len > cbor->max_size && cbor->max_size) 1293 if (len > cbor->max_size && cbor->max_size)
… …
1173 1309
1174 if (dec.err) 1310 if (dec.err)
1175 { 1311 {
1176 if (dec.shareable) 1312 if (dec.shareable)
1177 { 1313 {
1178 // need to break cyclic links, which whould all be in shareable 1314 // need to break cyclic links, which would all be in shareable
1179 int i; 1315 int i;
1180 SV **svp; 1316 SV **svp;
1181 1317
1182 for (i = av_len (dec.shareable) + 1; i--; ) 1318 for (i = av_len (dec.shareable) + 1; i--; )
1183 if ((svp = av_fetch (dec.shareable, i, 0))) 1319 if ((svp = av_fetch (dec.shareable, i, 0)))
1184 sv_setsv (*svp, &PL_sv_undef); 1320 sv_setsv (*svp, &PL_sv_undef);
1185 } 1321 }
1186 1322
1187 SvREFCNT_dec (sv); 1323 SvREFCNT_dec (sv);
1324
1325 if (dec.err_sv)
1326 sv_2mortal (dec.err_sv);
1327
1188 croak ("%s, at offset %d (octet 0x%02x)", dec.err, dec.cur - (U8 *)data, (int)(uint8_t)*dec.cur); 1328 croak ("%s, at offset %d (octet 0x%02x)", dec.err, dec.cur - (U8 *)data, (int)(uint8_t)*dec.cur);
1189 } 1329 }
1190 1330
1191 sv = sv_2mortal (sv); 1331 sv = sv_2mortal (sv);
1192 1332
1193 return sv; 1333 return sv;
1194} 1334}
1195 1335
1336/////////////////////////////////////////////////////////////////////////////
1337// incremental parser
1338
1339#define INCR_DONE(cbor) (AvFILLp (cbor->incr_count) < 0)
1340
1341// returns 0 for notyet, 1 for success or error
1342static int
1343incr_parse (CBOR *self, SV *cborstr)
1344{
1345 STRLEN cur;
1346 SvPV (cborstr, cur);
1347
1348 while (ecb_expect_true (self->incr_need <= cur))
1349 {
1350 // table of integer count bytes
1351 static I8 incr_len[MINOR_MASK + 1] = {
1352 0, 0, 0, 0, 0, 0, 0, 0,
1353 0, 0, 0, 0, 0, 0, 0, 0,
1354 0, 0, 0, 0, 0, 0, 0, 0,
1355 1, 2, 4, 8,-1,-1,-1,-2
1356 };
1357
1358 const U8 *p = SvPVX (cborstr) + self->incr_pos;
1359 U8 m = *p & MINOR_MASK;
1360 IV count = SvIVX (AvARRAY (self->incr_count)[AvFILLp (self->incr_count)]);
1361 I8 ilen = incr_len[m];
1362
1363 self->incr_need = self->incr_pos + 1;
1364
1365 if (ecb_expect_false (ilen < 0))
1366 {
1367 if (m != MINOR_INDEF)
1368 return 1; // error
1369
1370 if (*p == (MAJOR_MISC | MINOR_INDEF))
1371 {
1372 if (count >= 0)
1373 return 1; // error
1374
1375 count = 1;
1376 }
1377 else
1378 {
1379 av_push (self->incr_count, newSViv (-1)); //TODO: nest
1380 count = -1;
1381 }
1382 }
1383 else
1384 {
1385 self->incr_need += ilen;
1386 if (ecb_expect_false (self->incr_need > cur))
1387 return 0;
1388
1389 int major = *p >> MAJOR_SHIFT;
1390
1391 switch (major)
1392 {
1393 case MAJOR_TAG >> MAJOR_SHIFT:
1394 ++count; // tags merely prefix another value
1395 break;
1396
1397 case MAJOR_BYTES >> MAJOR_SHIFT:
1398 case MAJOR_TEXT >> MAJOR_SHIFT:
1399 case MAJOR_ARRAY >> MAJOR_SHIFT:
1400 case MAJOR_MAP >> MAJOR_SHIFT:
1401 {
1402 UV len;
1403
1404 if (ecb_expect_false (ilen))
1405 {
1406 len = 0;
1407
1408 do {
1409 len = (len << 8) | *++p;
1410 } while (--ilen);
1411 }
1412 else
1413 len = m;
1414
1415 switch (major)
1416 {
1417 case MAJOR_BYTES >> MAJOR_SHIFT:
1418 case MAJOR_TEXT >> MAJOR_SHIFT:
1419 self->incr_need += len;
1420 if (ecb_expect_false (self->incr_need > cur))
1421 return 0;
1422
1423 break;
1424
1425 case MAJOR_MAP >> MAJOR_SHIFT:
1426 len <<= 1;
1427 case MAJOR_ARRAY >> MAJOR_SHIFT:
1428 if (len)
1429 {
1430 av_push (self->incr_count, newSViv (len + 1)); //TODO: nest
1431 count = len + 1;
1432 }
1433 break;
1434 }
1435 }
1436 }
1437 }
1438
1439 self->incr_pos = self->incr_need;
1440
1441 if (count > 0)
1442 {
1443 while (!--count)
1444 {
1445 if (!AvFILLp (self->incr_count))
1446 return 1; // done
1447
1448 SvREFCNT_dec_NN (av_pop (self->incr_count));
1449 count = SvIVX (AvARRAY (self->incr_count)[AvFILLp (self->incr_count)]);
1450 }
1451
1452 SvIVX (AvARRAY (self->incr_count)[AvFILLp (self->incr_count)]) = count;
1453 }
1454 }
1455
1456 return 0;
1457}
1458
1459
1196///////////////////////////////////////////////////////////////////////////// 1460/////////////////////////////////////////////////////////////////////////////
1197// XS interface functions 1461// XS interface functions
1198 1462
1199MODULE = CBOR::XS PACKAGE = CBOR::XS 1463MODULE = CBOR::XS PACKAGE = CBOR::XS
1200 1464
… …
1212 1476
1213 default_filter = newSVpv ("CBOR::XS::default_filter", 0); 1477 default_filter = newSVpv ("CBOR::XS::default_filter", 0);
1214 1478
1215 sv_cbor = newSVpv ("CBOR", 0); 1479 sv_cbor = newSVpv ("CBOR", 0);
1216 SvREADONLY_on (sv_cbor); 1480 SvREADONLY_on (sv_cbor);
1481
1482 assert (("STRLEN must be an unsigned type", 0 <= (STRLEN)-1));
1217} 1483}
1218 1484
1219PROTOTYPES: DISABLE 1485PROTOTYPES: DISABLE
1220 1486
1221void CLONE (...) 1487void CLONE (...)
… …
1241 ALIAS: 1507 ALIAS:
1242 shrink = F_SHRINK 1508 shrink = F_SHRINK
1243 allow_unknown = F_ALLOW_UNKNOWN 1509 allow_unknown = F_ALLOW_UNKNOWN
1244 allow_sharing = F_ALLOW_SHARING 1510 allow_sharing = F_ALLOW_SHARING
1245 allow_cycles = F_ALLOW_CYCLES 1511 allow_cycles = F_ALLOW_CYCLES
1512 forbid_objects = F_FORBID_OBJECTS
1246 pack_strings = F_PACK_STRINGS 1513 pack_strings = F_PACK_STRINGS
1514 text_keys = F_TEXT_KEYS
1515 text_strings = F_TEXT_STRINGS
1247 validate_utf8 = F_VALIDATE_UTF8 1516 validate_utf8 = F_VALIDATE_UTF8
1248 PPCODE: 1517 PPCODE:
1249{ 1518{
1250 if (enable) 1519 if (enable)
1251 self->flags |= ix; 1520 self->flags |= ix;
… …
1259 ALIAS: 1528 ALIAS:
1260 get_shrink = F_SHRINK 1529 get_shrink = F_SHRINK
1261 get_allow_unknown = F_ALLOW_UNKNOWN 1530 get_allow_unknown = F_ALLOW_UNKNOWN
1262 get_allow_sharing = F_ALLOW_SHARING 1531 get_allow_sharing = F_ALLOW_SHARING
1263 get_allow_cycles = F_ALLOW_CYCLES 1532 get_allow_cycles = F_ALLOW_CYCLES
1533 get_forbid_objects = F_FORBID_OBJECTS
1264 get_pack_strings = F_PACK_STRINGS 1534 get_pack_strings = F_PACK_STRINGS
1535 get_text_keys = F_TEXT_KEYS
1536 get_text_strings = F_TEXT_STRINGS
1265 get_validate_utf8 = F_VALIDATE_UTF8 1537 get_validate_utf8 = F_VALIDATE_UTF8
1266 PPCODE: 1538 PPCODE:
1267 XPUSHs (boolSV (self->flags & ix)); 1539 XPUSHs (boolSV (self->flags & ix));
1268 1540
1269void max_depth (CBOR *self, U32 max_depth = 0x80000000UL) 1541void max_depth (CBOR *self, U32 max_depth = 0x80000000UL)
… …
1319 EXTEND (SP, 2); 1591 EXTEND (SP, 2);
1320 PUSHs (sv); 1592 PUSHs (sv);
1321 PUSHs (sv_2mortal (newSVuv (offset - SvPVX (cborstr)))); 1593 PUSHs (sv_2mortal (newSVuv (offset - SvPVX (cborstr))));
1322} 1594}
1323 1595
1596void incr_parse (CBOR *self, SV *cborstr)
1597 ALIAS:
1598 incr_parse_multiple = 1
1599 PPCODE:
1600{
1601 if (SvUTF8 (cborstr))
1602 sv_utf8_downgrade (cborstr, 0);
1603
1604 if (!self->incr_count)
1605 {
1606 self->incr_count = newAV ();
1607 self->incr_pos = 0;
1608 self->incr_need = 1;
1609
1610 av_push (self->incr_count, newSViv (1));
1611 }
1612
1613 do
1614 {
1615 if (!incr_parse (self, cborstr))
1616 {
1617 if (self->incr_need > self->max_size && self->max_size)
1618 croak ("attempted decode of CBOR text of %lu bytes size, but max_size is set to %lu",
1619 (unsigned long)self->incr_need, (unsigned long)self->max_size);
1620
1621 break;
1622 }
1623
1624 SV *sv;
1625 char *offset;
1626
1627 PUTBACK; sv = decode_cbor (cborstr, self, &offset); SPAGAIN;
1628 XPUSHs (sv);
1629
1630 sv_chop (cborstr, offset);
1631
1632 av_clear (self->incr_count);
1633 av_push (self->incr_count, newSViv (1));
1634
1635 self->incr_pos = 0;
1636 self->incr_need = self->incr_pos + 1;
1637 }
1638 while (ix);
1639}
1640
1641void incr_reset (CBOR *self)
1642 CODE:
1643{
1644 SvREFCNT_dec (self->incr_count);
1645 self->incr_count = 0;
1646}
1647
1324void DESTROY (CBOR *self) 1648void DESTROY (CBOR *self)
1325 PPCODE: 1649 PPCODE:
1326 cbor_free (self); 1650 cbor_free (self);
1327 1651
1328PROTOTYPES: ENABLE 1652PROTOTYPES: ENABLE

Diff Legend

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