checkAPIs.pl: support for new-style dissectors in check_hf_entries
[metze/wireshark/wip.git] / epan / oids_test.c
1 /* oids_test.c
2  * ASN.1 Object Identifier handling tests
3  * Copyright 2013, Edward J. Beroset <beroset@ieee.org>
4  *
5  * Wireshark - Network traffic analyzer
6  * By Gerald Combs <gerald@wireshark.org>
7  * Copyright 1998 Gerald Combs
8  *
9  * SPDX-License-Identifier: GPL-2.0-or-later
10  */
11
12 #include "config.h"
13
14 #include <stdio.h>
15 #include <string.h>
16 #include <glib.h>
17
18 #include "oids.h"
19 #include "wmem/wmem.h"
20
21 static wmem_allocator_t *test_scope;
22
23 typedef struct
24 {
25     const gchar *string;
26     const gchar *resolved;
27     guint encoded_len;
28     const gchar *encoded;
29     guint subids_len;
30     guint32 subids[];
31 } example_s;
32
33 example_s ex1 = {"2.1.1", "joint-iso-itu-t.1.1", 2, "\x51\x01", 3, {2,1,1} };
34 example_s ex2rel = {".81.1", ".81.1", 2, "\x51\x01", 2, {81,1} };
35 example_s ex3 = {"2.1.127.16383.2097151.268435455.128.16384.2097152.268435456",
36     "joint-iso-itu-t.1.127.16383.2097151.268435455.128.16384.2097152.268435456",
37     25, "\x51\x7f\xff\x7f\xff\xff\x7f\xff\xff\xff\x7f\x81\x00\x81\x80\x00\x81\x80\x80\x00\x81\x80\x80\x80\x00",
38     10, { 2, 1, 0x7F, 0x3FFF, 0x1FFFFF, 0x0FFFFFFF, 1+0x7F, 1+0x3FFF, 1+0x1FFFFF, 1+0x0FFFFFFF} };
39
40 example_s ex4 = {"2.1", "joint-iso-itu-t.1", 1, "\x51", 2, {2,1} };
41 example_s ex5 = {"2", "joint-iso-itu-t", 0, NULL, 1, {2} };
42 example_s ex6rel = {".81.127.16383.2097151.268435455.128.16384.2097152.268435456",
43     ".81.127.16383.2097151.268435455.128.16384.2097152.268435456",
44     25, "\x51\x7f\xff\x7f\xff\xff\x7f\xff\xff\xff\x7f\x81\x00\x81\x80\x00\x81\x80\x80\x00\x81\x80\x80\x80\x00",
45     9, { 81, 0x7F, 0x3FFF, 0x1FFFFF, 0x0FFFFFFF, 1+0x7F, 1+0x3FFF, 1+0x1FFFFF, 1+0x0FFFFFFF} };
46 example_s ex7 = {"2.1.1", "joint-iso-itu-t.asn1.basic-encoding", 2, "\x51\x01", 3, {2,1,1} };
47
48 /*
49  * These test are organized in order of the appearance, in oids.h, of
50  * the basic oids.c functions that they test.  This makes it easier to
51  * get a quick understanding of both the testing and the organization
52  * of oids.h.
53  *
54  * Tests are named /oids/2<desttype>/<srctype>[<extra>]
55  * where <desttype> is the resulting type of the conversion,
56  * <srctype> is the source type and <extra> is any additional
57  * information to make the test name unique.
58  *
59  * The types, for the purpose of this naming convention, are
60  * encoded, subids, string and resolved, both, struct.
61  */
62
63 /* OIDS TESTING FUNCTIONS (/oids/2subids/) */
64
65 static void
66 oids_test_2subids_encoded(void)
67 {
68     guint32 *subids = NULL;
69     guint len;
70     guint i;
71
72     len = oid_encoded2subid(NULL, ex1.encoded, ex1.encoded_len, &subids);
73     g_assert(len == ex1.subids_len);
74     for (i=0; i < len; i++)
75         g_assert(subids[i] == ex1.subids[i]);
76     wmem_free(NULL, subids);
77 }
78
79 static void
80 oids_test_2subids_encoded_long(void)
81 {
82     guint32 *subids = NULL;
83     guint len;
84     guint i;
85
86     len = oid_encoded2subid(NULL, ex3.encoded, ex3.encoded_len, &subids);
87     g_assert(len == ex3.subids_len);
88     for (i=0; i < len; i++)
89         g_assert(subids[i] == ex3.subids[i]);
90     wmem_free(NULL, subids);
91 }
92
93 static void
94 oids_test_2subids_encoded_absviasub(void)
95 {
96     guint32 *subids = NULL;
97     guint len;
98     guint i;
99
100     len = oid_encoded2subid_sub(NULL, ex1.encoded, ex1.encoded_len, &subids, TRUE);
101     g_assert(len == ex1.subids_len);
102     for (i=0; i < len; i++)
103         g_assert(subids[i] == ex1.subids[i]);
104     wmem_free(NULL, subids);
105 }
106
107 static void
108 oids_test_2subids_encoded_relviasub(void)
109 {
110     guint32 *subids = NULL;
111     guint len;
112     guint i;
113
114     len = oid_encoded2subid_sub(NULL, ex2rel.encoded, ex2rel.encoded_len, &subids, FALSE);
115     g_assert(len == ex2rel.subids_len);
116     for (i=0; i < len; i++)
117         g_assert(subids[i] == ex2rel.subids[i]);
118     wmem_free(NULL, subids);
119 }
120
121 static void
122 oids_test_2subids_string(void)
123 {
124     guint32 *subids = NULL;
125     guint len, i;
126
127     len = oid_string2subid(test_scope, ex1.string, &subids);
128     g_assert(len == ex1.subids_len);
129     for (i=0; i < len; i++)
130         g_assert(subids[i] == ex1.subids[i]);
131 }
132
133 static void
134 oids_test_2subids_string_tooshort(void)
135 {
136     guint32 *subids = NULL;
137     guint len, i;
138
139     len = oid_string2subid(test_scope, ex5.string, &subids);
140     g_assert(len == ex5.subids_len);
141     for (i=0; i < len; i++)
142         g_assert(subids[i] == ex5.subids[i]);
143 }
144
145 /* OIDS TESTING FUNCTIONS (/oids/2encoded/) */
146
147 static void
148 oids_test_2encoded_string_simple(void)
149 {
150     guint8 *encoded = NULL;
151     guint len;
152
153     len = oid_string2encoded(NULL, ex1.string, &encoded);
154     g_assert(len == ex1.encoded_len);
155     g_assert(0 == memcmp(encoded, ex1.encoded, len));
156     wmem_free(NULL, encoded);
157 }
158
159 static void
160 oids_test_2encoded_string_short(void)
161 {
162     guint8 *encoded = NULL;
163     guint len;
164
165     len = oid_string2encoded(NULL, ex4.string, &encoded);
166     g_assert(len == ex4.encoded_len);
167     g_assert(0 == memcmp(encoded, ex4.encoded, len));
168     wmem_free(NULL, encoded);
169 }
170
171 static void
172 oids_test_2encoded_string_long(void)
173 {
174     guint8 *encoded = NULL;
175     guint len;
176
177     len = oid_string2encoded(NULL, ex3.string, &encoded);
178     g_assert(len == ex3.encoded_len);
179     g_assert(0 == memcmp(encoded, ex3.encoded, len));
180     wmem_free(NULL, encoded);
181 }
182
183 static void
184 oids_test_2encoded_string_tooshort(void)
185 {
186     guint8 *encoded = NULL;
187     guint len;
188
189     len = oid_string2encoded(NULL, ex5.string, &encoded);
190     g_assert(len == ex5.encoded_len);
191     g_assert(0 == memcmp(encoded, ex5.encoded, len));
192     wmem_free(NULL, encoded);
193 }
194
195 static void
196 oids_test_2encoded_subids_simple(void)
197 {
198     guint8 *encoded = NULL;
199     guint len;
200
201     len = oid_subid2encoded(NULL, ex1.subids_len, ex1.subids, &encoded);
202     g_assert(len == ex1.encoded_len);
203     g_assert(0 == memcmp(encoded, ex1.encoded, len));
204     wmem_free(NULL, encoded);
205 }
206
207 static void
208 oids_test_2encoded_subids_bad(void)
209 {
210     guint8 *encoded = NULL;
211     guint len;
212
213     len = oid_subid2encoded(NULL, ex5.subids_len, ex5.subids, &encoded);
214     g_assert(len == ex5.encoded_len);
215     g_assert(0 == memcmp(encoded, ex5.encoded, len));
216     wmem_free(NULL, encoded);
217 }
218
219 /* OIDS TESTING FUNCTIONS (/oids/2string/) */
220
221 static void
222 oids_test_2string_encoded(void)
223 {
224     gchar* oid;
225
226     oid = oid_encoded2string(NULL, ex3.encoded, ex3.encoded_len);
227     g_assert_cmpstr(oid, ==, ex3.string);
228     wmem_free(NULL, oid);
229 }
230
231 static void
232 oids_test_2string_encoded_rel(void)
233 {
234     gchar* oid;
235
236     oid = rel_oid_encoded2string(NULL, ex6rel.encoded, ex3.encoded_len);
237     g_assert_cmpstr(oid, ==, ex6rel.string);
238     wmem_free(NULL, oid);
239 }
240
241
242 static void
243 oids_test_2string_subids_abs(void)
244 {
245     gchar* oid;
246
247     oid = oid_subid2string(NULL, ex1.subids, ex1.subids_len);
248     g_assert_cmpstr(oid, ==, ex1.string);
249     wmem_free(NULL, oid);
250 }
251
252 static void
253 oids_test_2string_subids_rel(void)
254 {
255     gchar* oid;
256
257     oid = rel_oid_subid2string(NULL, ex2rel.subids, ex2rel.subids_len, FALSE);
258     g_assert_cmpstr(oid, ==, ex2rel.string);
259     wmem_free(NULL, oid);
260 }
261
262 static void
263 oids_test_2string_subids_absviarel(void)
264 {
265     gchar* oid;
266
267     oid = rel_oid_subid2string(NULL, ex1.subids, ex1.subids_len, TRUE);
268     g_assert_cmpstr(oid, ==, ex1.string);
269     wmem_free(NULL, oid);
270 }
271
272 static void
273 oids_test_2string_subids_relsizes(void)
274 {
275     gchar* oid;
276
277     oid = rel_oid_subid2string(NULL, ex6rel.subids, ex6rel.subids_len, FALSE);
278     g_assert_cmpstr(oid, ==, ex6rel.string);
279     wmem_free(NULL, oid);
280 }
281
282 /* OIDS TESTING FUNCTIONS (/oids/2resolved/) */
283
284 static void
285 oids_test_2resolved_subids(void)
286 {
287     gchar* oid;
288
289     oid = oid_resolved(NULL, ex1.subids_len, ex1.subids);
290     g_assert_cmpstr(oid, ==, ex1.resolved);
291     wmem_free(NULL, oid);
292 }
293
294 static void
295 oids_test_2resolved_encoded(void)
296 {
297     gchar* oid;
298
299     oid = oid_resolved_from_encoded(NULL, ex1.encoded, ex1.encoded_len);
300     g_assert_cmpstr(oid, ==, ex1.resolved);
301     wmem_free(NULL, oid);
302 }
303
304 static void
305 oids_test_2resolved_encoded_rel(void)
306 {
307     gchar* oid;
308
309     oid = rel_oid_resolved_from_encoded(NULL, ex2rel.encoded, ex2rel.encoded_len);
310     g_assert_cmpstr(oid, ==, ex2rel.string);
311     wmem_free(NULL, oid);
312 }
313
314 static void
315 oids_test_2resolved_string(void)
316 {
317     gchar* oid;
318
319     oid = oid_resolved_from_string(NULL, ex1.string);
320     g_assert_cmpstr(oid, ==, ex1.resolved);
321     wmem_free(NULL, oid);
322 }
323
324 /* OIDS TESTING FUNCTIONS (/oids/2both/) */
325
326 static void
327 oids_test_2both_subids(void)
328 {
329     gchar* resolved;
330     gchar* oid;
331
332     oid_both(NULL, ex1.subids_len, ex1.subids, &resolved, &oid);
333     g_assert_cmpstr(resolved, ==, ex1.resolved);
334     g_assert_cmpstr(oid, ==, ex1.string);
335     wmem_free(NULL, resolved);
336     wmem_free(NULL, oid);
337 }
338
339 static void
340 oids_test_2both_encoded(void)
341 {
342     gchar* resolved;
343     gchar* oid;
344
345     oid_both_from_encoded(NULL, ex1.encoded, ex1.encoded_len, &resolved, &oid);
346     g_assert_cmpstr(resolved, ==, ex1.resolved);
347     g_assert_cmpstr(oid, ==, ex1.string);
348     wmem_free(NULL, resolved);
349     wmem_free(NULL, oid);
350 }
351
352 static void
353 oids_test_2both_string(void)
354 {
355     gchar* resolved;
356     gchar* oid;
357
358     oid_both_from_string(NULL, ex1.string, &resolved, &oid);
359     g_assert_cmpstr(resolved, ==, ex1.resolved);
360     g_assert_cmpstr(oid, ==, ex1.string);
361     wmem_free(NULL, resolved);
362     wmem_free(NULL, oid);
363 }
364
365 /* OIDS TESTING FUNCTIONS (/oids/2both/) */
366
367 static void
368 oids_test_2struct_subids(void)
369 {
370     guint matched;
371     guint left;
372     oid_info_t *st;
373
374     st = oid_get(ex1.subids_len, ex1.subids, &matched, &left);
375     g_assert(matched == 1);
376     g_assert(left == ex1.subids_len - 1);
377     g_assert(st != NULL);
378     g_assert_cmpstr(st->name, ==, "joint-iso-itu-t");
379 }
380
381 static void
382 oids_test_2struct_encoded(void)
383 {
384     guint matched;
385     guint left;
386     guint32 *subids = NULL;
387     oid_info_t *st;
388     guint len, i;
389
390     st = oid_get_from_encoded(NULL, ex1.encoded, ex1.encoded_len, &subids, &matched, &left);
391     g_assert(matched == 1);
392     g_assert(left == ex1.subids_len - 1);
393     g_assert(st != NULL);
394     g_assert_cmpstr(st->name, ==, "joint-iso-itu-t");
395     len = matched + left;
396     g_assert(len == ex1.subids_len);
397     for (i=0; i < len; i++)
398         g_assert(subids[i] == ex1.subids[i]);
399     wmem_free(NULL, subids);
400 }
401
402 static void
403 oids_test_2struct_string(void)
404 {
405     guint matched;
406     guint left;
407     guint32 *subids;
408     oid_info_t *st;
409     guint len, i;
410
411     st = oid_get_from_string(test_scope, ex1.string, &subids, &matched, &left);
412     g_assert(matched == 1);
413     g_assert(left == ex1.subids_len - 1);
414     g_assert(st != NULL);
415     g_assert_cmpstr(st->name, ==, "joint-iso-itu-t");
416     len = matched + left;
417     g_assert(len == ex1.subids_len);
418     for (i=0; i < len; i++)
419         g_assert(subids[i] == ex1.subids[i]);
420 }
421
422 static void
423 oids_test_add_subids(void)
424 {
425     gchar* oid;
426
427     oid_add(ex7.resolved, ex7.subids_len, ex7.subids);
428     oid = oid_resolved(NULL, ex7.subids_len, ex7.subids);
429     g_assert_cmpstr(oid, ==, ex7.resolved);
430     wmem_free(NULL, oid);
431 }
432
433 static void
434 oids_test_add_encoded(void)
435 {
436     gchar* oid;
437
438     oid_add_from_encoded(ex7.resolved, ex7.encoded, ex7.encoded_len);
439     oid = oid_resolved(NULL, ex7.subids_len, ex7.subids);
440     g_assert_cmpstr(oid, ==, ex7.resolved);
441     wmem_free(NULL, oid);
442 }
443
444 static void
445 oids_test_add_string(void)
446 {
447     gchar* oid;
448
449     oid_add_from_string(ex7.resolved, ex7.string);
450     oid = oid_resolved(NULL, ex7.subids_len, ex7.subids);
451     g_assert_cmpstr(oid, ==, ex7.resolved);
452     wmem_free(NULL, oid);
453 }
454
455 int
456 main(int argc, char **argv)
457 {
458     int result;
459
460     g_test_init(&argc, &argv, NULL);
461
462     /* /oids/2encoded */
463     g_test_add_func("/oids/2encoded/subids/simple",   oids_test_2encoded_subids_simple);
464     g_test_add_func("/oids/2encoded/subids/bad",   oids_test_2encoded_subids_bad);
465     g_test_add_func("/oids/2encoded/string/simple",   oids_test_2encoded_string_simple);
466     g_test_add_func("/oids/2encoded/string/short",   oids_test_2encoded_string_short);
467     g_test_add_func("/oids/2encoded/string/long",   oids_test_2encoded_string_long);
468     g_test_add_func("/oids/2encoded/string/tooshort",   oids_test_2encoded_string_tooshort);
469
470     /* /oids/2subids */
471     g_test_add_func("/oids/2subids/string",   oids_test_2subids_string);
472     g_test_add_func("/oids/2subids/string/tooshort",   oids_test_2subids_string_tooshort);
473     g_test_add_func("/oids/2subids/encoded",   oids_test_2subids_encoded);
474     g_test_add_func("/oids/2subids/encoded/long",   oids_test_2subids_encoded_long);
475     g_test_add_func("/oids/2subids/encoded/absviasub",   oids_test_2subids_encoded_absviasub);
476     g_test_add_func("/oids/2subids/encoded/relviasub",   oids_test_2subids_encoded_relviasub);
477
478
479     /* /oids/2string */
480     g_test_add_func("/oids/2string/subids/abs",   oids_test_2string_subids_abs);
481     g_test_add_func("/oids/2string/subids/rel",   oids_test_2string_subids_rel);
482     g_test_add_func("/oids/2string/subids/absviarel",   oids_test_2string_subids_absviarel);
483     g_test_add_func("/oids/2string/subids/relsizes",   oids_test_2string_subids_relsizes);
484     g_test_add_func("/oids/2string/encoded",   oids_test_2string_encoded);
485     g_test_add_func("/oids/2string/encoded/rel",   oids_test_2string_encoded_rel);
486
487     /* /oids/2resolved */
488     g_test_add_func("/oids/2resolved/subids",   oids_test_2resolved_subids);
489     g_test_add_func("/oids/2resolved/encoded",   oids_test_2resolved_encoded);
490     g_test_add_func("/oids/2resolved/encoded/rel",   oids_test_2resolved_encoded_rel);
491     g_test_add_func("/oids/2resolved/string",   oids_test_2resolved_string);
492
493     /* /oids/2both */
494     g_test_add_func("/oids/2both/subids",   oids_test_2both_subids);
495     g_test_add_func("/oids/2both/encoded",   oids_test_2both_encoded);
496     g_test_add_func("/oids/2both/string",   oids_test_2both_string);
497
498     /* /oids/2struct */
499     g_test_add_func("/oids/2struct/subids",   oids_test_2struct_subids);
500     g_test_add_func("/oids/2struct/encoded",   oids_test_2struct_encoded);
501     g_test_add_func("/oids/2struct/string",   oids_test_2struct_string);
502
503     /* /oids/add */
504     g_test_add_func("/oids/add/subids",   oids_test_add_subids);
505     g_test_add_func("/oids/add/encoded",   oids_test_add_encoded);
506     g_test_add_func("/oids/add/string",   oids_test_add_string);
507
508     wmem_init();
509     test_scope = wmem_allocator_new(WMEM_ALLOCATOR_STRICT);
510     oids_init();
511     result = g_test_run();
512     oids_cleanup();
513     wmem_destroy_allocator(test_scope);
514     wmem_cleanup();
515
516     return result;
517 }
518
519 /*
520  * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
521  *
522  * Local variables:
523  * c-basic-offset: 4
524  * tab-width: 8
525  * indent-tabs-mode: nil
526  * End:
527  *
528  * vi: set shiftwidth=4 tabstop=8 expandtab:
529  * :indentSize=4:tabSize=8:noTabs=true:
530  */