contrib/bsnmp/gensnmpdef/gensnmpdef.c

   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                         pindent(level);
 130                         printf("(%u", n->oid[level]);
 131                         n1 = smiGetNodeByOID(level + 1, n->oid);
 132                         printf(" ");
 133                         print_name(n1);
 134                         printf("\n");
 135                 }
 136                 level++;
 137         }
 138         return (level);
 139 }
 140
 141 static const char *const type_names[] = {
 142         [SMI_BASETYPE_UNKNOWN] =        "UNKNOWN_TYPE",
 143         [SMI_BASETYPE_INTEGER32] =      "INTEGER",
 144         [SMI_BASETYPE_OCTETSTRING] =    "OCTETSTRING",
 145         [SMI_BASETYPE_OBJECTIDENTIFIER] =       "OID",
 146         [SMI_BASETYPE_UNSIGNED32] =     "UNSIGNED32",
 147         [SMI_BASETYPE_INTEGER64] =      "INTEGER64",
 148         [SMI_BASETYPE_UNSIGNED64] =     "UNSIGNED64",
 149         [SMI_BASETYPE_FLOAT32] =        "FLOAT32",
 150         [SMI_BASETYPE_FLOAT64] =        "FLOAT64",
 151         [SMI_BASETYPE_FLOAT128] =       "FLOAT128",
 152         [SMI_BASETYPE_ENUM] =   "ENUM",
 153         [SMI_BASETYPE_BITS] =   "BITS",
 154 };
 155
 156 static const char *const type_map[] = {
 157         "Gauge32",      "GAUGE",
 158         "Gauge",        "GAUGE",
 159         "TimeTicks",    "TIMETICKS",
 160         "Counter32",    "COUNTER",
 161         "Counter",      "COUNTER",
 162         "Counter64",    "COUNTER64",
 163         "Integer32",    "INTEGER32",
 164         "IpAddress",    "IPADDRESS",
 165         NULL
 166 };
 167
 168 static void
 169 print_enum(SmiType *t)
 170 {
 171         SmiNamedNumber *nnum;
 172
 173         printf(" (");
 174         for (nnum = smiGetFirstNamedNumber(t); nnum != NULL;
 175             nnum = smiGetNextNamedNumber(nnum))
 176                 printf(" %ld %s", nnum->value.value.integer32, nnum->name);
 177         printf(" )");
 178 }
 179
 180 static void
 181 print_type(SmiNode *n)
 182 {
 183         SmiType *type;
 184         u_int m;
 185
 186         type = smiGetNodeType(n);
 187         assert(type != NULL);
 188
 189         if (type->name != NULL) {
 190                 for (m = 0; type_map[m] != NULL; m += 2)
 191                         if (strcmp(type_map[m], type->name) == 0) {
 192                                 printf("%s", type_map[m + 1]);
 193                                 return;
 194                         }
 195         }
 196         printf("%s", type_names[type->basetype]);
 197
 198         if (type->basetype == SMI_BASETYPE_ENUM ||
 199             type->basetype == SMI_BASETYPE_BITS)
 200                 print_enum(type);
 201
 202         else if (type->basetype == SMI_BASETYPE_OCTETSTRING &&
 203             type->name != NULL)
 204                 printf(" | %s", type->name);
 205 }
 206
 207 static void
 208 print_access(SmiAccess a)
 209 {
 210         if (a == SMI_ACCESS_READ_ONLY)
 211                 printf(" GET");
 212         else if (a == SMI_ACCESS_READ_WRITE)
 213                 printf(" GET SET");
 214 }
 215
 216 static void
 217 print_scalar(SmiNode *n, u_int level)
 218 {
 219         SmiNode *p;
 220
 221         assert (n->nodekind == SMI_NODEKIND_SCALAR);
 222
 223         save_node(n);
 224
 225         pindent(level);
 226         printf("(%u ", n->oid[level]);
 227         print_name(n);
 228         printf(" ");
 229         print_type(n);
 230
 231         /* generate the operation from the parent node name */
 232         p = smiGetParentNode(n);
 233         printf(" op_%s", p->name);
 234
 235         print_access(n->access);
 236
 237         printf(")\n");
 238 }
 239
 240 static void
 241 print_notification(SmiNode *n, u_int level)
 242 {
 243
 244         assert (n->nodekind == SMI_NODEKIND_NOTIFICATION);
 245
 246         save_node(n);
 247
 248         pindent(level);
 249         printf("(%u ", n->oid[level]);
 250         print_name(n);
 251         printf(" OID");
 252
 253         printf(" op_%s)\n", n->name);
 254 }
 255
 256 static void
 257 print_col(SmiNode *n, u_int level)
 258 {
 259         assert (n->nodekind == SMI_NODEKIND_COLUMN);
 260
 261         save_node(n);
 262
 263         pindent(level);
 264         printf("(%u ", n->oid[level]);
 265         print_name(n);
 266         printf(" ");
 267         print_type(n);
 268         print_access(n->access);
 269         printf(")\n");
 270 }
 271
 272 static void
 273 print_index(SmiNode *row)
 274 {
 275         SmiElement *e;
 276
 277         e = smiGetFirstElement(row);
 278         while (e != NULL) {
 279                 printf(" ");
 280                 print_type(smiGetElementNode(e));
 281                 e = smiGetNextElement(e);
 282         }
 283 }
 284
 285 static void
 286 print_table(SmiNode *n, u_int level)
 287 {
 288         SmiNode *row, *col, *rel;
 289
 290         assert (n->nodekind == SMI_NODEKIND_TABLE);
 291
 292         save_node(n);
 293
 294         pindent(level);
 295         printf("(%u ", n->oid[level]);
 296         print_name(n);
 297         printf("\n");
 298
 299         row = smiGetFirstChildNode(n);
 300         if (row->nodekind != SMI_NODEKIND_ROW)
 301                 errx(1, "%s: kind %u, not row", __func__, row->nodekind);
 302
 303         save_node(n);
 304
 305         pindent(level + 1);
 306         printf("(%u ", row->oid[level + 1]);
 307         print_name(row);
 308         printf(" :");
 309
 310         /* index */
 311         rel = smiGetRelatedNode(row);
 312         switch (row->indexkind) {
 313
 314           case SMI_INDEX_INDEX:
 315                 print_index(row);
 316                 break;
 317
 318           case SMI_INDEX_AUGMENT:
 319                 if (rel == NULL)
 320                         errx(1, "%s: cannot find augemented table", row->name);
 321                 print_index(rel);
 322                 break;
 323
 324           default:
 325                 errx(1, "%s: cannot handle index kind %u", row->name,
 326                     row->indexkind);
 327         }
 328
 329         printf(" op_%s", n->name);
 330         printf("\n");
 331
 332         col = smiGetFirstChildNode(row);
 333         while (col != NULL) {
 334                 print_col(col, level + 2);
 335                 col = smiGetNextChildNode(col);
 336         }
 337         pindent(level + 1);
 338         printf(")\n");
 339
 340         pindent(level);
 341         printf(")\n");
 342 }
 343
 344 static void
 345 print_it(SmiNode *n, u_int level)
 346 {
 347         switch (n->nodekind) {
 348
 349           case SMI_NODEKIND_NODE:
 350                 print_node(n, level);
 351                 break;
 352
 353           case SMI_NODEKIND_SCALAR:
 354                 print_scalar(n, level);
 355                 break;
 356
 357           case SMI_NODEKIND_TABLE:
 358                 print_table(n, level);
 359                 break;
 360
 361           case SMI_NODEKIND_COMPLIANCE:
 362           case SMI_NODEKIND_GROUP:
 363                 save_node(n);
 364                 break;
 365
 366           case SMI_NODEKIND_NOTIFICATION:
 367                 print_notification(n, level);
 368                 break;
 369
 370           default:
 371                 errx(1, "cannot handle %u nodes", n->nodekind);
 372         }
 373 }
 374
 375 static void
 376 print_node(SmiNode *n, u_int level)
 377 {
 378         assert (n->nodekind == SMI_NODEKIND_NODE);
 379
 380         save_node(n);
 381
 382         pindent(level);
 383         printf("(%u ", n->oid[level]);
 384         print_name(n);
 385         printf("\n");
 386
 387         n = smiGetFirstChildNode(n);
 388         while (n != NULL) {
 389                 print_it(n, level + 1);
 390                 n = smiGetNextChildNode(n);
 391         }
 392         pindent(level);
 393         printf(")\n");
 394 }
 395
 396 static void
 397 save_typdef(char *name)
 398 {
 399         struct tdef *t;
 400         t = malloc(sizeof(struct tdef));
 401
 402         if (t == NULL)
 403                 err(1, NULL);
 404
 405         memset(t, 0 , sizeof(struct tdef));
 406         t->name = name;
 407         SLIST_INSERT_HEAD(&tdefs, t, link);
 408 }
 409
 410 static void
 411 tdefs_cleanup(void)
 412 {
 413         struct tdef *t;
 414
 415         while ((t = SLIST_FIRST(&tdefs)) != NULL) {
 416                 SLIST_REMOVE_HEAD(&tdefs, link);
 417                 free(t);
 418         }
 419 }
 420
 421 static void
 422 print_enum_typedef(SmiType *t)
 423 {
 424         SmiNamedNumber *nnum;
 425
 426         for (nnum = smiGetFirstNamedNumber(t); nnum != NULL;
 427             nnum = smiGetNextNamedNumber(nnum)) {
 428                 printf("\t%ld %s\n" , nnum->value.value.integer32, nnum->name);
 429         }
 430 }
 431
 432 static void
 433 print_stype(SmiNode *n)
 434 {
 435         SmiType *type;
 436         struct tdef *t = NULL;
 437
 438         type = smiGetNodeType(n);
 439         assert(type != NULL);
 440
 441         if (type->basetype == SMI_BASETYPE_ENUM) {
 442                 if (do_typedef == 'e' && type->name != NULL) {
 443                         SLIST_FOREACH(t, &tdefs, link) {
 444                                 if (strcmp(t->name, type->name) == 0)
 445                                         return;
 446                         }
 447                         save_typdef(type->name);
 448                         printf("typedef %s ENUM (\n", type->name);
 449                 } else if (do_typedef == 'E' && type->name == NULL)
 450                         printf("typedef %sType ENUM (\n", n->name);
 451                 else
 452                         return;
 453
 454                 print_enum_typedef(type);
 455                 printf(")\n\n");
 456
 457         } else if (type->basetype == SMI_BASETYPE_BITS) {
 458                 if (do_typedef == 'e' && type->name != NULL) {
 459                         SLIST_FOREACH(t, &tdefs, link) {
 460                                 if (strcmp(t->name, type->name) == 0)
 461                                         return;
 462                         }
 463                         save_typdef(type->name);
 464                         printf("typedef %s BITS (\n", type->name);
 465                 } else if (do_typedef == 'E' && type->name == NULL)
 466                         printf("typedef %sType BITS (\n", n->name);
 467                 else
 468                         return;
 469
 470                 print_enum_typedef(type);
 471                 printf(")\n\n");
 472         }
 473 }
 474
 475 static void
 476 print_typdefs(SmiNode *n)
 477 {
 478         SmiNode *p;
 479
 480         p = n;
 481         n = smiGetFirstChildNode(n);
 482         while (n != NULL) {
 483                 switch (n->nodekind) {
 484                   case SMI_NODEKIND_SCALAR:
 485                   case SMI_NODEKIND_COLUMN:
 486                         print_stype(n);
 487                         break;
 488                   case SMI_NODEKIND_COMPLIANCE:
 489                   case SMI_NODEKIND_GROUP:
 490                         save_node(n);
 491                         return;
 492                   default:
 493                         break;
 494                 }
 495                 n = smiGetNextChildNode(n);
 496         }
 497
 498         save_node(p);
 499 }
 500
 501 int
 502 main(int argc, char *argv[])
 503 {
 504         int opt;
 505         int flags;
 506         SmiModule **mods;
 507         char *name;
 508         SmiNode *n, *last;
 509         u_int level;
 510         long u;
 511         char *end;
 512
 513         smiInit(NULL);
 514
 515         while ((opt = getopt(argc, argv, "c:Eeh")) != -1)
 516                 switch (opt) {
 517
 518                   case 'c':
 519                         errno = 0;
 520                         u = strtol(optarg, &end, 10);
 521                         if (errno != 0)
 522                                 err(1, "argument to -c");
 523                         if (*end != '\0')
 524                                 err(1, "%s: not a number", optarg);
 525                         if (u < 0 || u > 5)
 526                                 err(1, "%s: out of range", optarg);
 527                         cut = (u_int)u;
 528                         break;
 529
 530                   case 'E':
 531                         do_typedef = 'E';
 532                         break;
 533
 534                   case 'e':
 535                         do_typedef = 'e';
 536                         break;
 537
 538                   case 'h':
 539                         fprintf(stderr, usgtxt);
 540                         exit(0);
 541                 }
 542
 543         argc -= optind;
 544         argv += optind;
 545
 546         flags = smiGetFlags();
 547         flags |= SMI_FLAG_ERRORS;
 548         smiSetFlags(flags);
 549
 550         mods = malloc(sizeof(mods[0]) * argc);
 551         if (mods == NULL)
 552                 err(1, NULL);
 553
 554         for (opt = 0; opt < argc; opt++) {
 555                 if ((name = smiLoadModule(argv[opt])) == NULL)
 556                         err(1, "%s: cannot load", argv[opt]);
 557                 mods[opt] = smiGetModule(name);
 558         }
 559         level = 0;
 560         last = NULL;
 561         for (opt = 0; opt < argc; opt++) {
 562                 n = smiGetFirstNode(mods[opt], SMI_NODEKIND_ANY);
 563                 for (;;) {
 564                         if (do_typedef == 0) {
 565                                 level = open_node(n, level, &last);
 566                                 print_it(n, level);
 567                                 last = n;
 568                         } else
 569                                 print_typdefs(n);
 570
 571                         if (last_node == NULL ||
 572                             (n = smiGetNextNode(last_node, SMI_NODEKIND_ANY))
 573                             == NULL)
 574                                 break;
 575                 }
 576         }
 577         if (last != NULL && do_typedef == 0)
 578                 level = close_node(last->oidlen - 1, level - 1);
 579         else if (do_typedef != 0)
 580                 tdefs_cleanup();
 581
 582         return (0);
 583 }