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.19 by root, Sat Apr 20 16:34:34 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, //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,
82 BER_TAG = 1, 86 BER_TAG = 1,
83 BER_CONSTRUCTED = 2, 87 BER_FLAGS = 2,
84 BER_DATA = 3, 88 BER_DATA = 3,
85 BER_ARRAYSIZE 89 BER_ARRAYSIZE
86}; 90};
87 91
88#define MAX_OID_STRLEN 4096 92#define MAX_OID_STRLEN 4096
89 93
90typedef void profile_type; 94typedef void profile_type;
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
99
100#if PERL_VERSION < 18
101# define utf8_to_uvchr_buf(s,e,l) utf8_to_uvchr (s, l)
102#endif
95 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
… …
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);
… …
173 181
174 SvPVX (sv)[idx] = type; 182 SvPVX (sv)[idx] = type;
175} 183}
176 184
177static SV * 185static SV *
178profile_new () 186profile_new (void)
179{ 187{
180 SV *sv = newSVpvn ("", 0); 188 SV *sv = newSVpvn ("", 0);
181 189
182 static const struct { 190 static const struct {
183 int klass; 191 int klass;
184 int tag; 192 int tag;
185 int type; 193 int type;
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_INTEGER , 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/////////////////////////////////////////////////////////////////////////////
… …
247 248
248 return *cur++; 249 return *cur++;
249} 250}
250 251
251// get ber-encoded integer (i.e. pack "w") 252// get ber-encoded integer (i.e. pack "w")
252static U32 253static UV
253get_w (void) 254get_w (void)
254{ 255{
255 U32 res = 0; 256 UV res = 0;
256 257
257 for (;;) 258 for (;;)
258 { 259 {
259 U8 c = get_u8 (); 260 U8 c = get_u8 ();
260 res = (res << 7) | (c & 0x7f); 261 res = (res << 7) | (c & 0x7f);
… …
262 if (!(c & 0x80)) 263 if (!(c & 0x80))
263 return res; 264 return res;
264 } 265 }
265} 266}
266 267
268// get_w, but disallow padding
267static 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
268get_length (void) 283get_length (void)
269{ 284{
270 U32 res = get_u8 (); 285 UV res = get_u8 ();
271 286
272 if (res & 0x80) 287 if (res & 0x80)
273 { 288 {
274 int cnt = res & 0x7f; 289 int cnt = res & 0x7f;
275 res = 0; 290 res = 0;
… …
278 { 293 {
279 case 0: 294 case 0:
280 error ("indefinite ASN.1 lengths not supported"); 295 error ("indefinite ASN.1 lengths not supported");
281 return 0; 296 return 0;
282 297
298 //case 0x80: // indefinite length
299
300 //case 0xff: reserved
283 default: 301 default:
284 error ("ASN.1 length too long"); 302 error ("ASN.1 length too long");
285 return 0; 303 return 0;
286 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 ();
287 case 4: res = (res << 8) | get_u8 (); 309 case 4: res = (res << 8) | get_u8 ();
288 case 3: res = (res << 8) | get_u8 (); 310 case 3: res = (res << 8) | get_u8 ();
289 case 2: res = (res << 8) | get_u8 (); 311 case 2: res = (res << 8) | get_u8 ();
290 case 1: res = (res << 8) | get_u8 (); 312 case 1: res = (res << 8) | get_u8 ();
291 } 313 }
… …
293 315
294 return res; 316 return res;
295} 317}
296 318
297static SV * 319static SV *
298decode_int () 320decode_int (void)
299{ 321{
300 int len = get_length (); 322 UV len = get_length ();
301 323
302 if (len <= 0) 324 if (!len)
303 { 325 {
304 error ("integer length equal to zero"); 326 error ("invalid integer length equal to zero");
305 return 0; 327 return 0;
306 } 328 }
307 329
308 U8 *data = get_n (len); 330 U8 *data = get_n (len);
309 331
… …
313 335
314 do 336 do
315 val = (val << 8) | *data++; 337 val = (val << 8) | *data++;
316 while (--len); 338 while (--len);
317 339
318 // the cats to IV relies on implementation-defined behaviour (two's complement cast) 340 // 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. 341 // but that's ok, as perl relies on it as well.
320 return negative ? newSViv ((IV)val) : newSVuv (val); 342 return negative ? newSViv ((IV)val) : newSVuv (val);
321} 343}
322 344
323static SV * 345static SV *
324decode_data (void) 346decode_data (void)
325{ 347{
326 U32 len = get_length (); 348 UV len = get_length ();
327 U8 *data = get_n (len);
328 return newSVpvn ((char *)data, len); 349 return newSVpvn ((char *)get_n (len), len);
329} 350}
330 351
331// gelper for decode_object_identifier 352// helper for decode_object_identifier
332static char * 353static char *
333write_uv (char *buf, U32 u) 354write_uv (char *buf, UV u)
334{ 355{
335 // 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)
336 if (expect_true (u < 10)) 357 if (expect_true (u < 10))
337 *buf++ = u + '0'; 358 *buf++ = u + '0';
338 else 359 else
339 { 360 {
361 // this *could* be done much faster using branchless fixed-point arithmetics
340 char *beg = buf; 362 char *beg = buf;
341 363
342 do 364 do
343 { 365 {
344 *buf++ = u % 10 + '0'; 366 *buf++ = u % 10 + '0';
345 u /= 10; 367 u /= 10;
346 } 368 }
347 while (u); 369 while (u);
348 370
349 // reverse digits 371 // reverse digits
350 for (char *ptr = buf; --ptr != beg; ++beg) 372 char *ptr = buf;
373 while (--ptr > beg)
351 { 374 {
352 char c = *ptr; 375 char c = *ptr;
353 *ptr = *beg; 376 *ptr = *beg;
354 *beg = c; 377 *beg = c;
378 ++beg;
355 } 379 }
356 } 380 }
357 381
358 return buf; 382 return buf;
359} 383}
360 384
361static SV * 385static SV *
362decode_oid (int relative) 386decode_oid (int relative)
363{ 387{
364 U32 len = get_length (); 388 UV len = get_length ();
365 389
366 if (len <= 0) 390 if (len <= 0)
367 { 391 {
368 error ("OBJECT IDENTIFIER length equal to zero"); 392 error ("OBJECT IDENTIFIER length equal to zero");
369 return &PL_sv_undef; 393 return &PL_sv_undef;
370 } 394 }
371 395
372 U8 *end = cur + len; 396 U8 *end = cur + len;
373 U32 w = get_w (); 397 UV w = get_w_nopad ();
374 398
375 static char oid[MAX_OID_STRLEN]; // must be static 399 static char oid[MAX_OID_STRLEN]; // static, becaueds too large for stack
376 char *app = oid; 400 char *app = oid;
377 401
378 if (relative) 402 if (relative)
379 app = write_uv (app, w); 403 app = write_uv (app, w);
380 else 404 else if (w < 2 * 40)
381 { 405 {
382 app = write_uv (app, (U8)w / 40); 406 app = write_uv (app, (U8)w / 40);
383 *app++ = '.'; 407 *app++ = '.';
384 app = write_uv (app, (U8)w % 40); 408 app = write_uv (app, (U8)w % 40);
385 } 409 }
410 else
411 {
412 app = write_uv (app, 2);
413 *app++ = '.';
414 app = write_uv (app, w - 2 * 40);
415 }
386 416
417 while (cur < end)
418 {
387 // we assume an oid component is never > 64 bytes 419 // we assume an oid component is never > 64 digits
388 while (cur < end && oid + sizeof (oid) - app > 64) 420 if (oid + sizeof (oid) - app < 64)
389 { 421 croak ("BER_TYPE_OID to long to decode");
422
390 w = get_w (); 423 w = get_w_nopad ();
391 *app++ = '.'; 424 *app++ = '.';
392 app = write_uv (app, w); 425 app = write_uv (app, w);
393 } 426 }
394 427
395 return newSVpvn (oid, app - oid); 428 return newSVpvn (oid, app - oid);
396} 429}
397 430
431// TODO: this is unacceptably slow
398static SV * 432static SV *
433decode_ucs (int chrsize)
434{
435 SV *res = NEWSV (0, 0);
436
437 UV len = get_length ();
438
439 if (len & (chrsize - 1))
440 croak ("BER_TYPE_UCS has an invalid number of octets (%d)", len);
441
442 while (len)
443 {
444 U8 b1 = get_u8 ();
445 U8 b2 = get_u8 ();
446 U32 chr = (b1 << 8) | b2;
447
448 if (chrsize == 4)
449 {
450 U8 b3 = get_u8 ();
451 U8 b4 = get_u8 ();
452 chr = (chr << 16) | (b3 << 8) | b4;
453 }
454
455 U8 uchr [UTF8_MAXBYTES];
456 int uclen = uvuni_to_utf8 (uchr, chr) - uchr;
457
458 sv_catpvn (res, (const char *)uchr, uclen);
459 len -= chrsize;
460 }
461
462 SvUTF8_on (res);
463
464 return res;
465}
466
467static SV *
399decode_ber () 468decode_ber (void)
400{ 469{
401 int identifier = get_u8 (); 470 int identifier = get_u8 ();
402 471
403 SV *res; 472 SV *res;
404 473
… …
412 if (tag == ASN_TAG_BER) 481 if (tag == ASN_TAG_BER)
413 tag = get_w (); 482 tag = get_w ();
414 483
415 if (constructed) 484 if (constructed)
416 { 485 {
417 U32 len = get_length (); 486 UV len = get_length ();
418 U32 seqend = (cur - buf) + len; 487 UV seqend = (cur - buf) + len;
419 AV *av = (AV *)sv_2mortal ((SV *)newAV ()); 488 AV *av = (AV *)sv_2mortal ((SV *)newAV ());
420 489
421 while (cur < buf + seqend) 490 while (cur < buf + seqend)
422 av_push (av, decode_ber ()); 491 av_push (av, decode_ber ());
423 492
… …
428 } 497 }
429 else 498 else
430 switch (profile_lookup (cur_profile, klass, tag)) 499 switch (profile_lookup (cur_profile, klass, tag))
431 { 500 {
432 case BER_TYPE_NULL: 501 case BER_TYPE_NULL:
502 {
503 UV len = get_length ();
504
505 if (len)
506 croak ("BER_TYPE_NULL value with non-zero length %d encountered", len);
507
433 res = &PL_sv_undef; 508 res = &PL_sv_undef;
509 }
434 break; 510 break;
435 511
436 case BER_TYPE_BOOL: 512 case BER_TYPE_BOOL:
437 { 513 {
438 U32 len = get_length (); 514 UV len = get_length ();
439 515
440 if (len != 1) 516 if (len != 1)
441 croak ("BOOLEAN type with invalid length %d encountered", len); 517 croak ("BER_TYPE_BOOLEAN value with invalid length %d encountered", len);
442 518
443 res = newSVcacheint (get_u8 () ? 0 : 1); 519 res = newSVcacheint (!!get_u8 ());
444 } 520 }
445 break; 521 break;
446 522
447 case BER_TYPE_OID: 523 case BER_TYPE_OID:
448 res = decode_oid (0); 524 res = decode_oid (0);
… …
463 539
464 case BER_TYPE_BYTES: 540 case BER_TYPE_BYTES:
465 res = decode_data (); 541 res = decode_data ();
466 break; 542 break;
467 543
544 case BER_TYPE_IPADDRESS:
545 {
546 UV len = get_length ();
547
548 if (len != 4)
549 croak ("BER_TYPE_IPADDRESS type with invalid length %d encountered", len);
550
551 U8 c1 = get_u8 ();
552 U8 c2 = get_u8 ();
553 U8 c3 = get_u8 ();
554 U8 c4 = get_u8 ();
555
556 res = newSVpvf ("%d.%d.%d.%d", c1, c2, c3, c4);
557 }
558 break;
559
560 case BER_TYPE_UCS2:
561 res = decode_ucs (2);
562 break;
563
564 case BER_TYPE_UCS4:
565 res = decode_ucs (4);
566 break;
567
468 case BER_TYPE_REAL: 568 case BER_TYPE_REAL:
469 case BER_TYPE_UCS2:
470 case BER_TYPE_UCS4:
471 case BER_TYPE_CROAK: 569 case BER_TYPE_CROAK:
472 default: 570 default:
473 croak ("unconfigured/unsupported class/tag %d/%d", klass, tag); 571 croak ("unconfigured/unsupported class/tag %d/%d", klass, tag);
474 } 572 }
475 573
476 AV *av = newAV (); 574 AV *av = newAV ();
477 av_fill (av, BER_ARRAYSIZE - 1); 575 av_fill (av, BER_ARRAYSIZE - 1);
478 AvARRAY (av)[BER_CLASS ] = newSVcacheint (klass); 576 AvARRAY (av)[BER_CLASS] = newSVcacheint (klass);
479 AvARRAY (av)[BER_TAG ] = newSVcacheint (tag); 577 AvARRAY (av)[BER_TAG ] = newSVcacheint (tag);
480 AvARRAY (av)[BER_CONSTRUCTED] = newSVcacheint (constructed ? 1 : 0); 578 AvARRAY (av)[BER_FLAGS] = newSVcacheint (constructed ? 1 : 0);
481 AvARRAY (av)[BER_DATA ] = res; 579 AvARRAY (av)[BER_DATA ] = res;
482 580
483 return newRV_noinc ((SV *)av); 581 return newRV_noinc ((SV *)av);
484} 582}
485 583
486///////////////////////////////////////////////////////////////////////////// 584/////////////////////////////////////////////////////////////////////////////
… …
501static void 599static void
502set_buf (SV *sv) 600set_buf (SV *sv)
503{ 601{
504 STRLEN len; 602 STRLEN len;
505 buf_sv = sv; 603 buf_sv = sv;
506 buf = SvPVbyte (buf_sv, len); 604 buf = (U8 *)SvPVbyte (buf_sv, len);
507 cur = buf; 605 cur = buf;
508 end = buf + len; 606 end = buf + len;
509} 607}
510 608
511/* similar to SvGROW, but somewhat safer and guarantees exponential realloc strategy */ 609/* similar to SvGROW, but somewhat safer and guarantees exponential realloc strategy */
… …
525need (STRLEN len) 623need (STRLEN len)
526{ 624{
527 if (expect_false ((uintptr_t)(end - cur) < len)) 625 if (expect_false ((uintptr_t)(end - cur) < len))
528 { 626 {
529 STRLEN pos = cur - buf; 627 STRLEN pos = cur - buf;
530 buf = my_sv_grow (buf_sv, pos, len); 628 buf = (U8 *)my_sv_grow (buf_sv, pos, len);
531 cur = buf + pos; 629 cur = buf + pos;
532 end = buf + SvLEN (buf_sv) - 1; 630 end = buf + SvLEN (buf_sv) - 1;
533 } 631 }
534} 632}
535 633
… …
539 need (1); 637 need (1);
540 *cur++ = val; 638 *cur++ = val;
541} 639}
542 640
543static void 641static void
544put_w_nocheck (U32 val) 642put_w_nocheck (UV val)
545{ 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
546 *cur = (val >> 7 * 4) | 0x80; cur += val >= (1 << (7 * 4)); 651 *cur = (val >> 7 * 4) | 0x80; cur += val >= ((UV)1 << (7 * 4));
547 *cur = (val >> 7 * 3) | 0x80; cur += val >= (1 << (7 * 3)); 652 *cur = (val >> 7 * 3) | 0x80; cur += val >= ((UV)1 << (7 * 3));
548 *cur = (val >> 7 * 2) | 0x80; cur += val >= (1 << (7 * 2)); 653 *cur = (val >> 7 * 2) | 0x80; cur += val >= ((UV)1 << (7 * 2));
549 *cur = (val >> 7 * 1) | 0x80; cur += val >= (1 << (7 * 1)); 654 *cur = (val >> 7 * 1) | 0x80; cur += val >= ((UV)1 << (7 * 1));
550 *cur = val & 0x7f; cur += 1; 655 *cur = val & 0x7f; cur += 1;
551} 656}
552 657
553static void 658static void
554put_w (U32 val) 659put_w (UV val)
555{ 660{
556 need (5); // we only handle up to 5 bytes 661 need (5); // we only handle up to 5 bytes
557 662
558 put_w_nocheck (val); 663 put_w_nocheck (val);
559} 664}
560 665
561static U8 * 666static U8 *
562put_length_at (U32 val, U8 *cur) 667put_length_at (UV val, U8 *cur)
563{ 668{
564 if (val < 0x7fU) 669 if (val < 0x7fU)
565 *cur++ = val; 670 *cur++ = val;
566 else 671 else
567 { 672 {
568 U8 *lenb = cur++; 673 U8 *lenb = cur++;
569 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
570 *cur = val >> 24; cur += *cur > 0; 681 *cur = val >> 24; cur += *cur > 0;
571 *cur = val >> 16; cur += *cur > 0; 682 *cur = val >> 16; cur += *cur > 0;
572 *cur = val >> 8; cur += *cur > 0; 683 *cur = val >> 8; cur += *cur > 0;
573 *cur = val ; cur += 1; 684 *cur = val ; cur += 1;
574 685
… …
577 688
578 return cur; 689 return cur;
579} 690}
580 691
581static void 692static void
582put_length (U32 val) 693put_length (UV val)
583{ 694{
584 need (5); 695 need (5 + val);
585 cur = put_length_at (val, cur); 696 cur = put_length_at (val, cur);
586} 697}
587 698
588// return how many bytes the encoded length requires 699// return how many bytes the encoded length requires
589static int length_length (U32 val) 700static int length_length (UV val)
590{ 701{
591 return val < 0x7fU 702 return val < 0x7fU
592 ? 1 703 ? 1
593 : 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 ;
594} 715}
595 716
596static void 717static void
597encode_data (const char *ptr, STRLEN len) 718encode_data (const char *ptr, STRLEN len)
598{ 719{
599 put_length (len); 720 put_length (len);
600 need (len);
601 memcpy (cur, ptr, len); 721 memcpy (cur, ptr, len);
602 cur += len; 722 cur += len;
603} 723}
604 724
605static void 725static void
… …
661 781
662 *lenb = cur - lenb - 1; 782 *lenb = cur - lenb - 1;
663} 783}
664 784
665// we don't know the length yet, so we optimistically 785// we don't know the length yet, so we optimistically
666// assume the length will need one octet later. if that 786// assume the length will need one octet later. If that
667// turns out to be wrong, we memove as needed. 787// turns out to be wrong, we memmove as needed.
668// mark the beginning 788// mark the beginning
669static STRLEN 789static STRLEN
670len_fixup_mark () 790len_fixup_mark (void)
671{ 791{
672 return cur++ - buf; 792 return cur++ - buf;
673} 793}
674 794
675// patch up the length 795// patch up the length
… …
751 871
752 return (AV *)rv; 872 return (AV *)rv;
753} 873}
754 874
755static void 875static void
876encode_ucs (SV *data, int chrsize)
877{
878 STRLEN uchars = sv_len_utf8 (data);
879 STRLEN len;;
880 char *ptr = SvPVutf8 (data, len);
881
882 put_length (uchars * chrsize);
883
884 while (uchars--)
885 {
886 STRLEN uclen;
887 UV uchr = utf8_to_uvchr_buf ((U8 *)ptr, (U8 *)ptr + len, &uclen);
888
889 ptr += uclen;
890 len -= uclen;
891
892 if (chrsize == 4)
893 {
894 *cur++ = uchr >> 24;
895 *cur++ = uchr >> 16;
896 }
897
898 *cur++ = uchr >> 8;
899 *cur++ = uchr;
900 }
901}
902static void
756encode_ber (SV *tuple) 903encode_ber (SV *tuple)
757{ 904{
758 AV *av = ber_tuple (tuple); 905 AV *av = ber_tuple (tuple);
759 906
760 int klass = SvIV (AvARRAY (av)[BER_CLASS]); 907 int klass = SvIV (AvARRAY (av)[BER_CLASS]);
761 int tag = SvIV (AvARRAY (av)[BER_TAG]); 908 int tag = SvIV (AvARRAY (av)[BER_TAG]);
762 int constructed = SvIV (AvARRAY (av)[BER_CONSTRUCTED]) ? ASN_CONSTRUCTED : 0; 909 int constructed = SvIV (AvARRAY (av)[BER_FLAGS]) & 1 ? ASN_CONSTRUCTED : 0;
763 SV *data = AvARRAY (av)[BER_DATA]; 910 SV *data = AvARRAY (av)[BER_DATA];
764 911
765 int identifier = (klass << ASN_CLASS_SHIFT) | constructed; 912 int identifier = (klass << ASN_CLASS_SHIFT) | constructed;
766 913
767 if (expect_false (tag >= ASN_TAG_BER)) 914 if (expect_false (tag >= ASN_TAG_BER))
… …
786 int fill = AvFILL (av); 933 int fill = AvFILL (av);
787 934
788 if (expect_false (SvRMAGICAL (av))) 935 if (expect_false (SvRMAGICAL (av)))
789 croak ("BER constructed data must not be tied"); 936 croak ("BER constructed data must not be tied");
790 937
938 int i;
791 for (int i = 0; i <= fill; ++i) 939 for (i = 0; i <= fill; ++i)
792 encode_ber (AvARRAY (av)[i]); 940 encode_ber (AvARRAY (av)[i]);
793 941
794 len_fixup (mark); 942 len_fixup (mark);
795 } 943 }
796 else 944 else
… …
800 put_length (0); 948 put_length (0);
801 break; 949 break;
802 950
803 case BER_TYPE_BOOL: 951 case BER_TYPE_BOOL:
804 put_length (1); 952 put_length (1);
805 put_u8 (SvTRUE (data) ? 0xff : 0x00); 953 *cur++ = SvTRUE (data) ? 0xff : 0x00; // 0xff = DER/CER
806 break; 954 break;
807 955
808 case BER_TYPE_OID: 956 case BER_TYPE_OID:
809 encode_oid (data, 0); 957 encode_oid (data, 0);
810 break; 958 break;
… …
831 const char *ptr = SvPVutf8 (data, len); 979 const char *ptr = SvPVutf8 (data, len);
832 encode_data (ptr, len); 980 encode_data (ptr, len);
833 } 981 }
834 break; 982 break;
835 983
984 case BER_TYPE_IPADDRESS:
985 {
986 U8 ip[4];
987 sscanf (SvPV_nolen (data), "%hhu.%hhu.%hhu.%hhu", ip + 0, ip + 1, ip + 2, ip + 3);
988 encode_data ((const char *)ip, sizeof (ip));
989 }
990 break;
991
992 case BER_TYPE_UCS2:
993 encode_ucs (data, 2);
994 break;
995
996 case BER_TYPE_UCS4:
997 encode_ucs (data, 4);
998 break;
999
836 case BER_TYPE_REAL: 1000 case BER_TYPE_REAL:
837 case BER_TYPE_UCS2:
838 case BER_TYPE_UCS4:
839 case BER_TYPE_CROAK: 1001 case BER_TYPE_CROAK:
840 default: 1002 default:
841 croak ("unconfigured/unsupported class/tag %d/%d", klass, tag); 1003 croak ("unconfigured/unsupported class/tag %d/%d", klass, tag);
842 } 1004 }
843 1005
… …
859 const char *name; 1021 const char *name;
860 IV iv; 1022 IV iv;
861 } *civ, const_iv[] = { 1023 } *civ, const_iv[] = {
862#define const_iv(name) { # name, name }, 1024#define const_iv(name) { # name, name },
863 const_iv (ASN_BOOLEAN) 1025 const_iv (ASN_BOOLEAN)
864 const_iv (ASN_INTEGER32) 1026 const_iv (ASN_INTEGER)
865 const_iv (ASN_BIT_STRING) 1027 const_iv (ASN_BIT_STRING)
866 const_iv (ASN_OCTET_STRING) 1028 const_iv (ASN_OCTET_STRING)
867 const_iv (ASN_NULL) 1029 const_iv (ASN_NULL)
868 const_iv (ASN_OBJECT_IDENTIFIER) 1030 const_iv (ASN_OBJECT_IDENTIFIER)
869 const_iv (ASN_OBJECT_DESCRIPTOR) 1031 const_iv (ASN_OBJECT_DESCRIPTOR)
… …
898 const_iv (ASN_CONTEXT) 1060 const_iv (ASN_CONTEXT)
899 const_iv (ASN_PRIVATE) 1061 const_iv (ASN_PRIVATE)
900 1062
901 const_iv (BER_CLASS) 1063 const_iv (BER_CLASS)
902 const_iv (BER_TAG) 1064 const_iv (BER_TAG)
903 const_iv (BER_CONSTRUCTED) 1065 const_iv (BER_FLAGS)
904 const_iv (BER_DATA) 1066 const_iv (BER_DATA)
905 1067
906 const_iv (BER_TYPE_BYTES) 1068 const_iv (BER_TYPE_BYTES)
907 const_iv (BER_TYPE_UTF8) 1069 const_iv (BER_TYPE_UTF8)
908 const_iv (BER_TYPE_UCS2) 1070 const_iv (BER_TYPE_UCS2)
… …
911 const_iv (BER_TYPE_OID) 1073 const_iv (BER_TYPE_OID)
912 const_iv (BER_TYPE_RELOID) 1074 const_iv (BER_TYPE_RELOID)
913 const_iv (BER_TYPE_NULL) 1075 const_iv (BER_TYPE_NULL)
914 const_iv (BER_TYPE_BOOL) 1076 const_iv (BER_TYPE_BOOL)
915 const_iv (BER_TYPE_REAL) 1077 const_iv (BER_TYPE_REAL)
1078 const_iv (BER_TYPE_IPADDRESS)
916 const_iv (BER_TYPE_CROAK) 1079 const_iv (BER_TYPE_CROAK)
917 1080
918 const_iv (SNMP_IPADDRESS) 1081 const_iv (SNMP_IPADDRESS)
919 const_iv (SNMP_COUNTER32) 1082 const_iv (SNMP_COUNTER32)
920 const_iv (SNMP_UNSIGNED32) 1083 const_iv (SNMP_UNSIGNED32)
921 const_iv (SNMP_TIMETICKS) 1084 const_iv (SNMP_TIMETICKS)
922 const_iv (SNMP_OPAQUE) 1085 const_iv (SNMP_OPAQUE)
923 const_iv (SNMP_COUNTER64) 1086 const_iv (SNMP_COUNTER64)
924
925 }; 1087 };
926 1088
927 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ > const_iv; civ--) 1089 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)); 1090 newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
929
930 default_profile = profile_new ();
931} 1091}
932 1092
933SV * 1093SV *
934ber_decode (SV *ber, SV *profile = &PL_sv_undef) 1094ber_decode (SV *ber, SV *profile = &PL_sv_undef)
935 CODE: 1095 CODE:
936{ 1096{
937 cur_profile = SvPROFILE (profile); 1097 cur_profile = SvPROFILE (profile);
938 STRLEN len; 1098 STRLEN len;
939 buf = SvPVbyte (ber, len); 1099 buf = (U8 *)SvPVbyte (ber, len);
940 cur = buf; 1100 cur = buf;
941 end = buf + len; 1101 end = buf + len;
942 1102
943 RETVAL = decode_ber (); 1103 RETVAL = decode_ber ();
944} 1104}
945 OUTPUT: RETVAL 1105 OUTPUT: RETVAL
946 1106
947void 1107void
948ber_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)
949 PPCODE: 1109 PPCODE:
950{ 1110{
951 if (!SvOK (tuple)) 1111 if (!SvOK (tuple))
952 XSRETURN_NO; 1112 XSRETURN_NO;
953 1113
… …
955 croak ("ber_is: tuple must be BER tuple (array-ref)"); 1115 croak ("ber_is: tuple must be BER tuple (array-ref)");
956 1116
957 AV *av = (AV *)SvRV (tuple); 1117 AV *av = (AV *)SvRV (tuple);
958 1118
959 XPUSHs ( 1119 XPUSHs (
960 (!SvOK (klass) || SvIV (AvARRAY (av)[BER_CLASS ]) == SvIV (klass)) 1120 (!SvOK (klass) || SvIV (AvARRAY (av)[BER_CLASS]) == SvIV (klass))
961 && (!SvOK (tag) || SvIV (AvARRAY (av)[BER_TAG ]) == SvIV (tag)) 1121 && (!SvOK (tag) || SvIV (AvARRAY (av)[BER_TAG ]) == SvIV (tag))
962 && (!SvOK (constructed) || !SvIV (AvARRAY (av)[BER_CONSTRUCTED]) == !SvIV (constructed)) 1122 && (!SvOK (flags) || !SvIV (AvARRAY (av)[BER_FLAGS]) == !SvIV (flags))
963 && (!SvOK (data) || sv_eq (AvARRAY (av)[BER_DATA ], data)) 1123 && (!SvOK (data) || sv_eq (AvARRAY (av)[BER_DATA ], data))
964 ? &PL_sv_yes : &PL_sv_undef); 1124 ? &PL_sv_yes : &PL_sv_undef);
965} 1125}
966 1126
967void 1127void
968ber_is_seq (SV *tuple) 1128ber_is_seq (SV *tuple)
… …
972 XSRETURN_UNDEF; 1132 XSRETURN_UNDEF;
973 1133
974 AV *av = ber_tuple (tuple); 1134 AV *av = ber_tuple (tuple);
975 1135
976 XPUSHs ( 1136 XPUSHs (
977 SvIV (AvARRAY (av)[BER_CLASS ]) == ASN_UNIVERSAL 1137 SvIV (AvARRAY (av)[BER_CLASS]) == ASN_UNIVERSAL
978 && SvIV (AvARRAY (av)[BER_TAG ]) == ASN_SEQUENCE 1138 && SvIV (AvARRAY (av)[BER_TAG ]) == ASN_SEQUENCE
979 && SvIV (AvARRAY (av)[BER_CONSTRUCTED]) 1139 && SvIV (AvARRAY (av)[BER_FLAGS])
980 ? AvARRAY (av)[BER_DATA] : &PL_sv_undef); 1140 ? AvARRAY (av)[BER_DATA] : &PL_sv_undef);
981} 1141}
982 1142
983void 1143void
984ber_is_i32 (SV *tuple, SV *value = &PL_sv_undef) 1144ber_is_int (SV *tuple, SV *value = &PL_sv_undef)
985 PPCODE: 1145 PPCODE:
986{ 1146{
987 if (!SvOK (tuple)) 1147 if (!SvOK (tuple))
988 XSRETURN_NO; 1148 XSRETURN_NO;
989 1149
990 AV *av = ber_tuple (tuple); 1150 AV *av = ber_tuple (tuple);
991 1151
992 IV data = SvIV (AvARRAY (av)[BER_DATA]); 1152 UV data = SvUV (AvARRAY (av)[BER_DATA]);
993 1153
994 XPUSHs ( 1154 XPUSHs (
995 SvIV (AvARRAY (av)[BER_CLASS ]) == ASN_UNIVERSAL 1155 SvIV (AvARRAY (av)[BER_CLASS]) == ASN_UNIVERSAL
996 && SvIV (AvARRAY (av)[BER_TAG ]) == ASN_INTEGER32 1156 && SvIV (AvARRAY (av)[BER_TAG ]) == ASN_INTEGER
997 && !SvIV (AvARRAY (av)[BER_CONSTRUCTED]) 1157 && !SvIV (AvARRAY (av)[BER_FLAGS])
998 && (!SvOK (value) || data == SvIV (value)) 1158 && (!SvOK (value) || data == SvUV (value))
999 ? sv_2mortal (data ? newSViv (data) : newSVpv ("0 but true", 0)) 1159 ? sv_2mortal (data ? newSVsv (AvARRAY (av)[BER_DATA]) : newSVpv ("0 but true", 0))
1000 : &PL_sv_undef); 1160 : &PL_sv_undef);
1001} 1161}
1002 1162
1003void 1163void
1004ber_is_oid (SV *tuple, SV *oid = &PL_sv_undef) 1164ber_is_oid (SV *tuple, SV *oid = &PL_sv_undef)
… …
1008 XSRETURN_NO; 1168 XSRETURN_NO;
1009 1169
1010 AV *av = ber_tuple (tuple); 1170 AV *av = ber_tuple (tuple);
1011 1171
1012 XPUSHs ( 1172 XPUSHs (
1013 SvIV (AvARRAY (av)[BER_CLASS ]) == ASN_UNIVERSAL 1173 SvIV (AvARRAY (av)[BER_CLASS]) == ASN_UNIVERSAL
1014 && SvIV (AvARRAY (av)[BER_TAG ]) == ASN_OBJECT_IDENTIFIER 1174 && SvIV (AvARRAY (av)[BER_TAG ]) == ASN_OBJECT_IDENTIFIER
1015 && !SvIV (AvARRAY (av)[BER_CONSTRUCTED]) 1175 && !SvIV (AvARRAY (av)[BER_FLAGS])
1016 && (!SvOK (oid) || sv_eq (AvARRAY (av)[BER_DATA], oid)) 1176 && (!SvOK (oid) || sv_eq (AvARRAY (av)[BER_DATA], oid))
1017 ? newSVsv (AvARRAY (av)[BER_DATA]) : &PL_sv_undef); 1177 ? newSVsv (AvARRAY (av)[BER_DATA]) : &PL_sv_undef);
1018} 1178}
1019 1179
1020############################################################################# 1180#############################################################################
… …
1033 SvCUR_set (buf_sv, cur - buf); 1193 SvCUR_set (buf_sv, cur - buf);
1034 XPUSHs (buf_sv); 1194 XPUSHs (buf_sv);
1035} 1195}
1036 1196
1037SV * 1197SV *
1038ber_i32 (IV iv) 1198ber_int (SV *sv)
1039 CODE: 1199 CODE:
1040{ 1200{
1041 AV *av = newAV (); 1201 AV *av = newAV ();
1042 av_fill (av, BER_ARRAYSIZE - 1); 1202 av_fill (av, BER_ARRAYSIZE - 1);
1043 AvARRAY (av)[BER_CLASS ] = newSVcacheint (ASN_UNIVERSAL); 1203 AvARRAY (av)[BER_CLASS] = newSVcacheint (ASN_UNIVERSAL);
1044 AvARRAY (av)[BER_TAG ] = newSVcacheint (ASN_INTEGER32); 1204 AvARRAY (av)[BER_TAG ] = newSVcacheint (ASN_INTEGER);
1045 AvARRAY (av)[BER_CONSTRUCTED] = newSVcacheint (0); 1205 AvARRAY (av)[BER_FLAGS] = newSVcacheint (0);
1046 AvARRAY (av)[BER_DATA ] = newSViv (iv); 1206 AvARRAY (av)[BER_DATA ] = newSVsv (sv);
1047 RETVAL = newRV_noinc ((SV *)av); 1207 RETVAL = newRV_noinc ((SV *)av);
1048} 1208}
1049 OUTPUT: RETVAL 1209 OUTPUT: RETVAL
1050 1210
1051# TODO: not arrayref, but elements? 1211# TODO: not arrayref, but elements?
… …
1053ber_seq (SV *arrayref) 1213ber_seq (SV *arrayref)
1054 CODE: 1214 CODE:
1055{ 1215{
1056 AV *av = newAV (); 1216 AV *av = newAV ();
1057 av_fill (av, BER_ARRAYSIZE - 1); 1217 av_fill (av, BER_ARRAYSIZE - 1);
1058 AvARRAY (av)[BER_CLASS ] = newSVcacheint (ASN_UNIVERSAL); 1218 AvARRAY (av)[BER_CLASS] = newSVcacheint (ASN_UNIVERSAL);
1059 AvARRAY (av)[BER_TAG ] = newSVcacheint (ASN_SEQUENCE); 1219 AvARRAY (av)[BER_TAG ] = newSVcacheint (ASN_SEQUENCE);
1060 AvARRAY (av)[BER_CONSTRUCTED] = newSVcacheint (1); 1220 AvARRAY (av)[BER_FLAGS] = newSVcacheint (1);
1061 AvARRAY (av)[BER_DATA ] = newSVsv (arrayref); 1221 AvARRAY (av)[BER_DATA ] = newSVsv (arrayref);
1062 RETVAL = newRV_noinc ((SV *)av); 1222 RETVAL = newRV_noinc ((SV *)av);
1063} 1223}
1064 OUTPUT: RETVAL 1224 OUTPUT: RETVAL
1065 1225
1066MODULE = Convert::BER::XS PACKAGE = Convert::BER::XS::Profile 1226MODULE = Convert::BER::XS PACKAGE = Convert::BER::XS::Profile
… …
1069new (SV *klass) 1229new (SV *klass)
1070 CODE: 1230 CODE:
1071 RETVAL = profile_new (); 1231 RETVAL = profile_new ();
1072 OUTPUT: RETVAL 1232 OUTPUT: RETVAL
1073 1233
1234void
1235set (SV *profile, int klass, int tag, int type)
1236 CODE:
1237 profile_set (SvPROFILE (profile), klass, tag, type);
1238
1239IV
1240get (SV *profile, int klass, int tag)
1241 CODE:
1242 RETVAL = profile_lookup (SvPROFILE (profile), klass, tag);
1243 OUTPUT: RETVAL
1244
1245void
1246_set_default (SV *profile)
1247 CODE:
1248 default_profile = SvPROFILE (profile);
1249
1250

Diff Legend

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