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.60 by root, Sat Nov 26 00:47:02 2016 UTC vs.
Revision 1.74 by root, Wed Oct 27 14:59:22 2021 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
12#define ECB_NO_THREADS 1 13#define ECB_NO_THREADS 1
13#include "ecb.h" 14#include "ecb.h"
14 15
15// compatibility with perl <5.18 16// compatibility with perl <5.18
… …
20# define HvNAMELEN(hv) HvNAMELEN_get (hv) 21# define HvNAMELEN(hv) HvNAMELEN_get (hv)
21#endif 22#endif
22#ifndef HvNAMEUTF8 23#ifndef HvNAMEUTF8
23# define HvNAMEUTF8(hv) 0 24# define HvNAMEUTF8(hv) 0
24#endif 25#endif
26#ifndef SvREFCNT_inc_NN
27# define SvREFCNT_inc_NN(sv) SvREFCNT_inc (sv)
28#endif
25#ifndef SvREFCNT_dec_NN 29#ifndef SvREFCNT_dec_NN
26# define SvREFCNT_dec_NN(sv) SvREFCNT_dec (sv) 30# define SvREFCNT_dec_NN(sv) SvREFCNT_dec (sv)
27#endif 31#endif
32
33// perl's is_utf8_string interprets len=0 as "calculate len", but we want it to mean 0
34#define cbor_is_utf8_string(str,len) (!(len) || is_utf8_string ((str), (len)))
28 35
29// known major and minor types 36// known major and minor types
30enum cbor_type 37enum cbor_type
31{ 38{
32 MAJOR_SHIFT = 5, 39 MAJOR_SHIFT = 5,
… …
93 CBOR_TAG_B64 = 34, // base6 rfc46484, utf-8 100 CBOR_TAG_B64 = 34, // base6 rfc46484, utf-8
94 CBOR_TAG_REGEX = 35, // regex pcre/ecma262, utf-8 101 CBOR_TAG_REGEX = 35, // regex pcre/ecma262, utf-8
95 CBOR_TAG_MIME = 36, // mime message rfc2045, utf-8 102 CBOR_TAG_MIME = 36, // mime message rfc2045, utf-8
96 103
97 CBOR_TAG_MAGIC = 55799, // self-describe cbor 104 CBOR_TAG_MAGIC = 55799, // self-describe cbor
105};
106
107// known forced types, also hardcoded in CBOR.pm
108enum
109{
110 AS_CBOR = 0,
111 AS_INT = 1,
112 AS_BYTES = 2,
113 AS_TEXT = 3,
114 AS_FLOAT16 = 4,
115 AS_FLOAT32 = 5,
116 AS_FLOAT64 = 6,
117 AS_MAP = 7,
118 // possibly future enhancements: (generic) float, (generic) string
98}; 119};
99 120
100#define F_SHRINK 0x00000001UL 121#define F_SHRINK 0x00000001UL
101#define F_ALLOW_UNKNOWN 0x00000002UL 122#define F_ALLOW_UNKNOWN 0x00000002UL
102#define F_ALLOW_SHARING 0x00000004UL 123#define F_ALLOW_SHARING 0x00000004UL
… …
183#endif 204#endif
184 } 205 }
185} 206}
186 207
187// minimum length of a string to be registered for stringref 208// minimum length of a string to be registered for stringref
188ecb_inline int 209ecb_inline STRLEN
189minimum_string_length (UV idx) 210minimum_string_length (UV idx)
190{ 211{
191 return idx > 23 212 return idx <= 23 ? 3
192 ? idx > 0xffU 213 : idx <= 0xffU ? 4
193 ? idx > 0xffffU 214 : idx <= 0xffffU ? 5
194 ? idx > 0xffffffffU 215 : idx <= 0xffffffffU ? 7
195 ? 11 216 : 11;
196 : 7
197 : 5
198 : 4
199 : 3;
200} 217}
201 218
202///////////////////////////////////////////////////////////////////////////// 219/////////////////////////////////////////////////////////////////////////////
203// encoder 220// encoder
204 221
… …
217} enc_t; 234} enc_t;
218 235
219ecb_inline void 236ecb_inline void
220need (enc_t *enc, STRLEN len) 237need (enc_t *enc, STRLEN len)
221{ 238{
222 if (ecb_expect_false (enc->cur + len >= enc->end)) 239 if (ecb_expect_false ((uintptr_t)(enc->end - enc->cur) < len))
223 { 240 {
224 STRLEN cur = enc->cur - (char *)SvPVX (enc->sv); 241 STRLEN cur = enc->cur - (char *)SvPVX (enc->sv);
225 SvGROW (enc->sv, cur + (len < (cur >> 2) ? cur >> 2 : len) + 1); 242 SvGROW (enc->sv, cur + (len < (cur >> 2) ? cur >> 2 : len) + 1);
226 enc->cur = SvPVX (enc->sv) + cur; 243 enc->cur = SvPVX (enc->sv) + cur;
227 enc->end = SvPVX (enc->sv) + SvLEN (enc->sv) - 1; 244 enc->end = SvPVX (enc->sv) + SvLEN (enc->sv) - 1;
228 } 245 }
229} 246}
230 247
248static void encode_sv (enc_t *enc, SV *sv);
249
231ecb_inline void 250ecb_inline void
232encode_ch (enc_t *enc, char ch) 251encode_ch (enc_t *enc, char ch)
233{ 252{
234 need (enc, 1); 253 need (enc, 1);
235 *enc->cur++ = ch; 254 *enc->cur++ = ch;
236} 255}
237 256
257// used for tags, intregers, element counts and so on
238static void 258static void
239encode_uint (enc_t *enc, int major, UV len) 259encode_uint (enc_t *enc, int major, UV len)
240{ 260{
241 need (enc, 9); 261 need (enc, 9);
242 262
… …
273 *enc->cur++ = len >> 8; 293 *enc->cur++ = len >> 8;
274 *enc->cur++ = len; 294 *enc->cur++ = len;
275 } 295 }
276} 296}
277 297
298// encodes a perl value into a CBOR integer
299ecb_inline void
300encode_int (enc_t *enc, SV *sv)
301{
302 if (SvIsUV (sv))
303 encode_uint (enc, MAJOR_POS_INT, SvUVX (sv));
304 else if (SvIVX (sv) >= 0)
305 encode_uint (enc, MAJOR_POS_INT, SvIVX (sv));
306 else
307 encode_uint (enc, MAJOR_NEG_INT, -(SvIVX (sv) + 1));
308}
309
278ecb_inline void 310ecb_inline void
279encode_tag (enc_t *enc, UV tag) 311encode_tag (enc_t *enc, UV tag)
280{ 312{
281 encode_uint (enc, MAJOR_TAG, tag); 313 encode_uint (enc, MAJOR_TAG, tag);
282} 314}
… …
343 } 375 }
344 376
345 encode_str (enc, upgrade_utf8, utf8, str, len); 377 encode_str (enc, upgrade_utf8, utf8, str, len);
346} 378}
347 379
348static void encode_sv (enc_t *enc, SV *sv); 380ecb_inline void
381encode_float16 (enc_t *enc, NV nv)
382{
383 need (enc, 1+2);
384
385 *enc->cur++ = MAJOR_MISC | MISC_FLOAT16;
386
387 uint16_t fp = ecb_float_to_binary16 (nv);
388
389 if (!ecb_big_endian ())
390 fp = ecb_bswap16 (fp);
391
392 memcpy (enc->cur, &fp, 2);
393 enc->cur += 2;
394}
395
396ecb_inline void
397encode_float32 (enc_t *enc, NV nv)
398{
399 need (enc, 1+4);
400
401 *enc->cur++ = MAJOR_MISC | MISC_FLOAT32;
402
403 uint32_t fp = ecb_float_to_binary32 (nv);
404
405 if (!ecb_big_endian ())
406 fp = ecb_bswap32 (fp);
407
408 memcpy (enc->cur, &fp, 4);
409 enc->cur += 4;
410}
411
412ecb_inline void
413encode_float64 (enc_t *enc, NV nv)
414{
415 need (enc, 1+8);
416
417 *enc->cur++ = MAJOR_MISC | MISC_FLOAT64;
418
419 uint64_t fp = ecb_double_to_binary64 (nv);
420
421 if (!ecb_big_endian ())
422 fp = ecb_bswap64 (fp);
423
424 memcpy (enc->cur, &fp, 8);
425 enc->cur += 8;
426}
427
428ecb_inline void
429encode_bool (enc_t *enc, int istrue)
430{
431 encode_ch (enc, istrue ? MAJOR_MISC | SIMPLE_TRUE : MAJOR_MISC | SIMPLE_FALSE);
432}
433
434// encodes an arrayref containing key-value pairs as CBOR map
435ecb_inline void
436encode_array_as_map (enc_t *enc, SV *sv)
437{
438 if (enc->depth >= enc->cbor.max_depth)
439 croak (ERR_NESTING_EXCEEDED);
440
441 ++enc->depth;
442
443 // as_map does error checking for us, but we re-check in case
444 // things have changed.
445
446 if (!SvROK (sv) || SvTYPE (SvRV (sv)) != SVt_PVAV)
447 croak ("CBOR::XS::as_map requires an array reference (did you change the array after calling as_map?)");
448
449 AV *av = (AV *)SvRV (sv);
450 int i, len = av_len (av);
451
452 if (!(len & 1))
453 croak ("CBOR::XS::as_map requires an even number of elements (did you change the array after calling as_map?)");
454
455 encode_uint (enc, MAJOR_MAP, (len + 1) >> 1);
456
457 for (i = 0; i <= len; ++i)
458 {
459 SV **svp = av_fetch (av, i, 0);
460 encode_sv (enc, svp ? *svp : &PL_sv_undef);
461 }
462
463 --enc->depth;
464}
465
466ecb_inline void
467encode_forced (enc_t *enc, UV type, SV *sv)
468{
469 switch (type)
470 {
471 case AS_CBOR:
472 {
473 STRLEN len;
474 char *str = SvPVbyte (sv, len);
475
476 need (enc, len);
477 memcpy (enc->cur, str, len);
478 enc->cur += len;
479 }
480 break;
481
482 case AS_BYTES:
483 {
484 STRLEN len;
485 char *str = SvPVbyte (sv, len);
486 encode_strref (enc, 0, 0, str, len);
487 }
488 break;
489
490 case AS_TEXT:
491 {
492 STRLEN len;
493 char *str = SvPVutf8 (sv, len);
494 encode_strref (enc, 1, 1, str, len);
495 }
496 break;
497
498 case AS_INT: encode_int (enc, sv); break;
499
500 case AS_FLOAT16: encode_float16 (enc, SvNV (sv)); break;
501 case AS_FLOAT32: encode_float32 (enc, SvNV (sv)); break;
502 case AS_FLOAT64: encode_float64 (enc, SvNV (sv)); break;
503
504 case AS_MAP: encode_array_as_map (enc, sv); break;
505
506 default:
507 croak ("encountered malformed CBOR::XS::Tagged object");
508 }
509}
349 510
350static void 511static void
351encode_av (enc_t *enc, AV *av) 512encode_av (enc_t *enc, AV *av)
352{ 513{
353 int i, len = av_len (av); 514 int i, len = av_len (av);
… …
357 518
358 ++enc->depth; 519 ++enc->depth;
359 520
360 encode_uint (enc, MAJOR_ARRAY, len + 1); 521 encode_uint (enc, MAJOR_ARRAY, len + 1);
361 522
362 if (SvMAGICAL (av)) 523 if (ecb_expect_false (SvMAGICAL (av)))
363 for (i = 0; i <= len; ++i) 524 for (i = 0; i <= len; ++i)
364 { 525 {
365 SV **svp = av_fetch (av, i, 0); 526 SV **svp = av_fetch (av, i, 0);
366 encode_sv (enc, svp ? *svp : &PL_sv_undef); 527 encode_sv (enc, svp ? *svp : &PL_sv_undef);
367 } 528 }
… …
386 ++enc->depth; 547 ++enc->depth;
387 548
388 int pairs = hv_iterinit (hv); 549 int pairs = hv_iterinit (hv);
389 int mg = SvMAGICAL (hv); 550 int mg = SvMAGICAL (hv);
390 551
391 if (mg) 552 if (ecb_expect_false (mg))
392 encode_ch (enc, MAJOR_MAP | MINOR_INDEF); 553 encode_ch (enc, MAJOR_MAP | MINOR_INDEF);
393 else 554 else
394 encode_uint (enc, MAJOR_MAP, pairs); 555 encode_uint (enc, MAJOR_MAP, pairs);
395 556
396 while ((he = hv_iternext (hv))) 557 while ((he = hv_iternext (hv)))
… …
401 encode_strref (enc, enc->cbor.flags & (F_TEXT_KEYS | F_TEXT_STRINGS), HeKUTF8 (he), HeKEY (he), HeKLEN (he)); 562 encode_strref (enc, enc->cbor.flags & (F_TEXT_KEYS | F_TEXT_STRINGS), HeKUTF8 (he), HeKEY (he), HeKLEN (he));
402 563
403 encode_sv (enc, ecb_expect_false (mg) ? hv_iterval (hv, he) : HeVAL (he)); 564 encode_sv (enc, ecb_expect_false (mg) ? hv_iterval (hv, he) : HeVAL (he));
404 } 565 }
405 566
406 if (mg) 567 if (ecb_expect_false (mg))
407 encode_ch (enc, MAJOR_MISC | MINOR_INDEF); 568 encode_ch (enc, MAJOR_MISC | MINOR_INDEF);
408 569
409 --enc->depth; 570 --enc->depth;
410} 571}
411 572
… …
431 592
432 HV *stash = SvSTASH (sv); 593 HV *stash = SvSTASH (sv);
433 594
434 if (stash == boolean_stash) 595 if (stash == boolean_stash)
435 { 596 {
436 encode_ch (enc, SvIV (sv) ? MAJOR_MISC | SIMPLE_TRUE : MAJOR_MISC | SIMPLE_FALSE); 597 encode_bool (enc, SvIV (sv));
437 return; 598 return;
438 } 599 }
439 else if (stash == error_stash) 600 else if (stash == error_stash)
440 { 601 {
441 encode_ch (enc, MAJOR_MISC | SIMPLE_UNDEF); 602 encode_ch (enc, MAJOR_MISC | SIMPLE_UNDEF);
… …
444 else if (stash == tagged_stash) 605 else if (stash == tagged_stash)
445 { 606 {
446 if (svt != SVt_PVAV) 607 if (svt != SVt_PVAV)
447 croak ("encountered CBOR::XS::Tagged object that isn't an array"); 608 croak ("encountered CBOR::XS::Tagged object that isn't an array");
448 609
610 switch (av_len ((AV *)sv))
611 {
612 case 2-1:
613 // actually a tagged value
449 encode_uint (enc, MAJOR_TAG, SvUV (*av_fetch ((AV *)sv, 0, 1))); 614 encode_uint (enc, MAJOR_TAG, SvUV (*av_fetch ((AV *)sv, 0, 1)));
450 encode_sv (enc, *av_fetch ((AV *)sv, 1, 1)); 615 encode_sv (enc, *av_fetch ((AV *)sv, 1, 1));
616 break;
617
618 case 3-1:
619 // a forced type [value, type, undef]
620 encode_forced (enc, SvUV (*av_fetch ((AV *)sv, 1, 1)), *av_fetch ((AV *)sv, 0, 1));
621 break;
622
623 default:
624 croak ("encountered malformed CBOR::XS::Tagged object");
625 }
451 626
452 return; 627 return;
453 } 628 }
454 } 629 }
455 630
456 if (ecb_expect_false (SvREFCNT (sv) > 1) 631 if (ecb_expect_false (SvREFCNT (sv) > 1)
457 && ecb_expect_false (enc->cbor.flags & F_ALLOW_SHARING)) 632 && ecb_expect_false (enc->cbor.flags & F_ALLOW_SHARING))
458 { 633 {
459 if (!enc->shareable) 634 if (ecb_expect_false (!enc->shareable))
460 enc->shareable = (HV *)sv_2mortal ((SV *)newHV ()); 635 enc->shareable = (HV *)sv_2mortal ((SV *)newHV ());
461 636
462 SV **svp = hv_fetch (enc->shareable, (char *)&sv, sizeof (sv), 1); 637 SV **svp = hv_fetch (enc->shareable, (char *)&sv, sizeof (sv), 1);
463 638
464 if (SvOK (*svp)) 639 if (SvOK (*svp))
… …
510 else if ((method = gv_fetchmethod_autoload (stash, "FREEZE", 0)) != 0) 685 else if ((method = gv_fetchmethod_autoload (stash, "FREEZE", 0)) != 0)
511 { 686 {
512 dSP; 687 dSP;
513 688
514 ENTER; SAVETMPS; 689 ENTER; SAVETMPS;
515 SAVESTACK_POS ();
516 PUSHMARK (SP); 690 PUSHMARK (SP);
517 EXTEND (SP, 2); 691 EXTEND (SP, 2);
518 // we re-bless the reference to get overload and other niceties right 692 // we re-bless the reference to get overload and other niceties right
519 PUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash)); 693 PUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash));
520 PUSHs (sv_cbor); 694 PUSHs (sv_cbor);
… …
529 703
530 encode_tag (enc, CBOR_TAG_PERL_OBJECT); 704 encode_tag (enc, CBOR_TAG_PERL_OBJECT);
531 encode_uint (enc, MAJOR_ARRAY, count + 1); 705 encode_uint (enc, MAJOR_ARRAY, count + 1);
532 encode_strref (enc, 0, HvNAMEUTF8 (stash), HvNAME (stash), HvNAMELEN (stash)); 706 encode_strref (enc, 0, HvNAMEUTF8 (stash), HvNAME (stash), HvNAMELEN (stash));
533 707
534 while (count) 708 {
709 int i;
710
711 for (i = 0; i < count; ++i)
535 encode_sv (enc, SP[1 - count--]); 712 encode_sv (enc, SP[i + 1 - count]);
713
714 SP -= count;
715 }
536 716
537 PUTBACK; 717 PUTBACK;
538 718
539 FREETMPS; LEAVE; 719 FREETMPS; LEAVE;
540 } 720 }
… …
562 742
563 if (ecb_expect_false (nv == (NV)(U32)nv)) 743 if (ecb_expect_false (nv == (NV)(U32)nv))
564 encode_uint (enc, MAJOR_POS_INT, (U32)nv); 744 encode_uint (enc, MAJOR_POS_INT, (U32)nv);
565 //TODO: maybe I32? 745 //TODO: maybe I32?
566 else if (ecb_expect_false (nv == (float)nv)) 746 else if (ecb_expect_false (nv == (float)nv))
567 { 747 encode_float32 (enc, nv);
568 uint32_t fp = ecb_float_to_binary32 (nv);
569
570 *enc->cur++ = MAJOR_MISC | MISC_FLOAT32;
571
572 if (!ecb_big_endian ())
573 fp = ecb_bswap32 (fp);
574
575 memcpy (enc->cur, &fp, 4);
576 enc->cur += 4;
577 }
578 else 748 else
579 { 749 encode_float64 (enc, nv);
580 uint64_t fp = ecb_double_to_binary64 (nv);
581
582 *enc->cur++ = MAJOR_MISC | MISC_FLOAT64;
583
584 if (!ecb_big_endian ())
585 fp = ecb_bswap64 (fp);
586
587 memcpy (enc->cur, &fp, 8);
588 enc->cur += 8;
589 }
590} 750}
591 751
592static void 752static void
593encode_sv (enc_t *enc, SV *sv) 753encode_sv (enc_t *enc, SV *sv)
594{ 754{
… …
601 encode_strref (enc, enc->cbor.flags & F_TEXT_STRINGS, SvUTF8 (sv), str, len); 761 encode_strref (enc, enc->cbor.flags & F_TEXT_STRINGS, SvUTF8 (sv), str, len);
602 } 762 }
603 else if (SvNOKp (sv)) 763 else if (SvNOKp (sv))
604 encode_nv (enc, sv); 764 encode_nv (enc, sv);
605 else if (SvIOKp (sv)) 765 else if (SvIOKp (sv))
606 { 766 encode_int (enc, sv);
607 if (SvIsUV (sv))
608 encode_uint (enc, MAJOR_POS_INT, SvUVX (sv));
609 else if (SvIVX (sv) >= 0)
610 encode_uint (enc, MAJOR_POS_INT, SvIVX (sv));
611 else
612 encode_uint (enc, MAJOR_NEG_INT, -(SvIVX (sv) + 1));
613 }
614 else if (SvROK (sv)) 767 else if (SvROK (sv))
615 encode_rv (enc, SvRV (sv)); 768 encode_rv (enc, SvRV (sv));
616 else if (!SvOK (sv)) 769 else if (!SvOK (sv))
617 encode_ch (enc, MAJOR_MISC | SIMPLE_NULL); 770 encode_ch (enc, MAJOR_MISC | SIMPLE_NULL);
618 else if (enc->cbor.flags & F_ALLOW_UNKNOWN) 771 else if (enc->cbor.flags & F_ALLOW_UNKNOWN)
… …
625static SV * 778static SV *
626encode_cbor (SV *scalar, CBOR *cbor) 779encode_cbor (SV *scalar, CBOR *cbor)
627{ 780{
628 enc_t enc = { 0 }; 781 enc_t enc = { 0 };
629 782
630 enc.cbor = *cbor; 783 enc.cbor = *cbor;
631 enc.sv = sv_2mortal (NEWSV (0, INIT_SIZE)); 784 enc.sv = sv_2mortal (NEWSV (0, INIT_SIZE));
632 enc.cur = SvPVX (enc.sv); 785 enc.cur = SvPVX (enc.sv);
633 enc.end = SvEND (enc.sv); 786 enc.end = SvEND (enc.sv);
634 787
635 SvPOK_only (enc.sv); 788 SvPOK_only (enc.sv);
636 789
637 if (cbor->flags & F_PACK_STRINGS) 790 if (cbor->flags & F_PACK_STRINGS)
638 { 791 {
… …
698err_unexpected_end (dec_t *dec) 851err_unexpected_end (dec_t *dec)
699{ 852{
700 err_set (dec, "unexpected end of CBOR data"); 853 err_set (dec, "unexpected end of CBOR data");
701} 854}
702 855
703ecb_cold static void
704err_nesting_exceeded (dec_t *dec)
705{
706 err_set (dec, ERR_NESTING_EXCEEDED);
707}
708
709#define ERR_DO(do) SB do; goto fail; SE 856#define ERR_DO(do) SB do; goto fail; SE
710#define ERR(reason) ERR_DO (err_set (dec, reason)) 857#define ERR(reason) ERR_DO (err_set (dec, reason))
711#define ERR_ERRSV ERR_DO (err_errsv (dec)) 858#define ERR_ERRSV ERR_DO (err_errsv (dec))
712 859
713#define WANT(len) if (ecb_expect_false ((UV)(dec->end - dec->cur) < (UV)len)) ERR_DO (err_unexpected_end (dec)) 860#define WANT(len) if (ecb_expect_false ((uintptr_t)(dec->end - dec->cur) < (STRLEN)len)) ERR_DO (err_unexpected_end (dec))
714 861
715#define DEC_INC_DEPTH if (ecb_expect_false (++dec->depth > dec->cbor.max_depth)) ERR (ERR_NESTING_EXCEEDED) 862#define DEC_INC_DEPTH if (ecb_expect_false (++dec->depth > dec->cbor.max_depth)) ERR (ERR_NESTING_EXCEEDED)
716#define DEC_DEC_DEPTH --dec->depth 863#define DEC_DEC_DEPTH --dec->depth
717 864
718static UV 865static UV
… …
786 933
787 for (;;) 934 for (;;)
788 { 935 {
789 WANT (1); 936 WANT (1);
790 937
791 if (*dec->cur == (MAJOR_MISC | MINOR_INDEF)) 938 if (*dec->cur == (MAJOR_MISC | MINOR_INDEF) || dec->err)
792 { 939 {
793 ++dec->cur; 940 ++dec->cur;
794 break; 941 break;
795 } 942 }
796 943
… …
810 957
811 DEC_DEC_DEPTH; 958 DEC_DEC_DEPTH;
812 return newRV_noinc ((SV *)av); 959 return newRV_noinc ((SV *)av);
813 960
814fail: 961fail:
815 SvREFCNT_dec (av); 962 SvREFCNT_dec_NN (av);
816 DEC_DEC_DEPTH; 963 DEC_DEC_DEPTH;
817 return &PL_sv_undef; 964 return &PL_sv_undef;
818} 965}
819 966
820static void 967static void
… …
843 990
844 WANT (len); 991 WANT (len);
845 dec->cur += len; 992 dec->cur += len;
846 993
847 if (ecb_expect_false (dec->cbor.flags & F_VALIDATE_UTF8)) 994 if (ecb_expect_false (dec->cbor.flags & F_VALIDATE_UTF8))
848 if (!is_utf8_string (key, len)) 995 if (!cbor_is_utf8_string ((U8 *)key, len))
849 ERR ("corrupted CBOR data (invalid UTF-8 in map key)"); 996 ERR ("corrupted CBOR data (invalid UTF-8 in map key)");
850 997
851 hv_store (hv, key, -len, decode_sv (dec), 0); 998 hv_store (hv, key, -len, decode_sv (dec), 0);
852 999
853 return; 1000 return;
… …
883 1030
884 return; 1031 return;
885 } 1032 }
886 1033
887 hv_store_ent (hv, k, v, 0); 1034 hv_store_ent (hv, k, v, 0);
888 SvREFCNT_dec (k); 1035 SvREFCNT_dec_NN (k);
889 1036
890fail: 1037fail:
891 ; 1038 ;
892} 1039}
893 1040
… …
904 1051
905 for (;;) 1052 for (;;)
906 { 1053 {
907 WANT (1); 1054 WANT (1);
908 1055
909 if (*dec->cur == (MAJOR_MISC | MINOR_INDEF)) 1056 if (*dec->cur == (MAJOR_MISC | MINOR_INDEF) || dec->err)
910 { 1057 {
911 ++dec->cur; 1058 ++dec->cur;
912 break; 1059 break;
913 } 1060 }
914 1061
… …
927 1074
928 DEC_DEC_DEPTH; 1075 DEC_DEC_DEPTH;
929 return newRV_noinc ((SV *)hv); 1076 return newRV_noinc ((SV *)hv);
930 1077
931fail: 1078fail:
932 SvREFCNT_dec (hv); 1079 SvREFCNT_dec_NN (hv);
933 DEC_DEC_DEPTH; 1080 DEC_DEC_DEPTH;
934 return &PL_sv_undef; 1081 return &PL_sv_undef;
935} 1082}
936 1083
937static SV * 1084static SV *
938decode_str (dec_t *dec, int utf8) 1085decode_str (dec_t *dec, int utf8)
939{ 1086{
940 SV *sv = 0; 1087 SV *sv = 0;
941 1088
942 if ((*dec->cur & MINOR_MASK) == MINOR_INDEF) 1089 if (ecb_expect_false ((*dec->cur & MINOR_MASK) == MINOR_INDEF))
943 { 1090 {
944 // indefinite length strings 1091 // indefinite length strings
945 ++dec->cur; 1092 ++dec->cur;
946 1093
947 U8 major = *dec->cur & MAJOR_MISC; 1094 U8 major = *dec->cur & MAJOR_MISC;
… …
982 } 1129 }
983 1130
984 if (utf8) 1131 if (utf8)
985 { 1132 {
986 if (ecb_expect_false (dec->cbor.flags & F_VALIDATE_UTF8)) 1133 if (ecb_expect_false (dec->cbor.flags & F_VALIDATE_UTF8))
987 if (!is_utf8_string (SvPVX (sv), SvCUR (sv))) 1134 if (!cbor_is_utf8_string (SvPVX (sv), SvCUR (sv)))
988 ERR ("corrupted CBOR data (invalid UTF-8 in text string)"); 1135 ERR ("corrupted CBOR data (invalid UTF-8 in text string)");
989 1136
990 SvUTF8_on (sv); 1137 SvUTF8_on (sv);
991 } 1138 }
992 1139
… …
1015 sv = newRV_noinc (decode_sv (dec)); 1162 sv = newRV_noinc (decode_sv (dec));
1016 break; 1163 break;
1017 1164
1018 case CBOR_TAG_STRINGREF_NAMESPACE: 1165 case CBOR_TAG_STRINGREF_NAMESPACE:
1019 { 1166 {
1020 // do nmot use SAVETMPS/FREETMPS, as these will 1167 // do not use SAVETMPS/FREETMPS, as these will
1021 // erase mortalised caches, e.g. "shareable" 1168 // erase mortalised caches, e.g. "shareable"
1022 ENTER; 1169 ENTER;
1023 1170
1024 SAVESPTR (dec->stringref); 1171 SAVESPTR (dec->stringref);
1025 dec->stringref = (AV *)sv_2mortal ((SV *)newAV ()); 1172 dec->stringref = (AV *)sv_2mortal ((SV *)newAV ());
… …
1035 if ((*dec->cur >> MAJOR_SHIFT) != (MAJOR_POS_INT >> MAJOR_SHIFT)) 1182 if ((*dec->cur >> MAJOR_SHIFT) != (MAJOR_POS_INT >> MAJOR_SHIFT))
1036 ERR ("corrupted CBOR data (stringref index not an unsigned integer)"); 1183 ERR ("corrupted CBOR data (stringref index not an unsigned integer)");
1037 1184
1038 UV idx = decode_uint (dec); 1185 UV idx = decode_uint (dec);
1039 1186
1040 if (!dec->stringref || (int)idx > AvFILLp (dec->stringref)) 1187 if (!dec->stringref || idx >= (UV)(1 + AvFILLp (dec->stringref)))
1041 ERR ("corrupted CBOR data (stringref index out of bounds or outside namespace)"); 1188 ERR ("corrupted CBOR data (stringref index out of bounds or outside namespace)");
1042 1189
1043 sv = newSVsv (AvARRAY (dec->stringref)[idx]); 1190 sv = newSVsv (AvARRAY (dec->stringref)[idx]);
1044 } 1191 }
1045 break; 1192 break;
… …
1073 if ((*dec->cur >> MAJOR_SHIFT) != (MAJOR_POS_INT >> MAJOR_SHIFT)) 1220 if ((*dec->cur >> MAJOR_SHIFT) != (MAJOR_POS_INT >> MAJOR_SHIFT))
1074 ERR ("corrupted CBOR data (sharedref index not an unsigned integer)"); 1221 ERR ("corrupted CBOR data (sharedref index not an unsigned integer)");
1075 1222
1076 UV idx = decode_uint (dec); 1223 UV idx = decode_uint (dec);
1077 1224
1078 if (!dec->shareable || (int)idx > AvFILLp (dec->shareable)) 1225 if (!dec->shareable || idx >= (UV)(1 + AvFILLp (dec->shareable)))
1079 ERR ("corrupted CBOR data (sharedref index out of bounds)"); 1226 ERR ("corrupted CBOR data (sharedref index out of bounds)");
1080 1227
1081 sv = SvREFCNT_inc_NN (AvARRAY (dec->shareable)[idx]); 1228 sv = SvREFCNT_inc_NN (AvARRAY (dec->shareable)[idx]);
1082 1229
1083 if (sv == &PL_sv_undef) 1230 if (sv == &PL_sv_undef)
… …
1129 { 1276 {
1130 FREETMPS; LEAVE; 1277 FREETMPS; LEAVE;
1131 ERR_ERRSV; 1278 ERR_ERRSV;
1132 } 1279 }
1133 1280
1134 SvREFCNT_dec (sv); 1281 SvREFCNT_dec_NN (sv);
1135 sv = SvREFCNT_inc (POPs); 1282 sv = SvREFCNT_inc (POPs);
1136 1283
1137 PUTBACK; 1284 PUTBACK;
1138 1285
1139 FREETMPS; LEAVE; 1286 FREETMPS; LEAVE;
… …
1147 1294
1148 sv = decode_sv (dec); 1295 sv = decode_sv (dec);
1149 1296
1150 dSP; 1297 dSP;
1151 ENTER; SAVETMPS; 1298 ENTER; SAVETMPS;
1152 SAVESTACK_POS ();
1153 PUSHMARK (SP); 1299 PUSHMARK (SP);
1154 EXTEND (SP, 2); 1300 EXTEND (SP, 2);
1155 PUSHs (tag_sv); 1301 PUSHs (tag_sv);
1156 PUSHs (sv); 1302 PUSHs (sv);
1157 1303
… …
1159 int count = call_sv (dec->cbor.filter ? dec->cbor.filter : default_filter, G_ARRAY | G_EVAL); 1305 int count = call_sv (dec->cbor.filter ? dec->cbor.filter : default_filter, G_ARRAY | G_EVAL);
1160 SPAGAIN; 1306 SPAGAIN;
1161 1307
1162 if (SvTRUE (ERRSV)) 1308 if (SvTRUE (ERRSV))
1163 { 1309 {
1164 SvREFCNT_dec (tag_sv); 1310 SvREFCNT_dec_NN (tag_sv);
1165 FREETMPS; LEAVE; 1311 FREETMPS; LEAVE;
1166 ERR_ERRSV; 1312 ERR_ERRSV;
1167 } 1313 }
1168 1314
1169 if (count) 1315 if (count)
1170 { 1316 {
1171 SvREFCNT_dec (tag_sv); 1317 SvREFCNT_dec_NN (tag_sv);
1172 SvREFCNT_dec (sv); 1318 SvREFCNT_dec_NN (sv);
1173 sv = SvREFCNT_inc (POPs); 1319 sv = SvREFCNT_inc_NN (TOPs);
1320 SP -= count;
1174 } 1321 }
1175 else 1322 else
1176 { 1323 {
1177 AV *av = newAV (); 1324 AV *av = newAV ();
1178 av_push (av, tag_sv); 1325 av_push (av, tag_sv);
… …
1321 for (i = av_len (dec.shareable) + 1; i--; ) 1468 for (i = av_len (dec.shareable) + 1; i--; )
1322 if ((svp = av_fetch (dec.shareable, i, 0))) 1469 if ((svp = av_fetch (dec.shareable, i, 0)))
1323 sv_setsv (*svp, &PL_sv_undef); 1470 sv_setsv (*svp, &PL_sv_undef);
1324 } 1471 }
1325 1472
1326 SvREFCNT_dec (sv); 1473 SvREFCNT_dec_NN (sv);
1327 1474
1328 if (dec.err_sv) 1475 if (dec.err_sv)
1329 sv_2mortal (dec.err_sv); 1476 sv_2mortal (dec.err_sv);
1330 1477
1331 croak ("%s, at offset %d (octet 0x%02x)", dec.err, dec.cur - (U8 *)data, (int)(uint8_t)*dec.cur); 1478 croak ("%s, at offset %ld (octet 0x%02x)", dec.err, (long)(dec.cur - (U8 *)data), (int)(uint8_t)*dec.cur);
1332 } 1479 }
1333 1480
1334 sv = sv_2mortal (sv); 1481 sv = sv_2mortal (sv);
1335 1482
1336 return sv; 1483 return sv;
… …
1425 1572
1426 break; 1573 break;
1427 1574
1428 case MAJOR_MAP >> MAJOR_SHIFT: 1575 case MAJOR_MAP >> MAJOR_SHIFT:
1429 len <<= 1; 1576 len <<= 1;
1577 /* FALLTHROUGH */
1430 case MAJOR_ARRAY >> MAJOR_SHIFT: 1578 case MAJOR_ARRAY >> MAJOR_SHIFT:
1431 if (len) 1579 if (len)
1432 { 1580 {
1433 av_push (self->incr_count, newSViv (len + 1)); //TODO: nest 1581 av_push (self->incr_count, newSViv (len + 1)); //TODO: nest
1434 count = len + 1; 1582 count = len + 1;
… …
1674 cbor_init (&cbor); 1822 cbor_init (&cbor);
1675 PUTBACK; cborstr = decode_cbor (cborstr, &cbor, 0); SPAGAIN; 1823 PUTBACK; cborstr = decode_cbor (cborstr, &cbor, 0); SPAGAIN;
1676 XPUSHs (cborstr); 1824 XPUSHs (cborstr);
1677} 1825}
1678 1826
1827#ifdef __AFL_COMPILER
1828
1829void
1830afl_init ()
1831 CODE:
1832 __AFL_INIT ();
1833
1834int
1835afl_loop (unsigned int count = 10000)
1836 CODE:
1837 RETVAL = __AFL_LOOP (count);
1838 OUTPUT:
1839 RETVAL
1840
1841#endif
1842

Diff Legend

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