1 /*
2 * Copyright (C) 2004-2006
3 * Hartmut Brandt.
4 * All rights reserved.
5 *
6 * Author: Harti Brandt <harti@freebsd.org>
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 *
29 * $Begemot: gensnmpdef.c 383 2006-05-30 07:40:49Z brandt_h $
30 */
31 #include <sys/queue.h>
32
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <string.h>
36 #include <unistd.h>
37 #include <errno.h>
38 #include <err.h>
39 #include <assert.h>
40 #include <smi.h>
41
42 static const char usgtxt[] =
43 "Usage: gensnmpdef [-hEe] [-c <cut>] MIB [MIB ...]\n"
44 "Options:\n"
45 " -c specify the number of initial sub-oids to cut from the oids\n"
46 " -E extract named enum types. Print a typedef for all enums defined\n"
47 " in syntax clauses of normal objects. Suppress normal output.\n"
48 " -e extract unnamed enum types. Print a typedef for all enums defined\n"
49 " as textual conventions. Suppress normal output.\n"
50 " -h print this help\n"
51 "MIBs are searched according to the libsmi(3) search rules and can\n"
52 "be specified either by path or module name\n";
53
54 static SmiNode *last_node;
55 static u_int cut = 3;
56
57 struct tdef {
58 char *name;
59 SLIST_ENTRY(tdef) link;
60 };
61
62 static SLIST_HEAD(, tdef) tdefs = SLIST_HEAD_INITIALIZER(tdefs);
63 static int do_typedef = 0;
64
65 static void print_node(SmiNode *n, u_int level);
66
67 static void
save_node(SmiNode * n)68 save_node(SmiNode *n)
69 {
70 if (n != NULL)
71 last_node = n;
72 }
73
74 static void
pindent(u_int level)75 pindent(u_int level)
76 {
77 if (level >= cut)
78 printf("%*s", (level - cut) * 2, "");
79 }
80
81 static void
print_name(SmiNode * n)82 print_name(SmiNode *n)
83 {
84 char *p;
85
86 for (p = n->name; *p != '\0'; p++) {
87 if (*p == '-')
88 printf("_");
89 else
90 printf("%c", *p);
91 }
92 }
93
94 static u_int
close_node(u_int n,u_int level)95 close_node(u_int n, u_int level)
96 {
97 while (n--) {
98 pindent(level);
99 level--;
100 if (level >= cut)
101 printf(")\n");
102 }
103 return (level);
104 }
105
106 static u_int
open_node(const SmiNode * n,u_int level,SmiNode ** last)107 open_node(const SmiNode *n, u_int level, SmiNode **last)
108 {
109 SmiNode *n1;
110 u_int i;
111
112 if (*last != NULL) {
113 for (i = 0; i < (*last)->oidlen - 1; i++) {
114 if (i >= n->oidlen) {
115 level = close_node((*last)->oidlen -
116 n->oidlen, level);
117 break;
118 }
119 if ((*last)->oid[i] != n->oid[i])
120 break;
121 }
122 if (i < (*last)->oidlen - 1)
123 level = close_node((*last)->oidlen - 1 - i,
124 level - 1) + 1;
125 }
126
127 while (level < n->oidlen - 1) {
128 if (level >= cut) {
129 n1 = smiGetNodeByOID(level + 1, n->oid);
130 if (n1 == NULL)
131 continue;
132 pindent(level);
133 printf("(%u", n->oid[level]);
134 printf(" ");
135 print_name(n1);
136 printf("\n");
137 }
138 level++;
139 }
140 return (level);
141 }
142
143 static const char *const type_names[] = {
144 [SMI_BASETYPE_UNKNOWN] = "UNKNOWN_TYPE",
145 [SMI_BASETYPE_INTEGER32] = "INTEGER",
146 [SMI_BASETYPE_OCTETSTRING] = "OCTETSTRING",
147 [SMI_BASETYPE_OBJECTIDENTIFIER] = "OID",
148 [SMI_BASETYPE_UNSIGNED32] = "UNSIGNED32",
149 [SMI_BASETYPE_INTEGER64] = "INTEGER64",
150 [SMI_BASETYPE_UNSIGNED64] = "UNSIGNED64",
151 [SMI_BASETYPE_FLOAT32] = "FLOAT32",
152 [SMI_BASETYPE_FLOAT64] = "FLOAT64",
153 [SMI_BASETYPE_FLOAT128] = "FLOAT128",
154 [SMI_BASETYPE_ENUM] = "ENUM",
155 [SMI_BASETYPE_BITS] = "BITS",
156 };
157
158 static const char *const type_map[] = {
159 "Gauge32", "GAUGE",
160 "Gauge", "GAUGE",
161 "TimeTicks", "TIMETICKS",
162 "Counter32", "COUNTER",
163 "Counter", "COUNTER",
164 "Counter64", "COUNTER64",
165 "Integer32", "INTEGER32",
166 "IpAddress", "IPADDRESS",
167 NULL
168 };
169
170 static void
print_enum(SmiType * t)171 print_enum(SmiType *t)
172 {
173 SmiNamedNumber *nnum;
174
175 printf(" (");
176 for (nnum = smiGetFirstNamedNumber(t); nnum != NULL;
177 nnum = smiGetNextNamedNumber(nnum))
178 printf(" %ld %s", nnum->value.value.integer32, nnum->name);
179 printf(" )");
180 }
181
182 static void
print_type(SmiNode * n)183 print_type(SmiNode *n)
184 {
185 SmiType *type;
186 u_int m;
187
188 type = smiGetNodeType(n);
189 assert(type != NULL);
190
191 if (type->name != NULL) {
192 for (m = 0; type_map[m] != NULL; m += 2)
193 if (strcmp(type_map[m], type->name) == 0) {
194 printf("%s", type_map[m + 1]);
195 return;
196 }
197 }
198 printf("%s", type_names[type->basetype]);
199
200 if (type->basetype == SMI_BASETYPE_ENUM ||
201 type->basetype == SMI_BASETYPE_BITS)
202 print_enum(type);
203
204 else if (type->basetype == SMI_BASETYPE_OCTETSTRING &&
205 type->name != NULL)
206 printf(" | %s", type->name);
207 }
208
209 static void
print_access(SmiAccess a)210 print_access(SmiAccess a)
211 {
212 if (a == SMI_ACCESS_READ_ONLY)
213 printf(" GET");
214 else if (a == SMI_ACCESS_READ_WRITE)
215 printf(" GET SET");
216 }
217
218 static void
print_scalar(SmiNode * n,u_int level)219 print_scalar(SmiNode *n, u_int level)
220 {
221 SmiNode *p;
222
223 assert (n->nodekind == SMI_NODEKIND_SCALAR);
224
225 save_node(n);
226
227 pindent(level);
228 printf("(%u ", n->oid[level]);
229 print_name(n);
230 printf(" ");
231 print_type(n);
232
233 /* generate the operation from the parent node name */
234 p = smiGetParentNode(n);
235 printf(" op_%s", p->name);
236
237 print_access(n->access);
238
239 printf(")\n");
240 }
241
242 static void
print_notification(SmiNode * n,u_int level)243 print_notification(SmiNode *n, u_int level)
244 {
245
246 assert (n->nodekind == SMI_NODEKIND_NOTIFICATION);
247
248 save_node(n);
249
250 pindent(level);
251 printf("(%u ", n->oid[level]);
252 print_name(n);
253 printf(" OID");
254
255 printf(" op_%s)\n", n->name);
256 }
257
258 static void
print_col(SmiNode * n,u_int level)259 print_col(SmiNode *n, u_int level)
260 {
261 assert (n->nodekind == SMI_NODEKIND_COLUMN);
262
263 save_node(n);
264
265 pindent(level);
266 printf("(%u ", n->oid[level]);
267 print_name(n);
268 printf(" ");
269 print_type(n);
270 print_access(n->access);
271 printf(")\n");
272 }
273
274 static void
print_index(SmiNode * row)275 print_index(SmiNode *row)
276 {
277 SmiElement *e;
278
279 e = smiGetFirstElement(row);
280 while (e != NULL) {
281 printf(" ");
282 print_type(smiGetElementNode(e));
283 e = smiGetNextElement(e);
284 }
285 }
286
287 static void
print_table(SmiNode * n,u_int level)288 print_table(SmiNode *n, u_int level)
289 {
290 SmiNode *row, *col, *rel;
291
292 assert (n->nodekind == SMI_NODEKIND_TABLE);
293
294 save_node(n);
295
296 pindent(level);
297 printf("(%u ", n->oid[level]);
298 print_name(n);
299 printf("\n");
300
301 row = smiGetFirstChildNode(n);
302 if (row->nodekind != SMI_NODEKIND_ROW)
303 errx(1, "%s: kind %u, not row", __func__, row->nodekind);
304
305 save_node(n);
306
307 pindent(level + 1);
308 printf("(%u ", row->oid[level + 1]);
309 print_name(row);
310 printf(" :");
311
312 /* index */
313 rel = smiGetRelatedNode(row);
314 switch (row->indexkind) {
315
316 case SMI_INDEX_INDEX:
317 print_index(row);
318 break;
319
320 case SMI_INDEX_AUGMENT:
321 if (rel == NULL)
322 errx(1, "%s: cannot find augemented table", row->name);
323 print_index(rel);
324 break;
325
326 default:
327 errx(1, "%s: cannot handle index kind %u", row->name,
328 row->indexkind);
329 }
330
331 printf(" op_%s", n->name);
332 printf("\n");
333
334 col = smiGetFirstChildNode(row);
335 while (col != NULL) {
336 print_col(col, level + 2);
337 col = smiGetNextChildNode(col);
338 }
339 pindent(level + 1);
340 printf(")\n");
341
342 pindent(level);
343 printf(")\n");
344 }
345
346 static void
print_it(SmiNode * n,u_int level)347 print_it(SmiNode *n, u_int level)
348 {
349 switch (n->nodekind) {
350
351 case SMI_NODEKIND_NODE:
352 print_node(n, level);
353 break;
354
355 case SMI_NODEKIND_SCALAR:
356 print_scalar(n, level);
357 break;
358
359 case SMI_NODEKIND_TABLE:
360 print_table(n, level);
361 break;
362
363 case SMI_NODEKIND_COMPLIANCE:
364 case SMI_NODEKIND_GROUP:
365 save_node(n);
366 break;
367
368 case SMI_NODEKIND_NOTIFICATION:
369 print_notification(n, level);
370 break;
371
372 default:
373 errx(1, "cannot handle %u nodes", n->nodekind);
374 }
375 }
376
377 static void
print_node(SmiNode * n,u_int level)378 print_node(SmiNode *n, u_int level)
379 {
380 assert (n->nodekind == SMI_NODEKIND_NODE);
381
382 save_node(n);
383
384 pindent(level);
385 printf("(%u ", n->oid[level]);
386 print_name(n);
387 printf("\n");
388
389 n = smiGetFirstChildNode(n);
390 while (n != NULL) {
391 print_it(n, level + 1);
392 n = smiGetNextChildNode(n);
393 }
394 pindent(level);
395 printf(")\n");
396 }
397
398 static void
save_typdef(char * name)399 save_typdef(char *name)
400 {
401 struct tdef *t;
402
403 t = calloc(1, sizeof(struct tdef));
404 if (t == NULL)
405 err(1, NULL);
406
407 t->name = name;
408 SLIST_INSERT_HEAD(&tdefs, t, link);
409 }
410
411 static void
tdefs_cleanup(void)412 tdefs_cleanup(void)
413 {
414 struct tdef *t;
415
416 while ((t = SLIST_FIRST(&tdefs)) != NULL) {
417 SLIST_REMOVE_HEAD(&tdefs, link);
418 free(t);
419 }
420 }
421
422 static void
print_enum_typedef(SmiType * t)423 print_enum_typedef(SmiType *t)
424 {
425 SmiNamedNumber *nnum;
426
427 for (nnum = smiGetFirstNamedNumber(t); nnum != NULL;
428 nnum = smiGetNextNamedNumber(nnum)) {
429 printf("\t%ld %s\n" , nnum->value.value.integer32, nnum->name);
430 }
431 }
432
433 static void
print_stype(SmiNode * n)434 print_stype(SmiNode *n)
435 {
436 SmiType *type;
437 struct tdef *t = NULL;
438
439 type = smiGetNodeType(n);
440 assert(type != NULL);
441
442 if (type->basetype == SMI_BASETYPE_ENUM) {
443 if (do_typedef == 'e' && type->name != NULL) {
444 SLIST_FOREACH(t, &tdefs, link) {
445 if (strcmp(t->name, type->name) == 0)
446 return;
447 }
448 save_typdef(type->name);
449 printf("typedef %s ENUM (\n", type->name);
450 } else if (do_typedef == 'E' && type->name == NULL)
451 printf("typedef %sType ENUM (\n", n->name);
452 else
453 return;
454
455 print_enum_typedef(type);
456 printf(")\n\n");
457
458 } else if (type->basetype == SMI_BASETYPE_BITS) {
459 if (do_typedef == 'e' && type->name != NULL) {
460 SLIST_FOREACH(t, &tdefs, link) {
461 if (strcmp(t->name, type->name) == 0)
462 return;
463 }
464 save_typdef(type->name);
465 printf("typedef %s BITS (\n", type->name);
466 } else if (do_typedef == 'E' && type->name == NULL)
467 printf("typedef %sType BITS (\n", n->name);
468 else
469 return;
470
471 print_enum_typedef(type);
472 printf(")\n\n");
473 }
474 }
475
476 static void
print_typdefs(SmiNode * n)477 print_typdefs(SmiNode *n)
478 {
479 SmiNode *p;
480
481 p = n;
482 n = smiGetFirstChildNode(n);
483 while (n != NULL) {
484 switch (n->nodekind) {
485 case SMI_NODEKIND_SCALAR:
486 case SMI_NODEKIND_COLUMN:
487 print_stype(n);
488 break;
489 case SMI_NODEKIND_COMPLIANCE:
490 case SMI_NODEKIND_GROUP:
491 save_node(n);
492 return;
493 default:
494 break;
495 }
496 n = smiGetNextChildNode(n);
497 }
498
499 save_node(p);
500 }
501
502 int
main(int argc,char * argv[])503 main(int argc, char *argv[])
504 {
505 int opt;
506 int flags;
507 SmiModule **mods;
508 char *name;
509 SmiNode *n, *last;
510 u_int level;
511 long u;
512 char *end;
513
514 smiInit(NULL);
515
516 while ((opt = getopt(argc, argv, "c:Eeh")) != -1)
517 switch (opt) {
518
519 case 'c':
520 errno = 0;
521 u = strtol(optarg, &end, 10);
522 if (errno != 0)
523 err(1, "argument to -c");
524 if (*end != '\0')
525 err(1, "%s: not a number", optarg);
526 if (u < 0 || u > 5)
527 err(1, "%s: out of range", optarg);
528 cut = (u_int)u;
529 break;
530
531 case 'E':
532 do_typedef = 'E';
533 break;
534
535 case 'e':
536 do_typedef = 'e';
537 break;
538
539 case 'h':
540 fprintf(stderr, usgtxt);
541 exit(0);
542 }
543
544 argc -= optind;
545 argv += optind;
546
547 flags = smiGetFlags();
548 flags |= SMI_FLAG_ERRORS;
549 smiSetFlags(flags);
550
551 mods = malloc(sizeof(mods[0]) * argc);
552 if (mods == NULL)
553 err(1, NULL);
554
555 for (opt = 0; opt < argc; opt++) {
556 if ((name = smiLoadModule(argv[opt])) == NULL)
557 err(1, "%s: cannot load", argv[opt]);
558 mods[opt] = smiGetModule(name);
559 }
560 level = 0;
561 last = NULL;
562 for (opt = 0; opt < argc; opt++) {
563 if (mods[opt] == NULL) /* smiGetModule failed above */
564 continue;
565 n = smiGetFirstNode(mods[opt], SMI_NODEKIND_ANY);
566 if (n == NULL)
567 continue;
568 for (;;) {
569 if (do_typedef == 0) {
570 level = open_node(n, level, &last);
571 print_it(n, level);
572 last = n;
573 } else
574 print_typdefs(n);
575
576 if (last_node == NULL ||
577 (n = smiGetNextNode(last_node, SMI_NODEKIND_ANY))
578 == NULL)
579 break;
580 }
581 }
582 if (last != NULL && do_typedef == 0)
583 level = close_node(last->oidlen - 1, level - 1);
584 else if (do_typedef != 0)
585 tdefs_cleanup();
586
587 return (0);
588 }
589