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.5 by root, Fri Apr 19 23:50:53 2019 UTC vs.
Revision 1.13 by root, Sat Apr 20 13:46:14 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_INTEGER32 = 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, //X 18 ASN_OID = 0x06,
16 ASN_OBJECT_DESCRIPTOR = 0x07, //X 19 ASN_OBJECT_DESCRIPTOR = 0x07,
17 ASN_EXTERNAL = 0x08, //X 20 ASN_EXTERNAL = 0x08,
18 ASN_REAL = 0x09, //X 21 ASN_REAL = 0x09,
19 ASN_ENUMERATED = 0x0a, //X 22 ASN_ENUMERATED = 0x0a,
20 ASN_EMBEDDED_PDV = 0x0b, //X 23 ASN_EMBEDDED_PDV = 0x0b,
21 ASN_UTF8_STRING = 0x0c, //X 24 ASN_UTF8_STRING = 0x0c,
22 ASN_RELATIVE_OID = 0x0d, //X 25 ASN_RELATIVE_OID = 0x0d,
23 ASN_SEQUENCE = 0x10, 26 ASN_SEQUENCE = 0x10,
24 ASN_SET = 0x11, //X 27 ASN_SET = 0x11,
25 ASN_NUMERIC_STRING = 0x12, //X 28 ASN_NUMERIC_STRING = 0x12,
26 ASN_PRINTABLE_STRING = 0x13, //X 29 ASN_PRINTABLE_STRING = 0x13,
27 ASN_TELETEX_STRING = 0x14, //X 30 ASN_TELETEX_STRING = 0x14,
28 ASN_T61_STRING = 0x14, //X 31 ASN_T61_STRING = 0x14,
29 ASN_VIDEOTEX_STRING = 0x15, //X 32 ASN_VIDEOTEX_STRING = 0x15,
30 ASN_IA5_STRING = 0x16, //X 33 ASN_IA5_STRING = 0x16,
31 ASN_ASCII_STRING = 0x16, //X 34 ASN_ASCII_STRING = 0x16,
32 ASN_UTC_TIME = 0x17, //X 35 ASN_UTC_TIME = 0x17,
33 ASN_GENERALIZED_TIME = 0x18, //X 36 ASN_GENERALIZED_TIME = 0x18,
34 ASN_GRAPHIC_STRING = 0x19, //X 37 ASN_GRAPHIC_STRING = 0x19,
35 ASN_VISIBLE_STRING = 0x1a, //X 38 ASN_VISIBLE_STRING = 0x1a,
36 ASN_ISO646_STRING = 0x1a, //X 39 ASN_ISO646_STRING = 0x1a,
37 ASN_GENERAL_STRING = 0x1b, //X 40 ASN_GENERAL_STRING = 0x1b,
38 ASN_UNIVERSAL_STRING = 0x1c, //X 41 ASN_UNIVERSAL_STRING = 0x1c,
39 ASN_CHARACTER_STRING = 0x1d, //X 42 ASN_CHARACTER_STRING = 0x1d,
40 ASN_BMP_STRING = 0x1e, //X 43 ASN_BMP_STRING = 0x1e,
41 44
42 ASN_TAG_BER = 0x1f, 45 ASN_TAG_BER = 0x1f,
43 ASN_TAG_MASK = 0x1f, 46 ASN_TAG_MASK = 0x1f,
44 47
45 // primitive/constructed 48 // primitive/constructed
… …
72 BER_TYPE_OID, 75 BER_TYPE_OID,
73 BER_TYPE_RELOID, 76 BER_TYPE_RELOID,
74 BER_TYPE_NULL, 77 BER_TYPE_NULL,
75 BER_TYPE_BOOL, 78 BER_TYPE_BOOL,
76 BER_TYPE_REAL, 79 BER_TYPE_REAL,
80 BER_TYPE_IPADDRESS,
77 BER_TYPE_CROAK, 81 BER_TYPE_CROAK,
78}; 82};
79 83
80enum { 84enum {
81 BER_CLASS = 0, 85 BER_CLASS = 0,
… …
91 95
92static profile_type *cur_profile, *default_profile; 96static profile_type *cur_profile, *default_profile;
93static SV *buf_sv; // encoding buffer 97static SV *buf_sv; // encoding buffer
94static U8 *buf, *cur, *end; // buffer start, current, end 98static U8 *buf, *cur, *end; // buffer start, current, end
95 99
100#if PERL_VERSION < 18
101# define utf8_to_uvchr_buf(s,e,l) utf8_to_uvchr (s, l)
102#endif
103
96#if __GNUC__ >= 3 104#if __GNUC__ >= 3
97# define expect(expr,value) __builtin_expect ((expr), (value)) 105# define expect(expr,value) __builtin_expect ((expr), (value))
98# define INLINE static inline 106# define INLINE static inline
99#else 107#else
100# define expect(expr,value) (expr) 108# define expect(expr,value) (expr)
… …
129 137
130static profile_type * 138static profile_type *
131SvPROFILE (SV *profile) 139SvPROFILE (SV *profile)
132{ 140{
133 if (!SvOK (profile)) 141 if (!SvOK (profile))
134 profile = default_profile; 142 return default_profile;
135 143
136 if (!SvROK (profile)) 144 if (!SvROK (profile))
137 croak ("invalid profile"); 145 croak ("invalid profile");
138 146
139 profile = SvRV (profile); 147 profile = SvRV (profile);
… …
154 return BER_TYPE_BYTES; 162 return BER_TYPE_BYTES;
155 163
156 return SvPVX (sv)[idx]; 164 return SvPVX (sv)[idx];
157} 165}
158 166
159static int 167static void
160profile_set (profile_type *profile, int klass, int tag, int type) 168profile_set (profile_type *profile, int klass, int tag, int type)
161{ 169{
162 SV *sv = (SV *)profile; 170 SV *sv = (SV *)profile;
163 U32 idx = (tag << 2) + klass; 171 U32 idx = (tag << 2) + klass;
164 STRLEN oldlen = SvCUR (sv); 172 STRLEN oldlen = SvCUR (sv);
… …
186 } *celem, default_map[] = { 194 } *celem, default_map[] = {
187 { ASN_UNIVERSAL, ASN_BOOLEAN , BER_TYPE_BOOL }, 195 { ASN_UNIVERSAL, ASN_BOOLEAN , BER_TYPE_BOOL },
188 { ASN_UNIVERSAL, ASN_INTEGER32 , BER_TYPE_INT }, 196 { ASN_UNIVERSAL, ASN_INTEGER32 , BER_TYPE_INT },
189 { ASN_UNIVERSAL, ASN_NULL , BER_TYPE_NULL }, 197 { ASN_UNIVERSAL, ASN_NULL , BER_TYPE_NULL },
190 { ASN_UNIVERSAL, ASN_OBJECT_IDENTIFIER, BER_TYPE_OID }, 198 { ASN_UNIVERSAL, ASN_OBJECT_IDENTIFIER, BER_TYPE_OID },
191 { ASN_UNIVERSAL, ASN_OBJECT_DESCRIPTOR, BER_TYPE_OID },
192 { ASN_UNIVERSAL, ASN_RELATIVE_OID , BER_TYPE_RELOID }, 199 { ASN_UNIVERSAL, ASN_RELATIVE_OID , BER_TYPE_RELOID },
193 { ASN_UNIVERSAL, ASN_REAL , BER_TYPE_REAL }, 200 { ASN_UNIVERSAL, ASN_REAL , BER_TYPE_REAL },
201 { ASN_UNIVERSAL, ASN_ENUMERATED , BER_TYPE_INT },
194 { ASN_UNIVERSAL, ASN_UTF8_STRING , BER_TYPE_UTF8 }, 202 { ASN_UNIVERSAL, ASN_UTF8_STRING , BER_TYPE_UTF8 },
195 { ASN_UNIVERSAL, ASN_BMP_STRING , BER_TYPE_UCS2 }, 203 { ASN_UNIVERSAL, ASN_BMP_STRING , BER_TYPE_UCS2 },
196 { ASN_UNIVERSAL, ASN_UNIVERSAL_STRING , BER_TYPE_UCS4 }, 204 { ASN_UNIVERSAL, ASN_UNIVERSAL_STRING , BER_TYPE_UCS4 },
197 }; 205 };
198 206
199 //const_iv (SNMP_IPADDRESS)
200 //const_iv (SNMP_COUNTER32)
201 //const_iv (SNMP_UNSIGNED32)
202 //const_iv (SNMP_TIMETICKS)
203 //const_iv (SNMP_OPAQUE)
204 //const_iv (SNMP_COUNTER64)
205
206 for (celem = default_map + sizeof (default_map) / sizeof (default_map [0]); celem > default_map; celem--) 207 for (celem = default_map + sizeof (default_map) / sizeof (default_map [0]); celem-- > default_map; )
207 profile_set ((void *)sv, celem->klass, celem->tag, celem->type); 208 profile_set ((profile_type *)sv, celem->klass, celem->tag, celem->type);
208 209
209 return sv_bless (newRV_noinc (sv), profile_stash); 210 return sv_bless (newRV_noinc (sv), profile_stash);
210} 211}
211 212
212///////////////////////////////////////////////////////////////////////////// 213/////////////////////////////////////////////////////////////////////////////
… …
313 314
314 do 315 do
315 val = (val << 8) | *data++; 316 val = (val << 8) | *data++;
316 while (--len); 317 while (--len);
317 318
318 // the cats to IV relies on implementation-defined behaviour (two's complement cast) 319 // the cast to IV relies on implementation-defined behaviour (two's complement cast)
319 // but that's ok, as perl relies on it as well. 320 // but that's ok, as perl relies on it as well.
320 return negative ? newSViv ((IV)val) : newSVuv (val); 321 return negative ? newSViv ((IV)val) : newSVuv (val);
321} 322}
322 323
323static SV * 324static SV *
… …
335 // the one-digit case is absolutely predominant, so this pays off (hopefully) 336 // the one-digit case is absolutely predominant, so this pays off (hopefully)
336 if (expect_true (u < 10)) 337 if (expect_true (u < 10))
337 *buf++ = u + '0'; 338 *buf++ = u + '0';
338 else 339 else
339 { 340 {
341 // this *could* be done much faster using branchless fixed-ppint arithmetics
340 char *beg = buf; 342 char *beg = buf;
341 343
342 do 344 do
343 { 345 {
344 *buf++ = u % 10 + '0'; 346 *buf++ = u % 10 + '0';
345 u /= 10; 347 u /= 10;
346 } 348 }
347 while (u); 349 while (u);
348 350
349 // reverse digits 351 // reverse digits
350 for (char *ptr = buf; --ptr != beg; ++beg) 352 char *ptr = buf;
353 while (--ptr > beg)
351 { 354 {
352 char c = *ptr; 355 char c = *ptr;
353 *ptr = *beg; 356 *ptr = *beg;
354 *beg = c; 357 *beg = c;
358 ++beg;
355 } 359 }
356 } 360 }
357 361
358 return buf; 362 return buf;
359} 363}
… …
370 } 374 }
371 375
372 U8 *end = cur + len; 376 U8 *end = cur + len;
373 U32 w = get_w (); 377 U32 w = get_w ();
374 378
375 static char oid[MAX_OID_STRLEN]; // must be static 379 static char oid[MAX_OID_STRLEN]; // static, becaueds too large for stack
376 char *app = oid; 380 char *app = oid;
377 381
378 if (relative) 382 if (relative)
379 app = write_uv (app, w); 383 app = write_uv (app, w);
380 else 384 else
… …
382 app = write_uv (app, (U8)w / 40); 386 app = write_uv (app, (U8)w / 40);
383 *app++ = '.'; 387 *app++ = '.';
384 app = write_uv (app, (U8)w % 40); 388 app = write_uv (app, (U8)w % 40);
385 } 389 }
386 390
391 while (cur < end)
392 {
387 // we assume an oid component is never > 64 bytes 393 // we assume an oid component is never > 64 digits
388 while (cur < end && oid + sizeof (oid) - app > 64) 394 if (oid + sizeof (oid) - app < 64)
389 { 395 croak ("BER_TYPE_OID to long to decode");
396
390 w = get_w (); 397 w = get_w ();
391 *app++ = '.'; 398 *app++ = '.';
392 app = write_uv (app, w); 399 app = write_uv (app, w);
393 } 400 }
394 401
395 return newSVpvn (oid, app - oid); 402 return newSVpvn (oid, app - oid);
403}
404
405// TODO: this is unacceptably slow
406static SV *
407decode_ucs (int chrsize)
408{
409 SV *res = NEWSV (0, 0);
410
411 U32 len = get_length ();
412
413 if (len & (chrsize - 1))
414 croak ("BER_TYPE_UCS has an invalid number of octets (%d)", len);
415
416 while (len)
417 {
418 U8 b1 = get_u8 ();
419 U8 b2 = get_u8 ();
420 U32 chr = (b1 << 8) | b2;
421
422 if (chrsize == 4)
423 {
424 U8 b3 = get_u8 ();
425 U8 b4 = get_u8 ();
426 chr = (chr << 16) | (b3 << 8) | b4;
427 }
428
429 U8 uchr [UTF8_MAXBYTES];
430 int uclen = uvuni_to_utf8 (uchr, chr) - uchr;
431
432 sv_catpvn (res, (const char *)uchr, uclen);
433 len -= chrsize;
434 }
435
436 SvUTF8_on (res);
437
438 return res;
396} 439}
397 440
398static SV * 441static SV *
399decode_ber () 442decode_ber ()
400{ 443{
… …
428 } 471 }
429 else 472 else
430 switch (profile_lookup (cur_profile, klass, tag)) 473 switch (profile_lookup (cur_profile, klass, tag))
431 { 474 {
432 case BER_TYPE_NULL: 475 case BER_TYPE_NULL:
476 {
477 U32 len = get_length ();
478
479 if (len)
480 croak ("BER_TYPE_NULL value with non-zero length %d encountered", len);
481
433 res = &PL_sv_undef; 482 res = &PL_sv_undef;
483 }
434 break; 484 break;
435 485
436 case BER_TYPE_BOOL: 486 case BER_TYPE_BOOL:
437 { 487 {
438 U32 len = get_length (); 488 U32 len = get_length ();
439 489
440 if (len != 1) 490 if (len != 1)
441 croak ("BOOLEAN type with invalid length %d encountered", len); 491 croak ("BER_TYPE_BOOLEAN value with invalid length %d encountered", len);
442 492
443 res = newSVcacheint (get_u8 () ? 0 : 1); 493 res = newSVcacheint (!!get_u8 ());
444 } 494 }
445 break; 495 break;
446 496
447 case BER_TYPE_OID: 497 case BER_TYPE_OID:
448 res = decode_oid (0); 498 res = decode_oid (0);
… …
463 513
464 case BER_TYPE_BYTES: 514 case BER_TYPE_BYTES:
465 res = decode_data (); 515 res = decode_data ();
466 break; 516 break;
467 517
518 case BER_TYPE_IPADDRESS:
519 {
520 U32 len = get_length ();
521
522 if (len != 4)
523 croak ("BER_TYPE_IPADDRESS type with invalid length %d encountered", len);
524
525 U8 c1 = get_u8 ();
526 U8 c2 = get_u8 ();
527 U8 c3 = get_u8 ();
528 U8 c4 = get_u8 ();
529
530 res = newSVpvf ("%d.%d.%d.%d", c1, c2, c3, c4);
531 }
532 break;
533
534 case BER_TYPE_UCS2:
535 res = decode_ucs (2);
536 break;
537
538 case BER_TYPE_UCS4:
539 res = decode_ucs (4);
540 break;
541
468 case BER_TYPE_REAL: 542 case BER_TYPE_REAL:
469 case BER_TYPE_UCS2:
470 case BER_TYPE_UCS4:
471 case BER_TYPE_CROAK: 543 case BER_TYPE_CROAK:
472 default: 544 default:
473 croak ("unconfigured/unsupported class/tag %d/%d", klass, tag); 545 croak ("unconfigured/unsupported class/tag %d/%d", klass, tag);
474 } 546 }
475 547
… …
501static void 573static void
502set_buf (SV *sv) 574set_buf (SV *sv)
503{ 575{
504 STRLEN len; 576 STRLEN len;
505 buf_sv = sv; 577 buf_sv = sv;
506 buf = SvPVbyte (buf_sv, len); 578 buf = (U8 *)SvPVbyte (buf_sv, len);
507 cur = buf; 579 cur = buf;
508 end = buf + len; 580 end = buf + len;
509} 581}
510 582
511/* similar to SvGROW, but somewhat safer and guarantees exponential realloc strategy */ 583/* similar to SvGROW, but somewhat safer and guarantees exponential realloc strategy */
… …
525need (STRLEN len) 597need (STRLEN len)
526{ 598{
527 if (expect_false ((uintptr_t)(end - cur) < len)) 599 if (expect_false ((uintptr_t)(end - cur) < len))
528 { 600 {
529 STRLEN pos = cur - buf; 601 STRLEN pos = cur - buf;
530 buf = my_sv_grow (buf_sv, pos, len); 602 buf = (U8 *)my_sv_grow (buf_sv, pos, len);
531 cur = buf + pos; 603 cur = buf + pos;
532 end = buf + SvLEN (buf_sv) - 1; 604 end = buf + SvLEN (buf_sv) - 1;
533 } 605 }
534} 606}
535 607
… …
579} 651}
580 652
581static void 653static void
582put_length (U32 val) 654put_length (U32 val)
583{ 655{
584 need (5); 656 need (5 + val);
585 cur = put_length_at (val, cur); 657 cur = put_length_at (val, cur);
586} 658}
587 659
588// return how many bytes the encoded length requires 660// return how many bytes the encoded length requires
589static int length_length (U32 val) 661static int length_length (U32 val)
… …
595 667
596static void 668static void
597encode_data (const char *ptr, STRLEN len) 669encode_data (const char *ptr, STRLEN len)
598{ 670{
599 put_length (len); 671 put_length (len);
600 need (len);
601 memcpy (cur, ptr, len); 672 memcpy (cur, ptr, len);
602 cur += len; 673 cur += len;
603} 674}
604 675
605static void 676static void
… …
751 822
752 return (AV *)rv; 823 return (AV *)rv;
753} 824}
754 825
755static void 826static void
827encode_ucs (SV *data, int chrsize)
828{
829 STRLEN uchars = sv_len_utf8 (data);
830 STRLEN len;;
831 char *ptr = SvPVutf8 (data, len);
832
833 put_length (uchars * chrsize);
834
835 while (uchars--)
836 {
837 STRLEN uclen;
838 UV uchr = utf8_to_uvchr_buf ((U8 *)ptr, (U8 *)ptr + len, &uclen);
839
840 ptr += uclen;
841 len -= uclen;
842
843 if (chrsize == 4)
844 {
845 *cur++ = uchr >> 24;
846 *cur++ = uchr >> 16;
847 }
848
849 *cur++ = uchr >> 8;
850 *cur++ = uchr;
851 }
852}
853static void
756encode_ber (SV *tuple) 854encode_ber (SV *tuple)
757{ 855{
758 AV *av = ber_tuple (tuple); 856 AV *av = ber_tuple (tuple);
759 857
760 int klass = SvIV (AvARRAY (av)[BER_CLASS]); 858 int klass = SvIV (AvARRAY (av)[BER_CLASS]);
… …
786 int fill = AvFILL (av); 884 int fill = AvFILL (av);
787 885
788 if (expect_false (SvRMAGICAL (av))) 886 if (expect_false (SvRMAGICAL (av)))
789 croak ("BER constructed data must not be tied"); 887 croak ("BER constructed data must not be tied");
790 888
889 int i;
791 for (int i = 0; i <= fill; ++i) 890 for (i = 0; i <= fill; ++i)
792 encode_ber (AvARRAY (av)[i]); 891 encode_ber (AvARRAY (av)[i]);
793 892
794 len_fixup (mark); 893 len_fixup (mark);
795 } 894 }
796 else 895 else
… …
800 put_length (0); 899 put_length (0);
801 break; 900 break;
802 901
803 case BER_TYPE_BOOL: 902 case BER_TYPE_BOOL:
804 put_length (1); 903 put_length (1);
805 put_u8 (SvTRUE (data) ? 0xff : 0x00); 904 *cur++ = SvTRUE (data) ? 0xff : 0x00;
806 break; 905 break;
807 906
808 case BER_TYPE_OID: 907 case BER_TYPE_OID:
809 encode_oid (data, 0); 908 encode_oid (data, 0);
810 break; 909 break;
… …
831 const char *ptr = SvPVutf8 (data, len); 930 const char *ptr = SvPVutf8 (data, len);
832 encode_data (ptr, len); 931 encode_data (ptr, len);
833 } 932 }
834 break; 933 break;
835 934
935 case BER_TYPE_IPADDRESS:
936 {
937 U8 ip[4];
938 sscanf (SvPV_nolen (data), "%hhu.%hhu.%hhu.%hhu", ip + 0, ip + 1, ip + 2, ip + 3);
939 encode_data ((const char *)ip, sizeof (ip));
940 }
941 break;
942
943 case BER_TYPE_UCS2:
944 encode_ucs (data, 2);
945 break;
946
947 case BER_TYPE_UCS4:
948 encode_ucs (data, 4);
949 break;
950
836 case BER_TYPE_REAL: 951 case BER_TYPE_REAL:
837 case BER_TYPE_UCS2:
838 case BER_TYPE_UCS4:
839 case BER_TYPE_CROAK: 952 case BER_TYPE_CROAK:
840 default: 953 default:
841 croak ("unconfigured/unsupported class/tag %d/%d", klass, tag); 954 croak ("unconfigured/unsupported class/tag %d/%d", klass, tag);
842 } 955 }
843 956
… …
911 const_iv (BER_TYPE_OID) 1024 const_iv (BER_TYPE_OID)
912 const_iv (BER_TYPE_RELOID) 1025 const_iv (BER_TYPE_RELOID)
913 const_iv (BER_TYPE_NULL) 1026 const_iv (BER_TYPE_NULL)
914 const_iv (BER_TYPE_BOOL) 1027 const_iv (BER_TYPE_BOOL)
915 const_iv (BER_TYPE_REAL) 1028 const_iv (BER_TYPE_REAL)
1029 const_iv (BER_TYPE_IPADDRESS)
916 const_iv (BER_TYPE_CROAK) 1030 const_iv (BER_TYPE_CROAK)
917 1031
918 const_iv (SNMP_IPADDRESS) 1032 const_iv (SNMP_IPADDRESS)
919 const_iv (SNMP_COUNTER32) 1033 const_iv (SNMP_COUNTER32)
920 const_iv (SNMP_UNSIGNED32) 1034 const_iv (SNMP_UNSIGNED32)
921 const_iv (SNMP_TIMETICKS) 1035 const_iv (SNMP_TIMETICKS)
922 const_iv (SNMP_OPAQUE) 1036 const_iv (SNMP_OPAQUE)
923 const_iv (SNMP_COUNTER64) 1037 const_iv (SNMP_COUNTER64)
924
925 }; 1038 };
926 1039
927 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ > const_iv; civ--) 1040 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ > const_iv; civ--)
928 newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv)); 1041 newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
929
930 default_profile = profile_new ();
931} 1042}
932 1043
933SV * 1044SV *
934ber_decode (SV *ber, SV *profile = &PL_sv_undef) 1045ber_decode (SV *ber, SV *profile = &PL_sv_undef)
935 CODE: 1046 CODE:
936{ 1047{
937 cur_profile = SvPROFILE (profile); 1048 cur_profile = SvPROFILE (profile);
938 STRLEN len; 1049 STRLEN len;
939 buf = SvPVbyte (ber, len); 1050 buf = (U8 *)SvPVbyte (ber, len);
940 cur = buf; 1051 cur = buf;
941 end = buf + len; 1052 end = buf + len;
942 1053
943 RETVAL = decode_ber (); 1054 RETVAL = decode_ber ();
944} 1055}
… …
1069new (SV *klass) 1180new (SV *klass)
1070 CODE: 1181 CODE:
1071 RETVAL = profile_new (); 1182 RETVAL = profile_new ();
1072 OUTPUT: RETVAL 1183 OUTPUT: RETVAL
1073 1184
1185void
1186set (SV *profile, int klass, int tag, int type)
1187 CODE:
1188 profile_set (SvPROFILE (profile), klass, tag, type);
1189
1190IV
1191get (SV *profile, int klass, int tag)
1192 CODE:
1193 RETVAL = profile_lookup (SvPROFILE (profile), klass, tag);
1194 OUTPUT: RETVAL
1195
1196void
1197_set_default (SV *profile)
1198 CODE:
1199 default_profile = SvPROFILE (profile);
1200
1201

Diff Legend

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