contrib/bsnmp/snmpd/main.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  * Copyright (c) 2010 The FreeBSD Foundation
   9  * All rights reserved.
  10  *
  11  * Portions of this software were developed by Shteryana Sotirova Shopova
  12  * under sponsorship from the FreeBSD Foundation.
  13  *
  14  * Redistribution and use in source and binary forms, with or without
  15  * modification, are permitted provided that the following conditions
  16  * are met:
  17  * 1. Redistributions of source code must retain the above copyright
  18  *    notice, this list of conditions and the following disclaimer.
  19  * 2. Redistributions in binary form must reproduce the above copyright
  20  *    notice, this list of conditions and the following disclaimer in the
  21  *    documentation and/or other materials provided with the distribution.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  *
  35  * $Begemot: bsnmp/snmpd/main.c,v 1.100 2006/02/14 09:04:20 brandt_h Exp $
  36  *
  37  * SNMPd main stuff.
  38  */
  39
  40 #include <sys/queue.h>
  41 #include <sys/param.h>
  42 #include <sys/un.h>
  43 #include <sys/ucred.h>
  44 #include <sys/uio.h>
  45 #include <stdio.h>
  46 #include <stdlib.h>
  47 #include <stddef.h>
  48 #include <string.h>
  49 #include <stdarg.h>
  50 #include <ctype.h>
  51 #include <errno.h>
  52 #include <syslog.h>
  53 #include <unistd.h>
  54 #include <signal.h>
  55 #include <dlfcn.h>
  56
  57 #ifdef USE_TCPWRAPPERS
  58 #include <arpa/inet.h>
  59 #include <tcpd.h>
  60 #endif
  61
  62 #include "support.h"
  63 #include "snmpmod.h"
  64 #include "snmpd.h"
  65 #include "tree.h"
  66 #include "oid.h"
  67
  68 #include "trans_inet.h"
  69
  70 #define PATH_PID        "/var/run/%s.pid"
  71 #define PATH_CONFIG     "/etc/%s.config"
  72 #define PATH_ENGINE     "/var/%s.engine"
  73
  74 uint64_t this_tick;     /* start of processing of current packet (absolute) */
  75 uint64_t start_tick;    /* start of processing */
  76
  77 struct systemg systemg = {
  78         NULL,
  79         { 8, { 1, 3, 6, 1, 4, 1, 1115, 7352 }},
  80         NULL, NULL, NULL,
  81         64 + 8 + 4,
  82         0
  83 };
  84 struct debug debug = {
  85         0,              /* dump_pdus */
  86         LOG_DEBUG,      /* log_pri */
  87         0,              /* evdebug */
  88 };
  89
  90 struct snmpd snmpd = {
  91         2048,           /* txbuf */
  92         2048,           /* rxbuf */
  93         0,              /* comm_dis */
  94         0,              /* auth_traps */
  95         {0, 0, 0, 0},   /* trap1addr */
  96         VERS_ENABLE_ALL,/* version_enable */
  97 };
  98 struct snmpd_stats snmpd_stats;
  99
 100 struct snmpd_usmstat snmpd_usmstats;
 101
 102 /* snmpEngine */
 103 struct snmp_engine snmpd_engine;
 104
 105 /* snmpSerialNo */
 106 int32_t snmp_serial_no;
 107
 108 struct snmpd_target_stats snmpd_target_stats;
 109
 110 /* search path for config files */
 111 const char *syspath = PATH_SYSCONFIG;
 112
 113 /* list of all loaded modules */
 114 struct lmodules lmodules = TAILQ_HEAD_INITIALIZER(lmodules);
 115
 116 /* list of loaded modules during start-up in the order they were loaded */
 117 static struct lmodules modules_start = TAILQ_HEAD_INITIALIZER(modules_start);
 118
 119 /* list of all known communities */
 120 struct community_list community_list = TAILQ_HEAD_INITIALIZER(community_list);
 121
 122 /* list of all known USM users */
 123 static struct usm_userlist usm_userlist = SLIST_HEAD_INITIALIZER(usm_userlist);
 124
 125 /* A list of all VACM users configured, including v1, v2c and v3 */
 126 static struct vacm_userlist vacm_userlist =
 127     SLIST_HEAD_INITIALIZER(vacm_userlist);
 128
 129 /* A list of all VACM groups */
 130 static struct vacm_grouplist vacm_grouplist =
 131     SLIST_HEAD_INITIALIZER(vacm_grouplist);
 132
 133 static struct vacm_group vacm_default_group = {
 134         .groupname = "",
 135 };
 136
 137 /* The list of configured access entries */
 138 static struct vacm_accesslist vacm_accesslist =
 139     TAILQ_HEAD_INITIALIZER(vacm_accesslist);
 140
 141 /* The list of configured views */
 142 static struct vacm_viewlist vacm_viewlist =
 143     SLIST_HEAD_INITIALIZER(vacm_viewlist);
 144
 145 /* The list of configured contexts */
 146 static struct vacm_contextlist vacm_contextlist =
 147     SLIST_HEAD_INITIALIZER(vacm_contextlist);
 148
 149 /* list of all installed object resources */
 150 struct objres_list objres_list = TAILQ_HEAD_INITIALIZER(objres_list);
 151
 152 /* community value generator */
 153 static u_int next_community_index = 1;
 154
 155 /* list of all known ranges */
 156 struct idrange_list idrange_list = TAILQ_HEAD_INITIALIZER(idrange_list);
 157
 158 /* identifier generator */
 159 u_int next_idrange = 1;
 160
 161 /* list of all current timers */
 162 struct timer_list timer_list = LIST_HEAD_INITIALIZER(timer_list);
 163
 164 /* list of file descriptors */
 165 struct fdesc_list fdesc_list = LIST_HEAD_INITIALIZER(fdesc_list);
 166
 167 /* program arguments */
 168 static char **progargs;
 169 static int nprogargs;
 170
 171 /* current community */
 172 u_int   community;
 173 static struct community *comm;
 174
 175 /* current USM user */
 176 struct usm_user *usm_user;
 177
 178 /* file names */
 179 static char config_file[MAXPATHLEN + 1];
 180 static char pid_file[MAXPATHLEN + 1];
 181 char engine_file[MAXPATHLEN + 1];
 182
 183 #ifndef USE_LIBBEGEMOT
 184 /* event context */
 185 static evContext evctx;
 186 #endif
 187
 188 /* signal mask */
 189 static sigset_t blocked_sigs;
 190
 191 /* signal handling */
 192 static int work;
 193 #define WORK_DOINFO     0x0001
 194 #define WORK_RECONFIG   0x0002
 195
 196 /* oids */
 197 static const struct asn_oid
 198         oid_snmpMIB = OIDX_snmpMIB,
 199         oid_begemotSnmpd = OIDX_begemotSnmpd,
 200         oid_coldStart = OIDX_coldStart,
 201         oid_authenticationFailure = OIDX_authenticationFailure;
 202
 203 const struct asn_oid oid_zeroDotZero = { 2, { 0, 0 }};
 204
 205 const struct asn_oid oid_usmUnknownEngineIDs =
 206         { 11, { 1, 3, 6, 1, 6, 3, 15, 1, 1, 4, 0}};
 207
 208 const struct asn_oid oid_usmNotInTimeWindows =
 209         { 11, { 1, 3, 6, 1, 6, 3, 15, 1, 1, 2, 0}};
 210
 211 /* request id generator for traps */
 212 u_int trap_reqid;
 213
 214 /* help text */
 215 static const char usgtxt[] = "\
 216 Begemot simple SNMP daemon. Copyright (c) 2001-2002 Fraunhofer Institute for\n\
 217 Open Communication Systems (FhG Fokus). All rights reserved.\n\
 218 Copyright (c) 2010 The FreeBSD Foundation. All rights reserved.\n\
 219 usage: snmpd [-dh] [-c file] [-D options] [-e file] [-I path]\n\
 220              [-l prefix] [-m variable=value] [-p file]\n\
 221 options:\n\
 222   -d            don't daemonize\n\
 223   -h            print this info\n\
 224   -c file       specify configuration file\n\
 225   -D options    debugging options\n\
 226   -e file       specify engine id file\n\
 227   -I path       system include path\n\
 228   -l prefix     default basename for pid and config file\n\
 229   -m var=val    define variable\n\
 230   -p file       specify pid file\n\
 231 ";
 232
 233 /* hosts_access(3) request */
 234 #ifdef USE_TCPWRAPPERS
 235 static struct request_info req;
 236 #endif
 237
 238 /* transports */
 239 extern const struct transport_def udp_trans;
 240 extern const struct transport_def lsock_trans;
 241
 242 struct transport_list transport_list = TAILQ_HEAD_INITIALIZER(transport_list);
 243
 244 /* forward declarations */
 245 static void snmp_printf_func(const char *fmt, ...);
 246 static void snmp_error_func(const char *err, ...);
 247 static void snmp_debug_func(const char *err, ...);
 248 static void asn_error_func(const struct asn_buf *b, const char *err, ...);
 249
 250 /*
 251  * Allocate rx/tx buffer. We allocate one byte more for rx.
 252  */
 253 void *
 254 buf_alloc(int tx)
 255 {
 256         void *buf;
 257
 258         if ((buf = malloc(tx ? snmpd.txbuf : snmpd.rxbuf)) == NULL) {
 259                 syslog(LOG_CRIT, "cannot allocate buffer");
 260                 if (tx)
 261                         snmpd_stats.noTxbuf++;
 262                 else
 263                         snmpd_stats.noRxbuf++;
 264                 return (NULL);
 265         }
 266         return (buf);
 267 }
 268
 269 /*
 270  * Return the buffer size.
 271  */
 272 size_t
 273 buf_size(int tx)
 274 {
 275         return (tx ? snmpd.txbuf : snmpd.rxbuf);
 276 }
 277
 278 /*
 279  * Prepare a PDU for output
 280  */
 281 void
 282 snmp_output(struct snmp_pdu *pdu, u_char *sndbuf, size_t *sndlen,
 283     const char *dest)
 284 {
 285         struct asn_buf resp_b;
 286         enum snmp_code code;
 287
 288         resp_b.asn_ptr = sndbuf;
 289         resp_b.asn_len = snmpd.txbuf;
 290
 291         if ((code = snmp_pdu_encode(pdu, &resp_b)) != SNMP_CODE_OK) {
 292                 syslog(LOG_ERR, "cannot encode message (code=%d)", code);
 293                 abort();
 294         }
 295         if (debug.dump_pdus) {
 296                 snmp_printf("%s <- ", dest);
 297                 snmp_pdu_dump(pdu);
 298         }
 299         *sndlen = (size_t)(resp_b.asn_ptr - sndbuf);
 300 }
 301
 302 /*
 303  * Check USM PDU header credentials against local SNMP Engine & users.
 304  */
 305 static enum snmp_code
 306 snmp_pdu_auth_user(struct snmp_pdu *pdu)
 307 {
 308         usm_user = NULL;
 309
 310         /* un-authenticated snmpEngineId discovery */
 311         if (pdu->engine.engine_len == 0 && strlen(pdu->user.sec_name) == 0) {
 312                 pdu->engine.engine_len = snmpd_engine.engine_len;
 313                 memcpy(pdu->engine.engine_id, snmpd_engine.engine_id,
 314                     snmpd_engine.engine_len);
 315                 update_snmpd_engine_time();
 316                 pdu->engine.engine_boots = snmpd_engine.engine_boots;
 317                 pdu->engine.engine_time = snmpd_engine.engine_time;
 318                 pdu->flags |= SNMP_MSG_AUTODISCOVER;
 319                 return (SNMP_CODE_OK);
 320         }
 321
 322         if ((usm_user = usm_find_user(pdu->engine.engine_id,
 323             pdu->engine.engine_len, pdu->user.sec_name)) == NULL ||
 324             usm_user->status != 1 /* active */)
 325                 return (SNMP_CODE_BADUSER);
 326
 327         if (usm_user->user_engine_len != snmpd_engine.engine_len ||
 328             memcmp(usm_user->user_engine_id, snmpd_engine.engine_id,
 329             snmpd_engine.engine_len) != 0)
 330                 return (SNMP_CODE_BADENGINE);
 331
 332         pdu->user.priv_proto = usm_user->suser.priv_proto;
 333         memcpy(pdu->user.priv_key, usm_user->suser.priv_key,
 334             sizeof(pdu->user.priv_key));
 335
 336         /* authenticated snmpEngineId discovery */
 337         if ((pdu->flags & SNMP_MSG_AUTH_FLAG) != 0) {
 338                 update_snmpd_engine_time();
 339                 pdu->user.auth_proto = usm_user->suser.auth_proto;
 340                 memcpy(pdu->user.auth_key, usm_user->suser.auth_key,
 341                     sizeof(pdu->user.auth_key));
 342
 343                 if (pdu->engine.engine_boots == 0 &&
 344                     pdu->engine.engine_time == 0) {
 345                         update_snmpd_engine_time();
 346                         pdu->flags |= SNMP_MSG_AUTODISCOVER;
 347                         return (SNMP_CODE_OK);
 348                 }
 349
 350                 if (pdu->engine.engine_boots != snmpd_engine.engine_boots ||
 351                     abs(pdu->engine.engine_time - snmpd_engine.engine_time) >
 352                     SNMP_TIME_WINDOW)
 353                         return (SNMP_CODE_NOTINTIME);
 354         }
 355
 356         if (((pdu->flags & SNMP_MSG_PRIV_FLAG) != 0 &&
 357             (pdu->flags & SNMP_MSG_AUTH_FLAG) == 0) ||
 358             ((pdu->flags & SNMP_MSG_AUTH_FLAG) == 0 &&
 359             usm_user->suser.auth_proto != SNMP_AUTH_NOAUTH) ||
 360             ((pdu->flags & SNMP_MSG_PRIV_FLAG) == 0 &&
 361             usm_user->suser.priv_proto != SNMP_PRIV_NOPRIV))
 362                 return (SNMP_CODE_BADSECLEVEL);
 363
 364         return (SNMP_CODE_OK);
 365 }
 366
 367 /*
 368  * Check whether access to each of var bindings in the PDU is allowed based
 369  * on the user credentials against the configured User groups & VACM views.
 370  */
 371 enum snmp_code
 372 snmp_pdu_auth_access(struct snmp_pdu *pdu, int32_t *ip)
 373 {
 374         const char *uname;
 375         int32_t suboid, smodel;
 376         uint32_t i;
 377         struct vacm_user *vuser;
 378         struct vacm_access *acl;
 379         struct vacm_context *vacmctx;
 380         struct vacm_view *view;
 381
 382         /*
 383          * At least a default context exists if the snmpd_vacm(3) module is
 384          * running.
 385          */
 386         if (SLIST_EMPTY(&vacm_contextlist) ||
 387             (pdu->flags & SNMP_MSG_AUTODISCOVER) != 0)
 388                 return (SNMP_CODE_OK);
 389
 390         switch (pdu->version) {
 391         case SNMP_V1:
 392                 if ((uname = comm_string(community)) == NULL)
 393                         return (SNMP_CODE_FAILED);
 394                 smodel = SNMP_SECMODEL_SNMPv1;
 395                 break;
 396
 397         case SNMP_V2c:
 398                 if ((uname = comm_string(community)) == NULL)
 399                         return (SNMP_CODE_FAILED);
 400                 smodel = SNMP_SECMODEL_SNMPv2c;
 401                 break;
 402
 403         case SNMP_V3:
 404                 uname = pdu->user.sec_name;
 405                 if ((smodel = pdu->security_model) !=  SNMP_SECMODEL_USM)
 406                         return (SNMP_CODE_FAILED);
 407                 /* Compare the PDU context engine id against the agent's */
 408                 if (pdu->context_engine_len != snmpd_engine.engine_len ||
 409                     memcmp(pdu->context_engine, snmpd_engine.engine_id,
 410                     snmpd_engine.engine_len) != 0)
 411                         return (SNMP_CODE_FAILED);
 412                 break;
 413
 414         default:
 415                 abort();
 416         }
 417
 418         SLIST_FOREACH(vuser, &vacm_userlist, vvu)
 419                 if (strcmp(uname, vuser->secname) == 0 &&
 420                     vuser->sec_model == smodel)
 421                         break;
 422
 423         if (vuser == NULL || vuser->group == NULL)
 424                 return (SNMP_CODE_FAILED);
 425
 426         /* XXX: shteryana - recheck */
 427         TAILQ_FOREACH_REVERSE(acl, &vacm_accesslist, vacm_accesslist, vva) {
 428                 if (acl->group != vuser->group)
 429                         continue;
 430                 SLIST_FOREACH(vacmctx, &vacm_contextlist, vcl)
 431                         if (memcmp(vacmctx->ctxname, acl->ctx_prefix,
 432                             acl->ctx_match) == 0)
 433                                 goto match;
 434         }
 435
 436         return (SNMP_CODE_FAILED);
 437
 438 match:
 439
 440         switch (pdu->type) {
 441         case SNMP_PDU_GET:
 442         case SNMP_PDU_GETNEXT:
 443         case SNMP_PDU_GETBULK:
 444                 if ((view = acl->read_view) == NULL)
 445                         return (SNMP_CODE_FAILED);
 446                 break;
 447
 448         case SNMP_PDU_SET:
 449                 if ((view = acl->write_view) == NULL)
 450                         return (SNMP_CODE_FAILED);
 451                 break;
 452
 453         case SNMP_PDU_TRAP:
 454         case SNMP_PDU_INFORM:
 455         case SNMP_PDU_TRAP2:
 456         case SNMP_PDU_REPORT:
 457                 if ((view = acl->notify_view) == NULL)
 458                         return (SNMP_CODE_FAILED);
 459                 break;
 460         case SNMP_PDU_RESPONSE:
 461                 /* NOTREACHED */
 462                         return (SNMP_CODE_FAILED);
 463         default:
 464                 abort();
 465         }
 466
 467         for (i = 0; i < pdu->nbindings; i++) {
 468                 /* XXX - view->mask*/
 469                 suboid = asn_is_suboid(&view->subtree, &pdu->bindings[i].var);
 470                 if ((!suboid && !view->exclude) || (suboid && view->exclude)) {
 471                         *ip = i + 1;
 472                         return (SNMP_CODE_FAILED);
 473                 }
 474         }
 475
 476         return (SNMP_CODE_OK);
 477 }
 478
 479 /*
 480  * SNMP input. Start: decode the PDU, find the user or community.
 481  */
 482 enum snmpd_input_err
 483 snmp_input_start(const u_char *buf, size_t len, const char *source,
 484     struct snmp_pdu *pdu, int32_t *ip, size_t *pdulen)
 485 {
 486         struct asn_buf b;
 487         enum snmp_code code;
 488         enum snmpd_input_err ret;
 489         int sret;
 490
 491         /* update uptime */
 492         this_tick = get_ticks();
 493
 494         b.asn_cptr = buf;
 495         b.asn_len = len;
 496
 497         ret = SNMPD_INPUT_OK;
 498
 499         /* look whether we have enough bytes for the entire PDU. */
 500         switch (sret = snmp_pdu_snoop(&b)) {
 501
 502           case 0:
 503                 return (SNMPD_INPUT_TRUNC);
 504
 505           case -1:
 506                 snmpd_stats.inASNParseErrs++;
 507                 return (SNMPD_INPUT_FAILED);
 508         }
 509         b.asn_len = *pdulen = (size_t)sret;
 510
 511         memset(pdu, 0, sizeof(*pdu));
 512         if ((code = snmp_pdu_decode_header(&b, pdu)) != SNMP_CODE_OK)
 513                 goto decoded;
 514
 515         if (pdu->version == SNMP_V3) {
 516                 if (pdu->security_model != SNMP_SECMODEL_USM) {
 517                         code = SNMP_CODE_FAILED;
 518                         goto decoded;
 519                 }
 520                 if ((code = snmp_pdu_auth_user(pdu)) != SNMP_CODE_OK)
 521                         goto decoded;
 522                 if ((code =  snmp_pdu_decode_secmode(&b, pdu)) != SNMP_CODE_OK)
 523                         goto decoded;
 524         }
 525         code = snmp_pdu_decode_scoped(&b, pdu, ip);
 526
 527 decoded:
 528         snmpd_stats.inPkts++;
 529
 530         switch (code) {
 531
 532           case SNMP_CODE_FAILED:
 533                 snmpd_stats.inASNParseErrs++;
 534                 return (SNMPD_INPUT_FAILED);
 535
 536           case SNMP_CODE_BADVERS:
 537           bad_vers:
 538                 snmpd_stats.inBadVersions++;
 539                 return (SNMPD_INPUT_FAILED);
 540
 541           case SNMP_CODE_BADLEN:
 542                 if (pdu->type == SNMP_OP_SET)
 543                         ret = SNMPD_INPUT_VALBADLEN;
 544                 break;
 545
 546           case SNMP_CODE_OORANGE:
 547                 if (pdu->type == SNMP_OP_SET)
 548                         ret = SNMPD_INPUT_VALRANGE;
 549                 break;
 550
 551           case SNMP_CODE_BADENC:
 552                 if (pdu->type == SNMP_OP_SET)
 553                         ret = SNMPD_INPUT_VALBADENC;
 554                 break;
 555
 556           case SNMP_CODE_BADSECLEVEL:
 557                 snmpd_usmstats.unsupported_seclevels++;
 558                 return (SNMPD_INPUT_FAILED);
 559
 560           case SNMP_CODE_NOTINTIME:
 561                 snmpd_usmstats.not_in_time_windows++;
 562                 return (SNMPD_INPUT_FAILED);
 563
 564           case SNMP_CODE_BADUSER:
 565                 snmpd_usmstats.unknown_users++;
 566                 return (SNMPD_INPUT_FAILED);
 567
 568           case SNMP_CODE_BADENGINE:
 569                 snmpd_usmstats.unknown_engine_ids++;
 570                 return (SNMPD_INPUT_FAILED);
 571
 572           case SNMP_CODE_BADDIGEST:
 573                 snmpd_usmstats.wrong_digests++;
 574                 return (SNMPD_INPUT_FAILED);
 575
 576           case SNMP_CODE_EDECRYPT:
 577                 snmpd_usmstats.decrypt_errors++;
 578                 return (SNMPD_INPUT_FAILED);
 579
 580           case SNMP_CODE_OK:
 581                 switch (pdu->version) {
 582
 583                   case SNMP_V1:
 584                         if (!(snmpd.version_enable & VERS_ENABLE_V1))
 585                                 goto bad_vers;
 586                         break;
 587
 588                   case SNMP_V2c:
 589                         if (!(snmpd.version_enable & VERS_ENABLE_V2C))
 590                                 goto bad_vers;
 591                         break;
 592
 593                   case SNMP_V3:
 594                         if (!(snmpd.version_enable & VERS_ENABLE_V3))
 595                                 goto bad_vers;
 596                         break;
 597
 598                   case SNMP_Verr:
 599                         goto bad_vers;
 600                 }
 601                 break;
 602         }
 603
 604         if (debug.dump_pdus) {
 605                 snmp_printf("%s -> ", source);
 606                 snmp_pdu_dump(pdu);
 607         }
 608
 609         /*
 610          * Look, whether we know the community or user
 611          */
 612
 613         if (pdu->version != SNMP_V3) {
 614                 TAILQ_FOREACH(comm, &community_list, link)
 615                         if (comm->string != NULL &&
 616                             strcmp(comm->string, pdu->community) == 0)
 617                                 break;
 618
 619                 if (comm == NULL) {
 620                         snmpd_stats.inBadCommunityNames++;
 621                         snmp_pdu_free(pdu);
 622                         if (snmpd.auth_traps)
 623                                 snmp_send_trap(&oid_authenticationFailure,
 624                                     (struct snmp_value *)NULL);
 625                         ret = SNMPD_INPUT_BAD_COMM;
 626                 } else
 627                         community = comm->value;
 628         } else if (pdu->nbindings == 0) {
 629                 /* RFC 3414 - snmpEngineID Discovery */
 630                 if (strlen(pdu->user.sec_name) == 0) {
 631                         asn_append_oid(&(pdu->bindings[pdu->nbindings++].var),
 632                             &oid_usmUnknownEngineIDs);
 633                         pdu->context_engine_len = snmpd_engine.engine_len;
 634                         memcpy(pdu->context_engine, snmpd_engine.engine_id,
 635                             snmpd_engine.engine_len);
 636                 } else if (pdu->engine.engine_boots == 0 &&
 637                     pdu->engine.engine_time == 0) {
 638                         asn_append_oid(&(pdu->bindings[pdu->nbindings++].var),
 639                             &oid_usmNotInTimeWindows);
 640                         update_snmpd_engine_time();
 641                         pdu->engine.engine_boots = snmpd_engine.engine_boots;
 642                         pdu->engine.engine_time = snmpd_engine.engine_time;
 643                 }
 644         } else if (usm_user->suser.auth_proto != SNMP_AUTH_NOAUTH &&
 645              (pdu->engine.engine_boots == 0 || pdu->engine.engine_time == 0)) {
 646                 snmpd_usmstats.not_in_time_windows++;
 647                 ret = SNMPD_INPUT_FAILED;
 648         }
 649
 650         if ((code = snmp_pdu_auth_access(pdu, ip)) != SNMP_CODE_OK)
 651                 ret = SNMPD_INPUT_FAILED;
 652
 653         return (ret);
 654 }
 655
 656 /*
 657  * Will return only _OK or _FAILED
 658  */
 659 enum snmpd_input_err
 660 snmp_input_finish(struct snmp_pdu *pdu, const u_char *rcvbuf, size_t rcvlen,
 661     u_char *sndbuf, size_t *sndlen, const char *source,
 662     enum snmpd_input_err ierr, int32_t ivar, void *data)
 663 {
 664         struct snmp_pdu resp;
 665         struct asn_buf resp_b, pdu_b;
 666         enum snmp_ret ret;
 667
 668         resp_b.asn_ptr = sndbuf;
 669         resp_b.asn_len = snmpd.txbuf;
 670
 671         pdu_b.asn_cptr = rcvbuf;
 672         pdu_b.asn_len = rcvlen;
 673
 674         if (ierr != SNMPD_INPUT_OK) {
 675                 /* error decoding the input of a SET */
 676                 if (pdu->version == SNMP_V1)
 677                         pdu->error_status = SNMP_ERR_BADVALUE;
 678                 else if (ierr == SNMPD_INPUT_VALBADLEN)
 679                         pdu->error_status = SNMP_ERR_WRONG_LENGTH;
 680                 else if (ierr == SNMPD_INPUT_VALRANGE)
 681                         pdu->error_status = SNMP_ERR_WRONG_VALUE;
 682                 else
 683                         pdu->error_status = SNMP_ERR_WRONG_ENCODING;
 684
 685                 pdu->error_index = ivar;
 686
 687                 if (snmp_make_errresp(pdu, &pdu_b, &resp_b) == SNMP_RET_IGN) {
 688                         syslog(LOG_WARNING, "could not encode error response");
 689                         snmpd_stats.silentDrops++;
 690                         return (SNMPD_INPUT_FAILED);
 691                 }
 692
 693                 if (debug.dump_pdus) {
 694                         snmp_printf("%s <- ", source);
 695                         snmp_pdu_dump(pdu);
 696                 }
 697                 *sndlen = (size_t)(resp_b.asn_ptr - sndbuf);
 698                 return (SNMPD_INPUT_OK);
 699         }
 700
 701         switch (pdu->type) {
 702
 703           case SNMP_PDU_GET:
 704                 ret = snmp_get(pdu, &resp_b, &resp, data);
 705                 break;
 706
 707           case SNMP_PDU_GETNEXT:
 708                 ret = snmp_getnext(pdu, &resp_b, &resp, data);
 709                 break;
 710
 711           case SNMP_PDU_SET:
 712                 ret = snmp_set(pdu, &resp_b, &resp, data);
 713                 break;
 714
 715           case SNMP_PDU_GETBULK:
 716                 ret = snmp_getbulk(pdu, &resp_b, &resp, data);
 717                 break;
 718
 719           default:
 720                 ret = SNMP_RET_IGN;
 721                 break;
 722         }
 723
 724         switch (ret) {
 725
 726           case SNMP_RET_OK:
 727                 /* normal return - send a response */
 728                 if (debug.dump_pdus) {
 729                         snmp_printf("%s <- ", source);
 730                         snmp_pdu_dump(&resp);
 731                 }
 732                 *sndlen = (size_t)(resp_b.asn_ptr - sndbuf);
 733                 snmp_pdu_free(&resp);
 734                 return (SNMPD_INPUT_OK);
 735
 736           case SNMP_RET_IGN:
 737                 /* error - send nothing */
 738                 snmpd_stats.silentDrops++;
 739                 return (SNMPD_INPUT_FAILED);
 740
 741           case SNMP_RET_ERR:
 742                 /* error - send error response. The snmp routine has
 743                  * changed the error fields in the original message. */
 744                 resp_b.asn_ptr = sndbuf;
 745                 resp_b.asn_len = snmpd.txbuf;
 746                 if (snmp_make_errresp(pdu, &pdu_b, &resp_b) == SNMP_RET_IGN) {
 747                         syslog(LOG_WARNING, "could not encode error response");
 748                         snmpd_stats.silentDrops++;
 749                         return (SNMPD_INPUT_FAILED);
 750                 } else {
 751                         if (debug.dump_pdus) {
 752                                 snmp_printf("%s <- ", source);
 753                                 snmp_pdu_dump(pdu);
 754                         }
 755                         *sndlen = (size_t)(resp_b.asn_ptr - sndbuf);
 756                         return (SNMPD_INPUT_OK);
 757                 }
 758         }
 759         abort();
 760 }
 761
 762 /*
 763  * Insert a port into the right place in the transport's table of ports
 764  */
 765 void
 766 trans_insert_port(struct transport *t, struct tport *port)
 767 {
 768         struct tport *p;
 769
 770         port->transport = t;
 771         TAILQ_FOREACH(p, &t->table, link) {
 772                 if (asn_compare_oid(&p->index, &port->index) > 0) {
 773                         TAILQ_INSERT_BEFORE(p, port, link);
 774                         return;
 775                 }
 776         }
 777         TAILQ_INSERT_TAIL(&t->table, port, link);
 778 }
 779
 780 /*
 781  * Remove a port from a transport's list
 782  */
 783 void
 784 trans_remove_port(struct tport *port)
 785 {
 786
 787         TAILQ_REMOVE(&port->transport->table, port, link);
 788 }
 789
 790 /*
 791  * Find a port on a transport's list
 792  */
 793 struct tport *
 794 trans_find_port(struct transport *t, const struct asn_oid *idx, u_int sub)
 795 {
 796
 797         return (FIND_OBJECT_OID(&t->table, idx, sub));
 798 }
 799
 800 /*
 801  * Find next port on a transport's list
 802  */
 803 struct tport *
 804 trans_next_port(struct transport *t, const struct asn_oid *idx, u_int sub)
 805 {
 806
 807         return (NEXT_OBJECT_OID(&t->table, idx, sub));
 808 }
 809
 810 /*
 811  * Return first port
 812  */
 813 struct tport *
 814 trans_first_port(struct transport *t)
 815 {
 816
 817         return (TAILQ_FIRST(&t->table));
 818 }
 819
 820 /*
 821  * Iterate through all ports until a function returns a 0.
 822  */
 823 struct tport *
 824 trans_iter_port(struct transport *t, int (*func)(struct tport *, intptr_t),
 825     intptr_t arg)
 826 {
 827         struct tport *p;
 828
 829         TAILQ_FOREACH(p, &t->table, link)
 830                 if (func(p, arg) == 0)
 831                         return (p);
 832         return (NULL);
 833 }
 834
 835 /*
 836  * Register a transport
 837  */
 838 int
 839 trans_register(const struct transport_def *def, struct transport **pp)
 840 {
 841         u_int i;
 842         char or_descr[256];
 843
 844         if ((*pp = malloc(sizeof(**pp))) == NULL)
 845                 return (SNMP_ERR_GENERR);
 846
 847         /* construct index */
 848         (*pp)->index.len = strlen(def->name) + 1;
 849         (*pp)->index.subs[0] = strlen(def->name);
 850         for (i = 0; i < (*pp)->index.subs[0]; i++)
 851                 (*pp)->index.subs[i + 1] = def->name[i];
 852
 853         (*pp)->vtab = def;
 854
 855         if (FIND_OBJECT_OID(&transport_list, &(*pp)->index, 0) != NULL) {
 856                 free(*pp);
 857                 return (SNMP_ERR_INCONS_VALUE);
 858         }
 859
 860         /* register module */
 861         snprintf(or_descr, sizeof(or_descr), "%s transport mapping", def->name);
 862         if (((*pp)->or_index = or_register(&def->id, or_descr, NULL)) == 0) {
 863                 free(*pp);
 864                 return (SNMP_ERR_GENERR);
 865         }
 866
 867         INSERT_OBJECT_OID((*pp), &transport_list);
 868
 869         TAILQ_INIT(&(*pp)->table);
 870
 871         return (SNMP_ERR_NOERROR);
 872 }
 873
 874 /*
 875  * Unregister transport
 876  */
 877 int
 878 trans_unregister(struct transport *t)
 879 {
 880         if (!TAILQ_EMPTY(&t->table))
 881                 return (SNMP_ERR_INCONS_VALUE);
 882
 883         or_unregister(t->or_index);
 884         TAILQ_REMOVE(&transport_list, t, link);
 885
 886         return (SNMP_ERR_NOERROR);
 887 }
 888
 889 /*
 890  * File descriptor support
 891  */
 892 #ifdef USE_LIBBEGEMOT
 893 static void
 894 input(int fd, int mask __unused, void *uap)
 895 #else
 896 static void
 897 input(evContext ctx __unused, void *uap, int fd, int mask __unused)
 898 #endif
 899 {
 900         struct fdesc *f = uap;
 901
 902         (*f->func)(fd, f->udata);
 903 }
 904
 905 void
 906 fd_suspend(void *p)
 907 {
 908         struct fdesc *f = p;
 909
 910 #ifdef USE_LIBBEGEMOT
 911         if (f->id >= 0) {
 912                 poll_unregister(f->id);
 913                 f->id = -1;
 914         }
 915 #else
 916         if (evTestID(f->id)) {
 917                 (void)evDeselectFD(evctx, f->id);
 918                 evInitID(&f->id);
 919         }
 920 #endif
 921 }
 922
 923 int
 924 fd_resume(void *p)
 925 {
 926         struct fdesc *f = p;
 927         int err;
 928
 929 #ifdef USE_LIBBEGEMOT
 930         if (f->id >= 0)
 931                 return (0);
 932         if ((f->id = poll_register(f->fd, input, f, RPOLL_IN)) < 0) {
 933                 err = errno;
 934                 syslog(LOG_ERR, "select fd %d: %m", f->fd);
 935                 errno = err;
 936                 return (-1);
 937         }
 938 #else
 939         if (evTestID(f->id))
 940                 return (0);
 941         if (evSelectFD(evctx, f->fd, EV_READ, input, f, &f->id)) {
 942                 err = errno;
 943                 syslog(LOG_ERR, "select fd %d: %m", f->fd);
 944                 errno = err;
 945                 return (-1);
 946         }
 947 #endif
 948         return (0);
 949 }
 950
 951 void *
 952 fd_select(int fd, void (*func)(int, void *), void *udata, struct lmodule *mod)
 953 {
 954         struct fdesc *f;
 955         int err;
 956
 957         if ((f = malloc(sizeof(struct fdesc))) == NULL) {
 958                 err = errno;
 959                 syslog(LOG_ERR, "fd_select: %m");
 960                 errno = err;
 961                 return (NULL);
 962         }
 963         f->fd = fd;
 964         f->func = func;
 965         f->udata = udata;
 966         f->owner = mod;
 967 #ifdef USE_LIBBEGEMOT
 968         f->id = -1;
 969 #else
 970         evInitID(&f->id);
 971 #endif
 972
 973         if (fd_resume(f)) {
 974                 err = errno;
 975                 free(f);
 976                 errno = err;
 977                 return (NULL);
 978         }
 979
 980         LIST_INSERT_HEAD(&fdesc_list, f, link);
 981
 982         return (f);
 983 }
 984
 985 void
 986 fd_deselect(void *p)
 987 {
 988         struct fdesc *f = p;
 989
 990         LIST_REMOVE(f, link);
 991         fd_suspend(f);
 992         free(f);
 993 }
 994
 995 static void
 996 fd_flush(struct lmodule *mod)
 997 {
 998         struct fdesc *t, *t1;
 999
1000         t = LIST_FIRST(&fdesc_list);
1001         while (t != NULL) {
1002                 t1 = LIST_NEXT(t, link);
1003                 if (t->owner == mod)
1004                         fd_deselect(t);
1005                 t = t1;
1006         }
1007 }
1008
1009 /*
1010  * Consume a message from the input buffer
1011  */
1012 static void
1013 snmp_input_consume(struct port_input *pi)
1014 {
1015         if (!pi->stream) {
1016                 /* always consume everything */
1017                 pi->length = 0;
1018                 return;
1019         }
1020         if (pi->consumed >= pi->length) {
1021                 /* all bytes consumed */
1022                 pi->length = 0;
1023                 return;
1024         }
1025         memmove(pi->buf, pi->buf + pi->consumed, pi->length - pi->consumed);
1026         pi->length -= pi->consumed;
1027 }
1028
1029 /*
1030  * Input from a socket
1031  */
1032 int
1033 snmpd_input(struct port_input *pi, struct tport *tport)
1034 {
1035         u_char *sndbuf;
1036         size_t sndlen;
1037         struct snmp_pdu pdu;
1038         enum snmpd_input_err ierr, ferr;
1039         enum snmpd_proxy_err perr;
1040         ssize_t ret, slen;
1041         int32_t vi;
1042 #ifdef USE_TCPWRAPPERS
1043         char client[INET6_ADDRSTRLEN];
1044 #endif
1045
1046         ret = tport->transport->vtab->recv(tport, pi);
1047         if (ret == -1)
1048                 return (-1);
1049
1050 #ifdef USE_TCPWRAPPERS
1051         /*
1052          * In case of AF_INET{6} peer, do hosts_access(5) check.
1053          */
1054         if (pi->peer->sa_family != AF_LOCAL &&
1055             inet_ntop(pi->peer->sa_family,
1056             &((const struct sockaddr_in *)(const void *)pi->peer)->sin_addr,
1057             client, sizeof(client)) != NULL) {
1058                 request_set(&req, RQ_CLIENT_ADDR, client, 0);
1059                 if (hosts_access(&req) == 0) {
1060                         syslog(LOG_ERR, "refused connection from %.500s",
1061                             eval_client(&req));
1062                         return (-1);
1063                 }
1064         } else if (pi->peer->sa_family != AF_LOCAL)
1065                 syslog(LOG_ERR, "inet_ntop(): %m");
1066 #endif
1067
1068         /*
1069          * Handle input
1070          */
1071         ierr = snmp_input_start(pi->buf, pi->length, "SNMP", &pdu, &vi,
1072             &pi->consumed);
1073         if (ierr == SNMPD_INPUT_TRUNC) {
1074                 /* need more bytes. This is ok only for streaming transports.
1075                  * but only if we have not reached bufsiz yet. */
1076                 if (pi->stream) {
1077                         if (pi->length == buf_size(0)) {
1078                                 snmpd_stats.silentDrops++;
1079                                 return (-1);
1080                         }
1081                         return (0);
1082                 }
1083                 snmpd_stats.silentDrops++;
1084                 return (-1);
1085         }
1086
1087         /* can't check for bad SET pdus here, because a proxy may have to
1088          * check the access first. We don't want to return an error response
1089          * to a proxy PDU with a wrong community */
1090         if (ierr == SNMPD_INPUT_FAILED) {
1091                 /* for streaming transports this is fatal */
1092                 if (pi->stream)
1093                         return (-1);
1094                 snmp_input_consume(pi);
1095                 return (0);
1096         }
1097         if (ierr == SNMPD_INPUT_BAD_COMM) {
1098                 snmp_input_consume(pi);
1099                 return (0);
1100         }
1101
1102         /*
1103          * If that is a module community and the module has a proxy function,
1104          * the hand it over to the module.
1105          */
1106         if (comm != NULL && comm->owner != NULL &&
1107             comm->owner->config->proxy != NULL) {
1108                 perr = (*comm->owner->config->proxy)(&pdu, tport->transport,
1109                     &tport->index, pi->peer, pi->peerlen, ierr, vi,
1110                     !pi->cred || pi->priv);
1111
1112                 switch (perr) {
1113
1114                   case SNMPD_PROXY_OK:
1115                         snmp_input_consume(pi);
1116                         return (0);
1117
1118                   case SNMPD_PROXY_REJ:
1119                         break;
1120
1121                   case SNMPD_PROXY_DROP:
1122                         snmp_input_consume(pi);
1123                         snmp_pdu_free(&pdu);
1124                         snmpd_stats.proxyDrops++;
1125                         return (0);
1126
1127                   case SNMPD_PROXY_BADCOMM:
1128                         snmp_input_consume(pi);
1129                         snmp_pdu_free(&pdu);
1130                         snmpd_stats.inBadCommunityNames++;
1131                         if (snmpd.auth_traps)
1132                                 snmp_send_trap(&oid_authenticationFailure,
1133                                     (struct snmp_value *)NULL);
1134                         return (0);
1135
1136                   case SNMPD_PROXY_BADCOMMUSE:
1137                         snmp_input_consume(pi);
1138                         snmp_pdu_free(&pdu);
1139                         snmpd_stats.inBadCommunityUses++;
1140                         if (snmpd.auth_traps)
1141                                 snmp_send_trap(&oid_authenticationFailure,
1142                                     (struct snmp_value *)NULL);
1143                         return (0);
1144                 }
1145         }
1146
1147         /*
1148          * Check type
1149          */
1150         if (pdu.type == SNMP_PDU_RESPONSE ||
1151             pdu.type == SNMP_PDU_TRAP ||
1152             pdu.type == SNMP_PDU_TRAP2) {
1153                 snmpd_stats.silentDrops++;
1154                 snmpd_stats.inBadPduTypes++;
1155                 snmp_pdu_free(&pdu);
1156                 snmp_input_consume(pi);
1157                 return (0);
1158         }
1159
1160         /*
1161          * Check community
1162          */
1163         if (pdu.version < SNMP_V3 &&
1164             ((pi->cred && !pi->priv && pdu.type == SNMP_PDU_SET) ||
1165             (comm != NULL && comm->private != COMM_WRITE &&
1166             (pdu.type == SNMP_PDU_SET || comm->private != COMM_READ)))) {
1167                 snmpd_stats.inBadCommunityUses++;
1168                 snmp_pdu_free(&pdu);
1169                 snmp_input_consume(pi);
1170                 if (snmpd.auth_traps)
1171                         snmp_send_trap(&oid_authenticationFailure,
1172                             (struct snmp_value *)NULL);
1173                 return (0);
1174         }
1175
1176         /*
1177          * Execute it.
1178          */
1179         if ((sndbuf = buf_alloc(1)) == NULL) {
1180                 snmpd_stats.silentDrops++;
1181                 snmp_pdu_free(&pdu);
1182                 snmp_input_consume(pi);
1183                 return (0);
1184         }
1185         ferr = snmp_input_finish(&pdu, pi->buf, pi->length,
1186             sndbuf, &sndlen, "SNMP", ierr, vi, NULL);
1187
1188         if (ferr == SNMPD_INPUT_OK) {
1189                 if (tport->transport->vtab->send != NULL)
1190                         slen = tport->transport->vtab->send(tport, sndbuf,
1191                             sndlen, pi->peer, pi->peerlen);
1192                 else
1193                         slen = tport->transport->vtab->send2(tport, sndbuf,
1194                             sndlen, pi);
1195                 if (slen == -1)
1196                         syslog(LOG_ERR, "send*: %m");
1197                 else if ((size_t)slen != sndlen)
1198                         syslog(LOG_ERR, "send*: short write %zu/%zu", sndlen,
1199                             (size_t)slen);
1200         }
1201
1202         snmp_pdu_free(&pdu);
1203         free(sndbuf);
1204         snmp_input_consume(pi);
1205
1206         return (0);
1207 }
1208
1209 /*
1210  * Send a PDU to a given port. If this is a multi-socket port, use the
1211  * first socket.
1212  */
1213 void
1214 snmp_send_port(void *targ, const struct asn_oid *port, struct snmp_pdu *pdu,
1215     const struct sockaddr *addr, socklen_t addrlen)
1216 {
1217         struct transport *trans = targ;
1218         struct tport *tp;
1219         u_char *sndbuf;
1220         size_t sndlen;
1221         ssize_t len;
1222
1223         TAILQ_FOREACH(tp, &trans->table, link)
1224                 if (asn_compare_oid(port, &tp->index) == 0)
1225                         break;
1226         if (tp == 0)
1227                 return;
1228
1229         if ((sndbuf = buf_alloc(1)) == NULL)
1230                 return;
1231
1232         snmp_output(pdu, sndbuf, &sndlen, "SNMP PROXY");
1233
1234         if (trans->vtab->send != NULL)
1235                 len = trans->vtab->send(tp, sndbuf, sndlen, addr, addrlen);
1236         else
1237                 len = trans->vtab->send2(tp, sndbuf, sndlen, NULL);
1238
1239         if (len == -1)
1240                 syslog(LOG_ERR, "sendto: %m");
1241         else if ((size_t)len != sndlen)
1242                 syslog(LOG_ERR, "sendto: short write %zu/%zu",
1243                     sndlen, (size_t)len);
1244
1245         free(sndbuf);
1246 }
1247
1248
1249 /*
1250  * Close an input source
1251  *
1252  * \param pi    input instance
1253  */
1254 void
1255 snmpd_input_close(struct port_input *pi)
1256 {
1257         if (pi->id != NULL) {
1258                 fd_deselect(pi->id);
1259                 pi->id = NULL;
1260         }
1261         if (pi->fd >= 0) {
1262                 (void)close(pi->fd);
1263                 pi->fd = -1;
1264         }
1265         if (pi->buf != NULL) {
1266                 free(pi->buf);
1267                 pi->buf = NULL;
1268         }
1269 }
1270
1271 /*
1272  * Initialize an input source.
1273  *
1274  * \param pi    input instance
1275  */
1276 void
1277 snmpd_input_init(struct port_input *pi)
1278 {
1279         pi->id = NULL;
1280         pi->fd = -1;
1281         pi->buf = NULL;
1282 }
1283
1284 /*
1285  * Dump internal state.
1286  */
1287 #ifdef USE_LIBBEGEMOT
1288 static void
1289 info_func(void)
1290 #else
1291 static void
1292 info_func(evContext ctx __unused, void *uap __unused, const void *tag __unused)
1293 #endif
1294 {
1295         struct lmodule *m;
1296         u_int i;
1297         char buf[10000];
1298
1299         syslog(LOG_DEBUG, "Dump of SNMPd %lu\n", (u_long)getpid());
1300         for (i = 0; i < tree_size; i++) {
1301                 switch (tree[i].type) {
1302
1303                   case SNMP_NODE_LEAF:
1304                         sprintf(buf, "LEAF: %s %s", tree[i].name,
1305                             asn_oid2str(&tree[i].oid));
1306                         break;
1307
1308                   case SNMP_NODE_COLUMN:
1309                         sprintf(buf, "COL: %s %s", tree[i].name,
1310                             asn_oid2str(&tree[i].oid));
1311                         break;
1312                 }
1313                 syslog(LOG_DEBUG, "%s", buf);
1314         }
1315
1316         TAILQ_FOREACH(m, &lmodules, link)
1317                 if (m->config->dump)
1318                         (*m->config->dump)();
1319 }
1320
1321 /*
1322  * Re-read configuration
1323  */
1324 #ifdef USE_LIBBEGEMOT
1325 static void
1326 config_func(void)
1327 #else
1328 static void
1329 config_func(evContext ctx __unused, void *uap __unused,
1330     const void *tag __unused)
1331 #endif
1332 {
1333         struct lmodule *m;
1334
1335         if (read_config(config_file, NULL)) {
1336                 syslog(LOG_ERR, "error reading config file '%s'", config_file);
1337                 return;
1338         }
1339         TAILQ_FOREACH(m, &lmodules, link)
1340                 if (m->config->config)
1341                         (*m->config->config)();
1342 }
1343
1344 /*
1345  * On USR1 dump actual configuration.
1346  */
1347 static void
1348 onusr1(int s __unused)
1349 {
1350
1351         work |= WORK_DOINFO;
1352 }
1353 static void
1354 onhup(int s __unused)
1355 {
1356
1357         work |= WORK_RECONFIG;
1358 }
1359
1360 static void
1361 onterm(int s __unused)
1362 {
1363
1364         /* allow clean-up */
1365         exit(0);
1366 }
1367
1368 static void
1369 init_sigs(void)
1370 {
1371         struct sigaction sa;
1372
1373         sa.sa_handler = onusr1;
1374         sa.sa_flags = SA_RESTART;
1375         sigemptyset(&sa.sa_mask);
1376         if (sigaction(SIGUSR1, &sa, NULL)) {
1377                 syslog(LOG_ERR, "sigaction: %m");
1378                 exit(1);
1379         }
1380
1381         sa.sa_handler = onhup;
1382         if (sigaction(SIGHUP, &sa, NULL)) {
1383                 syslog(LOG_ERR, "sigaction: %m");
1384                 exit(1);
1385         }
1386
1387         sa.sa_handler = onterm;
1388         sa.sa_flags = 0;
1389         sigemptyset(&sa.sa_mask);
1390         if (sigaction(SIGTERM, &sa, NULL)) {
1391                 syslog(LOG_ERR, "sigaction: %m");
1392                 exit(1);
1393         }
1394         if (sigaction(SIGINT, &sa, NULL)) {
1395                 syslog(LOG_ERR, "sigaction: %m");
1396                 exit(1);
1397         }
1398 }
1399
1400 static void
1401 block_sigs(void)
1402 {
1403         sigset_t set;
1404
1405         sigfillset(&set);
1406         if (sigprocmask(SIG_BLOCK, &set, &blocked_sigs) == -1) {
1407                 syslog(LOG_ERR, "SIG_BLOCK: %m");
1408                 exit(1);
1409         }
1410 }
1411 static void
1412 unblock_sigs(void)
1413 {
1414         if (sigprocmask(SIG_SETMASK, &blocked_sigs, NULL) == -1) {
1415                 syslog(LOG_ERR, "SIG_SETMASK: %m");
1416                 exit(1);
1417         }
1418 }
1419
1420 /*
1421  * Shut down
1422  */
1423 static void
1424 term(void)
1425 {
1426         (void)unlink(pid_file);
1427 }
1428
1429 static void
1430 trans_stop(void)
1431 {
1432         struct transport *t;
1433
1434         TAILQ_FOREACH(t, &transport_list, link)
1435                 (void)t->vtab->stop(1);
1436 }
1437
1438 /*
1439  * Define a macro from the command line
1440  */
1441 static void
1442 do_macro(char *arg)
1443 {
1444         char *eq;
1445         int err;
1446
1447         if ((eq = strchr(arg, '=')) == NULL)
1448                 err = define_macro(arg, "");
1449         else {
1450                 *eq++ = '\0';
1451                 err = define_macro(arg, eq);
1452         }
1453         if (err == -1) {
1454                 syslog(LOG_ERR, "cannot save macro: %m");
1455                 exit(1);
1456         }
1457 }
1458
1459 /*
1460  * Re-implement getsubopt from scratch, because the second argument is broken
1461  * and will not compile with WARNS=5.
1462  */
1463 static int
1464 getsubopt1(char **arg, const char *const *options, char **valp, char **optp)
1465 {
1466         static const char *const delim = ",\t ";
1467         u_int i;
1468         char *ptr;
1469
1470         *optp = NULL;
1471
1472         /* skip leading junk */
1473         for (ptr = *arg; *ptr != '\0'; ptr++)
1474                 if (strchr(delim, *ptr) == NULL)
1475                         break;
1476         if (*ptr == '\0') {
1477                 *arg = ptr;
1478                 return (-1);
1479         }
1480         *optp = ptr;
1481
1482         /* find the end of the option */
1483         while (*++ptr != '\0')
1484                 if (strchr(delim, *ptr) != NULL || *ptr == '=')
1485                         break;
1486
1487         if (*ptr != '\0') {
1488                 if (*ptr == '=') {
1489                         *ptr++ = '\0';
1490                         *valp = ptr;
1491                         while (*ptr != '\0' && strchr(delim, *ptr) == NULL)
1492                                 ptr++;
1493                         if (*ptr != '\0')
1494                                 *ptr++ = '\0';
1495                 } else
1496                         *ptr++ = '\0';
1497         }
1498
1499         *arg = ptr;
1500
1501         for (i = 0; *options != NULL; options++, i++)
1502                 if (strcmp(*optp, *options) == 0)
1503                         return (i);
1504         return (-1);
1505 }
1506
1507 int
1508 main(int argc, char *argv[])
1509 {
1510         int opt;
1511         FILE *fp;
1512         int background = 1;
1513         struct tport *p;
1514         const char *prefix = "snmpd";
1515         struct lmodule *m;
1516         char *value = NULL, *option; /* XXX */
1517         struct transport *t;
1518
1519 #define DBG_DUMP        0
1520 #define DBG_EVENTS      1
1521 #define DBG_TRACE       2
1522         static const char *const debug_opts[] = {
1523                 "dump",
1524                 "events",
1525                 "trace",
1526                 NULL
1527         };
1528
1529         snmp_printf = snmp_printf_func;
1530         snmp_error = snmp_error_func;
1531         snmp_debug = snmp_debug_func;
1532         asn_error = asn_error_func;
1533
1534         while ((opt = getopt(argc, argv, "c:dD:e:hI:l:m:p:")) != EOF)
1535                 switch (opt) {
1536
1537                   case 'c':
1538                         strlcpy(config_file, optarg, sizeof(config_file));
1539                         break;
1540
1541                   case 'd':
1542                         background = 0;
1543                         break;
1544
1545                   case 'D':
1546                         while (*optarg) {
1547                                 switch (getsubopt1(&optarg, debug_opts,
1548                                     &value, &option)) {
1549
1550                                   case DBG_DUMP:
1551                                         debug.dump_pdus = 1;
1552                                         break;
1553
1554                                   case DBG_EVENTS:
1555                                         debug.evdebug++;
1556                                         break;
1557
1558                                   case DBG_TRACE:
1559                                         if (value == NULL)
1560                                                 syslog(LOG_ERR,
1561                                                     "no value for 'trace'");
1562                                         else
1563                                                 snmp_trace = strtoul(value,
1564                                                     NULL, 0);
1565                                         break;
1566
1567                                   case -1:
1568                                         if (suboptarg)
1569                                                 syslog(LOG_ERR,
1570                                                     "unknown debug flag '%s'",
1571                                                     option);
1572                                         else
1573                                                 syslog(LOG_ERR,
1574                                                     "missing debug flag");
1575                                         break;
1576                                 }
1577                         }
1578                         break;
1579
1580                   case 'e':
1581                         strlcpy(engine_file, optarg, sizeof(engine_file));
1582                         break;
1583                   case 'h':
1584                         fprintf(stderr, "%s", usgtxt);
1585                         exit(0);
1586
1587                   case 'I':
1588                         syspath = optarg;
1589                         break;
1590
1591                   case 'l':
1592                         prefix = optarg;
1593                         break;
1594
1595                   case 'm':
1596                         do_macro(optarg);
1597                         break;
1598
1599                   case 'p':
1600                         strlcpy(pid_file, optarg, sizeof(pid_file));
1601                         break;
1602                 }
1603
1604         openlog(prefix, LOG_PID | (background ? 0 : LOG_PERROR), LOG_USER);
1605         setlogmask(LOG_UPTO(debug.logpri - 1));
1606
1607         if (background && daemon(0, 0) < 0) {
1608                 syslog(LOG_ERR, "daemon: %m");
1609                 exit(1);
1610         }
1611
1612         argc -= optind;
1613         argv += optind;
1614
1615         progargs = argv;
1616         nprogargs = argc;
1617
1618         srandomdev();
1619
1620         snmp_serial_no = random();
1621
1622 #ifdef USE_TCPWRAPPERS
1623         /*
1624          * Initialize hosts_access(3) handler.
1625          */
1626         request_init(&req, RQ_DAEMON, "snmpd", 0);
1627         sock_methods(&req);
1628 #endif
1629
1630         /*
1631          * Initialize the tree.
1632          */
1633         if ((tree = malloc(sizeof(struct snmp_node) * CTREE_SIZE)) == NULL) {
1634                 syslog(LOG_ERR, "%m");
1635                 exit(1);
1636         }
1637         memcpy(tree, ctree, sizeof(struct snmp_node) * CTREE_SIZE);
1638         tree_size = CTREE_SIZE;
1639
1640         /*
1641          * Get standard communities
1642          */
1643         comm_define(COMM_READ, "SNMP read", NULL, NULL);
1644         comm_define(COMM_WRITE, "SNMP write", NULL, NULL);
1645         community = COMM_INITIALIZE;
1646
1647         trap_reqid = reqid_allocate(512, NULL);
1648
1649         if (config_file[0] == '\0')
1650                 snprintf(config_file, sizeof(config_file), PATH_CONFIG, prefix);
1651
1652         init_actvals();
1653         init_snmpd_engine();
1654
1655         this_tick = get_ticks();
1656         start_tick = this_tick;
1657
1658         /* start transports */
1659         if (atexit(trans_stop) == -1) {
1660                 syslog(LOG_ERR, "atexit failed: %m");
1661                 exit(1);
1662         }
1663         if (udp_trans.start() != SNMP_ERR_NOERROR)
1664                 syslog(LOG_WARNING, "cannot start UDP transport");
1665         if (lsock_trans.start() != SNMP_ERR_NOERROR)
1666                 syslog(LOG_WARNING, "cannot start LSOCK transport");
1667         if (inet_trans.start() != SNMP_ERR_NOERROR)
1668                 syslog(LOG_WARNING, "cannot start INET transport");
1669
1670 #ifdef USE_LIBBEGEMOT
1671         if (debug.evdebug > 0)
1672                 rpoll_trace = 1;
1673 #else
1674         if (evCreate(&evctx)) {
1675                 syslog(LOG_ERR, "evCreate: %m");
1676                 exit(1);
1677         }
1678         if (debug.evdebug > 0)
1679                 evSetDebug(evctx, 10, stderr);
1680 #endif
1681
1682         if (engine_file[0] == '\0')
1683                 snprintf(engine_file, sizeof(engine_file), PATH_ENGINE, prefix);
1684
1685         if (read_config(config_file, NULL)) {
1686                 syslog(LOG_ERR, "error in config file");
1687                 exit(1);
1688         }
1689
1690         TAILQ_FOREACH(t, &transport_list, link)
1691                 TAILQ_FOREACH(p, &t->table, link)
1692                         t->vtab->init_port(p);
1693
1694         init_sigs();
1695
1696         if (pid_file[0] == '\0')
1697                 snprintf(pid_file, sizeof(pid_file), PATH_PID, prefix);
1698
1699         if ((fp = fopen(pid_file, "w")) != NULL) {
1700                 fprintf(fp, "%u", getpid());
1701                 fclose(fp);
1702                 if (atexit(term) == -1) {
1703                         syslog(LOG_ERR, "atexit failed: %m");
1704                         (void)remove(pid_file);
1705                         exit(0);
1706                 }
1707         }
1708
1709         if (or_register(&oid_snmpMIB, "The MIB module for SNMPv2 entities.",
1710             NULL) == 0) {
1711                 syslog(LOG_ERR, "cannot register SNMPv2 MIB");
1712                 exit(1);
1713         }
1714         if (or_register(&oid_begemotSnmpd, "The MIB module for the Begemot SNMPd.",
1715             NULL) == 0) {
1716                 syslog(LOG_ERR, "cannot register begemotSnmpd MIB");
1717                 exit(1);
1718         }
1719
1720         while ((m = TAILQ_FIRST(&modules_start)) != NULL) {
1721                 m->flags &= ~LM_ONSTARTLIST;
1722                 TAILQ_REMOVE(&modules_start, m, start);
1723                 lm_start(m);
1724         }
1725
1726         snmp_send_trap(&oid_coldStart, (struct snmp_value *)NULL);
1727
1728         for (;;) {
1729 #ifndef USE_LIBBEGEMOT
1730                 evEvent event;
1731 #endif
1732                 struct lmodule *mod;
1733
1734                 TAILQ_FOREACH(mod, &lmodules, link)
1735                         if (mod->config->idle != NULL)
1736                                 (*mod->config->idle)();
1737
1738 #ifndef USE_LIBBEGEMOT
1739                 if (evGetNext(evctx, &event, EV_WAIT) == 0) {
1740                         if (evDispatch(evctx, event))
1741                                 syslog(LOG_ERR, "evDispatch: %m");
1742                 } else if (errno != EINTR) {
1743                         syslog(LOG_ERR, "evGetNext: %m");
1744                         exit(1);
1745                 }
1746 #else
1747                 poll_dispatch(1);
1748 #endif
1749
1750                 if (work != 0) {
1751                         block_sigs();
1752                         if (work & WORK_DOINFO) {
1753 #ifdef USE_LIBBEGEMOT
1754                                 info_func();
1755 #else
1756                                 if (evWaitFor(evctx, &work, info_func,
1757                                     NULL, NULL) == -1) {
1758                                         syslog(LOG_ERR, "evWaitFor: %m");
1759                                         exit(1);
1760                                 }
1761 #endif
1762                         }
1763                         if (work & WORK_RECONFIG) {
1764 #ifdef USE_LIBBEGEMOT
1765                                 config_func();
1766 #else
1767                                 if (evWaitFor(evctx, &work, config_func,
1768                                     NULL, NULL) == -1) {
1769                                         syslog(LOG_ERR, "evWaitFor: %m");
1770                                         exit(1);
1771                                 }
1772 #endif
1773                         }
1774                         work = 0;
1775                         unblock_sigs();
1776 #ifndef USE_LIBBEGEMOT
1777                         if (evDo(evctx, &work) == -1) {
1778                                 syslog(LOG_ERR, "evDo: %m");
1779                                 exit(1);
1780                         }
1781 #endif
1782                 }
1783         }
1784
1785         return (0);
1786 }
1787
1788 uint64_t
1789 get_ticks(void)
1790 {
1791         struct timeval tv;
1792         uint64_t ret;
1793
1794         if (gettimeofday(&tv, NULL))
1795                 abort();
1796         ret = tv.tv_sec * 100ULL + tv.tv_usec / 10000ULL;
1797         return (ret);
1798 }
1799
1800 /*
1801  * Timer support
1802  */
1803
1804 /*
1805  * Trampoline for the non-repeatable timers.
1806  */
1807 #ifdef USE_LIBBEGEMOT
1808 static void
1809 tfunc(int tid __unused, void *uap)
1810 #else
1811 static void
1812 tfunc(evContext ctx __unused, void *uap, struct timespec due __unused,
1813         struct timespec inter __unused)
1814 #endif
1815 {
1816         struct timer *tp = uap;
1817
1818         LIST_REMOVE(tp, link);
1819         tp->func(tp->udata);
1820         free(tp);
1821 }
1822
1823 /*
1824  * Trampoline for the repeatable timers.
1825  */
1826 #ifdef USE_LIBBEGEMOT
1827 static void
1828 trfunc(int tid __unused, void *uap)
1829 #else
1830 static void
1831 trfunc(evContext ctx __unused, void *uap, struct timespec due __unused,
1832         struct timespec inter __unused)
1833 #endif
1834 {
1835         struct timer *tp = uap;
1836
1837         tp->func(tp->udata);
1838 }
1839
1840 /*
1841  * Start a one-shot timer
1842  */
1843 void *
1844 timer_start(u_int ticks, void (*func)(void *), void *udata, struct lmodule *mod)
1845 {
1846         struct timer *tp;
1847 #ifndef USE_LIBBEGEMOT
1848         struct timespec due;
1849 #endif
1850
1851         if ((tp = malloc(sizeof(struct timer))) == NULL) {
1852                 syslog(LOG_CRIT, "out of memory for timer");
1853                 exit(1);
1854         }
1855
1856 #ifndef USE_LIBBEGEMOT
1857         due = evAddTime(evNowTime(),
1858             evConsTime(ticks / 100, (ticks % 100) * 10000));
1859 #endif
1860
1861         tp->udata = udata;
1862         tp->owner = mod;
1863         tp->func = func;
1864
1865         LIST_INSERT_HEAD(&timer_list, tp, link);
1866
1867 #ifdef USE_LIBBEGEMOT
1868         if ((tp->id = poll_start_timer(ticks * 10, 0, tfunc, tp)) < 0) {
1869                 syslog(LOG_ERR, "cannot set timer: %m");
1870                 exit(1);
1871         }
1872 #else
1873         if (evSetTimer(evctx, tfunc, tp, due, evConsTime(0, 0), &tp->id)
1874             == -1) {
1875                 syslog(LOG_ERR, "cannot set timer: %m");
1876                 exit(1);
1877         }
1878 #endif
1879         return (tp);
1880 }
1881
1882 /*
1883  * Start a repeatable timer. When used with USE_LIBBEGEMOT the first argument
1884  * is currently ignored and the initial number of ticks is set to the
1885  * repeat number of ticks.
1886  */
1887 void *
1888 timer_start_repeat(u_int ticks __unused, u_int repeat_ticks,
1889     void (*func)(void *), void *udata, struct lmodule *mod)
1890 {
1891         struct timer *tp;
1892 #ifndef USE_LIBBEGEMOT
1893         struct timespec due;
1894         struct timespec inter;
1895 #endif
1896
1897         if ((tp = malloc(sizeof(struct timer))) == NULL) {
1898                 syslog(LOG_CRIT, "out of memory for timer");
1899                 exit(1);
1900         }
1901
1902 #ifndef USE_LIBBEGEMOT
1903         due = evAddTime(evNowTime(),
1904             evConsTime(ticks / 100, (ticks % 100) * 10000));
1905         inter = evConsTime(repeat_ticks / 100, (repeat_ticks % 100) * 10000);
1906 #endif
1907
1908         tp->udata = udata;
1909         tp->owner = mod;
1910         tp->func = func;
1911
1912         LIST_INSERT_HEAD(&timer_list, tp, link);
1913
1914 #ifdef USE_LIBBEGEMOT
1915         if ((tp->id = poll_start_timer(repeat_ticks * 10, 1, trfunc, tp)) < 0) {
1916                 syslog(LOG_ERR, "cannot set timer: %m");
1917                 exit(1);
1918         }
1919 #else
1920         if (evSetTimer(evctx, trfunc, tp, due, inter, &tp->id) == -1) {
1921                 syslog(LOG_ERR, "cannot set timer: %m");
1922                 exit(1);
1923         }
1924 #endif
1925         return (tp);
1926 }
1927
1928 /*
1929  * Stop a timer.
1930  */
1931 void
1932 timer_stop(void *p)
1933 {
1934         struct timer *tp = p;
1935
1936         LIST_REMOVE(tp, link);
1937 #ifdef USE_LIBBEGEMOT
1938         poll_stop_timer(tp->id);
1939 #else
1940         if (evClearTimer(evctx, tp->id) == -1) {
1941                 syslog(LOG_ERR, "cannot stop timer: %m");
1942                 exit(1);
1943         }
1944 #endif
1945         free(p);
1946 }
1947
1948 static void
1949 timer_flush(struct lmodule *mod)
1950 {
1951         struct timer *t, *t1;
1952
1953         t = LIST_FIRST(&timer_list);
1954         while (t != NULL) {
1955                 t1 = LIST_NEXT(t, link);
1956                 if (t->owner == mod)
1957                         timer_stop(t);
1958                 t = t1;
1959         }
1960 }
1961
1962 static void
1963 snmp_printf_func(const char *fmt, ...)
1964 {
1965         va_list ap;
1966         static char *pend = NULL;
1967         char *ret, *new;
1968
1969         va_start(ap, fmt);
1970         vasprintf(&ret, fmt, ap);
1971         va_end(ap);
1972
1973         if (ret == NULL)
1974                 return;
1975         if (pend != NULL) {
1976                 if ((new = realloc(pend, strlen(pend) + strlen(ret) + 1))
1977                     == NULL) {
1978                         free(ret);
1979                         return;
1980                 }
1981                 pend = new;
1982                 strcat(pend, ret);
1983                 free(ret);
1984         } else
1985                 pend = ret;
1986
1987         while ((ret = strchr(pend, '\n')) != NULL) {
1988                 *ret = '\0';
1989                 syslog(LOG_DEBUG, "%s", pend);
1990                 if (strlen(ret + 1) == 0) {
1991                         free(pend);
1992                         pend = NULL;
1993                         break;
1994                 }
1995                 strcpy(pend, ret + 1);
1996         }
1997 }
1998
1999 static void
2000 snmp_error_func(const char *err, ...)
2001 {
2002         char errbuf[1000];
2003         va_list ap;
2004
2005         if (!(snmp_trace & LOG_SNMP_ERRORS))
2006                 return;
2007
2008         va_start(ap, err);
2009         snprintf(errbuf, sizeof(errbuf), "SNMP: ");
2010         vsnprintf(errbuf + strlen(errbuf),
2011             sizeof(errbuf) - strlen(errbuf), err, ap);
2012         va_end(ap);
2013
2014         syslog(LOG_ERR, "%s", errbuf);
2015 }
2016
2017 static void
2018 snmp_debug_func(const char *err, ...)
2019 {
2020         char errbuf[1000];
2021         va_list ap;
2022
2023         va_start(ap, err);
2024         snprintf(errbuf, sizeof(errbuf), "SNMP: ");
2025         vsnprintf(errbuf+strlen(errbuf), sizeof(errbuf)-strlen(errbuf),
2026             err, ap);
2027         va_end(ap);
2028
2029         syslog(LOG_DEBUG, "%s", errbuf);
2030 }
2031
2032 static void
2033 asn_error_func(const struct asn_buf *b, const char *err, ...)
2034 {
2035         char errbuf[1000];
2036         va_list ap;
2037         u_int i;
2038
2039         if (!(snmp_trace & LOG_ASN1_ERRORS))
2040                 return;
2041
2042         va_start(ap, err);
2043         snprintf(errbuf, sizeof(errbuf), "ASN.1: ");
2044         vsnprintf(errbuf + strlen(errbuf),
2045             sizeof(errbuf) - strlen(errbuf), err, ap);
2046         va_end(ap);
2047
2048         if (b != NULL) {
2049                 snprintf(errbuf + strlen(errbuf),
2050                     sizeof(errbuf) - strlen(errbuf), " at");
2051                 for (i = 0; b->asn_len > i; i++)
2052                         snprintf(errbuf + strlen(errbuf),
2053                             sizeof(errbuf) - strlen(errbuf),
2054                             " %02x", b->asn_cptr[i]);
2055         }
2056
2057         syslog(LOG_ERR, "%s", errbuf);
2058 }
2059
2060 /*
2061  * Create a new community
2062  */
2063 struct community*
2064 comm_define_ordered(u_int priv, const char *descr, struct asn_oid *idx,
2065     struct lmodule *owner, const char *str)
2066 {
2067         struct community *c, *p;
2068         u_int ncomm;
2069
2070         ncomm = idx->subs[idx->len - 1];
2071
2072         /* check that community doesn't already exist */
2073         TAILQ_FOREACH(c, &community_list, link)
2074                 if (c->value == ncomm)
2075                         return (c);
2076
2077         if ((c = malloc(sizeof(struct community))) == NULL) {
2078                 syslog(LOG_ERR, "%s: %m", __func__);
2079                 return (NULL);
2080         }
2081         c->owner = owner;
2082         c->value = ncomm;
2083         c->descr = descr;
2084         c->string = NULL;
2085         c->private = priv;
2086
2087         if (str != NULL) {
2088                 if((c->string = malloc(strlen(str)+1)) == NULL) {
2089                         free(c);
2090                         return (NULL);
2091                 }
2092                 strcpy(c->string, str);
2093         }
2094         /*
2095          * Insert ordered
2096          */
2097         c->index = *idx;
2098         TAILQ_FOREACH(p, &community_list, link) {
2099                 if (asn_compare_oid(&p->index, &c->index) > 0) {
2100                         TAILQ_INSERT_BEFORE(p, c, link);
2101                         break;
2102                 }
2103         }
2104         if (p == NULL)
2105                 TAILQ_INSERT_TAIL(&community_list, c, link);
2106         return (c);
2107 }
2108
2109 u_int
2110 comm_define(u_int priv, const char *descr, struct lmodule *owner,
2111     const char *str)
2112 {
2113         struct asn_oid idx, *p;
2114         struct community *c;
2115         u_int ncomm;
2116
2117         /* generate an identifier */
2118         do {
2119                 if ((ncomm = next_community_index++) == UINT_MAX)
2120                         next_community_index = 1;
2121                 TAILQ_FOREACH(c, &community_list, link)
2122                         if (c->value == ncomm)
2123                                 break;
2124         } while (c != NULL);
2125
2126         /* make index */
2127         if (owner != NULL)
2128                 p = &owner->index;
2129         else {
2130                 p = &idx;
2131                 p->len = 1;
2132                 p->subs[0] = 0;
2133         }
2134         p->subs[p->len++] = ncomm;
2135         c = comm_define_ordered(priv, descr, p, owner, str);
2136         if (c == NULL)
2137                 return (0);
2138         return (c->value);
2139 }
2140
2141 const char *
2142 comm_string(u_int ncomm)
2143 {
2144         struct community *p;
2145
2146         TAILQ_FOREACH(p, &community_list, link)
2147                 if (p->value == ncomm)
2148                         return (p->string);
2149         return (NULL);
2150 }
2151
2152 /*
2153  * Delete all communities allocated by a module
2154  */
2155 static void
2156 comm_flush(struct lmodule *mod)
2157 {
2158         struct community *p, *p1;
2159
2160         p = TAILQ_FIRST(&community_list);
2161         while (p != NULL) {
2162                 p1 = TAILQ_NEXT(p, link);
2163                 if (p->owner == mod) {
2164                         free(p->string);
2165                         TAILQ_REMOVE(&community_list, p, link);
2166                         free(p);
2167                 }
2168                 p = p1;
2169         }
2170 }
2171
2172 /*
2173  * Request ID handling.
2174  *
2175  * Allocate a new range of request ids. Use a first fit algorithm.
2176  */
2177 u_int
2178 reqid_allocate(int size, struct lmodule *mod)
2179 {
2180         u_int type;
2181         struct idrange *r, *r1;
2182
2183         if (size <= 0 || size > INT32_MAX) {
2184                 syslog(LOG_CRIT, "%s: size out of range: %d", __func__, size);
2185                 return (0);
2186         }
2187         /* allocate a type id */
2188         do {
2189                 if ((type = next_idrange++) == UINT_MAX)
2190                         next_idrange = 1;
2191                 TAILQ_FOREACH(r, &idrange_list, link)
2192                         if (r->type == type)
2193                                 break;
2194         } while(r != NULL);
2195
2196         /* find a range */
2197         if (TAILQ_EMPTY(&idrange_list))
2198                 r = NULL;
2199         else {
2200                 r = TAILQ_FIRST(&idrange_list);
2201                 if (r->base < size) {
2202                         while((r1 = TAILQ_NEXT(r, link)) != NULL) {
2203                                 if (r1->base - (r->base + r->size) >= size)
2204                                         break;
2205                                 r = r1;
2206                         }
2207                         r = r1;
2208                 }
2209                 if (r == NULL) {
2210                         r1 = TAILQ_LAST(&idrange_list, idrange_list);
2211                         if (INT32_MAX - size + 1 < r1->base + r1->size) {
2212                                 syslog(LOG_ERR, "out of id ranges (%u)", size);
2213                                 return (0);
2214                         }
2215                 }
2216         }
2217
2218         /* allocate structure */
2219         if ((r1 = malloc(sizeof(struct idrange))) == NULL) {
2220                 syslog(LOG_ERR, "%s: %m", __FUNCTION__);
2221                 return (0);
2222         }
2223
2224         r1->type = type;
2225         r1->size = size;
2226         r1->owner = mod;
2227         if (TAILQ_EMPTY(&idrange_list) || r == TAILQ_FIRST(&idrange_list)) {
2228                 r1->base = 0;
2229                 TAILQ_INSERT_HEAD(&idrange_list, r1, link);
2230         } else if (r == NULL) {
2231                 r = TAILQ_LAST(&idrange_list, idrange_list);
2232                 r1->base = r->base + r->size;
2233                 TAILQ_INSERT_TAIL(&idrange_list, r1, link);
2234         } else {
2235                 r = TAILQ_PREV(r, idrange_list, link);
2236                 r1->base = r->base + r->size;
2237                 TAILQ_INSERT_AFTER(&idrange_list, r, r1, link);
2238         }
2239         r1->next = r1->base;
2240
2241         return (type);
2242 }
2243
2244 int32_t
2245 reqid_next(u_int type)
2246 {
2247         struct idrange *r;
2248         int32_t id;
2249
2250         TAILQ_FOREACH(r, &idrange_list, link)
2251                 if (r->type == type)
2252                         break;
2253         if (r == NULL) {
2254                 syslog(LOG_CRIT, "wrong idrange type");
2255                 abort();
2256         }
2257         if ((id = r->next++) == r->base + (r->size - 1))
2258                 r->next = r->base;
2259         return (id);
2260 }
2261
2262 int32_t
2263 reqid_base(u_int type)
2264 {
2265         struct idrange *r;
2266
2267         TAILQ_FOREACH(r, &idrange_list, link)
2268                 if (r->type == type)
2269                         return (r->base);
2270         syslog(LOG_CRIT, "wrong idrange type");
2271         abort();
2272 }
2273
2274 u_int
2275 reqid_type(int32_t reqid)
2276 {
2277         struct idrange *r;
2278
2279         TAILQ_FOREACH(r, &idrange_list, link)
2280                 if (reqid >= r->base && reqid <= r->base + (r->size - 1))
2281                         return (r->type);
2282         return (0);
2283 }
2284
2285 int
2286 reqid_istype(int32_t reqid, u_int type)
2287 {
2288         return (reqid_type(reqid) == type);
2289 }
2290
2291 /*
2292  * Delete all communities allocated by a module
2293  */
2294 static void
2295 reqid_flush(struct lmodule *mod)
2296 {
2297         struct idrange *p, *p1;
2298
2299         p = TAILQ_FIRST(&idrange_list);
2300         while (p != NULL) {
2301                 p1 = TAILQ_NEXT(p, link);
2302                 if (p->owner == mod) {
2303                         TAILQ_REMOVE(&idrange_list, p, link);
2304                         free(p);
2305                 }
2306                 p = p1;
2307         }
2308 }
2309
2310 /*
2311  * Merge the given tree for the given module into the main tree.
2312  */
2313 static int
2314 compare_node(const void *v1, const void *v2)
2315 {
2316         const struct snmp_node *n1 = v1;
2317         const struct snmp_node *n2 = v2;
2318
2319         return (asn_compare_oid(&n1->oid, &n2->oid));
2320 }
2321 static int
2322 tree_merge(const struct snmp_node *ntree, u_int nsize, struct lmodule *mod)
2323 {
2324         struct snmp_node *xtree;
2325         u_int i;
2326
2327         xtree = realloc(tree, sizeof(*tree) * (tree_size + nsize));
2328         if (xtree == NULL) {
2329                 syslog(LOG_ERR, "tree_merge: %m");
2330                 return (-1);
2331         }
2332         tree = xtree;
2333         memcpy(&tree[tree_size], ntree, sizeof(*tree) * nsize);
2334
2335         for (i = 0; i < nsize; i++)
2336                 tree[tree_size + i].tree_data = mod;
2337
2338         tree_size += nsize;
2339
2340         qsort(tree, tree_size, sizeof(tree[0]), compare_node);
2341
2342         return (0);
2343 }
2344
2345 /*
2346  * Remove all nodes belonging to the loadable module
2347  */
2348 static void
2349 tree_unmerge(struct lmodule *mod)
2350 {
2351         u_int s, d;
2352
2353         for(s = d = 0; s < tree_size; s++)
2354                 if (tree[s].tree_data != mod) {
2355                         if (s != d)
2356                                 tree[d] = tree[s];
2357                         d++;
2358                 }
2359         tree_size = d;
2360 }
2361
2362 /*
2363  * Loadable modules
2364  */
2365 struct lmodule *
2366 lm_load(const char *path, const char *section)
2367 {
2368         struct lmodule *m;
2369         int err;
2370         int i;
2371         char *av[MAX_MOD_ARGS + 1];
2372         int ac;
2373         u_int u;
2374
2375         if ((m = malloc(sizeof(*m))) == NULL) {
2376                 syslog(LOG_ERR, "lm_load: %m");
2377                 return (NULL);
2378         }
2379         m->handle = NULL;
2380         m->flags = 0;
2381         strlcpy(m->section, section, sizeof(m->section));
2382
2383         if ((m->path = strdup(path)) == NULL) {
2384                 syslog(LOG_ERR, "lm_load: %m");
2385                 goto err;
2386         }
2387
2388         /*
2389          * Make index
2390          */
2391         m->index.subs[0] = strlen(section);
2392         m->index.len = m->index.subs[0] + 1;
2393         for (u = 0; u < m->index.subs[0]; u++)
2394                 m->index.subs[u + 1] = section[u];
2395
2396         /*
2397          * Load the object file and locate the config structure
2398          */
2399         if ((m->handle = dlopen(m->path, RTLD_NOW|RTLD_GLOBAL)) == NULL) {
2400                 syslog(LOG_ERR, "lm_load: open %s", dlerror());
2401                 goto err;
2402         }
2403
2404         if ((m->config = dlsym(m->handle, "config")) == NULL) {
2405                 syslog(LOG_ERR, "lm_load: no 'config' symbol %s", dlerror());
2406                 goto err;
2407         }
2408
2409         /*
2410          * Insert it into the right place
2411          */
2412         INSERT_OBJECT_OID(m, &lmodules);
2413
2414         /* preserve order */
2415         if (community == COMM_INITIALIZE) {
2416                 m->flags |= LM_ONSTARTLIST;
2417                 TAILQ_INSERT_TAIL(&modules_start, m, start);
2418         }
2419
2420         /*
2421          * make the argument vector.
2422          */
2423         ac = 0;
2424         for (i = 0; i < nprogargs; i++) {
2425                 if (strlen(progargs[i]) >= strlen(section) + 1 &&
2426                     strncmp(progargs[i], section, strlen(section)) == 0 &&
2427                     progargs[i][strlen(section)] == ':') {
2428                         if (ac == MAX_MOD_ARGS) {
2429                                 syslog(LOG_WARNING, "too many arguments for "
2430                                     "module '%s", section);
2431                                 break;
2432                         }
2433                         av[ac++] = &progargs[i][strlen(section)+1];
2434                 }
2435         }
2436         av[ac] = NULL;
2437
2438         /*
2439          * Run the initialization function
2440          */
2441         if ((err = (*m->config->init)(m, ac, av)) != 0) {
2442                 syslog(LOG_ERR, "lm_load: init failed: %d", err);
2443                 TAILQ_REMOVE(&lmodules, m, link);
2444                 goto err;
2445         }
2446
2447         return (m);
2448
2449   err:
2450         if ((m->flags & LM_ONSTARTLIST) != 0)
2451                 TAILQ_REMOVE(&modules_start, m, start);
2452         if (m->handle)
2453                 dlclose(m->handle);
2454         free(m->path);
2455         free(m);
2456         return (NULL);
2457 }
2458
2459 /*
2460  * Start a module
2461  */
2462 void
2463 lm_start(struct lmodule *mod)
2464 {
2465         const struct lmodule *m;
2466
2467         /*
2468          * Merge tree. If this fails, unload the module.
2469          */
2470         if (tree_merge(mod->config->tree, mod->config->tree_size, mod)) {
2471                 lm_unload(mod);
2472                 return;
2473         }
2474
2475         /*
2476          * Read configuration
2477          */
2478         if (read_config(config_file, mod)) {
2479                 syslog(LOG_ERR, "error in config file");
2480                 lm_unload(mod);
2481                 return;
2482         }
2483         if (mod->config->start)
2484                 (*mod->config->start)();
2485
2486         mod->flags |= LM_STARTED;
2487
2488         /*
2489          * Inform other modules
2490          */
2491         TAILQ_FOREACH(m, &lmodules, link)
2492                 if (m->config->loading)
2493                         (*m->config->loading)(mod, 1);
2494 }
2495
2496
2497 /*
2498  * Unload a module.
2499  */
2500 void
2501 lm_unload(struct lmodule *m)
2502 {
2503         int err;
2504         const struct lmodule *mod;
2505
2506         TAILQ_REMOVE(&lmodules, m, link);
2507         if (m->flags & LM_ONSTARTLIST)
2508                 TAILQ_REMOVE(&modules_start, m, start);
2509         tree_unmerge(m);
2510
2511         if ((m->flags & LM_STARTED) && m->config->fini &&
2512             (err = (*m->config->fini)()) != 0)
2513                 syslog(LOG_WARNING, "lm_unload(%s): fini %d", m->section, err);
2514
2515         comm_flush(m);
2516         reqid_flush(m);
2517         timer_flush(m);
2518         fd_flush(m);
2519
2520         dlclose(m->handle);
2521         free(m->path);
2522
2523         /*
2524          * Inform other modules
2525          */
2526         TAILQ_FOREACH(mod, &lmodules, link)
2527                 if (mod->config->loading)
2528                         (*mod->config->loading)(m, 0);
2529
2530         free(m);
2531 }
2532
2533 /*
2534  * Register an object resource and return the index (or 0 on failures)
2535  */
2536 u_int
2537 or_register(const struct asn_oid *or, const char *descr, struct lmodule *mod)
2538 {
2539         struct objres *objres, *or1;
2540         u_int idx;
2541
2542         /* find a free index */
2543         idx = 1;
2544         for (objres = TAILQ_FIRST(&objres_list);
2545              objres != NULL;
2546              objres = TAILQ_NEXT(objres, link)) {
2547                 if ((or1 = TAILQ_NEXT(objres, link)) == NULL ||
2548                     or1->index > objres->index + 1) {
2549                         idx = objres->index + 1;
2550                         break;
2551                 }
2552         }
2553
2554         if ((objres = malloc(sizeof(*objres))) == NULL)
2555                 return (0);
2556
2557         objres->index = idx;
2558         objres->oid = *or;
2559         strlcpy(objres->descr, descr, sizeof(objres->descr));
2560         objres->uptime = (uint32_t)(get_ticks() - start_tick);
2561         objres->module = mod;
2562
2563         INSERT_OBJECT_INT(objres, &objres_list);
2564
2565         systemg.or_last_change = objres->uptime;
2566
2567         return (idx);
2568 }
2569
2570 void
2571 or_unregister(u_int idx)
2572 {
2573         struct objres *objres;
2574
2575         TAILQ_FOREACH(objres, &objres_list, link)
2576                 if (objres->index == idx) {
2577                         TAILQ_REMOVE(&objres_list, objres, link);
2578                         free(objres);
2579                         return;
2580                 }
2581 }
2582
2583 /*
2584  * RFC 3414 User-based Security Model support
2585  */
2586
2587 struct snmpd_usmstat *
2588 bsnmpd_get_usm_stats(void)
2589 {
2590         return (&snmpd_usmstats);
2591 }
2592
2593 void
2594 bsnmpd_reset_usm_stats(void)
2595 {
2596         memset(&snmpd_usmstats, 0, sizeof(snmpd_usmstats));
2597 }
2598
2599 struct usm_user *
2600 usm_first_user(void)
2601 {
2602         return (SLIST_FIRST(&usm_userlist));
2603 }
2604
2605 struct usm_user *
2606 usm_next_user(struct usm_user *uuser)
2607 {
2608         if (uuser == NULL)
2609                 return (NULL);
2610
2611         return (SLIST_NEXT(uuser, up));
2612 }
2613
2614 struct usm_user *
2615 usm_find_user(uint8_t *engine, uint32_t elen, char *uname)
2616 {
2617         struct usm_user *uuser;
2618
2619         SLIST_FOREACH(uuser, &usm_userlist, up)
2620                 if (uuser->user_engine_len == elen &&
2621                     memcmp(uuser->user_engine_id, engine, elen) == 0 &&
2622                     strlen(uuser->suser.sec_name) == strlen(uname) &&
2623                     strcmp(uuser->suser.sec_name, uname) == 0)
2624                         break;
2625
2626         return (uuser);
2627 }
2628
2629 static int
2630 usm_compare_user(struct usm_user *u1, struct usm_user *u2)
2631 {
2632         uint32_t i;
2633
2634         if (u1->user_engine_len < u2->user_engine_len)
2635                 return (-1);
2636         if (u1->user_engine_len > u2->user_engine_len)
2637                 return (1);
2638
2639         for (i = 0; i < u1->user_engine_len; i++) {
2640                 if (u1->user_engine_id[i] < u2->user_engine_id[i])
2641                         return (-1);
2642                 if (u1->user_engine_id[i] > u2->user_engine_id[i])
2643                         return (1);
2644         }
2645
2646         if (strlen(u1->suser.sec_name) < strlen(u2->suser.sec_name))
2647                 return (-1);
2648         if (strlen(u1->suser.sec_name) > strlen(u2->suser.sec_name))
2649                 return (1);
2650
2651         for (i = 0; i < strlen(u1->suser.sec_name); i++) {
2652                 if (u1->suser.sec_name[i] < u2->suser.sec_name[i])
2653                         return (-1);
2654                 if (u1->suser.sec_name[i] > u2->suser.sec_name[i])
2655                         return (1);
2656         }
2657
2658         return (0);
2659 }
2660
2661 struct usm_user *
2662 usm_new_user(uint8_t *eid, uint32_t elen, char *uname)
2663 {
2664         int cmp;
2665         struct usm_user *uuser, *temp, *prev;
2666
2667         for (uuser = usm_first_user(); uuser != NULL;
2668             (uuser = usm_next_user(uuser))) {
2669                 if (uuser->user_engine_len == elen &&
2670                     strlen(uname) == strlen(uuser->suser.sec_name) &&
2671                     strcmp(uname, uuser->suser.sec_name) == 0 &&
2672                     memcmp(eid, uuser->user_engine_id, elen) == 0)
2673                         return (NULL);
2674         }
2675
2676         if ((uuser = (struct usm_user *)malloc(sizeof(*uuser))) == NULL)
2677                 return (NULL);
2678
2679         memset(uuser, 0, sizeof(*uuser));
2680         strlcpy(uuser->suser.sec_name, uname, SNMP_ADM_STR32_SIZ);
2681         memcpy(uuser->user_engine_id, eid, elen);
2682         uuser->user_engine_len = elen;
2683
2684         if ((prev = SLIST_FIRST(&usm_userlist)) == NULL ||
2685             usm_compare_user(uuser, prev) < 0) {
2686                 SLIST_INSERT_HEAD(&usm_userlist, uuser, up);
2687                 return (uuser);
2688         }
2689
2690         SLIST_FOREACH(temp, &usm_userlist, up) {
2691                 if ((cmp = usm_compare_user(uuser, temp)) <= 0)
2692                         break;
2693                 prev = temp;
2694         }
2695
2696         if (temp == NULL || cmp < 0)
2697                 SLIST_INSERT_AFTER(prev, uuser, up);
2698         else if (cmp > 0)
2699                 SLIST_INSERT_AFTER(temp, uuser, up);
2700         else {
2701                 syslog(LOG_ERR, "User %s exists", uuser->suser.sec_name);
2702                 free(uuser);
2703                 return (NULL);
2704         }
2705
2706         return (uuser);
2707 }
2708
2709 void
2710 usm_delete_user(struct usm_user *uuser)
2711 {
2712         SLIST_REMOVE(&usm_userlist, uuser, usm_user, up);
2713         free(uuser);
2714 }
2715
2716 void
2717 usm_flush_users(void)
2718 {
2719         struct usm_user *uuser;
2720
2721         while ((uuser = SLIST_FIRST(&usm_userlist)) != NULL) {
2722                 SLIST_REMOVE_HEAD(&usm_userlist, up);
2723                 free(uuser);
2724         }
2725
2726         SLIST_INIT(&usm_userlist);
2727 }
2728
2729 /*
2730  * RFC 3415 View-based Access Control Model support
2731  */
2732 struct vacm_user *
2733 vacm_first_user(void)
2734 {
2735         return (SLIST_FIRST(&vacm_userlist));
2736 }
2737
2738 struct vacm_user *
2739 vacm_next_user(struct vacm_user *vuser)
2740 {
2741         if (vuser == NULL)
2742                 return (NULL);
2743
2744         return (SLIST_NEXT(vuser, vvu));
2745 }
2746
2747 static int
2748 vacm_compare_user(struct vacm_user *v1, struct vacm_user *v2)
2749 {
2750         uint32_t i;
2751
2752         if (v1->sec_model < v2->sec_model)
2753                 return (-1);
2754         if (v1->sec_model > v2->sec_model)
2755                 return (1);
2756
2757         if (strlen(v1->secname) < strlen(v2->secname))
2758                 return (-1);
2759         if (strlen(v1->secname) > strlen(v2->secname))
2760                 return (1);
2761
2762         for (i = 0; i < strlen(v1->secname); i++) {
2763                 if (v1->secname[i] < v2->secname[i])
2764                         return (-1);
2765                 if (v1->secname[i] > v2->secname[i])
2766                         return (1);
2767         }
2768
2769         return (0);
2770 }
2771
2772 struct vacm_user *
2773 vacm_new_user(int32_t smodel, char *uname)
2774 {
2775         int cmp;
2776         struct vacm_user *user, *temp, *prev;
2777
2778         SLIST_FOREACH(user, &vacm_userlist, vvu)
2779                 if (strcmp(uname, user->secname) == 0 &&
2780                     smodel == user->sec_model)
2781                         return (NULL);
2782
2783         if ((user = (struct vacm_user *)malloc(sizeof(*user))) == NULL)
2784                 return (NULL);
2785
2786         memset(user, 0, sizeof(*user));
2787         user->group = &vacm_default_group;
2788         SLIST_INSERT_HEAD(&vacm_default_group.group_users, user, vvg);
2789         user->sec_model = smodel;
2790         strlcpy(user->secname, uname, sizeof(user->secname));
2791
2792         if ((prev = SLIST_FIRST(&vacm_userlist)) == NULL ||
2793             vacm_compare_user(user, prev) < 0) {
2794                 SLIST_INSERT_HEAD(&vacm_userlist, user, vvu);
2795                 return (user);
2796         }
2797
2798         SLIST_FOREACH(temp, &vacm_userlist, vvu) {
2799                 if ((cmp = vacm_compare_user(user, temp)) <= 0)
2800                         break;
2801                 prev = temp;
2802         }
2803
2804         if (temp == NULL || cmp < 0)
2805                 SLIST_INSERT_AFTER(prev, user, vvu);
2806         else if (cmp > 0)
2807                 SLIST_INSERT_AFTER(temp, user, vvu);
2808         else {
2809                 syslog(LOG_ERR, "User %s exists", user->secname);
2810                 free(user);
2811                 return (NULL);
2812         }
2813
2814         return (user);
2815 }
2816
2817 int
2818 vacm_delete_user(struct vacm_user *user)
2819 {
2820         if (user->group != NULL && user->group != &vacm_default_group) {
2821                 SLIST_REMOVE(&user->group->group_users, user, vacm_user, vvg);
2822                 if (SLIST_EMPTY(&user->group->group_users)) {
2823                         SLIST_REMOVE(&vacm_grouplist, user->group,
2824                             vacm_group, vge);
2825                         free(user->group);
2826                 }
2827         }
2828
2829         SLIST_REMOVE(&vacm_userlist, user, vacm_user, vvu);
2830         free(user);
2831
2832         return (0);
2833 }
2834
2835 int
2836 vacm_user_set_group(struct vacm_user *user, u_char *octets, u_int len)
2837 {
2838         struct vacm_group *group;
2839
2840         if (len >= SNMP_ADM_STR32_SIZ)
2841                 return (-1);
2842
2843         SLIST_FOREACH(group, &vacm_grouplist, vge)
2844                 if (strlen(group->groupname) == len &&
2845                     memcmp(octets, group->groupname, len) == 0)
2846                         break;
2847
2848         if (group == NULL) {
2849                 if ((group = (struct vacm_group *)malloc(sizeof(*group))) == NULL)
2850                         return (-1);
2851                 memset(group, 0, sizeof(*group));
2852                 memcpy(group->groupname, octets, len);
2853                 group->groupname[len] = '\0';
2854                 SLIST_INSERT_HEAD(&vacm_grouplist, group, vge);
2855         }
2856
2857         SLIST_REMOVE(&user->group->group_users, user, vacm_user, vvg);
2858         SLIST_INSERT_HEAD(&group->group_users, user, vvg);
2859         user->group = group;
2860
2861         return (0);
2862 }
2863
2864 void
2865 vacm_groups_init(void)
2866 {
2867         SLIST_INSERT_HEAD(&vacm_grouplist, &vacm_default_group, vge);
2868 }
2869
2870 struct vacm_access *
2871 vacm_first_access_rule(void)
2872 {
2873         return (TAILQ_FIRST(&vacm_accesslist));
2874 }
2875
2876 struct vacm_access *
2877 vacm_next_access_rule(struct vacm_access *acl)
2878 {
2879         if (acl == NULL)
2880                 return (NULL);
2881
2882         return (TAILQ_NEXT(acl, vva));
2883 }
2884
2885 static int
2886 vacm_compare_access_rule(struct vacm_access *v1, struct vacm_access *v2)
2887 {
2888         uint32_t i;
2889
2890         if (strlen(v1->group->groupname) < strlen(v2->group->groupname))
2891                 return (-1);
2892         if (strlen(v1->group->groupname) > strlen(v2->group->groupname))
2893                 return (1);
2894
2895         for (i = 0; i < strlen(v1->group->groupname); i++) {
2896                 if (v1->group->groupname[i] < v2->group->groupname[i])
2897                         return (-1);
2898                 if (v1->group->groupname[i] > v2->group->groupname[i])
2899                         return (1);
2900         }
2901
2902         if (strlen(v1->ctx_prefix) < strlen(v2->ctx_prefix))
2903                 return (-1);
2904         if (strlen(v1->ctx_prefix) > strlen(v2->ctx_prefix))
2905                 return (1);
2906
2907         for (i = 0; i < strlen(v1->ctx_prefix); i++) {
2908                 if (v1->ctx_prefix[i] < v2->ctx_prefix[i])
2909                         return (-1);
2910                 if (v1->ctx_prefix[i] > v2->ctx_prefix[i])
2911                         return (1);
2912         }
2913
2914         if (v1->sec_model < v2->sec_model)
2915                 return (-1);
2916         if (v1->sec_model > v2->sec_model)
2917                 return (1);
2918
2919         if (v1->sec_level < v2->sec_level)
2920                 return (-1);
2921         if (v1->sec_level > v2->sec_level)
2922                 return (1);
2923
2924         return (0);
2925 }
2926
2927 struct vacm_access *
2928 vacm_new_access_rule(char *gname, char *cprefix, int32_t smodel, int32_t slevel)
2929 {
2930         struct vacm_group *group;
2931         struct vacm_access *acl, *temp;
2932
2933         TAILQ_FOREACH(acl, &vacm_accesslist, vva) {
2934                 if (acl->group == NULL)
2935                         continue;
2936                 if (strcmp(gname, acl->group->groupname) == 0 &&
2937                     strcmp(cprefix, acl->ctx_prefix) == 0 &&
2938                     acl->sec_model == smodel && acl->sec_level == slevel)
2939                         return (NULL);
2940         }
2941
2942         /* Make sure the group exists */
2943         SLIST_FOREACH(group, &vacm_grouplist, vge)
2944                 if (strcmp(gname, group->groupname) == 0)
2945                         break;
2946
2947         if (group == NULL)
2948                 return (NULL);
2949
2950         if ((acl = (struct vacm_access *)malloc(sizeof(*acl))) == NULL)
2951                 return (NULL);
2952
2953         memset(acl, 0, sizeof(*acl));
2954         acl->group = group;
2955         strlcpy(acl->ctx_prefix, cprefix, sizeof(acl->ctx_prefix));
2956         acl->sec_model = smodel;
2957         acl->sec_level = slevel;
2958
2959         if ((temp = TAILQ_FIRST(&vacm_accesslist)) == NULL ||
2960             vacm_compare_access_rule(acl, temp) < 0) {
2961                 TAILQ_INSERT_HEAD(&vacm_accesslist, acl, vva);
2962                 return (acl);
2963         }
2964
2965         TAILQ_FOREACH(temp, &vacm_accesslist, vva)
2966                 if (vacm_compare_access_rule(acl, temp) < 0) {
2967                         TAILQ_INSERT_BEFORE(temp, acl, vva);
2968                         return (acl);
2969                 }
2970
2971         TAILQ_INSERT_TAIL(&vacm_accesslist, acl, vva);
2972
2973         return (acl);
2974 }
2975
2976 int
2977 vacm_delete_access_rule(struct vacm_access *acl)
2978 {
2979         TAILQ_REMOVE(&vacm_accesslist, acl, vva);
2980         free(acl);
2981
2982         return (0);
2983 }
2984
2985 struct vacm_view *
2986 vacm_first_view(void)
2987 {
2988         return (SLIST_FIRST(&vacm_viewlist));
2989 }
2990
2991 struct vacm_view *
2992 vacm_next_view(struct vacm_view *view)
2993 {
2994         if (view == NULL)
2995                 return (NULL);
2996
2997         return (SLIST_NEXT(view, vvl));
2998 }
2999
3000 static int
3001 vacm_compare_view(struct vacm_view *v1, struct vacm_view *v2)
3002 {
3003         uint32_t i;
3004
3005         if (strlen(v1->viewname) < strlen(v2->viewname))
3006                 return (-1);
3007         if (strlen(v1->viewname) > strlen(v2->viewname))
3008                 return (1);
3009
3010         for (i = 0; i < strlen(v1->viewname); i++) {
3011                 if (v1->viewname[i] < v2->viewname[i])
3012                         return (-1);
3013                 if (v1->viewname[i] > v2->viewname[i])
3014                         return (1);
3015         }
3016
3017         return (asn_compare_oid(&v1->subtree, &v2->subtree));
3018 }
3019
3020 struct vacm_view *
3021 vacm_new_view(char *vname, struct asn_oid *oid)
3022 {
3023         int cmp;
3024         struct vacm_view *view, *temp, *prev;
3025
3026         SLIST_FOREACH(view, &vacm_viewlist, vvl)
3027                 if (strcmp(vname, view->viewname) == 0)
3028                         return (NULL);
3029
3030         if ((view = (struct vacm_view *)malloc(sizeof(*view))) == NULL)
3031                 return (NULL);
3032
3033         memset(view, 0, sizeof(*view));
3034         strlcpy(view->viewname, vname, sizeof(view->viewname));
3035         asn_append_oid(&view->subtree, oid);
3036
3037         if ((prev = SLIST_FIRST(&vacm_viewlist)) == NULL ||
3038             vacm_compare_view(view, prev) < 0) {
3039                 SLIST_INSERT_HEAD(&vacm_viewlist, view, vvl);
3040                 return (view);
3041         }
3042
3043         SLIST_FOREACH(temp, &vacm_viewlist, vvl) {
3044                 if ((cmp = vacm_compare_view(view, temp)) <= 0)
3045                         break;
3046                 prev = temp;
3047         }
3048
3049         if (temp == NULL || cmp < 0)
3050                 SLIST_INSERT_AFTER(prev, view, vvl);
3051         else if (cmp > 0)
3052                 SLIST_INSERT_AFTER(temp, view, vvl);
3053         else {
3054                 syslog(LOG_ERR, "View %s exists", view->viewname);
3055                 free(view);
3056                 return (NULL);
3057         }
3058
3059         return (view);
3060 }
3061
3062 int
3063 vacm_delete_view(struct vacm_view *view)
3064 {
3065         SLIST_REMOVE(&vacm_viewlist, view, vacm_view, vvl);
3066         free(view);
3067
3068         return (0);
3069 }
3070
3071 struct vacm_context *
3072 vacm_first_context(void)
3073 {
3074         return (SLIST_FIRST(&vacm_contextlist));
3075 }
3076
3077 struct vacm_context *
3078 vacm_next_context(struct vacm_context *vacmctx)
3079 {
3080         if (vacmctx == NULL)
3081                 return (NULL);
3082
3083         return (SLIST_NEXT(vacmctx, vcl));
3084 }
3085
3086 struct vacm_context *
3087 vacm_add_context(char *ctxname, int regid)
3088 {
3089         int cmp;
3090         struct vacm_context *ctx, *temp, *prev;
3091
3092         SLIST_FOREACH(ctx, &vacm_contextlist, vcl)
3093                 if (strcmp(ctxname, ctx->ctxname) == 0) {
3094                         syslog(LOG_ERR, "Context %s exists", ctx->ctxname);
3095                         return (NULL);
3096                 }
3097
3098         if ((ctx = (struct vacm_context *)malloc(sizeof(*ctx))) == NULL)
3099                 return (NULL);
3100
3101         memset(ctx, 0, sizeof(*ctx));
3102         strlcpy(ctx->ctxname, ctxname, sizeof(ctx->ctxname));
3103         ctx->regid = regid;
3104
3105         if ((prev = SLIST_FIRST(&vacm_contextlist)) == NULL ||
3106             strlen(ctx->ctxname) < strlen(prev->ctxname) ||
3107             strcmp(ctx->ctxname, prev->ctxname) < 0) {
3108                 SLIST_INSERT_HEAD(&vacm_contextlist, ctx, vcl);
3109                 return (ctx);
3110         }
3111
3112         SLIST_FOREACH(temp, &vacm_contextlist, vcl) {
3113                 if (strlen(ctx->ctxname) < strlen(temp->ctxname) ||
3114                     strcmp(ctx->ctxname, temp->ctxname) < 0) {
3115                         cmp = -1;
3116                         break;
3117                 }
3118                 prev = temp;
3119         }
3120
3121         if (temp == NULL || cmp < 0)
3122                 SLIST_INSERT_AFTER(prev, ctx, vcl);
3123         else if (cmp > 0)
3124                 SLIST_INSERT_AFTER(temp, ctx, vcl);
3125         else {
3126                 syslog(LOG_ERR, "Context %s exists", ctx->ctxname);
3127                 free(ctx);
3128                 return (NULL);
3129         }
3130
3131         return (ctx);
3132 }
3133
3134 void
3135 vacm_flush_contexts(int regid)
3136 {
3137         struct vacm_context *ctx, *temp;
3138
3139         SLIST_FOREACH_SAFE(ctx, &vacm_contextlist, vcl, temp)
3140                 if (ctx->regid == regid) {
3141                         SLIST_REMOVE(&vacm_contextlist, ctx, vacm_context, vcl);
3142                         free(ctx);
3143                 }
3144 }