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

Diff Legend

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