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 68 save_node(SmiNode *n) 69 { 70 if (n != NULL) 71 last_node = n; 72 } 73 74 static void 75 pindent(u_int level) 76 { 77 if (level >= cut) 78 printf("%*s", (level - cut) * 2, ""); 79 } 80 81 static void 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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