ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/Convert-BER-XS/XS.xs
(Generate patch)

Comparing Convert-BER-XS/XS.xs (file contents):
Revision 1.14 by root, Sat Apr 20 14:09:56 2019 UTC vs.
Revision 1.19 by root, Sat Apr 20 16:34:34 2019 UTC

… …
8// sscanf format modifiers and more. 8// sscanf format modifiers and more.
9 9
10enum { 10enum {
11 // ASN_TAG 11 // ASN_TAG
12 ASN_BOOLEAN = 0x01, 12 ASN_BOOLEAN = 0x01,
13 ASN_INTEGER32 = 0x02, 13 ASN_INTEGER = 0x02,
14 ASN_BIT_STRING = 0x03, 14 ASN_BIT_STRING = 0x03,
15 ASN_OCTET_STRING = 0x04, 15 ASN_OCTET_STRING = 0x04,
16 ASN_NULL = 0x05, 16 ASN_NULL = 0x05,
17 ASN_OBJECT_IDENTIFIER = 0x06, 17 ASN_OBJECT_IDENTIFIER = 0x06,
18 ASN_OID = 0x06, 18 ASN_OID = 0x06,
… …
80 BER_TYPE_IPADDRESS, 80 BER_TYPE_IPADDRESS,
81 BER_TYPE_CROAK, 81 BER_TYPE_CROAK,
82}; 82};
83 83
84enum { 84enum {
85 BER_CLASS = 0, 85 BER_CLASS = 0,
86 BER_TAG = 1, 86 BER_TAG = 1,
87 BER_CONSTRUCTED = 2, 87 BER_FLAGS = 2,
88 BER_DATA = 3, 88 BER_DATA = 3,
89 BER_ARRAYSIZE 89 BER_ARRAYSIZE
90}; 90};
91 91
92#define MAX_OID_STRLEN 4096 92#define MAX_OID_STRLEN 4096
93 93
… …
191 int klass; 191 int klass;
192 int tag; 192 int tag;
193 int type; 193 int type;
194 } *celem, default_map[] = { 194 } *celem, default_map[] = {
195 { ASN_UNIVERSAL, ASN_BOOLEAN , BER_TYPE_BOOL }, 195 { ASN_UNIVERSAL, ASN_BOOLEAN , BER_TYPE_BOOL },
196 { ASN_UNIVERSAL, ASN_INTEGER32 , BER_TYPE_INT }, 196 { ASN_UNIVERSAL, ASN_INTEGER , BER_TYPE_INT },
197 { ASN_UNIVERSAL, ASN_NULL , BER_TYPE_NULL }, 197 { ASN_UNIVERSAL, ASN_NULL , BER_TYPE_NULL },
198 { ASN_UNIVERSAL, ASN_OBJECT_IDENTIFIER, BER_TYPE_OID }, 198 { ASN_UNIVERSAL, ASN_OBJECT_IDENTIFIER, BER_TYPE_OID },
199 { ASN_UNIVERSAL, ASN_RELATIVE_OID , BER_TYPE_RELOID }, 199 { ASN_UNIVERSAL, ASN_RELATIVE_OID , BER_TYPE_RELOID },
200 { ASN_UNIVERSAL, ASN_REAL , BER_TYPE_REAL }, 200 { ASN_UNIVERSAL, ASN_REAL , BER_TYPE_REAL },
201 { ASN_UNIVERSAL, ASN_ENUMERATED , BER_TYPE_INT }, 201 { ASN_UNIVERSAL, ASN_ENUMERATED , BER_TYPE_INT },
… …
248 248
249 return *cur++; 249 return *cur++;
250} 250}
251 251
252// get ber-encoded integer (i.e. pack "w") 252// get ber-encoded integer (i.e. pack "w")
253static U32 253static UV
254get_w (void) 254get_w (void)
255{ 255{
256 U32 res = 0; 256 UV res = 0;
257 257
258 for (;;) 258 for (;;)
259 { 259 {
260 U8 c = get_u8 (); 260 U8 c = get_u8 ();
261 res = (res << 7) | (c & 0x7f); 261 res = (res << 7) | (c & 0x7f);
… …
263 if (!(c & 0x80)) 263 if (!(c & 0x80))
264 return res; 264 return res;
265 } 265 }
266} 266}
267 267
268// get_w, but disallow padding
268static U32 269static UV
270get_w_nopad (void)
271{
272 U8 first = get_u8 ();
273
274 if (first == 0x80)
275 error ("illegal BER padding");
276
277 --cur;
278
279 return get_w ();
280}
281
282static UV
269get_length (void) 283get_length (void)
270{ 284{
271 U32 res = get_u8 (); 285 UV res = get_u8 ();
272 286
273 if (res & 0x80) 287 if (res & 0x80)
274 { 288 {
275 int cnt = res & 0x7f; 289 int cnt = res & 0x7f;
276 res = 0; 290 res = 0;
… …
279 { 293 {
280 case 0: 294 case 0:
281 error ("indefinite ASN.1 lengths not supported"); 295 error ("indefinite ASN.1 lengths not supported");
282 return 0; 296 return 0;
283 297
298 //case 0x80: // indefinite length
299
300 //case 0xff: reserved
284 default: 301 default:
285 error ("ASN.1 length too long"); 302 error ("ASN.1 length too long");
286 return 0; 303 return 0;
287 304
305 case 8: res = (res << 8) | get_u8 ();
306 case 7: res = (res << 8) | get_u8 ();
307 case 6: res = (res << 8) | get_u8 ();
308 case 5: res = (res << 8) | get_u8 ();
288 case 4: res = (res << 8) | get_u8 (); 309 case 4: res = (res << 8) | get_u8 ();
289 case 3: res = (res << 8) | get_u8 (); 310 case 3: res = (res << 8) | get_u8 ();
290 case 2: res = (res << 8) | get_u8 (); 311 case 2: res = (res << 8) | get_u8 ();
291 case 1: res = (res << 8) | get_u8 (); 312 case 1: res = (res << 8) | get_u8 ();
292 } 313 }
… …
296} 317}
297 318
298static SV * 319static SV *
299decode_int (void) 320decode_int (void)
300{ 321{
301 int len = get_length (); 322 UV len = get_length ();
302 323
303 if (len <= 0) 324 if (!len)
304 { 325 {
305 error ("integer length equal to zero"); 326 error ("invalid integer length equal to zero");
306 return 0; 327 return 0;
307 } 328 }
308 329
309 U8 *data = get_n (len); 330 U8 *data = get_n (len);
310 331
… …
322} 343}
323 344
324static SV * 345static SV *
325decode_data (void) 346decode_data (void)
326{ 347{
327 U32 len = get_length (); 348 UV len = get_length ();
328 U8 *data = get_n (len);
329 return newSVpvn ((char *)data, len); 349 return newSVpvn ((char *)get_n (len), len);
330} 350}
331 351
332// gelper for decode_object_identifier 352// helper for decode_object_identifier
333static char * 353static char *
334write_uv (char *buf, U32 u) 354write_uv (char *buf, UV u)
335{ 355{
336 // the one-digit case is absolutely predominant, so this pays off (hopefully) 356 // the one-digit case is absolutely predominant, so this pays off (hopefully)
337 if (expect_true (u < 10)) 357 if (expect_true (u < 10))
338 *buf++ = u + '0'; 358 *buf++ = u + '0';
339 else 359 else
340 { 360 {
341 // this *could* be done much faster using branchless fixed-ppint arithmetics 361 // this *could* be done much faster using branchless fixed-point arithmetics
342 char *beg = buf; 362 char *beg = buf;
343 363
344 do 364 do
345 { 365 {
346 *buf++ = u % 10 + '0'; 366 *buf++ = u % 10 + '0';
… …
363} 383}
364 384
365static SV * 385static SV *
366decode_oid (int relative) 386decode_oid (int relative)
367{ 387{
368 U32 len = get_length (); 388 UV len = get_length ();
369 389
370 if (len <= 0) 390 if (len <= 0)
371 { 391 {
372 error ("OBJECT IDENTIFIER length equal to zero"); 392 error ("OBJECT IDENTIFIER length equal to zero");
373 return &PL_sv_undef; 393 return &PL_sv_undef;
374 } 394 }
375 395
376 U8 *end = cur + len; 396 U8 *end = cur + len;
377 U32 w = get_w (); 397 UV w = get_w_nopad ();
378 398
379 static char oid[MAX_OID_STRLEN]; // static, becaueds too large for stack 399 static char oid[MAX_OID_STRLEN]; // static, becaueds too large for stack
380 char *app = oid; 400 char *app = oid;
381 401
382 if (relative) 402 if (relative)
383 app = write_uv (app, w); 403 app = write_uv (app, w);
384 else 404 else if (w < 2 * 40)
385 { 405 {
386 app = write_uv (app, (U8)w / 40); 406 app = write_uv (app, (U8)w / 40);
387 *app++ = '.'; 407 *app++ = '.';
388 app = write_uv (app, (U8)w % 40); 408 app = write_uv (app, (U8)w % 40);
389 } 409 }
410 else
411 {
412 app = write_uv (app, 2);
413 *app++ = '.';
414 app = write_uv (app, w - 2 * 40);
415 }
390 416
391 while (cur < end) 417 while (cur < end)
392 { 418 {
393 // we assume an oid component is never > 64 digits 419 // we assume an oid component is never > 64 digits
394 if (oid + sizeof (oid) - app < 64) 420 if (oid + sizeof (oid) - app < 64)
395 croak ("BER_TYPE_OID to long to decode"); 421 croak ("BER_TYPE_OID to long to decode");
396 422
397 w = get_w (); 423 w = get_w_nopad ();
398 *app++ = '.'; 424 *app++ = '.';
399 app = write_uv (app, w); 425 app = write_uv (app, w);
400 } 426 }
401 427
402 return newSVpvn (oid, app - oid); 428 return newSVpvn (oid, app - oid);
… …
406static SV * 432static SV *
407decode_ucs (int chrsize) 433decode_ucs (int chrsize)
408{ 434{
409 SV *res = NEWSV (0, 0); 435 SV *res = NEWSV (0, 0);
410 436
411 U32 len = get_length (); 437 UV len = get_length ();
412 438
413 if (len & (chrsize - 1)) 439 if (len & (chrsize - 1))
414 croak ("BER_TYPE_UCS has an invalid number of octets (%d)", len); 440 croak ("BER_TYPE_UCS has an invalid number of octets (%d)", len);
415 441
416 while (len) 442 while (len)
… …
455 if (tag == ASN_TAG_BER) 481 if (tag == ASN_TAG_BER)
456 tag = get_w (); 482 tag = get_w ();
457 483
458 if (constructed) 484 if (constructed)
459 { 485 {
460 U32 len = get_length (); 486 UV len = get_length ();
461 U32 seqend = (cur - buf) + len; 487 UV seqend = (cur - buf) + len;
462 AV *av = (AV *)sv_2mortal ((SV *)newAV ()); 488 AV *av = (AV *)sv_2mortal ((SV *)newAV ());
463 489
464 while (cur < buf + seqend) 490 while (cur < buf + seqend)
465 av_push (av, decode_ber ()); 491 av_push (av, decode_ber ());
466 492
… …
472 else 498 else
473 switch (profile_lookup (cur_profile, klass, tag)) 499 switch (profile_lookup (cur_profile, klass, tag))
474 { 500 {
475 case BER_TYPE_NULL: 501 case BER_TYPE_NULL:
476 { 502 {
477 U32 len = get_length (); 503 UV len = get_length ();
478 504
479 if (len) 505 if (len)
480 croak ("BER_TYPE_NULL value with non-zero length %d encountered", len); 506 croak ("BER_TYPE_NULL value with non-zero length %d encountered", len);
481 507
482 res = &PL_sv_undef; 508 res = &PL_sv_undef;
483 } 509 }
484 break; 510 break;
485 511
486 case BER_TYPE_BOOL: 512 case BER_TYPE_BOOL:
487 { 513 {
488 U32 len = get_length (); 514 UV len = get_length ();
489 515
490 if (len != 1) 516 if (len != 1)
491 croak ("BER_TYPE_BOOLEAN value with invalid length %d encountered", len); 517 croak ("BER_TYPE_BOOLEAN value with invalid length %d encountered", len);
492 518
493 res = newSVcacheint (!!get_u8 ()); 519 res = newSVcacheint (!!get_u8 ());
… …
515 res = decode_data (); 541 res = decode_data ();
516 break; 542 break;
517 543
518 case BER_TYPE_IPADDRESS: 544 case BER_TYPE_IPADDRESS:
519 { 545 {
520 U32 len = get_length (); 546 UV len = get_length ();
521 547
522 if (len != 4) 548 if (len != 4)
523 croak ("BER_TYPE_IPADDRESS type with invalid length %d encountered", len); 549 croak ("BER_TYPE_IPADDRESS type with invalid length %d encountered", len);
524 550
525 U8 c1 = get_u8 (); 551 U8 c1 = get_u8 ();
… …
545 croak ("unconfigured/unsupported class/tag %d/%d", klass, tag); 571 croak ("unconfigured/unsupported class/tag %d/%d", klass, tag);
546 } 572 }
547 573
548 AV *av = newAV (); 574 AV *av = newAV ();
549 av_fill (av, BER_ARRAYSIZE - 1); 575 av_fill (av, BER_ARRAYSIZE - 1);
550 AvARRAY (av)[BER_CLASS ] = newSVcacheint (klass); 576 AvARRAY (av)[BER_CLASS] = newSVcacheint (klass);
551 AvARRAY (av)[BER_TAG ] = newSVcacheint (tag); 577 AvARRAY (av)[BER_TAG ] = newSVcacheint (tag);
552 AvARRAY (av)[BER_CONSTRUCTED] = newSVcacheint (constructed ? 1 : 0); 578 AvARRAY (av)[BER_FLAGS] = newSVcacheint (constructed ? 1 : 0);
553 AvARRAY (av)[BER_DATA ] = res; 579 AvARRAY (av)[BER_DATA ] = res;
554 580
555 return newRV_noinc ((SV *)av); 581 return newRV_noinc ((SV *)av);
556} 582}
557 583
558///////////////////////////////////////////////////////////////////////////// 584/////////////////////////////////////////////////////////////////////////////
… …
611 need (1); 637 need (1);
612 *cur++ = val; 638 *cur++ = val;
613} 639}
614 640
615static void 641static void
616put_w_nocheck (U32 val) 642put_w_nocheck (UV val)
617{ 643{
644#if UVSIZE > 4
645 *cur = (val >> 7 * 9) | 0x80; cur += val >= ((UV)1 << (7 * 9));
646 *cur = (val >> 7 * 8) | 0x80; cur += val >= ((UV)1 << (7 * 8));
647 *cur = (val >> 7 * 7) | 0x80; cur += val >= ((UV)1 << (7 * 7));
648 *cur = (val >> 7 * 6) | 0x80; cur += val >= ((UV)1 << (7 * 6));
649 *cur = (val >> 7 * 5) | 0x80; cur += val >= ((UV)1 << (7 * 5));
650#endif
618 *cur = (val >> 7 * 4) | 0x80; cur += val >= (1 << (7 * 4)); 651 *cur = (val >> 7 * 4) | 0x80; cur += val >= ((UV)1 << (7 * 4));
619 *cur = (val >> 7 * 3) | 0x80; cur += val >= (1 << (7 * 3)); 652 *cur = (val >> 7 * 3) | 0x80; cur += val >= ((UV)1 << (7 * 3));
620 *cur = (val >> 7 * 2) | 0x80; cur += val >= (1 << (7 * 2)); 653 *cur = (val >> 7 * 2) | 0x80; cur += val >= ((UV)1 << (7 * 2));
621 *cur = (val >> 7 * 1) | 0x80; cur += val >= (1 << (7 * 1)); 654 *cur = (val >> 7 * 1) | 0x80; cur += val >= ((UV)1 << (7 * 1));
622 *cur = val & 0x7f; cur += 1; 655 *cur = val & 0x7f; cur += 1;
623} 656}
624 657
625static void 658static void
626put_w (U32 val) 659put_w (UV val)
627{ 660{
628 need (5); // we only handle up to 5 bytes 661 need (5); // we only handle up to 5 bytes
629 662
630 put_w_nocheck (val); 663 put_w_nocheck (val);
631} 664}
632 665
633static U8 * 666static U8 *
634put_length_at (U32 val, U8 *cur) 667put_length_at (UV val, U8 *cur)
635{ 668{
636 if (val < 0x7fU) 669 if (val < 0x7fU)
637 *cur++ = val; 670 *cur++ = val;
638 else 671 else
639 { 672 {
640 U8 *lenb = cur++; 673 U8 *lenb = cur++;
641 674
675#if UVSIZE > 4
676 *cur = val >> 56; cur += *cur > 0;
677 *cur = val >> 48; cur += *cur > 0;
678 *cur = val >> 40; cur += *cur > 0;
679 *cur = val >> 32; cur += *cur > 0;
680#endif
642 *cur = val >> 24; cur += *cur > 0; 681 *cur = val >> 24; cur += *cur > 0;
643 *cur = val >> 16; cur += *cur > 0; 682 *cur = val >> 16; cur += *cur > 0;
644 *cur = val >> 8; cur += *cur > 0; 683 *cur = val >> 8; cur += *cur > 0;
645 *cur = val ; cur += 1; 684 *cur = val ; cur += 1;
646 685
… …
649 688
650 return cur; 689 return cur;
651} 690}
652 691
653static void 692static void
654put_length (U32 val) 693put_length (UV val)
655{ 694{
656 need (5 + val); 695 need (5 + val);
657 cur = put_length_at (val, cur); 696 cur = put_length_at (val, cur);
658} 697}
659 698
660// return how many bytes the encoded length requires 699// return how many bytes the encoded length requires
661static int length_length (U32 val) 700static int length_length (UV val)
662{ 701{
663 return val < 0x7fU 702 return val < 0x7fU
664 ? 1 703 ? 1
665 : 2 + (val > 0xffU) + (val > 0xffffU) + (val > 0xffffffU); 704 : 2
705 + (val > 0xffU)
706 + (val > 0xffffU)
707 + (val > 0xffffffU)
708#if UVSIZE > 4
709 + (val > 0xffffffffU)
710 + (val > 0xffffffffffU)
711 + (val > 0xffffffffffffU)
712 + (val > 0xffffffffffffffU)
713#endif
714 ;
666} 715}
667 716
668static void 717static void
669encode_data (const char *ptr, STRLEN len) 718encode_data (const char *ptr, STRLEN len)
670{ 719{
… …
732 781
733 *lenb = cur - lenb - 1; 782 *lenb = cur - lenb - 1;
734} 783}
735 784
736// we don't know the length yet, so we optimistically 785// we don't know the length yet, so we optimistically
737// assume the length will need one octet later. if that 786// assume the length will need one octet later. If that
738// turns out to be wrong, we memove as needed. 787// turns out to be wrong, we memmove as needed.
739// mark the beginning 788// mark the beginning
740static STRLEN 789static STRLEN
741len_fixup_mark (void) 790len_fixup_mark (void)
742{ 791{
743 return cur++ - buf; 792 return cur++ - buf;
… …
855{ 904{
856 AV *av = ber_tuple (tuple); 905 AV *av = ber_tuple (tuple);
857 906
858 int klass = SvIV (AvARRAY (av)[BER_CLASS]); 907 int klass = SvIV (AvARRAY (av)[BER_CLASS]);
859 int tag = SvIV (AvARRAY (av)[BER_TAG]); 908 int tag = SvIV (AvARRAY (av)[BER_TAG]);
860 int constructed = SvIV (AvARRAY (av)[BER_CONSTRUCTED]) ? ASN_CONSTRUCTED : 0; 909 int constructed = SvIV (AvARRAY (av)[BER_FLAGS]) & 1 ? ASN_CONSTRUCTED : 0;
861 SV *data = AvARRAY (av)[BER_DATA]; 910 SV *data = AvARRAY (av)[BER_DATA];
862 911
863 int identifier = (klass << ASN_CLASS_SHIFT) | constructed; 912 int identifier = (klass << ASN_CLASS_SHIFT) | constructed;
864 913
865 if (expect_false (tag >= ASN_TAG_BER)) 914 if (expect_false (tag >= ASN_TAG_BER))
… …
899 put_length (0); 948 put_length (0);
900 break; 949 break;
901 950
902 case BER_TYPE_BOOL: 951 case BER_TYPE_BOOL:
903 put_length (1); 952 put_length (1);
904 *cur++ = SvTRUE (data) ? 0xff : 0x00; 953 *cur++ = SvTRUE (data) ? 0xff : 0x00; // 0xff = DER/CER
905 break; 954 break;
906 955
907 case BER_TYPE_OID: 956 case BER_TYPE_OID:
908 encode_oid (data, 0); 957 encode_oid (data, 0);
909 break; 958 break;
… …
972 const char *name; 1021 const char *name;
973 IV iv; 1022 IV iv;
974 } *civ, const_iv[] = { 1023 } *civ, const_iv[] = {
975#define const_iv(name) { # name, name }, 1024#define const_iv(name) { # name, name },
976 const_iv (ASN_BOOLEAN) 1025 const_iv (ASN_BOOLEAN)
977 const_iv (ASN_INTEGER32) 1026 const_iv (ASN_INTEGER)
978 const_iv (ASN_BIT_STRING) 1027 const_iv (ASN_BIT_STRING)
979 const_iv (ASN_OCTET_STRING) 1028 const_iv (ASN_OCTET_STRING)
980 const_iv (ASN_NULL) 1029 const_iv (ASN_NULL)
981 const_iv (ASN_OBJECT_IDENTIFIER) 1030 const_iv (ASN_OBJECT_IDENTIFIER)
982 const_iv (ASN_OBJECT_DESCRIPTOR) 1031 const_iv (ASN_OBJECT_DESCRIPTOR)
… …
1011 const_iv (ASN_CONTEXT) 1060 const_iv (ASN_CONTEXT)
1012 const_iv (ASN_PRIVATE) 1061 const_iv (ASN_PRIVATE)
1013 1062
1014 const_iv (BER_CLASS) 1063 const_iv (BER_CLASS)
1015 const_iv (BER_TAG) 1064 const_iv (BER_TAG)
1016 const_iv (BER_CONSTRUCTED) 1065 const_iv (BER_FLAGS)
1017 const_iv (BER_DATA) 1066 const_iv (BER_DATA)
1018 1067
1019 const_iv (BER_TYPE_BYTES) 1068 const_iv (BER_TYPE_BYTES)
1020 const_iv (BER_TYPE_UTF8) 1069 const_iv (BER_TYPE_UTF8)
1021 const_iv (BER_TYPE_UCS2) 1070 const_iv (BER_TYPE_UCS2)
… …
1054 RETVAL = decode_ber (); 1103 RETVAL = decode_ber ();
1055} 1104}
1056 OUTPUT: RETVAL 1105 OUTPUT: RETVAL
1057 1106
1058void 1107void
1059ber_is (SV *tuple, SV *klass = &PL_sv_undef, SV *tag = &PL_sv_undef, SV *constructed = &PL_sv_undef, SV *data = &PL_sv_undef) 1108ber_is (SV *tuple, SV *klass = &PL_sv_undef, SV *tag = &PL_sv_undef, SV *flags = &PL_sv_undef, SV *data = &PL_sv_undef)
1060 PPCODE: 1109 PPCODE:
1061{ 1110{
1062 if (!SvOK (tuple)) 1111 if (!SvOK (tuple))
1063 XSRETURN_NO; 1112 XSRETURN_NO;
1064 1113
… …
1066 croak ("ber_is: tuple must be BER tuple (array-ref)"); 1115 croak ("ber_is: tuple must be BER tuple (array-ref)");
1067 1116
1068 AV *av = (AV *)SvRV (tuple); 1117 AV *av = (AV *)SvRV (tuple);
1069 1118
1070 XPUSHs ( 1119 XPUSHs (
1071 (!SvOK (klass) || SvIV (AvARRAY (av)[BER_CLASS ]) == SvIV (klass)) 1120 (!SvOK (klass) || SvIV (AvARRAY (av)[BER_CLASS]) == SvIV (klass))
1072 && (!SvOK (tag) || SvIV (AvARRAY (av)[BER_TAG ]) == SvIV (tag)) 1121 && (!SvOK (tag) || SvIV (AvARRAY (av)[BER_TAG ]) == SvIV (tag))
1073 && (!SvOK (constructed) || !SvIV (AvARRAY (av)[BER_CONSTRUCTED]) == !SvIV (constructed)) 1122 && (!SvOK (flags) || !SvIV (AvARRAY (av)[BER_FLAGS]) == !SvIV (flags))
1074 && (!SvOK (data) || sv_eq (AvARRAY (av)[BER_DATA ], data)) 1123 && (!SvOK (data) || sv_eq (AvARRAY (av)[BER_DATA ], data))
1075 ? &PL_sv_yes : &PL_sv_undef); 1124 ? &PL_sv_yes : &PL_sv_undef);
1076} 1125}
1077 1126
1078void 1127void
1079ber_is_seq (SV *tuple) 1128ber_is_seq (SV *tuple)
… …
1083 XSRETURN_UNDEF; 1132 XSRETURN_UNDEF;
1084 1133
1085 AV *av = ber_tuple (tuple); 1134 AV *av = ber_tuple (tuple);
1086 1135
1087 XPUSHs ( 1136 XPUSHs (
1088 SvIV (AvARRAY (av)[BER_CLASS ]) == ASN_UNIVERSAL 1137 SvIV (AvARRAY (av)[BER_CLASS]) == ASN_UNIVERSAL
1089 && SvIV (AvARRAY (av)[BER_TAG ]) == ASN_SEQUENCE 1138 && SvIV (AvARRAY (av)[BER_TAG ]) == ASN_SEQUENCE
1090 && SvIV (AvARRAY (av)[BER_CONSTRUCTED]) 1139 && SvIV (AvARRAY (av)[BER_FLAGS])
1091 ? AvARRAY (av)[BER_DATA] : &PL_sv_undef); 1140 ? AvARRAY (av)[BER_DATA] : &PL_sv_undef);
1092} 1141}
1093 1142
1094void 1143void
1095ber_is_i32 (SV *tuple, SV *value = &PL_sv_undef) 1144ber_is_int (SV *tuple, SV *value = &PL_sv_undef)
1096 PPCODE: 1145 PPCODE:
1097{ 1146{
1098 if (!SvOK (tuple)) 1147 if (!SvOK (tuple))
1099 XSRETURN_NO; 1148 XSRETURN_NO;
1100 1149
1101 AV *av = ber_tuple (tuple); 1150 AV *av = ber_tuple (tuple);
1102 1151
1103 IV data = SvIV (AvARRAY (av)[BER_DATA]); 1152 UV data = SvUV (AvARRAY (av)[BER_DATA]);
1104 1153
1105 XPUSHs ( 1154 XPUSHs (
1106 SvIV (AvARRAY (av)[BER_CLASS ]) == ASN_UNIVERSAL 1155 SvIV (AvARRAY (av)[BER_CLASS]) == ASN_UNIVERSAL
1107 && SvIV (AvARRAY (av)[BER_TAG ]) == ASN_INTEGER32 1156 && SvIV (AvARRAY (av)[BER_TAG ]) == ASN_INTEGER
1108 && !SvIV (AvARRAY (av)[BER_CONSTRUCTED]) 1157 && !SvIV (AvARRAY (av)[BER_FLAGS])
1109 && (!SvOK (value) || data == SvIV (value)) 1158 && (!SvOK (value) || data == SvUV (value))
1110 ? sv_2mortal (data ? newSViv (data) : newSVpv ("0 but true", 0)) 1159 ? sv_2mortal (data ? newSVsv (AvARRAY (av)[BER_DATA]) : newSVpv ("0 but true", 0))
1111 : &PL_sv_undef); 1160 : &PL_sv_undef);
1112} 1161}
1113 1162
1114void 1163void
1115ber_is_oid (SV *tuple, SV *oid = &PL_sv_undef) 1164ber_is_oid (SV *tuple, SV *oid = &PL_sv_undef)
… …
1119 XSRETURN_NO; 1168 XSRETURN_NO;
1120 1169
1121 AV *av = ber_tuple (tuple); 1170 AV *av = ber_tuple (tuple);
1122 1171
1123 XPUSHs ( 1172 XPUSHs (
1124 SvIV (AvARRAY (av)[BER_CLASS ]) == ASN_UNIVERSAL 1173 SvIV (AvARRAY (av)[BER_CLASS]) == ASN_UNIVERSAL
1125 && SvIV (AvARRAY (av)[BER_TAG ]) == ASN_OBJECT_IDENTIFIER 1174 && SvIV (AvARRAY (av)[BER_TAG ]) == ASN_OBJECT_IDENTIFIER
1126 && !SvIV (AvARRAY (av)[BER_CONSTRUCTED]) 1175 && !SvIV (AvARRAY (av)[BER_FLAGS])
1127 && (!SvOK (oid) || sv_eq (AvARRAY (av)[BER_DATA], oid)) 1176 && (!SvOK (oid) || sv_eq (AvARRAY (av)[BER_DATA], oid))
1128 ? newSVsv (AvARRAY (av)[BER_DATA]) : &PL_sv_undef); 1177 ? newSVsv (AvARRAY (av)[BER_DATA]) : &PL_sv_undef);
1129} 1178}
1130 1179
1131############################################################################# 1180#############################################################################
… …
1144 SvCUR_set (buf_sv, cur - buf); 1193 SvCUR_set (buf_sv, cur - buf);
1145 XPUSHs (buf_sv); 1194 XPUSHs (buf_sv);
1146} 1195}
1147 1196
1148SV * 1197SV *
1149ber_i32 (IV iv) 1198ber_int (SV *sv)
1150 CODE: 1199 CODE:
1151{ 1200{
1152 AV *av = newAV (); 1201 AV *av = newAV ();
1153 av_fill (av, BER_ARRAYSIZE - 1); 1202 av_fill (av, BER_ARRAYSIZE - 1);
1154 AvARRAY (av)[BER_CLASS ] = newSVcacheint (ASN_UNIVERSAL); 1203 AvARRAY (av)[BER_CLASS] = newSVcacheint (ASN_UNIVERSAL);
1155 AvARRAY (av)[BER_TAG ] = newSVcacheint (ASN_INTEGER32); 1204 AvARRAY (av)[BER_TAG ] = newSVcacheint (ASN_INTEGER);
1156 AvARRAY (av)[BER_CONSTRUCTED] = newSVcacheint (0); 1205 AvARRAY (av)[BER_FLAGS] = newSVcacheint (0);
1157 AvARRAY (av)[BER_DATA ] = newSViv (iv); 1206 AvARRAY (av)[BER_DATA ] = newSVsv (sv);
1158 RETVAL = newRV_noinc ((SV *)av); 1207 RETVAL = newRV_noinc ((SV *)av);
1159} 1208}
1160 OUTPUT: RETVAL 1209 OUTPUT: RETVAL
1161 1210
1162# TODO: not arrayref, but elements? 1211# TODO: not arrayref, but elements?
… …
1164ber_seq (SV *arrayref) 1213ber_seq (SV *arrayref)
1165 CODE: 1214 CODE:
1166{ 1215{
1167 AV *av = newAV (); 1216 AV *av = newAV ();
1168 av_fill (av, BER_ARRAYSIZE - 1); 1217 av_fill (av, BER_ARRAYSIZE - 1);
1169 AvARRAY (av)[BER_CLASS ] = newSVcacheint (ASN_UNIVERSAL); 1218 AvARRAY (av)[BER_CLASS] = newSVcacheint (ASN_UNIVERSAL);
1170 AvARRAY (av)[BER_TAG ] = newSVcacheint (ASN_SEQUENCE); 1219 AvARRAY (av)[BER_TAG ] = newSVcacheint (ASN_SEQUENCE);
1171 AvARRAY (av)[BER_CONSTRUCTED] = newSVcacheint (1); 1220 AvARRAY (av)[BER_FLAGS] = newSVcacheint (1);
1172 AvARRAY (av)[BER_DATA ] = newSVsv (arrayref); 1221 AvARRAY (av)[BER_DATA ] = newSVsv (arrayref);
1173 RETVAL = newRV_noinc ((SV *)av); 1222 RETVAL = newRV_noinc ((SV *)av);
1174} 1223}
1175 OUTPUT: RETVAL 1224 OUTPUT: RETVAL
1176 1225
1177MODULE = Convert::BER::XS PACKAGE = Convert::BER::XS::Profile 1226MODULE = Convert::BER::XS PACKAGE = Convert::BER::XS::Profile

Diff Legend

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