usr.sbin/bsnmpd/tools/libbsnmptools/bsnmpmap.c

   1 /*-
   2  * Copyright (c) 2006 The FreeBSD Project
   3  * All rights reserved.
   4  *
   5  * Author: Shteryana Shopova <syrinx@FreeBSD.org>
   6  *
   7  * Redistribution of this software and documentation and use in source and
   8  * binary forms, with or without modification, are permitted provided that
   9  * the following conditions are met:
  10  *
  11  * 1. Redistributions of source code or documentation must retain the above
  12  *    copyright 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 THE 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 THE 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  * $FreeBSD$
  30  */
  31
  32 #include <sys/param.h>
  33 #include <sys/queue.h>
  34 #include <sys/uio.h>
  35
  36 #include <ctype.h>
  37 #include <err.h>
  38 #include <errno.h>
  39 #include <stdio.h>
  40 #include <stdlib.h>
  41 #include <string.h>
  42 #include <syslog.h>
  43 #include <unistd.h>
  44
  45 #include <bsnmp/asn1.h>
  46 #include <bsnmp/snmp.h>
  47 #include "bsnmptc.h"
  48 #include "bsnmptools.h"
  49
  50 #define DEBUG   if (_bsnmptools_debug) fprintf
  51
  52 /* Allocate memory and initialize list. */
  53 struct snmp_mappings *
  54 snmp_mapping_init(void)
  55 {
  56         struct snmp_mappings *m;
  57
  58         if ((m = calloc(1, sizeof(struct snmp_mappings))) == NULL) {
  59                 syslog(LOG_ERR, "malloc() failed: %s", strerror(errno));
  60                 return (NULL);
  61         }
  62
  63         return (m);
  64 }
  65
  66 #define         snmp_nodelist   mappings->nodelist
  67 #define         snmp_intlist    mappings->intlist
  68 #define         snmp_octlist    mappings->octlist
  69 #define         snmp_oidlist    mappings->oidlist
  70 #define         snmp_iplist     mappings->iplist
  71 #define         snmp_ticklist   mappings->ticklist
  72 #define         snmp_cntlist    mappings->cntlist
  73 #define         snmp_gaugelist  mappings->gaugelist
  74 #define         snmp_cnt64list  mappings->cnt64list
  75 #define         snmp_enumlist   mappings->enumlist
  76 #define         snmp_tablelist  mappings->tablelist
  77 #define         snmp_tclist     mappings->tclist
  78
  79 void
  80 enum_pairs_free(struct enum_pairs *headp)
  81 {
  82         struct enum_pair *e;
  83
  84         if (headp == NULL)
  85                 return;
  86
  87         while ((e = STAILQ_FIRST(headp)) != NULL) {
  88                 STAILQ_REMOVE_HEAD(headp, link);
  89
  90                 if (e->enum_str)
  91                         free(e->enum_str);
  92                 free(e);
  93         }
  94
  95         free(headp);
  96 }
  97
  98 void
  99 snmp_mapping_entryfree(struct snmp_oid2str *entry)
 100 {
 101         if (entry->string)
 102                 free(entry->string);
 103
 104         if (entry->tc == SNMP_TC_OWN)
 105                 enum_pairs_free(entry->snmp_enum);
 106
 107         free(entry);
 108 }
 109
 110 static void
 111 snmp_mapping_listfree(struct snmp_mapping *headp)
 112 {
 113         struct snmp_oid2str *p;
 114
 115         while ((p = SLIST_FIRST(headp)) != NULL) {
 116                 SLIST_REMOVE_HEAD(headp, link);
 117
 118                 if (p->string)
 119                         free(p->string);
 120
 121                 if (p->tc == SNMP_TC_OWN)
 122                         enum_pairs_free(p->snmp_enum);
 123                 free(p);
 124         }
 125
 126         SLIST_INIT(headp);
 127 }
 128
 129 void
 130 snmp_index_listfree(struct snmp_idxlist *headp)
 131 {
 132         struct index *i;
 133
 134         while ((i = STAILQ_FIRST(headp)) != NULL) {
 135                 STAILQ_REMOVE_HEAD(headp, link);
 136                 if (i->tc == SNMP_TC_OWN)
 137                         enum_pairs_free(i->snmp_enum);
 138                 free(i);
 139         }
 140
 141         STAILQ_INIT(headp);
 142 }
 143
 144 static void
 145 snmp_mapping_table_listfree(struct snmp_table_index *headp)
 146 {
 147         struct snmp_index_entry *t;
 148
 149         while ((t = SLIST_FIRST(headp)) != NULL) {
 150                 SLIST_REMOVE_HEAD(headp, link);
 151
 152                 if (t->string)
 153                         free(t->string);
 154
 155                 snmp_index_listfree(&(t->index_list));
 156                 free(t);
 157         }
 158 }
 159
 160 static void
 161 snmp_enumtc_listfree(struct snmp_enum_tc *headp)
 162 {
 163         struct enum_type *t;
 164
 165         while ((t = SLIST_FIRST(headp)) != NULL) {
 166                 SLIST_REMOVE_HEAD(headp, link);
 167
 168                 if (t->name)
 169                         free(t->name);
 170                 enum_pairs_free(t->snmp_enum);
 171                 free(t);
 172         }
 173 }
 174
 175 int
 176 snmp_mapping_free(struct snmp_toolinfo *snmptoolctx)
 177 {
 178         if (snmptoolctx == NULL || snmptoolctx->mappings == NULL)
 179                 return (-1);
 180
 181         snmp_mapping_listfree(&snmptoolctx->snmp_nodelist);
 182         snmp_mapping_listfree(&snmptoolctx->snmp_intlist);
 183         snmp_mapping_listfree(&snmptoolctx->snmp_octlist);
 184         snmp_mapping_listfree(&snmptoolctx->snmp_oidlist);
 185         snmp_mapping_listfree(&snmptoolctx->snmp_iplist);
 186         snmp_mapping_listfree(&snmptoolctx->snmp_ticklist);
 187         snmp_mapping_listfree(&snmptoolctx->snmp_cntlist);
 188         snmp_mapping_listfree(&snmptoolctx->snmp_gaugelist);
 189         snmp_mapping_listfree(&snmptoolctx->snmp_cnt64list);
 190         snmp_mapping_listfree(&snmptoolctx->snmp_enumlist);
 191         snmp_mapping_table_listfree(&snmptoolctx->snmp_tablelist);
 192         snmp_enumtc_listfree(&snmptoolctx->snmp_tclist);
 193         free(snmptoolctx->mappings);
 194
 195         return (0);
 196 }
 197
 198 static void
 199 snmp_dump_enumpairs(struct enum_pairs *headp)
 200 {
 201         struct enum_pair *entry;
 202
 203         if (headp == NULL)
 204                 return;
 205
 206         fprintf(stderr,"enums: ");
 207         STAILQ_FOREACH(entry, headp, link)
 208                 fprintf(stderr,"%d - %s, ", entry->enum_val,
 209                     (entry->enum_str == NULL)?"NULL":entry->enum_str);
 210
 211         fprintf(stderr,"; ");
 212 }
 213
 214 void
 215 snmp_dump_oid2str(struct snmp_oid2str *entry)
 216 {
 217         char buf[ASN_OIDSTRLEN];
 218
 219         if (entry != NULL) {
 220                 memset(buf, 0, sizeof(buf));
 221                 asn_oid2str_r(&(entry->var), buf);
 222                 DEBUG(stderr, "%s - %s - %d - %d - %d", buf, entry->string,
 223                     entry->syntax, entry->access, entry->strlen);
 224                 snmp_dump_enumpairs(entry->snmp_enum);
 225                 DEBUG(stderr,"%s \n", (entry->table_idx == NULL)?"No table":
 226                     entry->table_idx->string);
 227         }
 228 }
 229
 230 static void
 231 snmp_dump_indexlist(struct snmp_idxlist *headp)
 232 {
 233         struct index *entry;
 234
 235         if (headp == NULL)
 236                 return;
 237
 238         STAILQ_FOREACH(entry, headp, link) {
 239                 fprintf(stderr,"%d, ", entry->syntax);
 240                 snmp_dump_enumpairs(entry->snmp_enum);
 241         }
 242
 243         fprintf(stderr,"\n");
 244 }
 245
 246 /* Initialize the enum pairs list of a oid2str entry. */
 247 struct enum_pairs *
 248 enum_pairs_init(void)
 249 {
 250         struct enum_pairs *snmp_enum;
 251
 252         if ((snmp_enum = malloc(sizeof(struct enum_pairs))) == NULL) {
 253                 syslog(LOG_ERR, "malloc() failed: %s", strerror(errno));
 254                 return (NULL);
 255         }
 256
 257         STAILQ_INIT(snmp_enum);
 258         return (snmp_enum);
 259 }
 260
 261 /*
 262  * Given a number and string, allocate memory for a (int, string) pair and add
 263  * it to the given oid2str mapping entry's enum pairs list.
 264  */
 265 int32_t
 266 enum_pair_insert(struct enum_pairs *headp, int32_t enum_val, char *enum_str)
 267 {
 268         struct enum_pair *e_new;
 269
 270         if ((e_new = calloc(1, sizeof(struct enum_pair))) == NULL) {
 271                 syslog(LOG_ERR, "calloc() failed: %s", strerror(errno));
 272                 return (-1);
 273         }
 274
 275         if ((e_new->enum_str = strdup(enum_str)) == NULL) {
 276                 syslog(LOG_ERR, "strdup() failed: %s", strerror(errno));
 277                 free(e_new);
 278                 return (-1);
 279         }
 280
 281         e_new->enum_val = enum_val;
 282         STAILQ_INSERT_TAIL(headp, e_new, link);
 283
 284         return (1);
 285
 286 }
 287
 288 /*
 289  * Insert an entry in a list - entries are lexicographicaly order by asn_oid.
 290  * Returns 1 on success, -1 if list is not initialized, 0 if a matching oid already
 291  * exists. Error cheking is left to calling function.
 292  */
 293 static int
 294 snmp_mapping_insert(struct snmp_mapping *headp, struct snmp_oid2str *entry)
 295 {
 296         int32_t rc;
 297         struct snmp_oid2str *temp, *prev;
 298
 299         if (entry == NULL)
 300                 return(-1);
 301
 302         if ((prev = SLIST_FIRST(headp)) == NULL ||
 303             asn_compare_oid(&(entry->var), &(prev->var)) < 0) {
 304                 SLIST_INSERT_HEAD(headp, entry, link);
 305                 return (1);
 306         } else
 307                 rc = -1;        /* Make the compiler happy. */
 308
 309         SLIST_FOREACH(temp, headp, link) {
 310                 if ((rc = asn_compare_oid(&(entry->var), &(temp->var))) <= 0)
 311                         break;
 312                 prev = temp;
 313                 rc = -1;
 314         }
 315
 316         switch (rc) {
 317             case 0:
 318                 /* Ops, matching OIDs - hope the rest info also matches. */
 319                 if (strncmp(temp->string, entry->string, entry->strlen)) {
 320                         syslog(LOG_INFO, "Matching OIDs with different string "
 321                             "mappings: old - %s, new - %s", temp->string,
 322                             entry->string);
 323                         return (-1);
 324                 }
 325                 /*
 326                  * Ok, we have that already.
 327                  * As long as the strings match - don't complain.
 328                  */
 329                 return (0);
 330
 331             case 1:
 332                 SLIST_INSERT_AFTER(temp, entry, link);
 333                 break;
 334
 335             case -1:
 336                 SLIST_INSERT_AFTER(prev, entry, link);
 337                 break;
 338
 339             default:
 340                 /* NOTREACHED */
 341                 return (-1);
 342         }
 343
 344         return (1);
 345 }
 346
 347 int32_t
 348 snmp_node_insert(struct snmp_toolinfo *snmptoolctx, struct snmp_oid2str *entry)
 349 {
 350         if (snmptoolctx != NULL && snmptoolctx->mappings)
 351                 return (snmp_mapping_insert(&snmptoolctx->snmp_nodelist,entry));
 352
 353         return (-1);
 354 }
 355
 356 static int32_t
 357 snmp_int_insert(struct snmp_toolinfo *snmptoolctx, struct snmp_oid2str *entry)
 358 {
 359         if (snmptoolctx != NULL && snmptoolctx->mappings)
 360                 return (snmp_mapping_insert(&snmptoolctx->snmp_intlist,entry));
 361
 362         return (-1);
 363 }
 364
 365 static int32_t
 366 snmp_oct_insert(struct snmp_toolinfo *snmptoolctx, struct snmp_oid2str *entry)
 367 {
 368         if (snmptoolctx != NULL && snmptoolctx->mappings)
 369                 return (snmp_mapping_insert(&snmptoolctx->snmp_octlist,entry));
 370
 371         return (-1);
 372 }
 373
 374 static int32_t
 375 snmp_oid_insert(struct snmp_toolinfo *snmptoolctx, struct snmp_oid2str *entry)
 376 {
 377         if (snmptoolctx != NULL && snmptoolctx->mappings)
 378                 return (snmp_mapping_insert(&snmptoolctx->snmp_oidlist,entry));
 379
 380         return (-1);
 381 }
 382
 383 static int32_t
 384 snmp_ip_insert(struct snmp_toolinfo *snmptoolctx, struct snmp_oid2str *entry)
 385 {
 386         if (snmptoolctx != NULL && snmptoolctx->mappings)
 387                 return (snmp_mapping_insert(&snmptoolctx->snmp_iplist,entry));
 388
 389         return (-1);
 390 }
 391
 392 static int32_t
 393 snmp_tick_insert(struct snmp_toolinfo *snmptoolctx, struct snmp_oid2str *entry)
 394 {
 395         if (snmptoolctx != NULL && snmptoolctx->mappings)
 396                 return (snmp_mapping_insert(&snmptoolctx->snmp_ticklist,entry));
 397
 398         return (-1);
 399 }
 400
 401 static int32_t
 402 snmp_cnt_insert(struct snmp_toolinfo *snmptoolctx, struct snmp_oid2str *entry)
 403 {
 404         if (snmptoolctx != NULL && snmptoolctx->mappings)
 405                 return (snmp_mapping_insert(&snmptoolctx->snmp_cntlist,entry));
 406
 407         return (-1);
 408 }
 409
 410 static int32_t
 411 snmp_gauge_insert(struct snmp_toolinfo *snmptoolctx, struct snmp_oid2str *entry)
 412 {
 413         if (snmptoolctx != NULL && snmptoolctx->mappings)
 414                 return (snmp_mapping_insert(&snmptoolctx->snmp_gaugelist,entry));
 415
 416         return (-1);
 417 }
 418
 419 static int32_t
 420 snmp_cnt64_insert(struct snmp_toolinfo *snmptoolctx, struct snmp_oid2str *entry)
 421 {
 422         if (snmptoolctx != NULL && snmptoolctx->mappings)
 423                 return (snmp_mapping_insert(&snmptoolctx->snmp_cnt64list,entry));
 424
 425         return (-1);
 426 }
 427
 428 int32_t
 429 snmp_enum_insert(struct snmp_toolinfo *snmptoolctx, struct snmp_oid2str *entry)
 430 {
 431         if (snmptoolctx != NULL && snmptoolctx->mappings)
 432                 return (snmp_mapping_insert(&snmptoolctx->snmp_enumlist,entry));
 433
 434         return (-1);
 435 }
 436
 437 int32_t
 438 snmp_leaf_insert(struct snmp_toolinfo *snmptoolctx, struct snmp_oid2str *entry)
 439 {
 440         switch (entry->syntax) {
 441                 case SNMP_SYNTAX_INTEGER:
 442                         return (snmp_int_insert(snmptoolctx, entry));
 443                 case SNMP_SYNTAX_OCTETSTRING:
 444                         return (snmp_oct_insert(snmptoolctx, entry));
 445                 case SNMP_SYNTAX_OID:
 446                         return (snmp_oid_insert(snmptoolctx, entry));
 447                 case SNMP_SYNTAX_IPADDRESS:
 448                         return (snmp_ip_insert(snmptoolctx, entry));
 449                 case SNMP_SYNTAX_COUNTER:
 450                         return (snmp_cnt_insert(snmptoolctx, entry));
 451                 case SNMP_SYNTAX_GAUGE:
 452                         return (snmp_gauge_insert(snmptoolctx, entry));
 453                 case SNMP_SYNTAX_TIMETICKS:
 454                         return (snmp_tick_insert(snmptoolctx, entry));
 455                 case SNMP_SYNTAX_COUNTER64:
 456                         return (snmp_cnt64_insert(snmptoolctx, entry));
 457                 default:
 458                         break;
 459         }
 460
 461         return (-1);
 462 }
 463
 464 static int32_t
 465 snmp_index_insert(struct snmp_idxlist *headp, struct index *idx)
 466 {
 467         if (headp == NULL || idx == NULL)
 468                 return (-1);
 469
 470         STAILQ_INSERT_TAIL(headp, idx, link);
 471         return (1);
 472 }
 473
 474 int32_t
 475 snmp_syntax_insert(struct snmp_idxlist *headp, struct enum_pairs *enums,
 476     enum snmp_syntax syntax, enum snmp_tc tc)
 477 {
 478         struct index *idx;
 479
 480         if ((idx = calloc(1, sizeof(struct index))) == NULL) {
 481                 syslog(LOG_ERR, "malloc() failed: %s", strerror(errno));
 482                 return (-1);
 483         }
 484
 485         if (snmp_index_insert(headp, idx) < 0) {
 486                 free(idx);
 487                 return (-1);
 488         }
 489
 490         idx->syntax = syntax;
 491         idx->snmp_enum = enums;
 492         idx->tc = tc;
 493
 494         return (1);
 495 }
 496
 497 int32_t
 498 snmp_table_insert(struct snmp_toolinfo *snmptoolctx,
 499     struct snmp_index_entry *entry)
 500 {
 501         int32_t rc;
 502         struct snmp_index_entry *temp, *prev;
 503
 504         if (snmptoolctx == NULL || snmptoolctx->mappings == NULL ||
 505             entry == NULL)
 506                 return(-1);
 507
 508         if ((prev = SLIST_FIRST(&snmptoolctx->snmp_tablelist)) == NULL ||
 509             asn_compare_oid(&(entry->var), &(prev->var)) < 0) {
 510                 SLIST_INSERT_HEAD(&snmptoolctx->snmp_tablelist, entry, link);
 511                 return (1);
 512         } else
 513                 rc = -1;        /* Make the compiler happy. */
 514
 515         SLIST_FOREACH(temp, &snmptoolctx->snmp_tablelist, link) {
 516                 if ((rc = asn_compare_oid(&(entry->var), &(temp->var))) <= 0)
 517                         break;
 518                 prev = temp;
 519                 rc = -1;
 520         }
 521
 522         switch (rc) {
 523             case 0:
 524                 /* Ops, matching OIDs - hope the rest info also matches. */
 525                 if (strncmp(temp->string, entry->string, entry->strlen)) {
 526                         syslog(LOG_INFO, "Matching OIDs with different string "
 527                             "mapping - old - %s, new - %s", temp->string,
 528                             entry->string);
 529                         return (-1);
 530                 }
 531                 return(0);
 532
 533             case 1:
 534                 SLIST_INSERT_AFTER(temp, entry, link);
 535                 break;
 536
 537             case -1:
 538                 SLIST_INSERT_AFTER(prev, entry, link);
 539                 break;
 540
 541             default:
 542                 /* NOTREACHED */
 543                 return (-1);
 544         }
 545
 546         return (1);
 547 }
 548
 549 struct enum_type *
 550 snmp_enumtc_init(char *name)
 551 {
 552         struct enum_type *enum_tc;
 553
 554         if ((enum_tc = calloc(1, sizeof(struct enum_type))) == NULL) {
 555                 syslog(LOG_ERR, "malloc() failed: %s", strerror(errno));
 556                 return (NULL);
 557         }
 558
 559         if ((enum_tc->name = strdup(name)) == NULL) {
 560                 syslog(LOG_ERR, "malloc() failed: %s", strerror(errno));
 561                 free(enum_tc);
 562                 return (NULL);
 563         }
 564
 565         return (enum_tc);
 566 }
 567
 568 void
 569 snmp_enumtc_free(struct enum_type *tc)
 570 {
 571         if (tc->name)
 572                 free(tc->name);
 573         if (tc->snmp_enum)
 574                 enum_pairs_free(tc->snmp_enum);
 575         free(tc);
 576 }
 577
 578 void
 579 snmp_enumtc_insert(struct snmp_toolinfo *snmptoolctx, struct enum_type *entry)
 580 {
 581         if (snmptoolctx == NULL || snmptoolctx->mappings == NULL)
 582                 return; /* XXX no error handling? */
 583
 584         SLIST_INSERT_HEAD(&snmptoolctx->snmp_tclist, entry, link);
 585 }
 586
 587 struct enum_type *
 588 snmp_enumtc_lookup(struct snmp_toolinfo *snmptoolctx, char *name)
 589 {
 590         struct enum_type *temp;
 591
 592         if (snmptoolctx == NULL || snmptoolctx->mappings == NULL)
 593                 return (NULL);
 594
 595         SLIST_FOREACH(temp, &snmptoolctx->snmp_tclist, link) {
 596                 if (strcmp(temp->name, name) == 0)
 597                         return (temp);
 598         }
 599         return (NULL);
 600 }
 601
 602 static void
 603 snmp_mapping_dumplist(struct snmp_mapping *headp)
 604 {
 605         char buf[ASN_OIDSTRLEN];
 606         struct snmp_oid2str *entry;
 607
 608         if (headp == NULL)
 609                 return;
 610
 611         SLIST_FOREACH(entry,headp,link) {
 612                 memset(buf, 0, sizeof(buf));
 613                 asn_oid2str_r(&(entry->var), buf);
 614                 fprintf(stderr, "%s - %s - %d - %d - %d", buf, entry->string,
 615                     entry->syntax, entry->access ,entry->strlen);
 616                 fprintf(stderr," - %s \n", (entry->table_idx == NULL)?
 617                     "No table":entry->table_idx->string);
 618         }
 619 }
 620
 621 static void
 622 snmp_mapping_dumptable(struct snmp_table_index *headp)
 623 {
 624         char buf[ASN_OIDSTRLEN];
 625         struct snmp_index_entry *entry;
 626
 627         if (headp == NULL)
 628                 return;
 629
 630         SLIST_FOREACH(entry, headp, link) {
 631                 memset(buf, 0, sizeof(buf));
 632                 asn_oid2str_r(&(entry->var), buf);
 633                 fprintf(stderr,"%s - %s - %d - ", buf, entry->string,
 634                     entry->strlen);
 635                 snmp_dump_indexlist(&(entry->index_list));
 636         }
 637 }
 638
 639 void
 640 snmp_mapping_dump(struct snmp_toolinfo *snmptoolctx /* int bits */)
 641 {
 642         if (!_bsnmptools_debug)
 643                 return;
 644
 645         if (snmptoolctx == NULL) {
 646                 fprintf(stderr,"No snmptool context!\n");
 647                 return;
 648         }
 649
 650         if (snmptoolctx->mappings == NULL) {
 651                 fprintf(stderr,"No mappings!\n");
 652                 return;
 653         }
 654
 655         fprintf(stderr,"snmp_nodelist:\n");
 656         snmp_mapping_dumplist(&snmptoolctx->snmp_nodelist);
 657
 658         fprintf(stderr,"snmp_intlist:\n");
 659         snmp_mapping_dumplist(&snmptoolctx->snmp_intlist);
 660
 661         fprintf(stderr,"snmp_octlist:\n");
 662         snmp_mapping_dumplist(&snmptoolctx->snmp_octlist);
 663
 664         fprintf(stderr,"snmp_oidlist:\n");
 665         snmp_mapping_dumplist(&snmptoolctx->snmp_oidlist);
 666
 667         fprintf(stderr,"snmp_iplist:\n");
 668         snmp_mapping_dumplist(&snmptoolctx->snmp_iplist);
 669
 670         fprintf(stderr,"snmp_ticklist:\n");
 671         snmp_mapping_dumplist(&snmptoolctx->snmp_ticklist);
 672
 673         fprintf(stderr,"snmp_cntlist:\n");
 674         snmp_mapping_dumplist(&snmptoolctx->snmp_cntlist);
 675
 676         fprintf(stderr,"snmp_gaugelist:\n");
 677         snmp_mapping_dumplist(&snmptoolctx->snmp_gaugelist);
 678
 679         fprintf(stderr,"snmp_cnt64list:\n");
 680         snmp_mapping_dumplist(&snmptoolctx->snmp_cnt64list);
 681
 682         fprintf(stderr,"snmp_enumlist:\n");
 683         snmp_mapping_dumplist(&snmptoolctx->snmp_enumlist);
 684
 685         fprintf(stderr,"snmp_tablelist:\n");
 686         snmp_mapping_dumptable(&snmptoolctx->snmp_tablelist);
 687 }
 688
 689 char *
 690 enum_string_lookup(struct enum_pairs *headp, int32_t enum_val)
 691 {
 692         struct enum_pair *temp;
 693
 694         if (headp == NULL)
 695                 return (NULL);
 696
 697         STAILQ_FOREACH(temp, headp, link) {
 698                 if (temp->enum_val == enum_val)
 699                         return (temp->enum_str);
 700         }
 701
 702         return (NULL);
 703 }
 704
 705 int32_t
 706 enum_number_lookup(struct enum_pairs *headp, char *e_str)
 707 {
 708         struct enum_pair *tmp;
 709
 710         if (headp == NULL)
 711                 return (-1);
 712
 713         STAILQ_FOREACH(tmp, headp, link)
 714                 if (strncmp(tmp->enum_str, e_str, strlen(tmp->enum_str)) == 0)
 715                         return (tmp->enum_val);
 716
 717         return (-1);
 718 }
 719
 720 static int32_t
 721 snmp_lookuplist_string(struct snmp_mapping *headp, struct snmp_object *s)
 722 {
 723         struct snmp_oid2str *temp;
 724
 725         if (headp == NULL)
 726                 return (-1);
 727
 728         SLIST_FOREACH(temp, headp, link)
 729                 if (asn_compare_oid(&(temp->var), &(s->val.var)) == 0)
 730                         break;
 731
 732         if ((s->info = temp) == NULL)
 733                 return (-1);
 734
 735         return (1);
 736 }
 737
 738 /* provided an asn_oid find the corresponding string for it */
 739 static int32_t
 740 snmp_lookup_leaf(struct snmp_mapping *headp, struct snmp_object *s)
 741 {
 742         struct snmp_oid2str *temp;
 743
 744         if (headp == NULL)
 745                 return (-1);
 746
 747         SLIST_FOREACH(temp,headp,link) {
 748                 if ((asn_compare_oid(&(temp->var), &(s->val.var)) == 0) ||
 749                     (asn_is_suboid(&(temp->var), &(s->val.var)))) {
 750                         s->info = temp;
 751                         return (1);
 752                 }
 753         }
 754
 755         return (-1);
 756 }
 757
 758 int32_t
 759 snmp_lookup_leafstring(struct snmp_toolinfo *snmptoolctx, struct snmp_object *s)
 760 {
 761         if (snmptoolctx == NULL || snmptoolctx->mappings == NULL || s == NULL)
 762                 return (-1);
 763
 764         switch (s->val.syntax) {
 765                 case SNMP_SYNTAX_INTEGER:
 766                         return (snmp_lookup_leaf(&snmptoolctx->snmp_intlist, s));
 767                 case SNMP_SYNTAX_OCTETSTRING:
 768                         return (snmp_lookup_leaf(&snmptoolctx->snmp_octlist, s));
 769                 case SNMP_SYNTAX_OID:
 770                         return (snmp_lookup_leaf(&snmptoolctx->snmp_oidlist, s));
 771                 case SNMP_SYNTAX_IPADDRESS:
 772                         return (snmp_lookup_leaf(&snmptoolctx->snmp_iplist, s));
 773                 case SNMP_SYNTAX_COUNTER:
 774                         return (snmp_lookup_leaf(&snmptoolctx->snmp_cntlist, s));
 775                 case SNMP_SYNTAX_GAUGE:
 776                         return (snmp_lookup_leaf(
 777                             &snmptoolctx->snmp_gaugelist, s));
 778                 case SNMP_SYNTAX_TIMETICKS:
 779                         return (snmp_lookup_leaf(
 780                             &snmptoolctx->snmp_ticklist, s));
 781                 case SNMP_SYNTAX_COUNTER64:
 782                         return (snmp_lookup_leaf(
 783                             &snmptoolctx->snmp_cnt64list, s));
 784                 case SNMP_SYNTAX_NOSUCHOBJECT:
 785                         /* FALLTHROUGH */
 786                 case SNMP_SYNTAX_NOSUCHINSTANCE:
 787                         /* FALLTHROUGH */
 788                 case SNMP_SYNTAX_ENDOFMIBVIEW:
 789                         return (snmp_lookup_allstring(snmptoolctx, s));
 790                 default:
 791                         warnx("Unknown syntax - %d", s->val.syntax);
 792                         break;
 793         }
 794
 795         return (-1);
 796 }
 797
 798 int32_t
 799 snmp_lookup_enumstring(struct snmp_toolinfo *snmptoolctx, struct snmp_object *s)
 800 {
 801         if (snmptoolctx == NULL || snmptoolctx->mappings == NULL || s == NULL)
 802                 return (-1);
 803
 804         return (snmp_lookuplist_string(&snmptoolctx->snmp_enumlist, s));
 805 }
 806
 807 int32_t
 808 snmp_lookup_oidstring(struct snmp_toolinfo *snmptoolctx, struct snmp_object *s)
 809 {
 810         if (snmptoolctx == NULL || snmptoolctx->mappings == NULL || s == NULL)
 811                 return (-1);
 812
 813         return (snmp_lookuplist_string(&snmptoolctx->snmp_oidlist, s));
 814 }
 815
 816 int32_t
 817 snmp_lookup_nodestring(struct snmp_toolinfo *snmptoolctx, struct snmp_object *s)
 818 {
 819         if (snmptoolctx == NULL || snmptoolctx->mappings == NULL || s == NULL)
 820                 return (-1);
 821
 822         return (snmp_lookuplist_string(&snmptoolctx->snmp_nodelist, s));
 823 }
 824
 825 int32_t
 826 snmp_lookup_allstring(struct snmp_toolinfo *snmptoolctx, struct snmp_object *s)
 827 {
 828         if (snmptoolctx == NULL || snmptoolctx->mappings == NULL)
 829                 return (-1);
 830
 831         if (snmp_lookup_leaf(&snmptoolctx->snmp_intlist, s) > 0)
 832                 return (1);
 833         if (snmp_lookup_leaf(&snmptoolctx->snmp_octlist, s) > 0)
 834                 return (1);
 835         if (snmp_lookup_leaf(&snmptoolctx->snmp_oidlist, s) > 0)
 836                 return (1);
 837         if (snmp_lookup_leaf(&snmptoolctx->snmp_iplist, s) > 0)
 838                 return (1);
 839         if (snmp_lookup_leaf(&snmptoolctx->snmp_cntlist, s) > 0)
 840                 return (1);
 841         if (snmp_lookup_leaf(&snmptoolctx->snmp_gaugelist, s) > 0)
 842                 return (1);
 843         if (snmp_lookup_leaf(&snmptoolctx->snmp_ticklist, s) > 0)
 844                 return (1);
 845         if (snmp_lookup_leaf(&snmptoolctx->snmp_cnt64list, s) > 0)
 846                 return (1);
 847         if (snmp_lookuplist_string(&snmptoolctx->snmp_enumlist, s) > 0)
 848                 return (1);
 849         if (snmp_lookuplist_string(&snmptoolctx->snmp_nodelist, s) > 0)
 850                 return (1);
 851
 852         return (-1);
 853 }
 854
 855 int32_t
 856 snmp_lookup_nonleaf_string(struct snmp_toolinfo *snmptoolctx,
 857     struct snmp_object *s)
 858 {
 859         if (snmptoolctx == NULL)
 860                 return (-1);
 861
 862         if (snmp_lookuplist_string(&snmptoolctx->snmp_nodelist, s) > 0)
 863                 return (1);
 864         if (snmp_lookuplist_string(&snmptoolctx->snmp_enumlist, s) > 0)
 865                 return (1);
 866
 867         return (-1);
 868 }
 869
 870 static int32_t
 871 snmp_lookup_oidlist(struct snmp_mapping *hp, struct snmp_object *s, char *oid)
 872 {
 873         struct snmp_oid2str *temp;
 874
 875         if (hp == NULL)
 876                 return (-1);
 877
 878         SLIST_FOREACH(temp, hp, link) {
 879                 if (temp->strlen != strlen(oid))
 880                         continue;
 881
 882                 if (strncmp(temp->string, oid, temp->strlen))
 883                         continue;
 884
 885                 s->val.syntax = temp->syntax;
 886                 s->info = temp;
 887                 asn_append_oid(&(s->val.var), &(temp->var));
 888                 return (1);
 889         }
 890
 891         return (-1);
 892 }
 893
 894 static int32_t
 895 snmp_lookup_tablelist(struct snmp_toolinfo *snmptoolctx,
 896     struct snmp_table_index *headp, struct snmp_object *s, char *oid)
 897 {
 898         struct snmp_index_entry *temp;
 899
 900         if (snmptoolctx == NULL || headp == NULL)
 901                 return (-1);
 902
 903         SLIST_FOREACH(temp, headp, link) {
 904                 if (temp->strlen != strlen(oid))
 905                         continue;
 906
 907                 if (strncmp(temp->string, oid, temp->strlen))
 908                         continue;
 909
 910                 /*
 911                  * Another hack here - if we were given a table name
 912                  * return the corresponding pointer to it's entry.
 913                  * That should not change the reponce we'll get.
 914                  */
 915                 s->val.syntax = SNMP_SYNTAX_NULL;
 916                 asn_append_oid(&(s->val.var), &(temp->var));
 917                 if (snmp_lookup_leaf(&snmptoolctx->snmp_nodelist, s) > 0)
 918                         return (1);
 919                 else
 920                         return (-1);
 921         }
 922
 923         return (-1);
 924 }
 925
 926 int32_t
 927 snmp_lookup_oidall(struct snmp_toolinfo *snmptoolctx, struct snmp_object *s,
 928     char *oid)
 929 {
 930         if (snmptoolctx == NULL || s == NULL || oid == NULL)
 931                 return (-1);
 932
 933         if (snmp_lookup_oidlist(&snmptoolctx->snmp_intlist, s, oid) > 0)
 934                 return (1);
 935         if (snmp_lookup_oidlist(&snmptoolctx->snmp_octlist, s, oid) > 0)
 936                 return (1);
 937         if (snmp_lookup_oidlist(&snmptoolctx->snmp_oidlist, s, oid) > 0)
 938                 return (1);
 939         if (snmp_lookup_oidlist(&snmptoolctx->snmp_iplist, s, oid) > 0)
 940                 return (1);
 941         if (snmp_lookup_oidlist(&snmptoolctx->snmp_ticklist, s, oid) > 0)
 942                 return (1);
 943         if (snmp_lookup_oidlist(&snmptoolctx->snmp_cntlist, s, oid) > 0)
 944                 return (1);
 945         if (snmp_lookup_oidlist(&snmptoolctx->snmp_gaugelist, s, oid) > 0)
 946                 return (1);
 947         if (snmp_lookup_oidlist(&snmptoolctx->snmp_cnt64list, s, oid) > 0)
 948                 return (1);
 949         if (snmp_lookup_oidlist(&snmptoolctx->snmp_nodelist, s, oid) > 0)
 950                 return (1);
 951         if (snmp_lookup_tablelist(snmptoolctx, &snmptoolctx->snmp_tablelist,
 952             s, oid) > 0)
 953                 return (1);
 954
 955         return (-1);
 956 }
 957
 958 int32_t
 959 snmp_lookup_enumoid(struct snmp_toolinfo *snmptoolctx, struct snmp_object *s,
 960     char *oid)
 961 {
 962         if (snmptoolctx == NULL || s == NULL)
 963                 return (-1);
 964
 965         return (snmp_lookup_oidlist(&snmptoolctx->snmp_enumlist, s, oid));
 966 }
 967
 968 int32_t
 969 snmp_lookup_oid(struct snmp_toolinfo *snmptoolctx, struct snmp_object *s,
 970     char *oid)
 971 {
 972         if (snmptoolctx == NULL || s == NULL)
 973                 return (-1);
 974
 975         switch (s->val.syntax) {
 976                 case SNMP_SYNTAX_INTEGER:
 977                         return (snmp_lookup_oidlist(&snmptoolctx->snmp_intlist,
 978                             s, oid));
 979                 case SNMP_SYNTAX_OCTETSTRING:
 980                         return (snmp_lookup_oidlist(&snmptoolctx->snmp_octlist,
 981                             s, oid));
 982                 case SNMP_SYNTAX_OID:
 983                         return (snmp_lookup_oidlist(&snmptoolctx->snmp_oidlist,
 984                             s, oid));
 985                 case SNMP_SYNTAX_IPADDRESS:
 986                         return (snmp_lookup_oidlist(&snmptoolctx->snmp_iplist,
 987                             s, oid));
 988                 case SNMP_SYNTAX_COUNTER:
 989                         return (snmp_lookup_oidlist(&snmptoolctx->snmp_cntlist,
 990                             s, oid));
 991                 case SNMP_SYNTAX_GAUGE:
 992                         return (snmp_lookup_oidlist(&snmptoolctx->snmp_gaugelist,
 993                             s, oid));
 994                 case SNMP_SYNTAX_TIMETICKS:
 995                         return (snmp_lookup_oidlist(&snmptoolctx->snmp_ticklist,
 996                             s, oid));
 997                 case SNMP_SYNTAX_COUNTER64:
 998                         return (snmp_lookup_oidlist(&snmptoolctx->snmp_cnt64list,
 999                             s, oid));
1000                 case SNMP_SYNTAX_NULL:
1001                         return (snmp_lookup_oidlist(&snmptoolctx->snmp_nodelist,
1002                             s, oid));
1003                 default:
1004                         warnx("Unknown syntax - %d", s->val.syntax);
1005                         break;
1006         }
1007
1008         return (-1);
1009 }