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.11 by root, Sat Apr 20 12:25:23 2019 UTC vs.
Revision 1.16 by root, Sat Apr 20 15:37:27 2019 UTC

1#include "EXTERN.h" 1#include "EXTERN.h"
2#include "perl.h" 2#include "perl.h"
3#include "XSUB.h" 3#include "XSUB.h"
4 4
5// C99 required 5// C99 required!
6// this is not just for comments, but also for
7// integer constant semantics,
8// sscanf format modifiers and more.
6 9
7enum { 10enum {
8 // ASN_TAG 11 // ASN_TAG
9 ASN_BOOLEAN = 0x01, 12 ASN_BOOLEAN = 0x01,
10 ASN_INTEGER32 = 0x02, 13 ASN_INTEGER = 0x02,
11 ASN_BIT_STRING = 0x03, 14 ASN_BIT_STRING = 0x03,
12 ASN_OCTET_STRING = 0x04, 15 ASN_OCTET_STRING = 0x04,
13 ASN_NULL = 0x05, 16 ASN_NULL = 0x05,
14 ASN_OBJECT_IDENTIFIER = 0x06, 17 ASN_OBJECT_IDENTIFIER = 0x06,
15 ASN_OID = 0x06, 18 ASN_OID = 0x06,
… …
77 BER_TYPE_IPADDRESS, 80 BER_TYPE_IPADDRESS,
78 BER_TYPE_CROAK, 81 BER_TYPE_CROAK,
79}; 82};
80 83
81enum { 84enum {
82 BER_CLASS = 0, 85 BER_CLASS = 0,
83 BER_TAG = 1, 86 BER_TAG = 1,
84 BER_CONSTRUCTED = 2, 87 BER_FLAGS = 2,
85 BER_DATA = 3, 88 BER_DATA = 3,
86 BER_ARRAYSIZE 89 BER_ARRAYSIZE
87}; 90};
88 91
89#define MAX_OID_STRLEN 4096 92#define MAX_OID_STRLEN 4096
90 93
… …
178 181
179 SvPVX (sv)[idx] = type; 182 SvPVX (sv)[idx] = type;
180} 183}
181 184
182static SV * 185static SV *
183profile_new () 186profile_new (void)
184{ 187{
185 SV *sv = newSVpvn ("", 0); 188 SV *sv = newSVpvn ("", 0);
186 189
187 static const struct { 190 static const struct {
188 int klass; 191 int klass;
189 int tag; 192 int tag;
190 int type; 193 int type;
191 } *celem, default_map[] = { 194 } *celem, default_map[] = {
192 { ASN_UNIVERSAL, ASN_BOOLEAN , BER_TYPE_BOOL }, 195 { ASN_UNIVERSAL, ASN_BOOLEAN , BER_TYPE_BOOL },
193 { ASN_UNIVERSAL, ASN_INTEGER32 , BER_TYPE_INT }, 196 { ASN_UNIVERSAL, ASN_INTEGER , BER_TYPE_INT },
194 { ASN_UNIVERSAL, ASN_NULL , BER_TYPE_NULL }, 197 { ASN_UNIVERSAL, ASN_NULL , BER_TYPE_NULL },
195 { ASN_UNIVERSAL, ASN_OBJECT_IDENTIFIER, BER_TYPE_OID }, 198 { ASN_UNIVERSAL, ASN_OBJECT_IDENTIFIER, BER_TYPE_OID },
196 { ASN_UNIVERSAL, ASN_OBJECT_DESCRIPTOR, BER_TYPE_OID },
197 { ASN_UNIVERSAL, ASN_RELATIVE_OID , BER_TYPE_RELOID }, 199 { ASN_UNIVERSAL, ASN_RELATIVE_OID , BER_TYPE_RELOID },
198 { ASN_UNIVERSAL, ASN_REAL , BER_TYPE_REAL }, 200 { ASN_UNIVERSAL, ASN_REAL , BER_TYPE_REAL },
201 { ASN_UNIVERSAL, ASN_ENUMERATED , BER_TYPE_INT },
199 { ASN_UNIVERSAL, ASN_UTF8_STRING , BER_TYPE_UTF8 }, 202 { ASN_UNIVERSAL, ASN_UTF8_STRING , BER_TYPE_UTF8 },
200 { ASN_UNIVERSAL, ASN_BMP_STRING , BER_TYPE_UCS2 }, 203 { ASN_UNIVERSAL, ASN_BMP_STRING , BER_TYPE_UCS2 },
201 { ASN_UNIVERSAL, ASN_UNIVERSAL_STRING , BER_TYPE_UCS4 }, 204 { ASN_UNIVERSAL, ASN_UNIVERSAL_STRING , BER_TYPE_UCS4 },
202 }; 205 };
203 206
… …
245 248
246 return *cur++; 249 return *cur++;
247} 250}
248 251
249// get ber-encoded integer (i.e. pack "w") 252// get ber-encoded integer (i.e. pack "w")
250static U32 253static UV
251get_w (void) 254get_w (void)
252{ 255{
253 U32 res = 0; 256 UV res = 0;
254 257
255 for (;;) 258 for (;;)
256 { 259 {
257 U8 c = get_u8 (); 260 U8 c = get_u8 ();
258 res = (res << 7) | (c & 0x7f); 261 res = (res << 7) | (c & 0x7f);
… …
260 if (!(c & 0x80)) 263 if (!(c & 0x80))
261 return res; 264 return res;
262 } 265 }
263} 266}
264 267
265static U32 268static UV
266get_length (void) 269get_length (void)
267{ 270{
268 U32 res = get_u8 (); 271 UV res = get_u8 ();
269 272
270 if (res & 0x80) 273 if (res & 0x80)
271 { 274 {
272 int cnt = res & 0x7f; 275 int cnt = res & 0x7f;
273 res = 0; 276 res = 0;
… …
280 283
281 default: 284 default:
282 error ("ASN.1 length too long"); 285 error ("ASN.1 length too long");
283 return 0; 286 return 0;
284 287
288 case 8: res = (res << 8) | get_u8 ();
289 case 7: res = (res << 8) | get_u8 ();
290 case 6: res = (res << 8) | get_u8 ();
291 case 5: res = (res << 8) | get_u8 ();
285 case 4: res = (res << 8) | get_u8 (); 292 case 4: res = (res << 8) | get_u8 ();
286 case 3: res = (res << 8) | get_u8 (); 293 case 3: res = (res << 8) | get_u8 ();
287 case 2: res = (res << 8) | get_u8 (); 294 case 2: res = (res << 8) | get_u8 ();
288 case 1: res = (res << 8) | get_u8 (); 295 case 1: res = (res << 8) | get_u8 ();
289 } 296 }
… …
291 298
292 return res; 299 return res;
293} 300}
294 301
295static SV * 302static SV *
296decode_int () 303decode_int (void)
297{ 304{
298 int len = get_length (); 305 UV len = get_length ();
299 306
300 if (len <= 0) 307 if (!len)
301 { 308 {
302 error ("integer length equal to zero"); 309 error ("invalid integer length equal to zero");
303 return 0; 310 return 0;
304 } 311 }
305 312
306 U8 *data = get_n (len); 313 U8 *data = get_n (len);
307 314
… …
319} 326}
320 327
321static SV * 328static SV *
322decode_data (void) 329decode_data (void)
323{ 330{
324 U32 len = get_length (); 331 UV len = get_length ();
325 U8 *data = get_n (len);
326 return newSVpvn ((char *)data, len); 332 return newSVpvn ((char *)get_n (len), len);
327} 333}
328 334
329// gelper for decode_object_identifier 335// helper for decode_object_identifier
330static char * 336static char *
331write_uv (char *buf, U32 u) 337write_uv (char *buf, UV u)
332{ 338{
333 // the one-digit case is absolutely predominant, so this pays off (hopefully) 339 // the one-digit case is absolutely predominant, so this pays off (hopefully)
334 if (expect_true (u < 10)) 340 if (expect_true (u < 10))
335 *buf++ = u + '0'; 341 *buf++ = u + '0';
336 else 342 else
337 { 343 {
344 // this *could* be done much faster using branchless fixed-point arithmetics
338 char *beg = buf; 345 char *beg = buf;
339 346
340 do 347 do
341 { 348 {
342 *buf++ = u % 10 + '0'; 349 *buf++ = u % 10 + '0';
… …
344 } 351 }
345 while (u); 352 while (u);
346 353
347 // reverse digits 354 // reverse digits
348 char *ptr = buf; 355 char *ptr = buf;
349 while (--ptr != beg) 356 while (--ptr > beg)
350 { 357 {
351 char c = *ptr; 358 char c = *ptr;
352 *ptr = *beg; 359 *ptr = *beg;
353 *beg = c; 360 *beg = c;
354 ++beg; 361 ++beg;
… …
359} 366}
360 367
361static SV * 368static SV *
362decode_oid (int relative) 369decode_oid (int relative)
363{ 370{
364 U32 len = get_length (); 371 UV len = get_length ();
365 372
366 if (len <= 0) 373 if (len <= 0)
367 { 374 {
368 error ("OBJECT IDENTIFIER length equal to zero"); 375 error ("OBJECT IDENTIFIER length equal to zero");
369 return &PL_sv_undef; 376 return &PL_sv_undef;
370 } 377 }
371 378
372 U8 *end = cur + len; 379 U8 *end = cur + len;
373 U32 w = get_w (); 380 UV w = get_w ();
374 381
375 static char oid[MAX_OID_STRLEN]; // must be static 382 static char oid[MAX_OID_STRLEN]; // static, becaueds too large for stack
376 char *app = oid; 383 char *app = oid;
377 384
378 if (relative) 385 if (relative)
379 app = write_uv (app, w); 386 app = write_uv (app, w);
380 else 387 else
… …
382 app = write_uv (app, (U8)w / 40); 389 app = write_uv (app, (U8)w / 40);
383 *app++ = '.'; 390 *app++ = '.';
384 app = write_uv (app, (U8)w % 40); 391 app = write_uv (app, (U8)w % 40);
385 } 392 }
386 393
394 while (cur < end)
395 {
387 // we assume an oid component is never > 64 bytes 396 // we assume an oid component is never > 64 digits
388 while (cur < end && oid + sizeof (oid) - app > 64) 397 if (oid + sizeof (oid) - app < 64)
389 { 398 croak ("BER_TYPE_OID to long to decode");
399
390 w = get_w (); 400 w = get_w ();
391 *app++ = '.'; 401 *app++ = '.';
392 app = write_uv (app, w); 402 app = write_uv (app, w);
393 } 403 }
394 404
… …
399static SV * 409static SV *
400decode_ucs (int chrsize) 410decode_ucs (int chrsize)
401{ 411{
402 SV *res = NEWSV (0, 0); 412 SV *res = NEWSV (0, 0);
403 413
404 U32 len = get_length (); 414 UV len = get_length ();
405 415
406 if (len & (chrsize - 1)) 416 if (len & (chrsize - 1))
407 croak ("BER_TYPE_UCS has an invalid number of octets (%d)", len); 417 croak ("BER_TYPE_UCS has an invalid number of octets (%d)", len);
408 418
409 while (len) 419 while (len)
… …
430 440
431 return res; 441 return res;
432} 442}
433 443
434static SV * 444static SV *
435decode_ber () 445decode_ber (void)
436{ 446{
437 int identifier = get_u8 (); 447 int identifier = get_u8 ();
438 448
439 SV *res; 449 SV *res;
440 450
… …
448 if (tag == ASN_TAG_BER) 458 if (tag == ASN_TAG_BER)
449 tag = get_w (); 459 tag = get_w ();
450 460
451 if (constructed) 461 if (constructed)
452 { 462 {
453 U32 len = get_length (); 463 UV len = get_length ();
454 U32 seqend = (cur - buf) + len; 464 UV seqend = (cur - buf) + len;
455 AV *av = (AV *)sv_2mortal ((SV *)newAV ()); 465 AV *av = (AV *)sv_2mortal ((SV *)newAV ());
456 466
457 while (cur < buf + seqend) 467 while (cur < buf + seqend)
458 av_push (av, decode_ber ()); 468 av_push (av, decode_ber ());
459 469
… …
464 } 474 }
465 else 475 else
466 switch (profile_lookup (cur_profile, klass, tag)) 476 switch (profile_lookup (cur_profile, klass, tag))
467 { 477 {
468 case BER_TYPE_NULL: 478 case BER_TYPE_NULL:
479 {
480 UV len = get_length ();
481
482 if (len)
483 croak ("BER_TYPE_NULL value with non-zero length %d encountered", len);
484
469 res = &PL_sv_undef; 485 res = &PL_sv_undef;
486 }
470 break; 487 break;
471 488
472 case BER_TYPE_BOOL: 489 case BER_TYPE_BOOL:
473 { 490 {
474 U32 len = get_length (); 491 UV len = get_length ();
475 492
476 if (len != 1) 493 if (len != 1)
477 croak ("BER_TYPE_BOOLEAN type with invalid length %d encountered", len); 494 croak ("BER_TYPE_BOOLEAN value with invalid length %d encountered", len);
478 495
479 res = newSVcacheint (get_u8 () ? 0 : 1); 496 res = newSVcacheint (!!get_u8 ());
480 } 497 }
481 break; 498 break;
482 499
483 case BER_TYPE_OID: 500 case BER_TYPE_OID:
484 res = decode_oid (0); 501 res = decode_oid (0);
… …
501 res = decode_data (); 518 res = decode_data ();
502 break; 519 break;
503 520
504 case BER_TYPE_IPADDRESS: 521 case BER_TYPE_IPADDRESS:
505 { 522 {
506 U32 len = get_length (); 523 UV len = get_length ();
507 524
508 if (len != 4) 525 if (len != 4)
509 croak ("BER_TYPE_IPADDRESS type with invalid length %d encountered", len); 526 croak ("BER_TYPE_IPADDRESS type with invalid length %d encountered", len);
510 527
511 U8 c1 = get_u8 (); 528 U8 c1 = get_u8 ();
… …
531 croak ("unconfigured/unsupported class/tag %d/%d", klass, tag); 548 croak ("unconfigured/unsupported class/tag %d/%d", klass, tag);
532 } 549 }
533 550
534 AV *av = newAV (); 551 AV *av = newAV ();
535 av_fill (av, BER_ARRAYSIZE - 1); 552 av_fill (av, BER_ARRAYSIZE - 1);
536 AvARRAY (av)[BER_CLASS ] = newSVcacheint (klass); 553 AvARRAY (av)[BER_CLASS] = newSVcacheint (klass);
537 AvARRAY (av)[BER_TAG ] = newSVcacheint (tag); 554 AvARRAY (av)[BER_TAG ] = newSVcacheint (tag);
538 AvARRAY (av)[BER_CONSTRUCTED] = newSVcacheint (constructed ? 1 : 0); 555 AvARRAY (av)[BER_FLAGS] = newSVcacheint (constructed ? 1 : 0);
539 AvARRAY (av)[BER_DATA ] = res; 556 AvARRAY (av)[BER_DATA ] = res;
540 557
541 return newRV_noinc ((SV *)av); 558 return newRV_noinc ((SV *)av);
542} 559}
543 560
544///////////////////////////////////////////////////////////////////////////// 561/////////////////////////////////////////////////////////////////////////////
… …
597 need (1); 614 need (1);
598 *cur++ = val; 615 *cur++ = val;
599} 616}
600 617
601static void 618static void
602put_w_nocheck (U32 val) 619put_w_nocheck (UV val)
603{ 620{
621#if UVSIZE > 4
622 *cur = (val >> 7 * 9) | 0x80; cur += val >= ((UV)1 << (7 * 9));
623 *cur = (val >> 7 * 8) | 0x80; cur += val >= ((UV)1 << (7 * 8));
624 *cur = (val >> 7 * 7) | 0x80; cur += val >= ((UV)1 << (7 * 7));
625 *cur = (val >> 7 * 6) | 0x80; cur += val >= ((UV)1 << (7 * 6));
626 *cur = (val >> 7 * 5) | 0x80; cur += val >= ((UV)1 << (7 * 5));
627#endif
604 *cur = (val >> 7 * 4) | 0x80; cur += val >= (1 << (7 * 4)); 628 *cur = (val >> 7 * 4) | 0x80; cur += val >= ((UV)1 << (7 * 4));
605 *cur = (val >> 7 * 3) | 0x80; cur += val >= (1 << (7 * 3)); 629 *cur = (val >> 7 * 3) | 0x80; cur += val >= ((UV)1 << (7 * 3));
606 *cur = (val >> 7 * 2) | 0x80; cur += val >= (1 << (7 * 2)); 630 *cur = (val >> 7 * 2) | 0x80; cur += val >= ((UV)1 << (7 * 2));
607 *cur = (val >> 7 * 1) | 0x80; cur += val >= (1 << (7 * 1)); 631 *cur = (val >> 7 * 1) | 0x80; cur += val >= ((UV)1 << (7 * 1));
608 *cur = val & 0x7f; cur += 1; 632 *cur = val & 0x7f; cur += 1;
609} 633}
610 634
611static void 635static void
612put_w (U32 val) 636put_w (UV val)
613{ 637{
614 need (5); // we only handle up to 5 bytes 638 need (5); // we only handle up to 5 bytes
615 639
616 put_w_nocheck (val); 640 put_w_nocheck (val);
617} 641}
618 642
619static U8 * 643static U8 *
620put_length_at (U32 val, U8 *cur) 644put_length_at (UV val, U8 *cur)
621{ 645{
622 if (val < 0x7fU) 646 if (val < 0x7fU)
623 *cur++ = val; 647 *cur++ = val;
624 else 648 else
625 { 649 {
626 U8 *lenb = cur++; 650 U8 *lenb = cur++;
627 651
652#if UVSIZE > 4
653 *cur = val >> 56; cur += *cur > 0;
654 *cur = val >> 48; cur += *cur > 0;
655 *cur = val >> 40; cur += *cur > 0;
656 *cur = val >> 32; cur += *cur > 0;
657#endif
628 *cur = val >> 24; cur += *cur > 0; 658 *cur = val >> 24; cur += *cur > 0;
629 *cur = val >> 16; cur += *cur > 0; 659 *cur = val >> 16; cur += *cur > 0;
630 *cur = val >> 8; cur += *cur > 0; 660 *cur = val >> 8; cur += *cur > 0;
631 *cur = val ; cur += 1; 661 *cur = val ; cur += 1;
632 662
… …
635 665
636 return cur; 666 return cur;
637} 667}
638 668
639static void 669static void
640put_length (U32 val) 670put_length (UV val)
641{ 671{
642 need (5 + val); 672 need (5 + val);
643 cur = put_length_at (val, cur); 673 cur = put_length_at (val, cur);
644} 674}
645 675
646// return how many bytes the encoded length requires 676// return how many bytes the encoded length requires
647static int length_length (U32 val) 677static int length_length (UV val)
648{ 678{
649 return val < 0x7fU 679 return val < 0x7fU
650 ? 1 680 ? 1
651 : 2 + (val > 0xffU) + (val > 0xffffU) + (val > 0xffffffU); 681 : 2
682 + (val > 0xffU)
683 + (val > 0xffffU)
684 + (val > 0xffffffU)
685#if UVSIZE > 4
686 + (val > 0xffffffffU)
687 + (val > 0xffffffffffU)
688 + (val > 0xffffffffffffU)
689 + (val > 0xffffffffffffffU)
690#endif
691 ;
652} 692}
653 693
654static void 694static void
655encode_data (const char *ptr, STRLEN len) 695encode_data (const char *ptr, STRLEN len)
656{ 696{
… …
718 758
719 *lenb = cur - lenb - 1; 759 *lenb = cur - lenb - 1;
720} 760}
721 761
722// we don't know the length yet, so we optimistically 762// we don't know the length yet, so we optimistically
723// assume the length will need one octet later. if that 763// assume the length will need one octet later. If that
724// turns out to be wrong, we memove as needed. 764// turns out to be wrong, we memmove as needed.
725// mark the beginning 765// mark the beginning
726static STRLEN 766static STRLEN
727len_fixup_mark () 767len_fixup_mark (void)
728{ 768{
729 return cur++ - buf; 769 return cur++ - buf;
730} 770}
731 771
732// patch up the length 772// patch up the length
… …
841{ 881{
842 AV *av = ber_tuple (tuple); 882 AV *av = ber_tuple (tuple);
843 883
844 int klass = SvIV (AvARRAY (av)[BER_CLASS]); 884 int klass = SvIV (AvARRAY (av)[BER_CLASS]);
845 int tag = SvIV (AvARRAY (av)[BER_TAG]); 885 int tag = SvIV (AvARRAY (av)[BER_TAG]);
846 int constructed = SvIV (AvARRAY (av)[BER_CONSTRUCTED]) ? ASN_CONSTRUCTED : 0; 886 int constructed = SvIV (AvARRAY (av)[BER_FLAGS]) & 1 ? ASN_CONSTRUCTED : 0;
847 SV *data = AvARRAY (av)[BER_DATA]; 887 SV *data = AvARRAY (av)[BER_DATA];
848 888
849 int identifier = (klass << ASN_CLASS_SHIFT) | constructed; 889 int identifier = (klass << ASN_CLASS_SHIFT) | constructed;
850 890
851 if (expect_false (tag >= ASN_TAG_BER)) 891 if (expect_false (tag >= ASN_TAG_BER))
… …
958 const char *name; 998 const char *name;
959 IV iv; 999 IV iv;
960 } *civ, const_iv[] = { 1000 } *civ, const_iv[] = {
961#define const_iv(name) { # name, name }, 1001#define const_iv(name) { # name, name },
962 const_iv (ASN_BOOLEAN) 1002 const_iv (ASN_BOOLEAN)
963 const_iv (ASN_INTEGER32) 1003 const_iv (ASN_INTEGER)
964 const_iv (ASN_BIT_STRING) 1004 const_iv (ASN_BIT_STRING)
965 const_iv (ASN_OCTET_STRING) 1005 const_iv (ASN_OCTET_STRING)
966 const_iv (ASN_NULL) 1006 const_iv (ASN_NULL)
967 const_iv (ASN_OBJECT_IDENTIFIER) 1007 const_iv (ASN_OBJECT_IDENTIFIER)
968 const_iv (ASN_OBJECT_DESCRIPTOR) 1008 const_iv (ASN_OBJECT_DESCRIPTOR)
… …
997 const_iv (ASN_CONTEXT) 1037 const_iv (ASN_CONTEXT)
998 const_iv (ASN_PRIVATE) 1038 const_iv (ASN_PRIVATE)
999 1039
1000 const_iv (BER_CLASS) 1040 const_iv (BER_CLASS)
1001 const_iv (BER_TAG) 1041 const_iv (BER_TAG)
1002 const_iv (BER_CONSTRUCTED) 1042 const_iv (BER_FLAGS)
1003 const_iv (BER_DATA) 1043 const_iv (BER_DATA)
1004 1044
1005 const_iv (BER_TYPE_BYTES) 1045 const_iv (BER_TYPE_BYTES)
1006 const_iv (BER_TYPE_UTF8) 1046 const_iv (BER_TYPE_UTF8)
1007 const_iv (BER_TYPE_UCS2) 1047 const_iv (BER_TYPE_UCS2)
… …
1040 RETVAL = decode_ber (); 1080 RETVAL = decode_ber ();
1041} 1081}
1042 OUTPUT: RETVAL 1082 OUTPUT: RETVAL
1043 1083
1044void 1084void
1045ber_is (SV *tuple, SV *klass = &PL_sv_undef, SV *tag = &PL_sv_undef, SV *constructed = &PL_sv_undef, SV *data = &PL_sv_undef) 1085ber_is (SV *tuple, SV *klass = &PL_sv_undef, SV *tag = &PL_sv_undef, SV *flags = &PL_sv_undef, SV *data = &PL_sv_undef)
1046 PPCODE: 1086 PPCODE:
1047{ 1087{
1048 if (!SvOK (tuple)) 1088 if (!SvOK (tuple))
1049 XSRETURN_NO; 1089 XSRETURN_NO;
1050 1090
… …
1052 croak ("ber_is: tuple must be BER tuple (array-ref)"); 1092 croak ("ber_is: tuple must be BER tuple (array-ref)");
1053 1093
1054 AV *av = (AV *)SvRV (tuple); 1094 AV *av = (AV *)SvRV (tuple);
1055 1095
1056 XPUSHs ( 1096 XPUSHs (
1057 (!SvOK (klass) || SvIV (AvARRAY (av)[BER_CLASS ]) == SvIV (klass)) 1097 (!SvOK (klass) || SvIV (AvARRAY (av)[BER_CLASS]) == SvIV (klass))
1058 && (!SvOK (tag) || SvIV (AvARRAY (av)[BER_TAG ]) == SvIV (tag)) 1098 && (!SvOK (tag) || SvIV (AvARRAY (av)[BER_TAG ]) == SvIV (tag))
1059 && (!SvOK (constructed) || !SvIV (AvARRAY (av)[BER_CONSTRUCTED]) == !SvIV (constructed)) 1099 && (!SvOK (flags) || !SvIV (AvARRAY (av)[BER_FLAGS]) == !SvIV (flags))
1060 && (!SvOK (data) || sv_eq (AvARRAY (av)[BER_DATA ], data)) 1100 && (!SvOK (data) || sv_eq (AvARRAY (av)[BER_DATA ], data))
1061 ? &PL_sv_yes : &PL_sv_undef); 1101 ? &PL_sv_yes : &PL_sv_undef);
1062} 1102}
1063 1103
1064void 1104void
1065ber_is_seq (SV *tuple) 1105ber_is_seq (SV *tuple)
… …
1069 XSRETURN_UNDEF; 1109 XSRETURN_UNDEF;
1070 1110
1071 AV *av = ber_tuple (tuple); 1111 AV *av = ber_tuple (tuple);
1072 1112
1073 XPUSHs ( 1113 XPUSHs (
1074 SvIV (AvARRAY (av)[BER_CLASS ]) == ASN_UNIVERSAL 1114 SvIV (AvARRAY (av)[BER_CLASS]) == ASN_UNIVERSAL
1075 && SvIV (AvARRAY (av)[BER_TAG ]) == ASN_SEQUENCE 1115 && SvIV (AvARRAY (av)[BER_TAG ]) == ASN_SEQUENCE
1076 && SvIV (AvARRAY (av)[BER_CONSTRUCTED]) 1116 && SvIV (AvARRAY (av)[BER_FLAGS])
1077 ? AvARRAY (av)[BER_DATA] : &PL_sv_undef); 1117 ? AvARRAY (av)[BER_DATA] : &PL_sv_undef);
1078} 1118}
1079 1119
1080void 1120void
1081ber_is_i32 (SV *tuple, SV *value = &PL_sv_undef) 1121ber_is_int (SV *tuple, SV *value = &PL_sv_undef)
1082 PPCODE: 1122 PPCODE:
1083{ 1123{
1084 if (!SvOK (tuple)) 1124 if (!SvOK (tuple))
1085 XSRETURN_NO; 1125 XSRETURN_NO;
1086 1126
1087 AV *av = ber_tuple (tuple); 1127 AV *av = ber_tuple (tuple);
1088 1128
1089 IV data = SvIV (AvARRAY (av)[BER_DATA]); 1129 UV data = SvUV (AvARRAY (av)[BER_DATA]);
1090 1130
1091 XPUSHs ( 1131 XPUSHs (
1092 SvIV (AvARRAY (av)[BER_CLASS ]) == ASN_UNIVERSAL 1132 SvIV (AvARRAY (av)[BER_CLASS]) == ASN_UNIVERSAL
1093 && SvIV (AvARRAY (av)[BER_TAG ]) == ASN_INTEGER32 1133 && SvIV (AvARRAY (av)[BER_TAG ]) == ASN_INTEGER
1094 && !SvIV (AvARRAY (av)[BER_CONSTRUCTED]) 1134 && !SvIV (AvARRAY (av)[BER_FLAGS])
1095 && (!SvOK (value) || data == SvIV (value)) 1135 && (!SvOK (value) || data == SvUV (value))
1096 ? sv_2mortal (data ? newSViv (data) : newSVpv ("0 but true", 0)) 1136 ? sv_2mortal (data ? newSVsv (AvARRAY (av)[BER_DATA]) : newSVpv ("0 but true", 0))
1097 : &PL_sv_undef); 1137 : &PL_sv_undef);
1098} 1138}
1099 1139
1100void 1140void
1101ber_is_oid (SV *tuple, SV *oid = &PL_sv_undef) 1141ber_is_oid (SV *tuple, SV *oid = &PL_sv_undef)
… …
1105 XSRETURN_NO; 1145 XSRETURN_NO;
1106 1146
1107 AV *av = ber_tuple (tuple); 1147 AV *av = ber_tuple (tuple);
1108 1148
1109 XPUSHs ( 1149 XPUSHs (
1110 SvIV (AvARRAY (av)[BER_CLASS ]) == ASN_UNIVERSAL 1150 SvIV (AvARRAY (av)[BER_CLASS]) == ASN_UNIVERSAL
1111 && SvIV (AvARRAY (av)[BER_TAG ]) == ASN_OBJECT_IDENTIFIER 1151 && SvIV (AvARRAY (av)[BER_TAG ]) == ASN_OBJECT_IDENTIFIER
1112 && !SvIV (AvARRAY (av)[BER_CONSTRUCTED]) 1152 && !SvIV (AvARRAY (av)[BER_FLAGS])
1113 && (!SvOK (oid) || sv_eq (AvARRAY (av)[BER_DATA], oid)) 1153 && (!SvOK (oid) || sv_eq (AvARRAY (av)[BER_DATA], oid))
1114 ? newSVsv (AvARRAY (av)[BER_DATA]) : &PL_sv_undef); 1154 ? newSVsv (AvARRAY (av)[BER_DATA]) : &PL_sv_undef);
1115} 1155}
1116 1156
1117############################################################################# 1157#############################################################################
… …
1130 SvCUR_set (buf_sv, cur - buf); 1170 SvCUR_set (buf_sv, cur - buf);
1131 XPUSHs (buf_sv); 1171 XPUSHs (buf_sv);
1132} 1172}
1133 1173
1134SV * 1174SV *
1135ber_i32 (IV iv) 1175ber_int (SV *sv)
1136 CODE: 1176 CODE:
1137{ 1177{
1138 AV *av = newAV (); 1178 AV *av = newAV ();
1139 av_fill (av, BER_ARRAYSIZE - 1); 1179 av_fill (av, BER_ARRAYSIZE - 1);
1140 AvARRAY (av)[BER_CLASS ] = newSVcacheint (ASN_UNIVERSAL); 1180 AvARRAY (av)[BER_CLASS] = newSVcacheint (ASN_UNIVERSAL);
1141 AvARRAY (av)[BER_TAG ] = newSVcacheint (ASN_INTEGER32); 1181 AvARRAY (av)[BER_TAG ] = newSVcacheint (ASN_INTEGER);
1142 AvARRAY (av)[BER_CONSTRUCTED] = newSVcacheint (0); 1182 AvARRAY (av)[BER_FLAGS] = newSVcacheint (0);
1143 AvARRAY (av)[BER_DATA ] = newSViv (iv); 1183 AvARRAY (av)[BER_DATA ] = newSVsv (sv);
1144 RETVAL = newRV_noinc ((SV *)av); 1184 RETVAL = newRV_noinc ((SV *)av);
1145} 1185}
1146 OUTPUT: RETVAL 1186 OUTPUT: RETVAL
1147 1187
1148# TODO: not arrayref, but elements? 1188# TODO: not arrayref, but elements?
… …
1150ber_seq (SV *arrayref) 1190ber_seq (SV *arrayref)
1151 CODE: 1191 CODE:
1152{ 1192{
1153 AV *av = newAV (); 1193 AV *av = newAV ();
1154 av_fill (av, BER_ARRAYSIZE - 1); 1194 av_fill (av, BER_ARRAYSIZE - 1);
1155 AvARRAY (av)[BER_CLASS ] = newSVcacheint (ASN_UNIVERSAL); 1195 AvARRAY (av)[BER_CLASS] = newSVcacheint (ASN_UNIVERSAL);
1156 AvARRAY (av)[BER_TAG ] = newSVcacheint (ASN_SEQUENCE); 1196 AvARRAY (av)[BER_TAG ] = newSVcacheint (ASN_SEQUENCE);
1157 AvARRAY (av)[BER_CONSTRUCTED] = newSVcacheint (1); 1197 AvARRAY (av)[BER_FLAGS] = newSVcacheint (1);
1158 AvARRAY (av)[BER_DATA ] = newSVsv (arrayref); 1198 AvARRAY (av)[BER_DATA ] = newSVsv (arrayref);
1159 RETVAL = newRV_noinc ((SV *)av); 1199 RETVAL = newRV_noinc ((SV *)av);
1160} 1200}
1161 OUTPUT: RETVAL 1201 OUTPUT: RETVAL
1162 1202
1163MODULE = Convert::BER::XS PACKAGE = Convert::BER::XS::Profile 1203MODULE = Convert::BER::XS PACKAGE = Convert::BER::XS::Profile

Diff Legend

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