[ViewVC] Diff of: cvs/Convert-BER-XS/XS.xs

Comparing Convert-BER-XS/XS.xs (file contents):
Revision 1.4 by root, Fri Apr 19 20:38:38 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
7	enum {	10	enum {
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_BMPSTRING = 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
46	ASN_CONSTRUCTED = 0x20,	49	ASN_CONSTRUCTED = 0x20,
47		50
48	// ASN_CLASS	51	// ASN_CLASS
49	ASN_UNIVERSAL = 0x00,	52	ASN_UNIVERSAL = 0x00,
50	ASN_APPLICATION = 0x40,	53	ASN_APPLICATION = 0x01,
51	ASN_CONTEXT = 0x80,	54	ASN_CONTEXT = 0x02,
52	ASN_PRIVATE = 0xc0,	55	ASN_PRIVATE = 0x03,
53		56
54	ASN_CLASS_MASK = 0xc0,	57	ASN_CLASS_MASK = 0xc0,
55	ASN_CLASS_SHIFT = 6,	58	ASN_CLASS_SHIFT = 6,
56		59
57	// ASN_APPLICATION SNMP	60	// ASN_APPLICATION SNMP
62	SNMP_OPAQUE = 0x04,	65	SNMP_OPAQUE = 0x04,
63	SNMP_COUNTER64 = 0x06,	66	SNMP_COUNTER64 = 0x06,
64	};	67	};
65		68
66	enum {	69	enum {
		70	BER_TYPE_BYTES,
		71	BER_TYPE_UTF8,
		72	BER_TYPE_UCS2,
		73	BER_TYPE_UCS4,
		74	BER_TYPE_INT,
		75	BER_TYPE_OID,
		76	BER_TYPE_RELOID,
		77	BER_TYPE_NULL,
		78	BER_TYPE_BOOL,
		79	BER_TYPE_REAL,
		80	BER_TYPE_IPADDRESS,
		81	BER_TYPE_CROAK,
		82	};
		83
		84	enum {
67	BER_CLASS = 0,	85	BER_CLASS = 0,
68	BER_TAG = 1,	86	BER_TAG = 1,
69	BER_CONSTRUCTED = 2,	87	BER_FLAGS = 2,
70	BER_DATA = 3,	88	BER_DATA = 3,
71	BER_ARRAYSIZE	89	BER_ARRAYSIZE
72	};	90	};
73		91
74	#define MAX_OID_STRLEN 4096	92	#define MAX_OID_STRLEN 4096
75		93
		94	typedef void profile_type;
		95
		96	static profile_type cur_profile, default_profile;
76	static SV *buf_sv; // encoding buffer	97	static SV *buf_sv; // encoding buffer
77	static U8 buf, cur, *end; // buffer start, current, end	98	static 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
78		103
79	#if __GNUC__ >= 3	104	#if __GNUC__ >= 3
80	# define expect(expr,value) __builtin_expect ((expr), (value))	105	# define expect(expr,value) __builtin_expect ((expr), (value))
81	# define INLINE static inline	106	# define INLINE static inline
82	#else	107	#else
…		…
85	#endif	110	#endif
86		111
87	#define expect_false(expr) expect ((expr) != 0, 0)	112	#define expect_false(expr) expect ((expr) != 0, 0)
88	#define expect_true(expr) expect ((expr) != 0, 1)	113	#define expect_true(expr) expect ((expr) != 0, 1)
89		114
		115	/////////////////////////////////////////////////////////////////////////////
		116
		117	static SV *sviv_cache[32];
		118
90	// for "small" integers, return a readonly sv, otherwise create a new one	119	// for "small" integers, return a readonly sv, otherwise create a new one
91	static SV *newSVcacheint (int val)	120	static SV *newSVcacheint (int val)
92	{	121	{
93	static SV *cache[32];
94
95	if (expect_false (val < 0 \|\| val >= sizeof (cache)))	122	if (expect_false (val < 0 \|\| val >= sizeof (sviv_cache)))
96	return newSViv (val);	123	return newSViv (val);
97		124
98	if (expect_false (!cache [val]))	125	if (expect_false (!sviv_cache [val]))
99	{	126	{
100	cache [val] = newSVuv (val);	127	sviv_cache [val] = newSVuv (val);
101	SvREADONLY_on (cache [val]);	128	SvREADONLY_on (sviv_cache [val]);
102	}	129	}
103		130
104	return SvREFCNT_inc_NN (cache [val]);	131	return SvREFCNT_inc_NN (sviv_cache [val]);
		132	}
		133
		134	/////////////////////////////////////////////////////////////////////////////
		135
		136	static HV *profile_stash;
		137
		138	static profile_type *
		139	SvPROFILE (SV *profile)
		140	{
		141	if (!SvOK (profile))
		142	return default_profile;
		143
		144	if (!SvROK (profile))
		145	croak ("invalid profile");
		146
		147	profile = SvRV (profile);
		148
		149	if (SvSTASH (profile) != profile_stash)
		150	croak ("invalid profile object");
		151
		152	return (void *)profile;
		153	}
		154
		155	static int
		156	profile_lookup (profile_type *profile, int klass, int tag)
		157	{
		158	SV sv = (SV )profile;
		159	U32 idx = (tag << 2) + klass;
		160
		161	if (expect_false (idx >= SvCUR (sv)))
		162	return BER_TYPE_BYTES;
		163
		164	return SvPVX (sv)[idx];
		165	}
		166
		167	static void
		168	profile_set (profile_type *profile, int klass, int tag, int type)
		169	{
		170	SV sv = (SV )profile;
		171	U32 idx = (tag << 2) + klass;
		172	STRLEN oldlen = SvCUR (sv);
		173	STRLEN newlen = idx + 2;
		174
		175	if (idx >= oldlen)
		176	{
		177	sv_grow (sv, newlen);
		178	memset (SvPVX (sv) + oldlen, BER_TYPE_BYTES, newlen - oldlen);
		179	SvCUR_set (sv, newlen);
		180	}
		181
		182	SvPVX (sv)[idx] = type;
		183	}
		184
		185	static SV *
		186	profile_new (void)
		187	{
		188	SV *sv = newSVpvn ("", 0);
		189
		190	static const struct {
		191	int klass;
		192	int tag;
		193	int type;
		194	} *celem, default_map[] = {
		195	{ ASN_UNIVERSAL, ASN_BOOLEAN , BER_TYPE_BOOL },
		196	{ ASN_UNIVERSAL, ASN_INTEGER , BER_TYPE_INT },
		197	{ ASN_UNIVERSAL, ASN_NULL , BER_TYPE_NULL },
		198	{ ASN_UNIVERSAL, ASN_OBJECT_IDENTIFIER, BER_TYPE_OID },
		199	{ ASN_UNIVERSAL, ASN_RELATIVE_OID , BER_TYPE_RELOID },
		200	{ ASN_UNIVERSAL, ASN_REAL , BER_TYPE_REAL },
		201	{ ASN_UNIVERSAL, ASN_ENUMERATED , BER_TYPE_INT },
		202	{ ASN_UNIVERSAL, ASN_UTF8_STRING , BER_TYPE_UTF8 },
		203	{ ASN_UNIVERSAL, ASN_BMP_STRING , BER_TYPE_UCS2 },
		204	{ ASN_UNIVERSAL, ASN_UNIVERSAL_STRING , BER_TYPE_UCS4 },
		205	};
		206
		207	for (celem = default_map + sizeof (default_map) / sizeof (default_map [0]); celem-- > default_map; )
		208	profile_set ((profile_type *)sv, celem->klass, celem->tag, celem->type);
		209
		210	return sv_bless (newRV_noinc (sv), profile_stash);
105	}	211	}
106		212
107	/////////////////////////////////////////////////////////////////////////////	213	/////////////////////////////////////////////////////////////////////////////
108	// decoder	214	// decoder
109		215
…		…
142		248
143	return *cur++;	249	return *cur++;
144	}	250	}
145		251
146	// get ber-encoded integer (i.e. pack "w")	252	// get ber-encoded integer (i.e. pack "w")
147	static U32	253	static UV
148	get_w (void)	254	get_w (void)
149	{	255	{
150	U32 res = 0;	256	UV res = 0;
151		257
152	for (;;)	258	for (;;)
153	{	259	{
154	U8 c = get_u8 ();	260	U8 c = get_u8 ();
155	res = (res << 7) \| (c & 0x7f);	261	res = (res << 7) \| (c & 0x7f);
…		…
157	if (!(c & 0x80))	263	if (!(c & 0x80))
158	return res;	264	return res;
159	}	265	}
160	}	266	}
161		267
		268	// get_w, but disallow padding
162	static U32	269	static UV
		270	get_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
		282	static UV
163	get_length (void)	283	get_length (void)
164	{	284	{
165	U32 res = get_u8 ();	285	UV res = get_u8 ();
166		286
167	if (res & 0x80)	287	if (res & 0x80)
168	{	288	{
169	int cnt = res & 0x7f;	289	int cnt = res & 0x7f;
170	res = 0;	290	res = 0;
…		…
173	{	293	{
174	case 0:	294	case 0:
175	error ("indefinite ASN.1 lengths not supported");	295	error ("indefinite ASN.1 lengths not supported");
176	return 0;	296	return 0;
177		297
		298	//case 0x80: // indefinite length
		299
		300	//case 0xff: reserved
178	default:	301	default:
179	error ("ASN.1 length too long");	302	error ("ASN.1 length too long");
180	return 0;	303	return 0;
181		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 ();
182	case 4: res = (res << 8) \| get_u8 ();	309	case 4: res = (res << 8) \| get_u8 ();
183	case 3: res = (res << 8) \| get_u8 ();	310	case 3: res = (res << 8) \| get_u8 ();
184	case 2: res = (res << 8) \| get_u8 ();	311	case 2: res = (res << 8) \| get_u8 ();
185	case 1: res = (res << 8) \| get_u8 ();	312	case 1: res = (res << 8) \| get_u8 ();
186	}	313	}
187	}	314	}
188		315
189	return res;	316	return res;
190	}	317	}
191		318
192	static U32	319	static SV *
193	get_integer32 (void)	320	decode_int (void)
194	{	321	{
195	U32 length = get_length ();	322	UV len = get_length ();
196		323
197	if (length <= 0)	324	if (!len)
198	{	325	{
199	error ("INTEGER32 length equal to zero");	326	error ("invalid integer length equal to zero");
200	return 0;	327	return 0;
201	}	328	}
202		329
203	U8 *data = get_n (length);	330	U8 *data = get_n (len);
204		331
205	if (length > 5 \|\| (length > 4 && data [0]))	332	int negative = data [0] & 0x80;
206	{
207	error ("INTEGER32 length too long");
208	return 0;
209	}
210		333
211	U32 res = data [0] & 0x80 ? 0xffffffff : 0;	334	UV val = negative ? -1 : 0; // copy signbit to all bits
212		335
213	while (length--)	336	do
214	res = (res << 8) \| *data++;	337	val = (val << 8) \| *data++;
		338	while (--len);
215		339
216	return res;	340	// the cast to IV relies on implementation-defined behaviour (two's complement cast)
		341	// but that's ok, as perl relies on it as well.
		342	return negative ? newSViv ((IV)val) : newSVuv (val);
217	}	343	}
218		344
219	static SV *	345	static SV *
220	decode_integer32 (void)	346	decode_data (void)
221	{	347	{
222	return newSViv ((I32)get_integer32 ());
223	}
224
225	static SV *
226	decode_unsigned32 (void)
227	{
228	return newSVuv ((U32)get_integer32 ());
229	}
230
231	#if IVSIZE >= 8
232
233	static U64TYPE
234	get_integer64 (void)
235	{
236	U32 length = get_length ();	348	UV len = get_length ();
237		349	return newSVpvn ((char *)get_n (len), len);
238	if (length <= 0)
239	{
240	error ("INTEGER64 length equal to zero");
241	return 0;
242	}
243
244	U8 *data = get_n (length);
245
246	if (length > 9 \|\| (length > 8 && data [0]))
247	{
248	error ("INTEGER64 length too long");
249	return 0;
250	}
251
252	U64TYPE res = data [0] & 0x80 ? 0xffffffffffffffff : 0;
253
254	while (length--)
255	res = (res << 8) \| *data++;
256
257	return res;
258	}	350	}
259		351
260	static SV *
261	decode_integer64 (void)
262	{
263	return newSViv ((I64TYPE)get_integer64 ());
264	}
265
266	static SV *
267	decode_unsigned64 (void)
268	{
269	return newSVuv ((U64TYPE)get_integer64 ());
270	}
271
272	#endif
273
274	static SV *
275	decode_octet_string (void)
276	{
277	U32 length = get_length ();
278	U8 *data = get_n (length);
279	return newSVpvn (data, length);
280	}
281
282	// gelper for decode_object_identifier	352	// helper for decode_object_identifier
283	static char *	353	static char *
284	write_uv (char *buf, U32 u)	354	write_uv (char *buf, UV u)
285	{	355	{
286	// 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)
287	if (u < 10)	357	if (expect_true (u < 10))
288	*buf++ = u + '0';	358	*buf++ = u + '0';
289	else	359	else
290	{	360	{
		361	// this could be done much faster using branchless fixed-point arithmetics
291	char *beg = buf;	362	char *beg = buf;
292		363
293	do	364	do
294	{	365	{
295	*buf++ = u % 10 + '0';	366	*buf++ = u % 10 + '0';
296	u /= 10;	367	u /= 10;
297	}	368	}
298	while (u);	369	while (u);
299		370
300	// reverse digits	371	// reverse digits
301	for (char *ptr = buf; --ptr != beg; ++beg)	372	char *ptr = buf;
		373	while (--ptr > beg)
302	{	374	{
303	char c = *ptr;	375	char c = *ptr;
304	ptr = beg;	376	ptr = beg;
305	*beg = c;	377	*beg = c;
		378	++beg;
306	}	379	}
307	}	380	}
308		381
309	return buf;	382	return buf;
310	}	383	}
311		384
312	static SV *	385	static SV *
313	decode_object_identifier (void)	386	decode_oid (int relative)
314	{	387	{
315	U32 length = get_length ();	388	UV len = get_length ();
316		389
317	if (length <= 0)	390	if (len <= 0)
318	{	391	{
319	error ("OBJECT IDENTIFIER length equal to zero");	392	error ("OBJECT IDENTIFIER length equal to zero");
320	return &PL_sv_undef;	393	return &PL_sv_undef;
321	}	394	}
322		395
323	U8 *end = cur + length;	396	U8 *end = cur + len;
324	U32 w = get_w ();	397	UV w = get_w_nopad ();
325		398
326	static char oid[MAX_OID_STRLEN]; // must be static	399	static char oid[MAX_OID_STRLEN]; // static, becaueds too large for stack
327	char *app = oid;	400	char *app = oid;
328		401
		402	if (relative)
		403	app = write_uv (app, w);
		404	else if (w < 2 * 40)
		405	{
329	app = write_uv (app, (U8)w / 40);	406	app = write_uv (app, (U8)w / 40);
330	*app++ = '.';	407	*app++ = '.';
331	app = write_uv (app, (U8)w % 40);	408	app = write_uv (app, (U8)w % 40);
		409	}
		410	else
		411	{
		412	app = write_uv (app, 2);
		413	*app++ = '.';
		414	app = write_uv (app, w - 2 * 40);
		415	}
332		416
		417	while (cur < end)
		418	{
333	// we assume an oid component is never > 64 bytes	419	// we assume an oid component is never > 64 digits
334	while (cur < end && oid + sizeof (oid) - app > 64)	420	if (oid + sizeof (oid) - app < 64)
335	{	421	croak ("BER_TYPE_OID to long to decode");
		422
336	w = get_w ();	423	w = get_w_nopad ();
337	*app++ = '.';	424	*app++ = '.';
338	app = write_uv (app, w);	425	app = write_uv (app, w);
339	}	426	}
340		427
341	return newSVpvn (oid, app - oid);	428	return newSVpvn (oid, app - oid);
342	}	429	}
343		430
		431	// TODO: this is unacceptably slow
344	static SV *	432	static SV *
		433	decode_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
		467	static SV *
345	decode_ber ()	468	decode_ber (void)
346	{	469	{
347	int identifier = get_u8 ();	470	int identifier = get_u8 ();
348		471
349	SV *res;	472	SV *res;
350		473
351	int constructed = identifier & ASN_CONSTRUCTED;	474	int constructed = identifier & ASN_CONSTRUCTED;
352	int klass = identifier & ASN_CLASS_MASK;	475	int klass = (identifier & ASN_CLASS_MASK) >> ASN_CLASS_SHIFT;
353	int tag = identifier & ASN_TAG_MASK;	476	int tag = identifier & ASN_TAG_MASK;
354		477
355	if (tag == ASN_TAG_BER)	478	if (tag == ASN_TAG_BER)
356	tag = get_w ();	479	tag = get_w ();
357		480
358	if (tag == ASN_TAG_BER)	481	if (tag == ASN_TAG_BER)
359	tag = get_w ();	482	tag = get_w ();
360		483
361	if (constructed)	484	if (constructed)
362	{	485	{
363	U32 len = get_length ();	486	UV len = get_length ();
364	U32 seqend = (cur - buf) + len;	487	UV seqend = (cur - buf) + len;
365	AV av = (AV )sv_2mortal ((SV *)newAV ());	488	AV av = (AV )sv_2mortal ((SV *)newAV ());
366		489
367	while (cur < buf + seqend)	490	while (cur < buf + seqend)
368	av_push (av, decode_ber ());	491	av_push (av, decode_ber ());
369		492
…		…
371	croak ("constructed type %02x overflow (%x %x)\n", identifier, cur - buf, seqend);	494	croak ("constructed type %02x overflow (%x %x)\n", identifier, cur - buf, seqend);
372		495
373	res = newRV_inc ((SV *)av);	496	res = newRV_inc ((SV *)av);
374	}	497	}
375	else	498	else
376	switch (identifier)	499	switch (profile_lookup (cur_profile, klass, tag))
377	{	500	{
378	case ASN_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
379	res = &PL_sv_undef;	508	res = &PL_sv_undef;
		509	}
380	break;	510	break;
381		511
382	case ASN_OBJECT_IDENTIFIER:	512	case BER_TYPE_BOOL:
		513	{
		514	UV len = get_length ();
		515
		516	if (len != 1)
		517	croak ("BER_TYPE_BOOLEAN value with invalid length %d encountered", len);
		518
		519	res = newSVcacheint (!!get_u8 ());
		520	}
		521	break;
		522
		523	case BER_TYPE_OID:
383	res = decode_object_identifier ();	524	res = decode_oid (0);
384	break;	525	break;
385		526
386	case ASN_INTEGER32:	527	case BER_TYPE_RELOID:
		528	res = decode_oid (1);
		529	break;
		530
		531	case BER_TYPE_INT:
387	res = decode_integer32 ();	532	res = decode_int ();
388	break;	533	break;
389		534
390	case ASN_APPLICATION \| SNMP_UNSIGNED32:	535	case BER_TYPE_UTF8:
391	case ASN_APPLICATION \| SNMP_COUNTER32:	536	res = decode_data ();
392	case ASN_APPLICATION \| SNMP_TIMETICKS:	537	SvUTF8_on (res);
		538	break;
		539
		540	case BER_TYPE_BYTES:
		541	res = decode_data ();
		542	break;
		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:
393	res = decode_unsigned32 ();	565	res = decode_ucs (4);
394	break;	566	break;
395		567
396	#if 0 // handled by default case	568	case BER_TYPE_REAL:
397	case ASN_OCTET_STRING:	569	case BER_TYPE_CROAK:
398	case ASN_APPLICATION \| ASN_IPADDRESS:
399	case ASN_APPLICATION \| ASN_OPAQUE:
400	res = decode_octet_string ();
401	break;
402	#endif
403
404	case ASN_APPLICATION \| SNMP_COUNTER64:
405	res = decode_integer64 ();
406	break;
407
408	default:	570	default:
409	res = decode_octet_string ();	571	croak ("unconfigured/unsupported class/tag %d/%d", klass, tag);
410	break;
411	}	572	}
412		573
413	AV *av = newAV ();	574	AV *av = newAV ();
414	av_fill (av, BER_ARRAYSIZE - 1);	575	av_fill (av, BER_ARRAYSIZE - 1);
415	AvARRAY (av)[BER_CLASS ] = newSVcacheint (klass >> ASN_CLASS_SHIFT);	576	AvARRAY (av)[BER_CLASS] = newSVcacheint (klass);
416	AvARRAY (av)[BER_TAG ] = newSVcacheint (tag);	577	AvARRAY (av)[BER_TAG ] = newSVcacheint (tag);
417	AvARRAY (av)[BER_CONSTRUCTED] = newSVcacheint (constructed ? 1 : 0);	578	AvARRAY (av)[BER_FLAGS] = newSVcacheint (constructed ? 1 : 0);
418	AvARRAY (av)[BER_DATA ] = res;	579	AvARRAY (av)[BER_DATA ] = res;
419		580
420	return newRV_noinc ((SV *)av);	581	return newRV_noinc ((SV *)av);
421	}	582	}
422		583
423	/////////////////////////////////////////////////////////////////////////////	584	/////////////////////////////////////////////////////////////////////////////
…		…
438	static void	599	static void
439	set_buf (SV *sv)	600	set_buf (SV *sv)
440	{	601	{
441	STRLEN len;	602	STRLEN len;
442	buf_sv = sv;	603	buf_sv = sv;
443	buf = SvPVbyte (buf_sv, len);	604	buf = (U8 *)SvPVbyte (buf_sv, len);
444	cur = buf;	605	cur = buf;
445	end = buf + len;	606	end = buf + len;
446	}	607	}
447		608
448	/* similar to SvGROW, but somewhat safer and guarantees exponential realloc strategy */	609	/* similar to SvGROW, but somewhat safer and guarantees exponential realloc strategy */
…		…
462	need (STRLEN len)	623	need (STRLEN len)
463	{	624	{
464	if (expect_false ((uintptr_t)(end - cur) < len))	625	if (expect_false ((uintptr_t)(end - cur) < len))
465	{	626	{
466	STRLEN pos = cur - buf;	627	STRLEN pos = cur - buf;
467	buf = my_sv_grow (buf_sv, pos, len);	628	buf = (U8 *)my_sv_grow (buf_sv, pos, len);
468	cur = buf + pos;	629	cur = buf + pos;
469	end = buf + SvLEN (buf_sv) - 1;	630	end = buf + SvLEN (buf_sv) - 1;
470	}	631	}
471	}	632	}
472		633
…		…
476	need (1);	637	need (1);
477	*cur++ = val;	638	*cur++ = val;
478	}	639	}
479		640
480	static void	641	static void
481	put_w_nocheck (U32 val)	642	put_w_nocheck (UV val)
482	{	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
483	cur = (val >> 7 4) \| 0x80; cur += val >= (1 << (7 * 4));	651	cur = (val >> 7 4) \| 0x80; cur += val >= ((UV)1 << (7 * 4));
484	cur = (val >> 7 3) \| 0x80; cur += val >= (1 << (7 * 3));	652	cur = (val >> 7 3) \| 0x80; cur += val >= ((UV)1 << (7 * 3));
485	cur = (val >> 7 2) \| 0x80; cur += val >= (1 << (7 * 2));	653	cur = (val >> 7 2) \| 0x80; cur += val >= ((UV)1 << (7 * 2));
486	cur = (val >> 7 1) \| 0x80; cur += val >= (1 << (7 * 1));	654	cur = (val >> 7 1) \| 0x80; cur += val >= ((UV)1 << (7 * 1));
487	*cur = val & 0x7f; cur += 1;	655	*cur = val & 0x7f; cur += 1;
488	}	656	}
489		657
490	static void	658	static void
491	put_w (U32 val)	659	put_w (UV val)
492	{	660	{
493	need (5); // we only handle up to 5 bytes	661	need (5); // we only handle up to 5 bytes
494		662
495	put_w_nocheck (val);	663	put_w_nocheck (val);
496	}	664	}
497		665
498	static U8 *	666	static U8 *
499	put_length_at (U32 val, U8 *cur)	667	put_length_at (UV val, U8 *cur)
500	{	668	{
501	if (val < 0x7fU)	669	if (val < 0x7fU)
502	*cur++ = val;	670	*cur++ = val;
503	else	671	else
504	{	672	{
505	U8 *lenb = cur++;	673	U8 *lenb = cur++;
506		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
507	cur = val >> 24; cur += cur > 0;	681	cur = val >> 24; cur += cur > 0;
508	cur = val >> 16; cur += cur > 0;	682	cur = val >> 16; cur += cur > 0;
509	cur = val >> 8; cur += cur > 0;	683	cur = val >> 8; cur += cur > 0;
510	*cur = val ; cur += 1;	684	*cur = val ; cur += 1;
511		685
…		…
514		688
515	return cur;	689	return cur;
516	}	690	}
517		691
518	static void	692	static void
519	put_length (U32 val)	693	put_length (UV val)
520	{	694	{
521	need (5);	695	need (5 + val);
522	cur = put_length_at (val, cur);	696	cur = put_length_at (val, cur);
523	}	697	}
524		698
525	// return how many bytes the encoded length requires	699	// return how many bytes the encoded length requires
526	static int length_length (U32 val)	700	static int length_length (UV val)
527	{	701	{
528	return val < 0x7fU	702	return val < 0x7fU
529	? 1	703	? 1
530	: 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	;
531	}	715	}
532		716
533	static void	717	static void
534	encode_octet_string (SV *sv)	718	encode_data (const char *ptr, STRLEN len)
535	{	719	{
536	STRLEN len;
537	char *ptr = SvPVbyte (sv, len);
538
539	put_length (len);	720	put_length (len);
540	need (len);
541	memcpy (cur, ptr, len);	721	memcpy (cur, ptr, len);
542	cur += len;	722	cur += len;
543	}	723	}
544		724
545	static void	725	static void
546	encode_integer32 (IV iv)	726	encode_uv (UV uv)
547	{	727	{
548	need (5);	728	}
		729
		730	static void
		731	encode_int (SV *sv)
		732	{
		733	need (8 + 1 + 1); // 64 bit + length + extra 0
		734
		735	if (expect_false (!SvIOK (sv)))
		736	sv_2iv_flags (sv, 0);
549		737
550	U8 *lenb = cur++;	738	U8 *lenb = cur++;
551		739
552	if (iv < 0)	740	if (SvIOK_notUV (sv))
553	{	741	{
		742	IV iv = SvIVX (sv);
		743
		744	if (expect_false (iv < 0))
		745	{
554	// get two's complement bit pattern - works even on hypthetical non-2c machines	746	// get two's complement bit pattern - works even on hypothetical non-2c machines
555	U32 uv = iv;	747	UV uv = iv;
556		748
		749	#if UVSIZE > 4
		750	*cur = uv >> 56; cur += !!(~uv & 0xff80000000000000U);
		751	*cur = uv >> 48; cur += !!(~uv & 0xffff800000000000U);
		752	*cur = uv >> 40; cur += !!(~uv & 0xffffff8000000000U);
		753	*cur = uv >> 32; cur += !!(~uv & 0xffffffff80000000U);
		754	#endif
557	*cur = uv >> 24; cur += !!(~uv & 0xff800000U);	755	*cur = uv >> 24; cur += !!(~uv & 0xffffffffff800000U);
558	*cur = uv >> 16; cur += !!(~uv & 0xffff8000U);	756	*cur = uv >> 16; cur += !!(~uv & 0xffffffffffff8000U);
559	*cur = uv >> 8; cur += !!(~uv & 0xffffff80U);	757	*cur = uv >> 8; cur += !!(~uv & 0xffffffffffffff80U);
560	*cur = uv ; cur += 1;	758	*cur = uv ; cur += 1;
561	}	759
562	else	760	*lenb = cur - lenb - 1;
		761
		762	return;
		763	}
563	{	764	}
564	cur = iv >> 24; cur += cur > 0;	765
565	cur = iv >> 16; cur += cur > 0;	766	UV uv = SvUV (sv);
566	cur = iv >> 8; cur += cur > 0;	767
		768	// prepend an extra 0 if the high bit is 1
		769	cur = 0; cur += !!(uv & ((UV)1 << (UVSIZE 8 - 1)));
		770
		771	#if UVSIZE > 4
		772	*cur = uv >> 56; cur += !!(uv & 0xff80000000000000U);
		773	*cur = uv >> 48; cur += !!(uv & 0xffff800000000000U);
		774	*cur = uv >> 40; cur += !!(uv & 0xffffff8000000000U);
		775	*cur = uv >> 32; cur += !!(uv & 0xffffffff80000000U);
		776	#endif
		777	*cur = uv >> 24; cur += !!(uv & 0xffffffffff800000U);
		778	*cur = uv >> 16; cur += !!(uv & 0xffffffffffff8000U);
		779	*cur = uv >> 8; cur += !!(uv & 0xffffffffffffff80U);
567	*cur = iv ; cur += 1;	780	*cur = uv ; cur += 1;
568	}
569		781
570	*lenb = cur - lenb - 1;	782	*lenb = cur - lenb - 1;
571	}	783	}
572		784
573	static void
574	encode_unsigned64 (U64TYPE uv)
575	{
576	need (9);
577
578	U8 *lenb = cur++;
579
580	cur = uv >> 56; cur += cur > 0;
581	cur = uv >> 48; cur += cur > 0;
582	cur = uv >> 40; cur += cur > 0;
583	cur = uv >> 32; cur += cur > 0;
584	cur = uv >> 24; cur += cur > 0;
585	cur = uv >> 16; cur += cur > 0;
586	cur = uv >> 8; cur += cur > 0;
587	*cur = uv ; cur += 1;
588
589	*lenb = cur - lenb - 1;
590	}
591
592	// we don't know the length yet, so we optimistically	785	// we don't know the length yet, so we optimistically
593	// assume the length will need one octet later. if that	786	// assume the length will need one octet later. If that
594	// turns out to be wrong, we memove as needed.	787	// turns out to be wrong, we memmove as needed.
595	// mark the beginning	788	// mark the beginning
596	static STRLEN	789	static STRLEN
597	len_fixup_mark ()	790	len_fixup_mark (void)
598	{	791	{
599	return cur++ - buf;	792	return cur++ - buf;
600	}	793	}
601		794
602	// patch up the length	795	// patch up the length
…		…
631		824
632	return str;	825	return str;
633	}	826	}
634		827
635	static void	828	static void
636	encode_object_identifier (SV *oid)	829	encode_oid (SV *oid, int relative)
637	{	830	{
638	STRLEN slen;	831	STRLEN len;
639	char *ptr = SvPV (oid, slen); // utf8 vs. bytes does not matter	832	char *ptr = SvPV (oid, len); // utf8 vs. bytes does not matter
640		833
641	// we need at most as many octets as the string form	834	// we need at most as many octets as the string form
642	need (slen + 1);	835	need (len + 1);
643	STRLEN mark = len_fixup_mark ();	836	STRLEN mark = len_fixup_mark ();
644		837
645	UV w1, w2;	838	UV w1, w2;
646		839
		840	if (!relative)
		841	{
647	ptr = read_uv (ptr, &w1);	842	ptr = read_uv (ptr, &w1);
648	ptr = read_uv (ptr, &w2);	843	ptr = read_uv (ptr, &w2);
649		844
650	put_w_nocheck (w1 * 40 + w2);	845	put_w_nocheck (w1 * 40 + w2);
		846	}
651		847
652	while (*ptr)	848	while (*ptr)
653	{	849	{
654	ptr = read_uv (ptr, &w1);	850	ptr = read_uv (ptr, &w1);
655	put_w_nocheck (w1);	851	put_w_nocheck (w1);
656	}	852	}
657		853
658	len_fixup (mark);	854	len_fixup (mark);
659	}	855	}
660		856
661	// checkl whether an SV is a BER tuple and returns its AV *	857	// check whether an SV is a BER tuple and returns its AV *
662	static AV *	858	static AV *
663	ber_tuple (SV *tuple)	859	ber_tuple (SV *tuple)
664	{	860	{
665	SV *rv;	861	SV *rv;
666		862
…		…
675		871
676	return (AV *)rv;	872	return (AV *)rv;
677	}	873	}
678		874
679	static void	875	static void
		876	encode_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	}
		902	static void
680	encode_ber (SV *tuple)	903	encode_ber (SV *tuple)
681	{	904	{
682	AV *av = ber_tuple (tuple);	905	AV *av = ber_tuple (tuple);
683		906
684	int klass = SvIV (AvARRAY (av)[BER_CLASS]);	907	int klass = SvIV (AvARRAY (av)[BER_CLASS]);
685	int tag = SvIV (AvARRAY (av)[BER_TAG]);	908	int tag = SvIV (AvARRAY (av)[BER_TAG]);
686	int constructed = SvIV (AvARRAY (av)[BER_CONSTRUCTED]) ? ASN_CONSTRUCTED : 0;	909	int constructed = SvIV (AvARRAY (av)[BER_FLAGS]) & 1 ? ASN_CONSTRUCTED : 0;
687	SV *data = AvARRAY (av)[BER_DATA];	910	SV *data = AvARRAY (av)[BER_DATA];
688		911
689	int identifier = (klass << ASN_CLASS_SHIFT) \| constructed;	912	int identifier = (klass << ASN_CLASS_SHIFT) \| constructed;
690		913
691	if (expect_false (tag >= ASN_TAG_BER))	914	if (expect_false (tag >= ASN_TAG_BER))
…		…
710	int fill = AvFILL (av);	933	int fill = AvFILL (av);
711		934
712	if (expect_false (SvRMAGICAL (av)))	935	if (expect_false (SvRMAGICAL (av)))
713	croak ("BER constructed data must not be tied");	936	croak ("BER constructed data must not be tied");
714		937
		938	int i;
715	for (int i = 0; i <= fill; ++i)	939	for (i = 0; i <= fill; ++i)
716	encode_ber (AvARRAY (av)[i]);	940	encode_ber (AvARRAY (av)[i]);
717		941
718	len_fixup (mark);	942	len_fixup (mark);
719	}	943	}
720	else	944	else
721	switch (identifier \| tag)	945	switch (profile_lookup (cur_profile, klass, tag))
722	{	946	{
723	case ASN_NULL:	947	case BER_TYPE_NULL:
724	put_length (0);	948	put_length (0);
725	break;	949	break;
726		950
727	case ASN_OBJECT_IDENTIFIER:	951	case BER_TYPE_BOOL:
		952	put_length (1);
		953	*cur++ = SvTRUE (data) ? 0xff : 0x00; // 0xff = DER/CER
		954	break;
		955
		956	case BER_TYPE_OID:
728	encode_object_identifier (data);	957	encode_oid (data, 0);
729	break;	958	break;
730		959
731	case ASN_INTEGER32:	960	case BER_TYPE_RELOID:
		961	encode_oid (data, 1);
		962	break;
		963
		964	case BER_TYPE_INT:
732	encode_integer32 (SvIV (data));	965	encode_int (data);
733	break;	966	break;
734		967
735	case ASN_APPLICATION \| SNMP_UNSIGNED32:	968	case BER_TYPE_BYTES:
736	case ASN_APPLICATION \| SNMP_COUNTER32:	969	{
737	case ASN_APPLICATION \| SNMP_TIMETICKS:	970	STRLEN len;
738	case ASN_APPLICATION \| SNMP_COUNTER64:	971	const char *ptr = SvPVbyte (data, len);
739	encode_unsigned64 (SvUV (data));	972	encode_data (ptr, len);
		973	}
740	break;	974	break;
741		975
		976	case BER_TYPE_UTF8:
		977	{
		978	STRLEN len;
		979	const char *ptr = SvPVutf8 (data, len);
		980	encode_data (ptr, len);
		981	}
		982	break;
		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
		1000	case BER_TYPE_REAL:
		1001	case BER_TYPE_CROAK:
742	default:	1002	default:
743	encode_octet_string (data);	1003	croak ("unconfigured/unsupported class/tag %d/%d", klass, tag);
744	break;
745	}	1004	}
746		1005
747	}	1006	}
748		1007
749	/////////////////////////////////////////////////////////////////////////////	1008	/////////////////////////////////////////////////////////////////////////////
…		…
753	PROTOTYPES: ENABLE	1012	PROTOTYPES: ENABLE
754		1013
755	BOOT:	1014	BOOT:
756	{	1015	{
757	HV *stash = gv_stashpv ("Convert::BER::XS", 1);	1016	HV *stash = gv_stashpv ("Convert::BER::XS", 1);
		1017
		1018	profile_stash = gv_stashpv ("Convert::BER::XS::Profile", 1);
758		1019
759	static const struct {	1020	static const struct {
760	const char *name;	1021	const char *name;
761	IV iv;	1022	IV iv;
762	} *civ, const_iv[] = {	1023	} *civ, const_iv[] = {
763	{ "ASN_BOOLEAN", ASN_BOOLEAN },	1024	#define const_iv(name) { # name, name },
764	{ "ASN_INTEGER32", ASN_INTEGER32 },	1025	const_iv (ASN_BOOLEAN)
765	{ "ASN_BIT_STRING", ASN_BIT_STRING },	1026	const_iv (ASN_INTEGER)
766	{ "ASN_OCTET_STRING", ASN_OCTET_STRING },	1027	const_iv (ASN_BIT_STRING)
767	{ "ASN_NULL", ASN_NULL },	1028	const_iv (ASN_OCTET_STRING)
768	{ "ASN_OBJECT_IDENTIFIER", ASN_OBJECT_IDENTIFIER },	1029	const_iv (ASN_NULL)
769	{ "ASN_TAG_BER", ASN_TAG_BER },	1030	const_iv (ASN_OBJECT_IDENTIFIER)
770	{ "ASN_TAG_MASK", ASN_TAG_MASK },	1031	const_iv (ASN_OBJECT_DESCRIPTOR)
771	{ "ASN_CONSTRUCTED", ASN_CONSTRUCTED },	1032	const_iv (ASN_OID)
772	{ "ASN_UNIVERSAL", ASN_UNIVERSAL >> ASN_CLASS_SHIFT },	1033	const_iv (ASN_EXTERNAL)
773	{ "ASN_APPLICATION", ASN_APPLICATION >> ASN_CLASS_SHIFT },	1034	const_iv (ASN_REAL)
774	{ "ASN_CONTEXT", ASN_CONTEXT >> ASN_CLASS_SHIFT },	1035	const_iv (ASN_SEQUENCE)
775	{ "ASN_PRIVATE", ASN_PRIVATE >> ASN_CLASS_SHIFT },	1036	const_iv (ASN_ENUMERATED)
776	{ "ASN_CLASS_MASK", ASN_CLASS_MASK },	1037	const_iv (ASN_EMBEDDED_PDV)
777	{ "ASN_CLASS_SHIFT", ASN_CLASS_SHIFT },	1038	const_iv (ASN_UTF8_STRING)
778	{ "ASN_SEQUENCE", ASN_SEQUENCE },	1039	const_iv (ASN_RELATIVE_OID)
779	{ "SNMP_IPADDRESS", SNMP_IPADDRESS },	1040	const_iv (ASN_SET)
780	{ "SNMP_COUNTER32", SNMP_COUNTER32 },	1041	const_iv (ASN_NUMERIC_STRING)
781	{ "SNMP_UNSIGNED32", SNMP_UNSIGNED32 },	1042	const_iv (ASN_PRINTABLE_STRING)
782	{ "SNMP_TIMETICKS", SNMP_TIMETICKS },	1043	const_iv (ASN_TELETEX_STRING)
783	{ "SNMP_OPAQUE", SNMP_OPAQUE },	1044	const_iv (ASN_T61_STRING)
784	{ "SNMP_COUNTER64", SNMP_COUNTER64 },	1045	const_iv (ASN_VIDEOTEX_STRING)
		1046	const_iv (ASN_IA5_STRING)
		1047	const_iv (ASN_ASCII_STRING)
		1048	const_iv (ASN_UTC_TIME)
		1049	const_iv (ASN_GENERALIZED_TIME)
		1050	const_iv (ASN_GRAPHIC_STRING)
		1051	const_iv (ASN_VISIBLE_STRING)
		1052	const_iv (ASN_ISO646_STRING)
		1053	const_iv (ASN_GENERAL_STRING)
		1054	const_iv (ASN_UNIVERSAL_STRING)
		1055	const_iv (ASN_CHARACTER_STRING)
		1056	const_iv (ASN_BMP_STRING)
785		1057
786	{ "BER_CLASS" , BER_CLASS },	1058	const_iv (ASN_UNIVERSAL)
787	{ "BER_TAG" , BER_TAG },	1059	const_iv (ASN_APPLICATION)
788	{ "BER_CONSTRUCTED", BER_CONSTRUCTED },	1060	const_iv (ASN_CONTEXT)
789	{ "BER_DATA" , BER_DATA },	1061	const_iv (ASN_PRIVATE)
		1062
		1063	const_iv (BER_CLASS)
		1064	const_iv (BER_TAG)
		1065	const_iv (BER_FLAGS)
		1066	const_iv (BER_DATA)
		1067
		1068	const_iv (BER_TYPE_BYTES)
		1069	const_iv (BER_TYPE_UTF8)
		1070	const_iv (BER_TYPE_UCS2)
		1071	const_iv (BER_TYPE_UCS4)
		1072	const_iv (BER_TYPE_INT)
		1073	const_iv (BER_TYPE_OID)
		1074	const_iv (BER_TYPE_RELOID)
		1075	const_iv (BER_TYPE_NULL)
		1076	const_iv (BER_TYPE_BOOL)
		1077	const_iv (BER_TYPE_REAL)
		1078	const_iv (BER_TYPE_IPADDRESS)
		1079	const_iv (BER_TYPE_CROAK)
		1080
		1081	const_iv (SNMP_IPADDRESS)
		1082	const_iv (SNMP_COUNTER32)
		1083	const_iv (SNMP_UNSIGNED32)
		1084	const_iv (SNMP_TIMETICKS)
		1085	const_iv (SNMP_OPAQUE)
		1086	const_iv (SNMP_COUNTER64)
790	};	1087	};
791		1088
792	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--)
793	newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv));	1090	newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
794	}	1091	}
795		1092
796	SV *	1093	SV *
797	ber_decode (SV *ber)	1094	ber_decode (SV ber, SV profile = &PL_sv_undef)
798	CODE:	1095	CODE:
799	{	1096	{
		1097	cur_profile = SvPROFILE (profile);
800	STRLEN len;	1098	STRLEN len;
801
802	buf = SvPVbyte (ber, len);	1099	buf = (U8 *)SvPVbyte (ber, len);
803	cur = buf;	1100	cur = buf;
804	end = buf + len;	1101	end = buf + len;
805		1102
806	RETVAL = decode_ber ();	1103	RETVAL = decode_ber ();
807	}	1104	}
808	OUTPUT: RETVAL	1105	OUTPUT: RETVAL
809		1106
810	void	1107	void
811	ber_is (SV tuple, SV klass = &PL_sv_undef, SV tag = &PL_sv_undef, SV constructed = &PL_sv_undef, SV *data = &PL_sv_undef)	1108	ber_is (SV tuple, SV klass = &PL_sv_undef, SV tag = &PL_sv_undef, SV flags = &PL_sv_undef, SV *data = &PL_sv_undef)
812	PPCODE:	1109	PPCODE:
813	{	1110	{
814	if (!SvOK (tuple))	1111	if (!SvOK (tuple))
815	XSRETURN_NO;	1112	XSRETURN_NO;
816		1113
…		…
818	croak ("ber_is: tuple must be BER tuple (array-ref)");	1115	croak ("ber_is: tuple must be BER tuple (array-ref)");
819		1116
820	AV av = (AV )SvRV (tuple);	1117	AV av = (AV )SvRV (tuple);
821		1118
822	XPUSHs (	1119	XPUSHs (
823	(!SvOK (klass) \|\| SvIV (AvARRAY (av)[BER_CLASS ]) == SvIV (klass))	1120	(!SvOK (klass) \|\| SvIV (AvARRAY (av)[BER_CLASS]) == SvIV (klass))
824	&& (!SvOK (tag) \|\| SvIV (AvARRAY (av)[BER_TAG ]) == SvIV (tag))	1121	&& (!SvOK (tag) \|\| SvIV (AvARRAY (av)[BER_TAG ]) == SvIV (tag))
825	&& (!SvOK (constructed) \|\| !SvIV (AvARRAY (av)[BER_CONSTRUCTED]) == !SvIV (constructed))	1122	&& (!SvOK (flags) \|\| !SvIV (AvARRAY (av)[BER_FLAGS]) == !SvIV (flags))
826	&& (!SvOK (data) \|\| sv_eq (AvARRAY (av)[BER_DATA ], data))	1123	&& (!SvOK (data) \|\| sv_eq (AvARRAY (av)[BER_DATA ], data))
827	? &PL_sv_yes : &PL_sv_undef);	1124	? &PL_sv_yes : &PL_sv_undef);
828	}	1125	}
829		1126
830	void	1127	void
831	ber_is_seq (SV *tuple)	1128	ber_is_seq (SV *tuple)
…		…
835	XSRETURN_UNDEF;	1132	XSRETURN_UNDEF;
836		1133
837	AV *av = ber_tuple (tuple);	1134	AV *av = ber_tuple (tuple);
838		1135
839	XPUSHs (	1136	XPUSHs (
840	SvIV (AvARRAY (av)[BER_CLASS ]) == ASN_UNIVERSAL	1137	SvIV (AvARRAY (av)[BER_CLASS]) == ASN_UNIVERSAL
841	&& SvIV (AvARRAY (av)[BER_TAG ]) == ASN_SEQUENCE	1138	&& SvIV (AvARRAY (av)[BER_TAG ]) == ASN_SEQUENCE
842	&& SvIV (AvARRAY (av)[BER_CONSTRUCTED])	1139	&& SvIV (AvARRAY (av)[BER_FLAGS])
843	? AvARRAY (av)[BER_DATA] : &PL_sv_undef);	1140	? AvARRAY (av)[BER_DATA] : &PL_sv_undef);
844	}	1141	}
845		1142
846	void	1143	void
847	ber_is_i32 (SV tuple, SV value = &PL_sv_undef)	1144	ber_is_int (SV tuple, SV value = &PL_sv_undef)
848	PPCODE:	1145	PPCODE:
849	{	1146	{
850	if (!SvOK (tuple))	1147	if (!SvOK (tuple))
851	XSRETURN_NO;	1148	XSRETURN_NO;
852		1149
853	AV *av = ber_tuple (tuple);	1150	AV *av = ber_tuple (tuple);
854		1151
855	IV data = SvIV (AvARRAY (av)[BER_DATA]);	1152	UV data = SvUV (AvARRAY (av)[BER_DATA]);
856		1153
857	XPUSHs (	1154	XPUSHs (
858	SvIV (AvARRAY (av)[BER_CLASS ]) == ASN_UNIVERSAL	1155	SvIV (AvARRAY (av)[BER_CLASS]) == ASN_UNIVERSAL
859	&& SvIV (AvARRAY (av)[BER_TAG ]) == ASN_INTEGER32	1156	&& SvIV (AvARRAY (av)[BER_TAG ]) == ASN_INTEGER
860	&& !SvIV (AvARRAY (av)[BER_CONSTRUCTED])	1157	&& !SvIV (AvARRAY (av)[BER_FLAGS])
861	&& (!SvOK (value) \|\| data == SvIV (value))	1158	&& (!SvOK (value) \|\| data == SvUV (value))
862	? sv_2mortal (data ? newSViv (data) : newSVpv ("0 but true", 0))	1159	? sv_2mortal (data ? newSVsv (AvARRAY (av)[BER_DATA]) : newSVpv ("0 but true", 0))
863	: &PL_sv_undef);	1160	: &PL_sv_undef);
864	}	1161	}
865		1162
866	void	1163	void
867	ber_is_oid (SV tuple, SV oid = &PL_sv_undef)	1164	ber_is_oid (SV tuple, SV oid = &PL_sv_undef)
…		…
871	XSRETURN_NO;	1168	XSRETURN_NO;
872		1169
873	AV *av = ber_tuple (tuple);	1170	AV *av = ber_tuple (tuple);
874		1171
875	XPUSHs (	1172	XPUSHs (
876	SvIV (AvARRAY (av)[BER_CLASS ]) == ASN_UNIVERSAL	1173	SvIV (AvARRAY (av)[BER_CLASS]) == ASN_UNIVERSAL
877	&& SvIV (AvARRAY (av)[BER_TAG ]) == ASN_OBJECT_IDENTIFIER	1174	&& SvIV (AvARRAY (av)[BER_TAG ]) == ASN_OBJECT_IDENTIFIER
878	&& !SvIV (AvARRAY (av)[BER_CONSTRUCTED])	1175	&& !SvIV (AvARRAY (av)[BER_FLAGS])
879	&& (!SvOK (oid) \|\| sv_eq (AvARRAY (av)[BER_DATA], oid))	1176	&& (!SvOK (oid) \|\| sv_eq (AvARRAY (av)[BER_DATA], oid))
880	? newSVsv (AvARRAY (av)[BER_DATA]) : &PL_sv_undef);	1177	? newSVsv (AvARRAY (av)[BER_DATA]) : &PL_sv_undef);
881	}	1178	}
882		1179
883	#############################################################################	1180	#############################################################################
884		1181
885	void	1182	void
886	ber_encode (SV *tuple)	1183	ber_encode (SV tuple, SV profile = &PL_sv_undef)
887	PPCODE:	1184	PPCODE:
888	{	1185	{
		1186	cur_profile = SvPROFILE (profile);
889	buf_sv = sv_2mortal (NEWSV (0, 256));	1187	buf_sv = sv_2mortal (NEWSV (0, 256));
890	SvPOK_only (buf_sv);	1188	SvPOK_only (buf_sv);
891	set_buf (buf_sv);	1189	set_buf (buf_sv);
892		1190
893	encode_ber (tuple);	1191	encode_ber (tuple);
…		…
895	SvCUR_set (buf_sv, cur - buf);	1193	SvCUR_set (buf_sv, cur - buf);
896	XPUSHs (buf_sv);	1194	XPUSHs (buf_sv);
897	}	1195	}
898		1196
899	SV *	1197	SV *
900	ber_i32 (IV iv)	1198	ber_int (SV *sv)
901	CODE:	1199	CODE:
902	{	1200	{
903	AV *av = newAV ();	1201	AV *av = newAV ();
904	av_fill (av, BER_ARRAYSIZE - 1);	1202	av_fill (av, BER_ARRAYSIZE - 1);
905	AvARRAY (av)[BER_CLASS ] = newSVcacheint (ASN_UNIVERSAL);	1203	AvARRAY (av)[BER_CLASS] = newSVcacheint (ASN_UNIVERSAL);
906	AvARRAY (av)[BER_TAG ] = newSVcacheint (ASN_INTEGER32);	1204	AvARRAY (av)[BER_TAG ] = newSVcacheint (ASN_INTEGER);
907	AvARRAY (av)[BER_CONSTRUCTED] = newSVcacheint (0);	1205	AvARRAY (av)[BER_FLAGS] = newSVcacheint (0);
908	AvARRAY (av)[BER_DATA ] = newSViv (iv);	1206	AvARRAY (av)[BER_DATA ] = newSVsv (sv);
909	RETVAL = newRV_noinc ((SV *)av);	1207	RETVAL = newRV_noinc ((SV *)av);
910	}	1208	}
911	OUTPUT: RETVAL	1209	OUTPUT: RETVAL
912		1210
913	# TODO: not arrayref, but elements?	1211	# TODO: not arrayref, but elements?
…		…
915	ber_seq (SV *arrayref)	1213	ber_seq (SV *arrayref)
916	CODE:	1214	CODE:
917	{	1215	{
918	AV *av = newAV ();	1216	AV *av = newAV ();
919	av_fill (av, BER_ARRAYSIZE - 1);	1217	av_fill (av, BER_ARRAYSIZE - 1);
920	AvARRAY (av)[BER_CLASS ] = newSVcacheint (ASN_UNIVERSAL);	1218	AvARRAY (av)[BER_CLASS] = newSVcacheint (ASN_UNIVERSAL);
921	AvARRAY (av)[BER_TAG ] = newSVcacheint (ASN_SEQUENCE);	1219	AvARRAY (av)[BER_TAG ] = newSVcacheint (ASN_SEQUENCE);
922	AvARRAY (av)[BER_CONSTRUCTED] = newSVcacheint (1);	1220	AvARRAY (av)[BER_FLAGS] = newSVcacheint (1);
923	AvARRAY (av)[BER_DATA ] = newSVsv (arrayref);	1221	AvARRAY (av)[BER_DATA ] = newSVsv (arrayref);
924	RETVAL = newRV_noinc ((SV *)av);	1222	RETVAL = newRV_noinc ((SV *)av);
925	}	1223	}
926	OUTPUT: RETVAL	1224	OUTPUT: RETVAL
927		1225
		1226	MODULE = Convert::BER::XS PACKAGE = Convert::BER::XS::Profile
		1227
		1228	SV *
		1229	new (SV *klass)
		1230	CODE:
		1231	RETVAL = profile_new ();
		1232	OUTPUT: RETVAL
		1233
		1234	void
		1235	set (SV *profile, int klass, int tag, int type)
		1236	CODE:
		1237	profile_set (SvPROFILE (profile), klass, tag, type);
		1238
		1239	IV
		1240	get (SV *profile, int klass, int tag)
		1241	CODE:
		1242	RETVAL = profile_lookup (SvPROFILE (profile), klass, tag);
		1243	OUTPUT: RETVAL
		1244
		1245	void
		1246	_set_default (SV *profile)
		1247	CODE:
		1248	default_profile = SvPROFILE (profile);
		1249
		1250

Diff Legend

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

Comparing Convert-BER-XS/XS.xs (file contents): Revision 1.4 by root, Fri Apr 19 20:38:38 2019 UTC vs. Revision 1.19 by root, Sat Apr 20 16:34:34 2019 UTC

Diff Legend

Comparing Convert-BER-XS/XS.xs (file contents):
Revision 1.4 by root, Fri Apr 19 20:38:38 2019 UTC vs.
Revision 1.19 by root, Sat Apr 20 16:34:34 2019 UTC