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