contrib/bsnmp/snmpd/config.c

   1 /*
   2  * Copyright (c) 2001-2003
   3  *      Fraunhofer Institute for Open Communication Systems (FhG Fokus).
   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: bsnmp/snmpd/config.c,v 1.25 2006/02/14 09:04:20 brandt_h Exp $
  30  *
  31  * Parse configuration file.
  32  */
  33 #include <sys/types.h>
  34 #include <sys/queue.h>
  35 #include <sys/socket.h>
  36 #include <sys/un.h>
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40 #include <stdarg.h>
  41 #include <ctype.h>
  42 #include <errno.h>
  43 #include <syslog.h>
  44 #include <unistd.h>
  45 #include <limits.h>
  46 #include <netdb.h>
  47 #include <setjmp.h>
  48 #include <inttypes.h>
  49
  50 #include "snmpmod.h"
  51 #include "snmpd.h"
  52 #include "tree.h"
  53
  54 /*
  55 #define DEBUGGING
  56 */
  57
  58 /*
  59  * config_file: EMPTY | config_file line
  60  *
  61  * line: oid '=' value
  62  *     | '%' STRING
  63  *     | STRING := REST_OF_LINE
  64  *     | STRING ?= REST_OF_LINE
  65  *     | . INCLUDE STRING
  66  *
  67  * oid: STRING suboid
  68  *
  69  * suboid: EMPTY | suboid '.' subid
  70  *
  71  * subid: NUM | STRING | '[' STRING ']'
  72  *
  73  * value: EMPTY | STRING | NUM
  74  */
  75
  76 /*
  77  * Input context for macros and includes
  78  */
  79 enum input_type {
  80         INPUT_FILE      = 1,
  81         INPUT_STRING
  82 };
  83 struct input {
  84         enum input_type type;
  85         union {
  86             struct {
  87                 FILE    *fp;
  88                 char    *filename;
  89                 u_int   lno;
  90             }           file;
  91             struct {
  92                 char    *macro;
  93                 char    *str;
  94                 char    *ptr;
  95                 size_t  left;
  96             }           str;
  97         } u;
  98         LIST_ENTRY(input) link;
  99 };
 100 static LIST_HEAD(, input) inputs;
 101
 102 #define input_fp        u.file.fp
 103 #define input_filename  u.file.filename
 104 #define input_lno       u.file.lno
 105 #define input_macro     u.str.macro
 106 #define input_str       u.str.str
 107 #define input_ptr       u.str.ptr
 108 #define input_left      u.str.left
 109
 110 static int input_push;
 111 static int input_buf[2];
 112
 113 /*
 114  * Configuration data. The configuration file is handled as one single
 115  * SNMP transaction. So we need to keep the assignment data for the
 116  * commit or rollback pass. Note, that dependencies and finish functions
 117  * are NOT allowed here.
 118  */
 119 struct assign {
 120         struct snmp_value value;
 121         struct snmp_scratch scratch;
 122         const char *node_name;
 123
 124         TAILQ_ENTRY(assign) link;
 125 };
 126 static TAILQ_HEAD(assigns, assign) assigns = TAILQ_HEAD_INITIALIZER(assigns);
 127
 128
 129 static struct snmp_context *snmp_ctx;
 130
 131 struct macro {
 132         char    *name;
 133         char    *value;
 134         size_t  length;
 135         LIST_ENTRY(macro) link;
 136         int     perm;
 137 };
 138 static LIST_HEAD(, macro) macros = LIST_HEAD_INITIALIZER(macros);
 139
 140 enum {
 141         TOK_EOF = 0200,
 142         TOK_EOL,
 143         TOK_NUM,
 144         TOK_STR,
 145         TOK_HOST,
 146         TOK_ASSIGN,
 147         TOK_QASSIGN,
 148 };
 149
 150 /* lexer values and last token */
 151 static uint64_t numval;
 152 static char     strval[_POSIX2_LINE_MAX];
 153 static size_t   strvallen;
 154 static int      token;
 155
 156 /* error return */
 157 static jmp_buf  errjmp[4];
 158 static volatile int errstk;
 159
 160 # define ERRPUSH()      (setjmp(errjmp[errstk++]))
 161 # define ERRPOP()       ((void)(errstk--))
 162 # define ERRNEXT()      (longjmp(errjmp[--errstk], 1))
 163 # define ERR()          (longjmp(errjmp[--errstk], 1))
 164
 165 /* section context */
 166 static int ignore;
 167
 168 /*
 169  * Report an error and jump to the error label
 170  */
 171 static void report(const char *fmt, ...) __dead2 __printflike(1, 2);
 172
 173 static void
 174 report(const char *fmt, ...)
 175 {
 176         va_list ap;
 177         const struct input *input;
 178
 179         va_start(ap, fmt);
 180         vsyslog(LOG_ERR, fmt, ap);
 181         va_end(ap);
 182
 183         LIST_FOREACH(input, &inputs, link) {
 184                 switch (input->type) {
 185
 186                   case INPUT_FILE:
 187                         syslog(LOG_ERR, "  in file %s line %u",
 188                             input->input_filename, input->input_lno);
 189                         break;
 190
 191                   case INPUT_STRING:
 192                         syslog(LOG_ERR, "  in macro %s pos %td",
 193                             input->input_macro,
 194                             input->input_ptr - input->input_str);
 195                         break;
 196                 }
 197         }
 198         ERR();
 199 }
 200
 201 /*
 202  * Open a file for input
 203  */
 204 static int
 205 input_open_file(const char *fname, int sysdir)
 206 {
 207         struct input *input;
 208         FILE *fp;
 209         char path[PATH_MAX + 1];
 210         const char *col;
 211         const char *ptr;
 212
 213         if (sysdir) {
 214                 ptr = syspath;
 215                 fp = NULL;
 216                 while (*ptr != '\0') {
 217                         if ((col = strchr(ptr, ':')) == NULL) {
 218                                 snprintf(path, sizeof(path), "%s/%s",
 219                                     ptr, fname);
 220                                 col = ptr + strlen(ptr) - 1;
 221                         } else if (col == ptr)
 222                                 snprintf(path, sizeof(path), "./%s", fname);
 223                         else
 224                                 snprintf(path, sizeof(path), "%.*s/%s",
 225                                     (int)(col - ptr), ptr, fname);
 226                         if ((fp = fopen(path, "r")) != NULL)
 227                                 break;
 228                         ptr = col + 1;
 229                 }
 230         } else
 231                 fp = fopen(fname, "r");
 232
 233         if (fp == NULL)
 234                 report("%s: %m", fname);
 235
 236         if ((input = malloc(sizeof(*input))) == NULL) {
 237                 fclose(fp);
 238                 return (-1);
 239         }
 240         if ((input->input_filename = malloc(strlen(fname) + 1)) == NULL) {
 241                 fclose(fp);
 242                 free(input);
 243                 return (-1);
 244         }
 245         strcpy(input->input_filename, fname);
 246         input->input_fp = fp;
 247         input->input_lno = 1;
 248         input->type = INPUT_FILE;
 249         LIST_INSERT_HEAD(&inputs, input, link);
 250         return (0);
 251 }
 252
 253 /*
 254  * Make a macro the next input
 255  */
 256 static void
 257 input_open_macro(struct macro *m)
 258 {
 259         struct input *input;
 260
 261         if ((input = malloc(sizeof(*input))) == NULL)
 262                 report("%m");
 263         input->type = INPUT_STRING;
 264         input->input_macro = m->name;
 265         if ((input->input_str = malloc(m->length)) == NULL) {
 266                 free(input);
 267                 report("%m");
 268         }
 269         memcpy(input->input_str, m->value, m->length);
 270         input->input_ptr = input->input_str;
 271         input->input_left = m->length;
 272         LIST_INSERT_HEAD(&inputs, input, link);
 273 }
 274
 275 /*
 276  * Close top input source
 277  */
 278 static void
 279 input_close(void)
 280 {
 281         struct input *input;
 282
 283         if ((input = LIST_FIRST(&inputs)) == NULL)
 284                 abort();
 285         switch (input->type) {
 286
 287           case INPUT_FILE:
 288                 fclose(input->input_fp);
 289                 free(input->input_filename);
 290                 break;
 291
 292           case INPUT_STRING:
 293                 free(input->input_str);
 294                 break;
 295         }
 296         LIST_REMOVE(input, link);
 297         free(input);
 298 }
 299
 300 /*
 301  * Close all inputs
 302  */
 303 static void
 304 input_close_all(void)
 305 {
 306         while (!LIST_EMPTY(&inputs))
 307                 input_close();
 308 }
 309
 310 /*
 311  * Push back one character
 312  */
 313 static void
 314 input_ungetc(int c)
 315 {
 316         if (c == EOF)
 317                 report("pushing EOF");
 318         if (input_push == 2)
 319                 report("pushing third char");
 320         input_buf[input_push++] = c;
 321 }
 322
 323
 324 /*
 325  * Return next character from the input without preprocessing.
 326  */
 327 static int
 328 input_getc_raw(void)
 329 {
 330         int c;
 331         struct input *input;
 332
 333         if (input_push != 0) {
 334                 c = input_buf[--input_push];
 335                 goto ok;
 336         }
 337         while ((input = LIST_FIRST(&inputs)) != NULL) {
 338                 switch (input->type) {
 339
 340                   case INPUT_FILE:
 341                         if ((c = getc(input->input_fp)) == EOF) {
 342                                 if (ferror(input->input_fp))
 343                                         report("read error: %m");
 344                                 input_close();
 345                                 break;
 346                         }
 347                         if (c == '\n')
 348                                 input->input_lno++;
 349                         goto ok;
 350
 351                   case INPUT_STRING:
 352                         if (input->input_left-- == 0) {
 353                                 input_close();
 354                                 break;
 355                         }
 356                         c = *input->input_ptr++;
 357                         goto ok;
 358                 }
 359         }
 360 # ifdef DEBUGGING
 361         fprintf(stderr, "EOF");
 362 # endif
 363         return (EOF);
 364
 365   ok:
 366 # ifdef DEBUGGING
 367         if (!isascii(c) || !isprint(c))
 368                 fprintf(stderr, "'%#2x'", c);
 369         else
 370                 fprintf(stderr, "'%c'", c);
 371 # endif
 372         return (c);
 373 }
 374
 375 /*
 376  * Get character with and \\n -> processing.
 377  */
 378 static int
 379 input_getc_plain(void)
 380 {
 381         int c;
 382
 383   again:
 384         if ((c = input_getc_raw()) == '\\') {
 385                 if ((c = input_getc_raw()) == '\n')
 386                         goto again;
 387                 if (c != EOF)
 388                         input_ungetc(c);
 389                 return ('\\');
 390         }
 391         return (c);
 392 }
 393
 394 /*
 395  * Get next character with substitution of macros
 396  */
 397 static int
 398 input_getc(void)
 399 {
 400         int c;
 401         struct macro *m;
 402         char    name[_POSIX2_LINE_MAX];
 403         size_t  namelen;
 404
 405   again:
 406         if ((c = input_getc_plain()) != '$')
 407                 return (c);
 408
 409         if ((c = input_getc()) == EOF)
 410                 report("unexpected EOF");
 411         if (c != '(')
 412                 report("expecting '(' after '$'");
 413
 414         namelen = 0;
 415         while ((c = input_getc()) != EOF && c != ')') {
 416                 if (isalpha(c) || c == '_' || (namelen != 0 && isdigit(c)))
 417                         name[namelen++] = c;
 418                 else
 419                         goto badchar;
 420         }
 421         if (c == EOF)
 422                 report("unexpected EOF");
 423         name[namelen++] = '\0';
 424
 425         LIST_FOREACH(m, &macros, link)
 426                 if (strcmp(m->name, name) == 0)
 427                         break;
 428         if (m == NULL)
 429                 report("undefined macro '%s'", name);
 430
 431         input_open_macro(m);
 432         goto again;
 433
 434   badchar:
 435         if (!isascii(c) || !isprint(c))
 436                 report("unexpected character %#2x", (u_int)c);
 437         else
 438                 report("bad character '%c'", c);
 439 }
 440
 441
 442 static void
 443 input_getnum(u_int base, u_int flen)
 444 {
 445         int c;
 446         u_int cnt;
 447
 448         cnt = 0;
 449         numval = 0;
 450         while (flen == 0 || cnt < flen) {
 451                 if ((c = input_getc()) == EOF) {
 452                         if (cnt == 0)
 453                                 report("bad number");
 454                         return;
 455                 }
 456                 if (isdigit(c)) {
 457                         if (base == 8 && (c == '8' || c == '9')) {
 458                                 input_ungetc(c);
 459                                 if (cnt == 0)
 460                                         report("bad number");
 461                                 return;
 462                         }
 463                         numval = numval * base + (c - '0');
 464                 } else if (base == 16 && isxdigit(c)) {
 465                         if (islower(c))
 466                                 numval = numval * base + (c - 'a' + 10);
 467                         else
 468                                 numval = numval * base + (c - 'A' + 10);
 469                 } else {
 470                         input_ungetc(c);
 471                         if (cnt == 0)
 472                                 report("bad number");
 473                         return;
 474                 }
 475                 cnt++;
 476         }
 477 }
 478
 479 static int
 480 # ifdef DEBUGGING
 481 _gettoken(void)
 482 # else
 483 gettoken(void)
 484 # endif
 485 {
 486         int c;
 487         char *end;
 488         static const char esc[] = "abfnrtv";
 489         static const char chr[] = "\a\b\f\n\r\t\v";
 490
 491         /*
 492          * Skip any whitespace before the next token
 493          */
 494         while ((c = input_getc()) != EOF) {
 495                 if (!isspace(c) || c == '\n')
 496                         break;
 497         }
 498         if (c == EOF)
 499                 return (token = TOK_EOF);
 500         if (!isascii(c))
 501                 goto badchar;
 502
 503         /*
 504          * Skip comments
 505          */
 506         if (c == '#') {
 507                 while ((c = input_getc_plain()) != EOF) {
 508                         if (c == '\n')
 509                                 return (token = TOK_EOL);
 510                 }
 511                 goto badeof;
 512         }
 513
 514         /*
 515          * Single character tokens
 516          */
 517         if (c == '\n')
 518                 return (token = TOK_EOL);
 519         if (c == '.' || c == '%' || c == '=' || c == '<' || c == '>')
 520                 return (token = c);
 521         if (c == ':') {
 522                 if ((c = input_getc()) == '=')
 523                         return (token = TOK_ASSIGN);
 524                 input_ungetc(c);
 525                 return (token = ':');
 526         }
 527         if (c == '?') {
 528                 if ((c = input_getc()) == '=')
 529                         return (token = TOK_QASSIGN);
 530                 input_ungetc(c);
 531                 goto badchar;
 532         }
 533
 534         /*
 535          * Sort out numbers
 536          */
 537         if (isdigit(c)) {
 538                 if (c == '0') {
 539                         if ((c = input_getc()) == 'x' || c == 'X') {
 540                                 input_getnum(16, 0);
 541                         } else if (isdigit(c)) {
 542                                 input_ungetc(c);
 543                                 input_getnum(8, 0);
 544                         } else {
 545                                 if (c != EOF)
 546                                         input_ungetc(c);
 547                                 numval = 0;
 548                                 c = 1;
 549                         }
 550                 } else {
 551                         input_ungetc(c);
 552                         input_getnum(10, 0);
 553                 }
 554                 return (token = TOK_NUM);
 555         }
 556
 557         /*
 558          * Must be a string then
 559          */
 560         strvallen = 0;
 561
 562 # define GETC(C) do {                                                   \
 563         if ((c = input_getc()) == EOF)                                  \
 564                 goto badeof;                                            \
 565         if (!isascii(c) || (!isprint(c) && c != '\t'))                  \
 566                 goto badchar;                                           \
 567 } while(0)
 568
 569         if (c == '"') {
 570                 for(;;) {
 571                         GETC(c);
 572                         if (c == '"') {
 573                                 strval[strvallen] = '\0';
 574                                 break;
 575                         }
 576                         if (c != '\\') {
 577                                 strval[strvallen++] = c;
 578                                 continue;
 579                         }
 580                         GETC(c);
 581                         if ((end = strchr(esc, c)) != NULL) {
 582                                 strval[strvallen++] = chr[end - esc];
 583                                 continue;
 584                         }
 585                         if (c == 'x') {
 586                                 input_getnum(16, 2);
 587                                 c = numval;
 588                         } else if (c >= '0' && c <= '7') {
 589                                 input_ungetc(c);
 590                                 input_getnum(8, 3);
 591                                 c = numval;
 592                         }
 593                         strval[strvallen++] = c;
 594                 }
 595 # undef GETC
 596
 597         } else if (c == '[') {
 598                 /*
 599                  * Skip leading space
 600                  */
 601                 while ((c = input_getc()) != EOF && isspace(c))
 602                         ;
 603                 if (c == EOF)
 604                         goto badeof;
 605                 while (c != ']' && !isspace(c)) {
 606                         if (!isalnum(c) && c != '.' && c != '-')
 607                                 goto badchar;
 608                         strval[strvallen++] = c;
 609                         if ((c = input_getc()) == EOF)
 610                                 goto badeof;
 611                 }
 612                 while (c != ']' && isspace(c)) {
 613                         if ((c = input_getc()) == EOF)
 614                                 goto badeof;
 615                 }
 616                 if (c != ']')
 617                         goto badchar;
 618                 strval[strvallen] = '\0';
 619                 return (token = TOK_HOST);
 620
 621         } else if (!isalpha(c) && c != '_') {
 622                 goto badchar;
 623
 624         } else {
 625                 for (;;) {
 626                         strval[strvallen++] = c;
 627                         if ((c = input_getc()) == EOF)
 628                                 goto badeof;
 629                         if (!isalnum(c) && c != '_' && c != '-') {
 630                                 input_ungetc(c);
 631                                 strval[strvallen] = '\0';
 632                                 break;
 633                         }
 634                 }
 635         }
 636
 637         return (token = TOK_STR);
 638
 639   badeof:
 640         report("unexpected EOF");
 641
 642   badchar:
 643         if (!isascii(c) || !isprint(c))
 644                 report("unexpected character %#2x", (u_int)c);
 645         else
 646                 report("bad character '%c'", c);
 647 }
 648
 649 # ifdef DEBUGGING
 650 static int
 651 gettoken()
 652 {
 653         _gettoken();
 654         if (isascii(token) && isprint(token))
 655                 printf("(%c)", token);
 656         else {
 657                 switch (token) {
 658
 659                   case TOK_EOF:
 660                         printf("(EOF)");
 661                         break;
 662                   case TOK_EOL:
 663                         printf("(EOL)");
 664                         break;
 665                   case TOK_NUM:
 666                         printf("(NUM %llu)", numval);
 667                         break;
 668                   case TOK_STR:
 669                         printf("(STR %.*s)", (int)strvallen, strval);
 670                         break;
 671                   case TOK_HOST:
 672                         printf("(HOST %s)", strval);
 673                         break;
 674                   default:
 675                         printf("(%#2x)", token);
 676                         break;
 677                 }
 678         }
 679         return (token);
 680 }
 681 #endif
 682
 683
 684 /*
 685  * Try to execute the assignment.
 686  */
 687 static void
 688 handle_assignment(const struct snmp_node *node, struct asn_oid *vindex,
 689     const struct snmp_value *value)
 690 {
 691         u_int i;
 692         int err;
 693         struct assign *tp;
 694         char nodename[100];
 695
 696         if (node->type == SNMP_NODE_LEAF) {
 697                 /* index must be one single zero or no index at all */
 698                 if (vindex->len > 1 || (vindex->len == 1 &&
 699                     vindex->subs[0] != 0))
 700                         report("bad index on leaf node");
 701                 vindex->len = 1;
 702                 vindex->subs[0] = 0;
 703         } else {
 704                 /* resulting oid must not be too long */
 705                 if (node->oid.len + vindex->len > ASN_MAXOIDLEN)
 706                         report("resulting OID too long");
 707         }
 708
 709         /*
 710          * Get the next assignment entry for the transaction.
 711          */
 712         if ((tp = malloc(sizeof(*tp))) == NULL)
 713                 report("%m");
 714
 715         tp->value = *value;
 716         tp->node_name = node->name;
 717
 718         /*
 719          * Build the OID
 720          */
 721         tp->value.var = node->oid;
 722         for (i = 0; i < vindex->len; i++)
 723                 tp->value.var.subs[tp->value.var.len++] = vindex->subs[i];
 724
 725         /*
 726          * Puzzle together the variables for the call and call the
 727          * set routine. The set routine may make our node pointer
 728          * invalid (if we happend to call the module loader) so
 729          * get a copy of the node name beforehands.
 730          */
 731         snprintf(nodename, sizeof(nodename), "%s", node->name);
 732         snmp_ctx->scratch = &tp->scratch;
 733         snmp_ctx->var_index = 0;
 734         err = (*node->op)(snmp_ctx, &tp->value, node->oid.len, node->index,
 735             SNMP_OP_SET);
 736         if (err != 0) {
 737                 free(tp);
 738                 report("assignment to %s.%s returns %d", nodename,
 739                     asn_oid2str(vindex), err);
 740         }
 741
 742         TAILQ_INSERT_TAIL(&assigns, tp, link);
 743 }
 744
 745
 746 /*
 747  * Parse the section statement
 748  */
 749 static void
 750 parse_section(const struct lmodule *mod)
 751 {
 752         if (token != TOK_STR)
 753                 report("expecting section name");
 754
 755         if (strcmp(strval, "snmpd") == 0) {
 756                 if (mod != NULL)
 757                         /* loading a module - ignore common stuff */
 758                         ignore = 1;
 759                 else
 760                         /* global configuration - don't ignore */
 761                         ignore = 0;
 762         } else {
 763                 if (mod == NULL) {
 764                         /* global configuration - ignore module stuff */
 765                         ignore = 1;
 766                 } else {
 767                         /* loading module - check if it's our section */
 768                         ignore = (strcmp(strval, mod->section) != 0);
 769                 }
 770         }
 771         gettoken();
 772 }
 773
 774 /*
 775  * Convert a hostname to four u_chars
 776  */
 777 static void
 778 gethost(const char *host, u_char *ip)
 779 {
 780         struct addrinfo hints, *res;
 781         int error;
 782         struct sockaddr_in *sain;
 783
 784         memset(&hints, 0, sizeof(hints));
 785         hints.ai_family = AF_INET;
 786         hints.ai_socktype = SOCK_DGRAM;
 787         hints.ai_protocol = IPPROTO_UDP;
 788         hints.ai_flags = AI_PASSIVE;
 789         error = getaddrinfo(host, NULL, &hints, &res);
 790         if (error != 0)
 791                 report("%s: %s", host, gai_strerror(error));
 792         if (res == NULL)
 793                 report("%s: unknown hostname", host);
 794
 795         sain = (struct sockaddr_in *)(void *)res->ai_addr;
 796         sain->sin_addr.s_addr = ntohl(sain->sin_addr.s_addr);
 797         ip[0] = sain->sin_addr.s_addr >> 24;
 798         ip[1] = sain->sin_addr.s_addr >> 16;
 799         ip[2] = sain->sin_addr.s_addr >>  8;
 800         ip[3] = sain->sin_addr.s_addr >>  0;
 801
 802         freeaddrinfo(res);
 803 }
 804
 805 /*
 806  * Parse the left hand side of a config line.
 807  */
 808 static const struct snmp_node *
 809 parse_oid(const char *varname, struct asn_oid *oid)
 810 {
 811         struct snmp_node *node;
 812         u_int i;
 813         u_char ip[4];
 814         struct asn_oid str_oid;
 815
 816         for (node = tree; node < &tree[tree_size]; node++)
 817                 if (strcmp(varname, node->name) == 0)
 818                         break;
 819         if (node == &tree[tree_size])
 820                 node = NULL;
 821
 822         oid->len = 0;
 823         while (token == '.') {
 824                 if (gettoken() == TOK_NUM) {
 825                         if (numval > ASN_MAXID)
 826                                 report("subid too large %#"QUADXFMT, numval);
 827                         if (oid->len == ASN_MAXOIDLEN)
 828                                 report("index too long");
 829                         if (gettoken() != ':')
 830                                 oid->subs[oid->len++] = numval;
 831                         else {
 832                                 str_oid.len = 0;
 833                                 str_oid.subs[str_oid.len++] = numval;
 834                                 while (gettoken() == TOK_NUM) {
 835                                         str_oid.subs[str_oid.len++] = numval;
 836                                         if (gettoken() != ':')
 837                                                 break;
 838                                 }
 839                                 oid->subs[oid->len++] = str_oid.len;
 840                                 asn_append_oid(oid, &str_oid);
 841                         }
 842
 843                 } else if (token == TOK_STR) {
 844                         if (strvallen + oid->len + 1 > ASN_MAXOIDLEN)
 845                                 report("oid too long");
 846                         oid->subs[oid->len++] = strvallen;
 847                         for (i = 0; i < strvallen; i++)
 848                                 oid->subs[oid->len++] = strval[i];
 849                         gettoken();
 850
 851                 } else if (token == TOK_HOST) {
 852                         gethost(strval, ip);
 853                         if (oid->len + 4 > ASN_MAXOIDLEN)
 854                                 report("index too long");
 855                         for (i = 0; i < 4; i++)
 856                                 oid->subs[oid->len++] = ip[i];
 857                         gettoken();
 858                 } else
 859                         report("bad token in index");
 860         }
 861
 862         return (node);
 863 }
 864
 865 /*
 866  * Parse the value for an assignment.
 867  */
 868 static void
 869 parse_syntax_null(struct snmp_value *value __unused)
 870 {
 871         if (token != TOK_EOL)
 872                 report("bad NULL syntax");
 873 }
 874
 875 static void
 876 parse_syntax_integer(struct snmp_value *value)
 877 {
 878         if (token != TOK_NUM)
 879                 report("bad INTEGER syntax");
 880         if (numval > 0x7fffffff)
 881                 report("INTEGER too large %"QUADFMT, numval);
 882
 883         value->v.integer = numval;
 884         gettoken();
 885 }
 886
 887 static void
 888 parse_syntax_counter64(struct snmp_value *value)
 889 {
 890         if (token != TOK_NUM)
 891                 report("bad COUNTER64 syntax");
 892
 893         value->v.counter64 = numval;
 894         gettoken();
 895 }
 896
 897 static void
 898 parse_syntax_octetstring(struct snmp_value *value)
 899 {
 900         u_long alloc;
 901         u_char *noct;
 902
 903         if (token == TOK_STR) {
 904                 value->v.octetstring.len = strvallen;
 905                 value->v.octetstring.octets = malloc(strvallen);
 906                 (void)memcpy(value->v.octetstring.octets, strval, strvallen);
 907                 gettoken();
 908                 return;
 909         }
 910
 911         /* XX:XX:XX syntax */
 912         value->v.octetstring.octets = NULL;
 913         value->v.octetstring.len = 0;
 914
 915         if (token != TOK_NUM)
 916                 /* empty string is allowed */
 917                 return;
 918
 919         if (ERRPUSH()) {
 920                 free(value->v.octetstring.octets);
 921                 ERRNEXT();
 922         }
 923
 924         alloc = 0;
 925         for (;;) {
 926                 if (token != TOK_NUM)
 927                         report("bad OCTETSTRING syntax");
 928                 if (numval > 0xff)
 929                         report("byte value too large");
 930                 if (alloc == value->v.octetstring.len) {
 931                         alloc += 100;
 932                         noct = realloc(value->v.octetstring.octets, alloc);
 933                         if (noct == NULL)
 934                                 report("%m");
 935                         value->v.octetstring.octets = noct;
 936                 }
 937                 value->v.octetstring.octets[value->v.octetstring.len++]
 938                     = numval;
 939                 if (gettoken() != ':')
 940                         break;
 941                 gettoken();
 942         }
 943         ERRPOP();
 944 }
 945
 946 static void
 947 parse_syntax_oid(struct snmp_value *value)
 948 {
 949         value->v.oid.len = 0;
 950
 951         if (token != TOK_NUM)
 952                 return;
 953
 954         for (;;) {
 955                 if (token != TOK_NUM)
 956                         report("bad OID syntax");
 957                 if (numval > ASN_MAXID)
 958                         report("subid too large");
 959                 if (value->v.oid.len == ASN_MAXOIDLEN)
 960                         report("OID too long");
 961                 value->v.oid.subs[value->v.oid.len++] = numval;
 962                 if (gettoken() != '.')
 963                         break;
 964                 gettoken();
 965         }
 966 }
 967
 968 static void
 969 parse_syntax_ipaddress(struct snmp_value *value)
 970 {
 971         int i;
 972         u_char ip[4];
 973
 974         if (token == TOK_NUM) {
 975                 /* numerical address */
 976                 i = 0;
 977                 for (;;) {
 978                         if (numval >= 256)
 979                                 report("ip address part too large");
 980                         value->v.ipaddress[i++] = numval;
 981                         if (i == 4)
 982                                 break;
 983                         if (gettoken() != '.')
 984                                 report("expecting '.' in ip address");
 985                 }
 986                 gettoken();
 987
 988         } else if (token == TOK_HOST) {
 989                 /* host name */
 990                 gethost(strval, ip);
 991                 for (i = 0; i < 4; i++)
 992                         value->v.ipaddress[i] = ip[i];
 993                 gettoken();
 994
 995         } else
 996                 report("bad ip address syntax");
 997 }
 998
 999 static void
1000 parse_syntax_uint32(struct snmp_value *value)
1001 {
1002
1003         if (token != TOK_NUM)
1004                 report("bad number syntax");
1005         if (numval > 0xffffffff)
1006                 report("number too large");
1007         value->v.uint32 = numval;
1008         gettoken();
1009 }
1010
1011 /*
1012  * Parse an assignement line
1013  */
1014 static void
1015 parse_assign(const char *varname)
1016 {
1017         struct snmp_value value;
1018         struct asn_oid vindex;
1019         const struct snmp_node *node;
1020
1021         node = parse_oid(varname, &vindex);
1022         if (token != '=')
1023                 report("'=' expected, got '%c'", token);
1024         gettoken();
1025
1026         if (ignore) {
1027                 /* skip rest of line */
1028                 while (token != TOK_EOL && token != TOK_EOF)
1029                         gettoken();
1030                 return;
1031         }
1032         if (node == NULL)
1033                 report("unknown variable");
1034
1035         switch (value.syntax = node->syntax) {
1036
1037           case SNMP_SYNTAX_NULL:
1038                 parse_syntax_null(&value);
1039                 break;
1040
1041           case SNMP_SYNTAX_INTEGER:
1042                 parse_syntax_integer(&value);
1043                 break;
1044
1045           case SNMP_SYNTAX_COUNTER64:
1046                 parse_syntax_counter64(&value);
1047                 break;
1048
1049           case SNMP_SYNTAX_OCTETSTRING:
1050                 parse_syntax_octetstring(&value);
1051                 break;
1052
1053           case SNMP_SYNTAX_OID:
1054                 parse_syntax_oid(&value);
1055                 break;
1056
1057           case SNMP_SYNTAX_IPADDRESS:
1058                 parse_syntax_ipaddress(&value);
1059                 break;
1060
1061           case SNMP_SYNTAX_COUNTER:
1062           case SNMP_SYNTAX_GAUGE:
1063           case SNMP_SYNTAX_TIMETICKS:
1064                 parse_syntax_uint32(&value);
1065                 break;
1066
1067           case SNMP_SYNTAX_NOSUCHOBJECT:
1068           case SNMP_SYNTAX_NOSUCHINSTANCE:
1069           case SNMP_SYNTAX_ENDOFMIBVIEW:
1070                 abort();
1071         }
1072
1073         if (ERRPUSH()) {
1074                 snmp_value_free(&value);
1075                 ERRNEXT();
1076         }
1077
1078         handle_assignment(node, &vindex, &value);
1079
1080         ERRPOP();
1081 }
1082
1083 /*
1084  * Handle macro definition line
1085  * We have already seen the := and the input now stands at the character
1086  * after the =. Skip whitespace and then call the input routine directly to
1087  * eat up characters.
1088  */
1089 static void
1090 parse_define(const char *varname)
1091 {
1092         char *volatile string;
1093         char *new;
1094         volatile size_t alloc, length;
1095         int c;
1096         struct macro *m;
1097         int t = token;
1098
1099         alloc = 100;
1100         length = 0;
1101         if ((string = malloc(alloc)) == NULL)
1102                 report("%m");
1103
1104         if (ERRPUSH()) {
1105                 free(string);
1106                 ERRNEXT();
1107         }
1108
1109         while ((c = input_getc_plain()) != EOF) {
1110                 if (c == '\n' || !isspace(c))
1111                         break;
1112         }
1113
1114         while (c != EOF && c != '#' && c != '\n') {
1115                 if (alloc == length) {
1116                         alloc *= 2;
1117                         if ((new = realloc(string, alloc)) == NULL)
1118                                 report("%m");
1119                         string = new;
1120                 }
1121                 string[length++] = c;
1122                 c = input_getc_plain();
1123         }
1124         if (c == '#') {
1125                 while ((c = input_getc_plain()) != EOF && c != '\n')
1126                         ;
1127         }
1128         if (c == EOF)
1129                 report("EOF in macro definition");
1130
1131         LIST_FOREACH(m, &macros, link)
1132                 if (strcmp(m->name, varname) == 0)
1133                         break;
1134
1135         if (m == NULL) {
1136                 if ((m = malloc(sizeof(*m))) == NULL)
1137                         report("%m");
1138                 if ((m->name = malloc(strlen(varname) + 1)) == NULL) {
1139                         free(m);
1140                         report("%m");
1141                 }
1142                 strcpy(m->name, varname);
1143                 m->perm = 0;
1144                 LIST_INSERT_HEAD(&macros, m, link);
1145
1146                 m->value = string;
1147                 m->length = length;
1148         } else {
1149                 if (t == TOK_ASSIGN) {
1150                         free(m->value);
1151                         m->value = string;
1152                         m->length = length;
1153                 }
1154         }
1155
1156         token = TOK_EOL;
1157
1158         ERRPOP();
1159 }
1160
1161 /*
1162  * Free all macros
1163  */
1164 static void
1165 macro_free_all(void)
1166 {
1167         static struct macro *m, *m1;
1168
1169         m = LIST_FIRST(&macros);
1170         while (m != NULL) {
1171                 m1 = LIST_NEXT(m, link);
1172                 if (!m->perm) {
1173                         free(m->name);
1174                         free(m->value);
1175                         LIST_REMOVE(m, link);
1176                         free(m);
1177                 }
1178                 m = m1;
1179         }
1180 }
1181
1182 /*
1183  * Parse an include directive and switch to the new file
1184  */
1185 static void
1186 parse_include(void)
1187 {
1188         int sysdir = 0;
1189         char fname[_POSIX2_LINE_MAX];
1190
1191         if (gettoken() == '<') {
1192                 sysdir = 1;
1193                 if (gettoken() != TOK_STR)
1194                         report("expecting filename after in .include");
1195         } else if (token != TOK_STR)
1196                 report("expecting filename after in .include");
1197
1198         strcpy(fname, strval);
1199         if (sysdir && gettoken() != '>')
1200                 report("expecting '>'");
1201         gettoken();
1202         if (input_open_file(fname, sysdir) == -1)
1203                 report("%s: %m", fname);
1204 }
1205
1206 /*
1207  * Parse the configuration file
1208  */
1209 static void
1210 parse_file(const struct lmodule *mod)
1211 {
1212         char varname[_POSIX2_LINE_MAX];
1213
1214         while (gettoken() != TOK_EOF) {
1215                 if (token == TOK_EOL)
1216                         /* empty line */
1217                         continue;
1218                 if (token == '%') {
1219                         gettoken();
1220                         parse_section(mod);
1221                 } else if (token == '.') {
1222                         if (gettoken() != TOK_STR)
1223                                 report("keyword expected after '.'");
1224                         if (strcmp(strval, "include") == 0)
1225                                 parse_include();
1226                         else
1227                                 report("unknown keyword '%s'", strval);
1228                 } else if (token == TOK_STR) {
1229                         strcpy(varname, strval);
1230                         if (gettoken() == TOK_ASSIGN || token == TOK_QASSIGN)
1231                                 parse_define(varname);
1232                         else
1233                                 parse_assign(varname);
1234                 }
1235                 if (token != TOK_EOL)
1236                         report("eol expected");
1237         }
1238 }
1239
1240 /*
1241  * Do rollback on errors
1242  */
1243 static void
1244 do_rollback(void)
1245 {
1246         struct assign *tp;
1247         struct snmp_node *node;
1248
1249         while ((tp = TAILQ_LAST(&assigns, assigns)) != NULL) {
1250                 TAILQ_REMOVE(&assigns, tp, link);
1251                 for (node = tree; node < &tree[tree_size]; node++)
1252                         if (node->name == tp->node_name) {
1253                                 snmp_ctx->scratch = &tp->scratch;
1254                                 (void)(*node->op)(snmp_ctx, &tp->value,
1255                                     node->oid.len, node->index,
1256                                     SNMP_OP_ROLLBACK);
1257                                 break;
1258                         }
1259                 if (node == &tree[tree_size])
1260                         syslog(LOG_ERR, "failed to find node for "
1261                             "rollback");
1262                 snmp_value_free(&tp->value);
1263                 free(tp);
1264         }
1265 }
1266
1267 /*
1268  * Do commit
1269  */
1270 static void
1271 do_commit(void)
1272 {
1273         struct assign *tp;
1274         struct snmp_node *node;
1275
1276         while ((tp = TAILQ_FIRST(&assigns)) != NULL) {
1277                 TAILQ_REMOVE(&assigns, tp, link);
1278                 for (node = tree; node < &tree[tree_size]; node++)
1279                         if (node->name == tp->node_name) {
1280                                 snmp_ctx->scratch = &tp->scratch;
1281                                 (void)(*node->op)(snmp_ctx, &tp->value,
1282                                     node->oid.len, node->index, SNMP_OP_COMMIT);
1283                                 break;
1284                         }
1285                 if (node == &tree[tree_size])
1286                         syslog(LOG_ERR, "failed to find node for commit");
1287                 snmp_value_free(&tp->value);
1288                 free(tp);
1289         }
1290 }
1291
1292 /*
1293  * Read the configuration file. Handle the entire file as one transaction.
1294  *
1295  * If lodmod is NULL, the sections for 'snmpd' and all loaded modules are
1296  * executed. If it is not NULL, only the sections for that module are handled.
1297  */
1298 int
1299 read_config(const char *fname, struct lmodule *lodmod)
1300 {
1301         int err;
1302         char objbuf[ASN_OIDSTRLEN];
1303         char idxbuf[ASN_OIDSTRLEN];
1304
1305         ignore = 0;
1306
1307         input_push = 0;
1308
1309         if (ERRPUSH())
1310                 return (-1);
1311         if (input_open_file(fname, 0) == -1) {
1312                 syslog(LOG_ERR, "%s: %m", fname);
1313                 return (-1);
1314         }
1315         ERRPOP();
1316         community = COMM_INITIALIZE;
1317
1318         if ((snmp_ctx = snmp_init_context()) == NULL) {
1319                 input_close_all();
1320                 syslog(LOG_ERR, "%m");
1321                 return (-1);
1322         }
1323
1324         if (ERRPUSH()) {
1325                 do_rollback();
1326                 input_close_all();
1327                 macro_free_all();
1328                 free(snmp_ctx);
1329                 return (-1);
1330         }
1331         parse_file(lodmod);
1332         ERRPOP();
1333
1334         if ((err = snmp_dep_commit(snmp_ctx)) != SNMP_ERR_NOERROR) {
1335                 syslog(LOG_ERR, "init dep failed: %u %s %s", err,
1336                     asn_oid2str_r(&snmp_ctx->dep->obj, objbuf),
1337                     asn_oid2str_r(&snmp_ctx->dep->idx, idxbuf));
1338                 snmp_dep_rollback(snmp_ctx);
1339                 do_rollback();
1340                 input_close_all();
1341                 macro_free_all();
1342                 free(snmp_ctx);
1343                 return (-1);
1344         }
1345
1346         do_commit();
1347         snmp_dep_finish(snmp_ctx);
1348
1349         macro_free_all();
1350
1351         free(snmp_ctx);
1352
1353         return (0);
1354 }
1355
1356 /*
1357  * Define a permanent macro
1358  */
1359 int
1360 define_macro(const char *name, const char *value)
1361 {
1362         struct macro *m;
1363
1364         if ((m = malloc(sizeof(*m))) == NULL)
1365                 return (-1);
1366         if ((m->name = malloc(strlen(name) + 1)) == NULL) {
1367                 free(m);
1368                 return (-1);
1369         }
1370         strcpy(m->name, name);
1371         if ((m->value = malloc(strlen(value) + 1)) == NULL) {
1372                 free(m->name);
1373                 free(m);
1374                 return (-1);
1375         }
1376         strcpy(m->value, value);
1377         m->length = strlen(value);
1378         m->perm = 1;
1379         LIST_INSERT_HEAD(&macros, m, link);
1380         return (0);
1381 }