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 <stdbool.h>
46 #include <stdio.h>
47 #include <stdlib.h>
48 #include <stddef.h>
49 #include <string.h>
50 #include <stdarg.h>
51 #include <ctype.h>
52 #include <errno.h>
53 #include <syslog.h>
54 #include <unistd.h>
55 #include <signal.h>
56 #include <dlfcn.h>
57
58 #ifdef USE_TCPWRAPPERS
59 #include <arpa/inet.h>
60 #include <tcpd.h>
61 #endif
62
63 #include "support.h"
64 #include "snmpmod.h"
65 #include "snmpd.h"
66 #include "tree.h"
67 #include "oid.h"
68
69 #include "trans_inet.h"
70
71 #define PATH_PID "/var/run/%s.pid"
72 #define PATH_CONFIG "/etc/%s.config"
73 #define PATH_ENGINE "/var/%s.engine"
74
75 uint64_t this_tick; /* start of processing of current packet (absolute) */
76 uint64_t start_tick; /* start of processing */
77
78 struct systemg systemg = {
79 NULL,
80 { 8, { 1, 3, 6, 1, 4, 1, 1115, 7352 }},
81 NULL, NULL, NULL,
82 64 + 8 + 4,
83 0
84 };
85 struct debug debug = {
86 0, /* dump_pdus */
87 LOG_DEBUG, /* log_pri */
88 0, /* evdebug */
89 };
90
91 struct snmpd snmpd = {
92 2048, /* txbuf */
93 2048, /* rxbuf */
94 0, /* comm_dis */
95 0, /* auth_traps */
96 {0, 0, 0, 0}, /* trap1addr */
97 VERS_ENABLE_ALL,/* version_enable */
98 };
99 struct snmpd_stats snmpd_stats;
100
101 struct snmpd_usmstat snmpd_usmstats;
102
103 /* snmpEngine */
104 struct snmp_engine snmpd_engine;
105
106 /* snmpSerialNo */
107 int32_t snmp_serial_no;
108
109 struct snmpd_target_stats snmpd_target_stats;
110
111 /* search path for config files */
112 const char *syspath = PATH_SYSCONFIG;
113
114 /* list of all loaded modules */
115 struct lmodules lmodules = TAILQ_HEAD_INITIALIZER(lmodules);
116
117 /* list of loaded modules during start-up in the order they were loaded */
118 static struct lmodules modules_start = TAILQ_HEAD_INITIALIZER(modules_start);
119
120 /* list of all known communities */
121 struct community_list community_list = TAILQ_HEAD_INITIALIZER(community_list);
122
123 /* list of all known USM users */
124 static struct usm_userlist usm_userlist = SLIST_HEAD_INITIALIZER(usm_userlist);
125
126 /* A list of all VACM users configured, including v1, v2c and v3 */
127 static struct vacm_userlist vacm_userlist =
128 SLIST_HEAD_INITIALIZER(vacm_userlist);
129
130 /* A list of all VACM groups */
131 static struct vacm_grouplist vacm_grouplist =
132 SLIST_HEAD_INITIALIZER(vacm_grouplist);
133
134 static struct vacm_group vacm_default_group = {
135 .groupname = "",
136 };
137
138 /* The list of configured access entries */
139 static struct vacm_accesslist vacm_accesslist =
140 TAILQ_HEAD_INITIALIZER(vacm_accesslist);
141
142 /* The list of configured views */
143 static struct vacm_viewlist vacm_viewlist =
144 SLIST_HEAD_INITIALIZER(vacm_viewlist);
145
146 /* The list of configured contexts */
147 static struct vacm_contextlist vacm_contextlist =
148 SLIST_HEAD_INITIALIZER(vacm_contextlist);
149
150 /* list of all installed object resources */
151 struct objres_list objres_list = TAILQ_HEAD_INITIALIZER(objres_list);
152
153 /* community value generator */
154 static u_int next_community_index = 1;
155
156 /* list of all known ranges */
157 struct idrange_list idrange_list = TAILQ_HEAD_INITIALIZER(idrange_list);
158
159 /* identifier generator */
160 u_int next_idrange = 1;
161
162 /* list of all current timers */
163 struct timer_list timer_list = LIST_HEAD_INITIALIZER(timer_list);
164
165 /* list of file descriptors */
166 struct fdesc_list fdesc_list = LIST_HEAD_INITIALIZER(fdesc_list);
167
168 /* program arguments */
169 static char **progargs;
170 static int nprogargs;
171
172 /* current community */
173 u_int community;
174 static struct community *comm;
175
176 /* current USM user */
177 struct usm_user *usm_user;
178
179 /* file names */
180 static char config_file[MAXPATHLEN + 1];
181 static char pid_file[MAXPATHLEN + 1];
182 char engine_file[MAXPATHLEN + 1];
183
184 #ifndef USE_LIBBEGEMOT
185 /* event context */
186 static evContext evctx;
187 #endif
188
189 /* signal mask */
190 static sigset_t blocked_sigs;
191
192 /* signal handling */
193 static int work;
194 #define WORK_DOINFO 0x0001
195 #define WORK_RECONFIG 0x0002
196
197 /* oids */
198 static const struct asn_oid
199 oid_snmpMIB = OIDX_snmpMIB,
200 oid_begemotSnmpd = OIDX_begemotSnmpd,
201 oid_coldStart = OIDX_coldStart,
202 oid_authenticationFailure = OIDX_authenticationFailure;
203
204 const struct asn_oid oid_zeroDotZero = { 2, { 0, 0 }};
205
206 const struct asn_oid oid_usmUnknownEngineIDs =
207 { 11, { 1, 3, 6, 1, 6, 3, 15, 1, 1, 4, 0}};
208
209 const struct asn_oid oid_usmNotInTimeWindows =
210 { 11, { 1, 3, 6, 1, 6, 3, 15, 1, 1, 2, 0}};
211
212 /* request id generator for traps */
213 u_int trap_reqid;
214
215 /* help text */
216 static const char usgtxt[] = "\
217 Begemot simple SNMP daemon. Copyright (c) 2001-2002 Fraunhofer Institute for\n\
218 Open Communication Systems (FhG Fokus). All rights reserved.\n\
219 Copyright (c) 2010 The FreeBSD Foundation. All rights reserved.\n\
220 usage: snmpd [-dh] [-c file] [-D options] [-e file] [-I path]\n\
221 [-l prefix] [-m variable=value] [-p file]\n\
222 options:\n\
223 -d don't daemonize\n\
224 -h print this info\n\
225 -c file specify configuration file\n\
226 -D options debugging options\n\
227 -e file specify engine id file\n\
228 -I path system include path\n\
229 -l prefix default basename for pid and config file\n\
230 -m var=val define variable\n\
231 -p file specify pid file\n\
232 ";
233
234 /* hosts_access(3) request */
235 #ifdef USE_TCPWRAPPERS
236 static struct request_info req;
237 #endif
238
239 /* transports */
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 *
buf_alloc(int tx)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
buf_size(int tx)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
snmp_output(struct snmp_pdu * pdu,u_char * sndbuf,size_t * sndlen,const char * dest)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
snmp_pdu_auth_user(struct snmp_pdu * pdu)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
snmp_pdu_auth_access(struct snmp_pdu * pdu,int32_t * ip)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
snmp_input_start(const u_char * buf,size_t len,const char * source,struct snmp_pdu * pdu,int32_t * ip,size_t * pdulen)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 (pdu->user.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
snmp_input_finish(struct snmp_pdu * pdu,const u_char * rcvbuf,size_t rcvlen,u_char * sndbuf,size_t * sndlen,const char * source,enum snmpd_input_err ierr,int32_t ivar,void * data)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
trans_insert_port(struct transport * t,struct tport * port)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
trans_remove_port(struct tport * port)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 *
trans_find_port(struct transport * t,const struct asn_oid * idx,u_int sub)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 *
trans_next_port(struct transport * t,const struct asn_oid * idx,u_int sub)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 *
trans_first_port(struct transport * t)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 *
trans_iter_port(struct transport * t,int (* func)(struct tport *,intptr_t),intptr_t arg)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
trans_register(const struct transport_def * def,struct transport ** pp)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
trans_unregister(struct transport * t)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
input(int fd,int mask __unused,void * uap)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
fd_suspend(void * p)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
fd_resume(void * p)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 *
fd_select(int fd,void (* func)(int,void *),void * udata,struct lmodule * mod)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
fd_deselect(void * p)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
fd_flush(struct lmodule * mod)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
snmp_input_consume(struct port_input * pi)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
snmpd_input(struct port_input * pi,struct tport * tport)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 slen = tport->transport->vtab->send(tport, sndbuf, sndlen, pi);
1190 if (slen == -1)
1191 syslog(LOG_ERR, "send*: %m");
1192 else if ((size_t)slen != sndlen)
1193 syslog(LOG_ERR, "send*: short write %zu/%zu", sndlen,
1194 (size_t)slen);
1195 }
1196
1197 snmp_pdu_free(&pdu);
1198 free(sndbuf);
1199 snmp_input_consume(pi);
1200
1201 return (0);
1202 }
1203
1204 /*
1205 * Send a PDU to a given port. If this is a multi-socket port, use the
1206 * first socket.
1207 */
1208 void
snmp_send_port(void * targ,const struct asn_oid * port,struct snmp_pdu * pdu,const struct sockaddr * addr,socklen_t addrlen)1209 snmp_send_port(void *targ, const struct asn_oid *port, struct snmp_pdu *pdu,
1210 const struct sockaddr *addr, socklen_t addrlen)
1211 {
1212 struct port_input pi = {
1213 .fd = -1,
1214 .peer = __DECONST(struct sockaddr *, addr),
1215 .peerlen = 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 len = trans->vtab->send(tp, sndbuf, sndlen, &pi);
1235
1236 if (len == -1)
1237 syslog(LOG_ERR, "sendto: %m");
1238 else if ((size_t)len != sndlen)
1239 syslog(LOG_ERR, "sendto: short write %zu/%zu",
1240 sndlen, (size_t)len);
1241
1242 free(sndbuf);
1243 }
1244
1245
1246 /*
1247 * Close an input source
1248 *
1249 * \param pi input instance
1250 */
1251 void
snmpd_input_close(struct port_input * pi)1252 snmpd_input_close(struct port_input *pi)
1253 {
1254 if (pi->id != NULL) {
1255 fd_deselect(pi->id);
1256 pi->id = NULL;
1257 }
1258 if (pi->fd >= 0) {
1259 (void)close(pi->fd);
1260 pi->fd = -1;
1261 }
1262 if (pi->buf != NULL) {
1263 free(pi->buf);
1264 pi->buf = NULL;
1265 }
1266 }
1267
1268 /*
1269 * Initialize an input source.
1270 *
1271 * \param pi input instance
1272 */
1273 void
snmpd_input_init(struct port_input * pi)1274 snmpd_input_init(struct port_input *pi)
1275 {
1276 pi->id = NULL;
1277 pi->fd = -1;
1278 pi->buf = NULL;
1279 }
1280
1281 /*
1282 * Dump internal state.
1283 */
1284 #ifdef USE_LIBBEGEMOT
1285 static void
info_func(void)1286 info_func(void)
1287 #else
1288 static void
1289 info_func(evContext ctx __unused, void *uap __unused, const void *tag __unused)
1290 #endif
1291 {
1292 struct lmodule *m;
1293 u_int i;
1294 char buf[10000];
1295
1296 syslog(LOG_DEBUG, "Dump of SNMPd %lu\n", (u_long)getpid());
1297 for (i = 0; i < tree_size; i++) {
1298 switch (tree[i].type) {
1299
1300 case SNMP_NODE_LEAF:
1301 sprintf(buf, "LEAF: %s %s", tree[i].name,
1302 asn_oid2str(&tree[i].oid));
1303 break;
1304
1305 case SNMP_NODE_COLUMN:
1306 sprintf(buf, "COL: %s %s", tree[i].name,
1307 asn_oid2str(&tree[i].oid));
1308 break;
1309 }
1310 syslog(LOG_DEBUG, "%s", buf);
1311 }
1312
1313 TAILQ_FOREACH(m, &lmodules, link)
1314 if (m->config->dump)
1315 (*m->config->dump)();
1316 }
1317
1318 /*
1319 * Re-read configuration
1320 */
1321 #ifdef USE_LIBBEGEMOT
1322 static void
config_func(void)1323 config_func(void)
1324 #else
1325 static void
1326 config_func(evContext ctx __unused, void *uap __unused,
1327 const void *tag __unused)
1328 #endif
1329 {
1330 struct lmodule *m;
1331
1332 if (read_config(config_file, NULL)) {
1333 syslog(LOG_ERR, "error reading config file '%s'", config_file);
1334 return;
1335 }
1336 TAILQ_FOREACH(m, &lmodules, link)
1337 if (m->config->config)
1338 (*m->config->config)();
1339 }
1340
1341 /*
1342 * On USR1 dump actual configuration.
1343 */
1344 static void
onusr1(int s __unused)1345 onusr1(int s __unused)
1346 {
1347
1348 work |= WORK_DOINFO;
1349 }
1350 static void
onhup(int s __unused)1351 onhup(int s __unused)
1352 {
1353
1354 work |= WORK_RECONFIG;
1355 }
1356
1357 static void
onterm(int s __unused)1358 onterm(int s __unused)
1359 {
1360
1361 /* allow clean-up */
1362 exit(0);
1363 }
1364
1365 static void
init_sigs(void)1366 init_sigs(void)
1367 {
1368 struct sigaction sa;
1369
1370 sa.sa_handler = onusr1;
1371 sa.sa_flags = SA_RESTART;
1372 sigemptyset(&sa.sa_mask);
1373 if (sigaction(SIGUSR1, &sa, NULL)) {
1374 syslog(LOG_ERR, "sigaction: %m");
1375 exit(1);
1376 }
1377
1378 sa.sa_handler = onhup;
1379 if (sigaction(SIGHUP, &sa, NULL)) {
1380 syslog(LOG_ERR, "sigaction: %m");
1381 exit(1);
1382 }
1383
1384 sa.sa_handler = onterm;
1385 sa.sa_flags = 0;
1386 sigemptyset(&sa.sa_mask);
1387 if (sigaction(SIGTERM, &sa, NULL)) {
1388 syslog(LOG_ERR, "sigaction: %m");
1389 exit(1);
1390 }
1391 if (sigaction(SIGINT, &sa, NULL)) {
1392 syslog(LOG_ERR, "sigaction: %m");
1393 exit(1);
1394 }
1395 }
1396
1397 static void
block_sigs(void)1398 block_sigs(void)
1399 {
1400 sigset_t set;
1401
1402 sigfillset(&set);
1403 if (sigprocmask(SIG_BLOCK, &set, &blocked_sigs) == -1) {
1404 syslog(LOG_ERR, "SIG_BLOCK: %m");
1405 exit(1);
1406 }
1407 }
1408 static void
unblock_sigs(void)1409 unblock_sigs(void)
1410 {
1411 if (sigprocmask(SIG_SETMASK, &blocked_sigs, NULL) == -1) {
1412 syslog(LOG_ERR, "SIG_SETMASK: %m");
1413 exit(1);
1414 }
1415 }
1416
1417 /*
1418 * Shut down
1419 */
1420 static void
term(void)1421 term(void)
1422 {
1423 (void)unlink(pid_file);
1424 }
1425
1426 static void
trans_stop(void)1427 trans_stop(void)
1428 {
1429 struct transport *t;
1430
1431 TAILQ_FOREACH(t, &transport_list, link)
1432 (void)t->vtab->stop(1);
1433 }
1434
1435 /*
1436 * Define a macro from the command line
1437 */
1438 static void
do_macro(char * arg)1439 do_macro(char *arg)
1440 {
1441 char *eq;
1442 int err;
1443
1444 if ((eq = strchr(arg, '=')) == NULL)
1445 err = define_macro(arg, "");
1446 else {
1447 *eq++ = '\0';
1448 err = define_macro(arg, eq);
1449 }
1450 if (err == -1) {
1451 syslog(LOG_ERR, "cannot save macro: %m");
1452 exit(1);
1453 }
1454 }
1455
1456 /*
1457 * Re-implement getsubopt from scratch, because the second argument is broken
1458 * and will not compile with WARNS=5.
1459 */
1460 static int
getsubopt1(char ** arg,const char * const * options,char ** valp,char ** optp)1461 getsubopt1(char **arg, const char *const *options, char **valp, char **optp)
1462 {
1463 static const char *const delim = ",\t ";
1464 u_int i;
1465 char *ptr;
1466
1467 *optp = NULL;
1468
1469 /* skip leading junk */
1470 for (ptr = *arg; *ptr != '\0'; ptr++)
1471 if (strchr(delim, *ptr) == NULL)
1472 break;
1473 if (*ptr == '\0') {
1474 *arg = ptr;
1475 return (-1);
1476 }
1477 *optp = ptr;
1478
1479 /* find the end of the option */
1480 while (*++ptr != '\0')
1481 if (strchr(delim, *ptr) != NULL || *ptr == '=')
1482 break;
1483
1484 if (*ptr != '\0') {
1485 if (*ptr == '=') {
1486 *ptr++ = '\0';
1487 *valp = ptr;
1488 while (*ptr != '\0' && strchr(delim, *ptr) == NULL)
1489 ptr++;
1490 if (*ptr != '\0')
1491 *ptr++ = '\0';
1492 } else
1493 *ptr++ = '\0';
1494 }
1495
1496 *arg = ptr;
1497
1498 for (i = 0; *options != NULL; options++, i++)
1499 if (strcmp(*optp, *options) == 0)
1500 return (i);
1501 return (-1);
1502 }
1503
1504 int
main(int argc,char * argv[])1505 main(int argc, char *argv[])
1506 {
1507 int opt;
1508 FILE *fp;
1509 bool background = true;
1510 struct tport *p;
1511 const char *prefix = "snmpd";
1512 struct lmodule *m;
1513 char *value = NULL, *option; /* XXX */
1514 struct transport *t;
1515
1516 #define DBG_DUMP 0
1517 #define DBG_EVENTS 1
1518 #define DBG_TRACE 2
1519 static const char *const debug_opts[] = {
1520 "dump",
1521 "events",
1522 "trace",
1523 NULL
1524 };
1525
1526 while ((opt = getopt(argc, argv, "c:dD:e:hI:l:m:p:")) != EOF)
1527 switch (opt) {
1528
1529 case 'c':
1530 strlcpy(config_file, optarg, sizeof(config_file));
1531 break;
1532
1533 case 'd':
1534 background = false;
1535 break;
1536
1537 case 'D':
1538 while (*optarg) {
1539 switch (getsubopt1(&optarg, debug_opts,
1540 &value, &option)) {
1541
1542 case DBG_DUMP:
1543 debug.dump_pdus = 1;
1544 break;
1545
1546 case DBG_EVENTS:
1547 debug.evdebug++;
1548 break;
1549
1550 case DBG_TRACE:
1551 if (value == NULL)
1552 syslog(LOG_ERR,
1553 "no value for 'trace'");
1554 else
1555 snmp_trace = strtoul(value,
1556 NULL, 0);
1557 break;
1558
1559 case -1:
1560 if (suboptarg)
1561 syslog(LOG_ERR,
1562 "unknown debug flag '%s'",
1563 option);
1564 else
1565 syslog(LOG_ERR,
1566 "missing debug flag");
1567 break;
1568 }
1569 }
1570 break;
1571
1572 case 'e':
1573 strlcpy(engine_file, optarg, sizeof(engine_file));
1574 break;
1575 case 'h':
1576 fprintf(stderr, "%s", usgtxt);
1577 exit(0);
1578
1579 case 'I':
1580 syspath = optarg;
1581 break;
1582
1583 case 'l':
1584 prefix = optarg;
1585 break;
1586
1587 case 'm':
1588 do_macro(optarg);
1589 break;
1590
1591 case 'p':
1592 strlcpy(pid_file, optarg, sizeof(pid_file));
1593 break;
1594 }
1595
1596 if (background) {
1597 snmp_printf = snmp_printf_func;
1598 snmp_error = snmp_error_func;
1599 snmp_debug = snmp_debug_func;
1600 asn_error = asn_error_func;
1601 }
1602
1603 openlog(prefix, LOG_PID | (background ? 0 : LOG_PERROR), LOG_USER);
1604 setlogmask(LOG_UPTO(debug.logpri - 1));
1605
1606 if (background && daemon(0, 0) < 0) {
1607 syslog(LOG_ERR, "daemon: %m");
1608 exit(1);
1609 }
1610
1611 argc -= optind;
1612 argv += optind;
1613
1614 progargs = argv;
1615 nprogargs = argc;
1616
1617 snmp_serial_no = arc4random();
1618
1619 #ifdef USE_TCPWRAPPERS
1620 /*
1621 * Initialize hosts_access(3) handler.
1622 */
1623 request_init(&req, RQ_DAEMON, "snmpd", 0);
1624 sock_methods(&req);
1625 #endif
1626
1627 /*
1628 * Initialize the tree.
1629 */
1630 if ((tree = malloc(sizeof(struct snmp_node) * CTREE_SIZE)) == NULL) {
1631 syslog(LOG_ERR, "%m");
1632 exit(1);
1633 }
1634 memcpy(tree, ctree, sizeof(struct snmp_node) * CTREE_SIZE);
1635 tree_size = CTREE_SIZE;
1636
1637 /*
1638 * Get standard communities
1639 */
1640 comm_define(COMM_READ, "SNMP read", NULL, NULL);
1641 comm_define(COMM_WRITE, "SNMP write", NULL, NULL);
1642 community = COMM_INITIALIZE;
1643
1644 trap_reqid = reqid_allocate(512, NULL);
1645
1646 if (config_file[0] == '\0')
1647 snprintf(config_file, sizeof(config_file), PATH_CONFIG, prefix);
1648
1649 init_actvals();
1650 init_snmpd_engine();
1651
1652 this_tick = get_ticks();
1653 start_tick = this_tick;
1654
1655 /* start transports */
1656 if (atexit(trans_stop) == -1) {
1657 syslog(LOG_ERR, "atexit failed: %m");
1658 exit(1);
1659 }
1660 if (lsock_trans.start() != SNMP_ERR_NOERROR)
1661 syslog(LOG_WARNING, "cannot start LSOCK transport");
1662 if (inet_trans.start() != SNMP_ERR_NOERROR)
1663 syslog(LOG_WARNING, "cannot start INET transport");
1664
1665 #ifdef USE_LIBBEGEMOT
1666 if (debug.evdebug > 0)
1667 rpoll_trace = 1;
1668 #else
1669 if (evCreate(&evctx)) {
1670 syslog(LOG_ERR, "evCreate: %m");
1671 exit(1);
1672 }
1673 if (debug.evdebug > 0)
1674 evSetDebug(evctx, 10, stderr);
1675 #endif
1676
1677 if (engine_file[0] == '\0')
1678 snprintf(engine_file, sizeof(engine_file), PATH_ENGINE, prefix);
1679
1680 if (read_config(config_file, NULL)) {
1681 syslog(LOG_ERR, "error in config file");
1682 exit(1);
1683 }
1684
1685 TAILQ_FOREACH(t, &transport_list, link)
1686 TAILQ_FOREACH(p, &t->table, link)
1687 t->vtab->init_port(p);
1688
1689 init_sigs();
1690
1691 if (pid_file[0] == '\0')
1692 snprintf(pid_file, sizeof(pid_file), PATH_PID, prefix);
1693
1694 if ((fp = fopen(pid_file, "w")) != NULL) {
1695 fprintf(fp, "%u", getpid());
1696 fclose(fp);
1697 if (atexit(term) == -1) {
1698 syslog(LOG_ERR, "atexit failed: %m");
1699 (void)remove(pid_file);
1700 exit(0);
1701 }
1702 }
1703
1704 if (or_register(&oid_snmpMIB, "The MIB module for SNMPv2 entities.",
1705 NULL) == 0) {
1706 syslog(LOG_ERR, "cannot register SNMPv2 MIB");
1707 exit(1);
1708 }
1709 if (or_register(&oid_begemotSnmpd, "The MIB module for the Begemot SNMPd.",
1710 NULL) == 0) {
1711 syslog(LOG_ERR, "cannot register begemotSnmpd MIB");
1712 exit(1);
1713 }
1714
1715 while ((m = TAILQ_FIRST(&modules_start)) != NULL) {
1716 m->flags &= ~LM_ONSTARTLIST;
1717 TAILQ_REMOVE(&modules_start, m, start);
1718 lm_start(m);
1719 }
1720
1721 snmp_send_trap(&oid_coldStart, (struct snmp_value *)NULL);
1722
1723 for (;;) {
1724 #ifndef USE_LIBBEGEMOT
1725 evEvent event;
1726 #endif
1727 struct lmodule *mod;
1728
1729 TAILQ_FOREACH(mod, &lmodules, link)
1730 if (mod->config->idle != NULL)
1731 (*mod->config->idle)();
1732
1733 #ifndef USE_LIBBEGEMOT
1734 if (evGetNext(evctx, &event, EV_WAIT) == 0) {
1735 if (evDispatch(evctx, event))
1736 syslog(LOG_ERR, "evDispatch: %m");
1737 } else if (errno != EINTR) {
1738 syslog(LOG_ERR, "evGetNext: %m");
1739 exit(1);
1740 }
1741 #else
1742 poll_dispatch(1);
1743 #endif
1744
1745 if (work != 0) {
1746 block_sigs();
1747 if (work & WORK_DOINFO) {
1748 #ifdef USE_LIBBEGEMOT
1749 info_func();
1750 #else
1751 if (evWaitFor(evctx, &work, info_func,
1752 NULL, NULL) == -1) {
1753 syslog(LOG_ERR, "evWaitFor: %m");
1754 exit(1);
1755 }
1756 #endif
1757 }
1758 if (work & WORK_RECONFIG) {
1759 #ifdef USE_LIBBEGEMOT
1760 config_func();
1761 #else
1762 if (evWaitFor(evctx, &work, config_func,
1763 NULL, NULL) == -1) {
1764 syslog(LOG_ERR, "evWaitFor: %m");
1765 exit(1);
1766 }
1767 #endif
1768 }
1769 work = 0;
1770 unblock_sigs();
1771 #ifndef USE_LIBBEGEMOT
1772 if (evDo(evctx, &work) == -1) {
1773 syslog(LOG_ERR, "evDo: %m");
1774 exit(1);
1775 }
1776 #endif
1777 }
1778 }
1779
1780 return (0);
1781 }
1782
1783 uint64_t
get_ticks(void)1784 get_ticks(void)
1785 {
1786 struct timeval tv;
1787 uint64_t ret;
1788
1789 if (gettimeofday(&tv, NULL))
1790 abort();
1791 ret = tv.tv_sec * 100ULL + tv.tv_usec / 10000ULL;
1792 return (ret);
1793 }
1794
1795 /*
1796 * Timer support
1797 */
1798
1799 /*
1800 * Trampoline for the non-repeatable timers.
1801 */
1802 #ifdef USE_LIBBEGEMOT
1803 static void
tfunc(int tid __unused,void * uap)1804 tfunc(int tid __unused, void *uap)
1805 #else
1806 static void
1807 tfunc(evContext ctx __unused, void *uap, struct timespec due __unused,
1808 struct timespec inter __unused)
1809 #endif
1810 {
1811 struct timer *tp = uap;
1812
1813 LIST_REMOVE(tp, link);
1814 tp->func(tp->udata);
1815 free(tp);
1816 }
1817
1818 /*
1819 * Trampoline for the repeatable timers.
1820 */
1821 #ifdef USE_LIBBEGEMOT
1822 static void
trfunc(int tid __unused,void * uap)1823 trfunc(int tid __unused, void *uap)
1824 #else
1825 static void
1826 trfunc(evContext ctx __unused, void *uap, struct timespec due __unused,
1827 struct timespec inter __unused)
1828 #endif
1829 {
1830 struct timer *tp = uap;
1831
1832 tp->func(tp->udata);
1833 }
1834
1835 /*
1836 * Start a one-shot timer
1837 */
1838 void *
timer_start(u_int ticks,void (* func)(void *),void * udata,struct lmodule * mod)1839 timer_start(u_int ticks, void (*func)(void *), void *udata, struct lmodule *mod)
1840 {
1841 struct timer *tp;
1842 #ifndef USE_LIBBEGEMOT
1843 struct timespec due;
1844 #endif
1845
1846 if ((tp = malloc(sizeof(struct timer))) == NULL) {
1847 syslog(LOG_CRIT, "out of memory for timer");
1848 exit(1);
1849 }
1850
1851 #ifndef USE_LIBBEGEMOT
1852 due = evAddTime(evNowTime(),
1853 evConsTime(ticks / 100, (ticks % 100) * 10000));
1854 #endif
1855
1856 tp->udata = udata;
1857 tp->owner = mod;
1858 tp->func = func;
1859
1860 LIST_INSERT_HEAD(&timer_list, tp, link);
1861
1862 #ifdef USE_LIBBEGEMOT
1863 if ((tp->id = poll_start_timer(ticks * 10, 0, tfunc, tp)) < 0) {
1864 syslog(LOG_ERR, "cannot set timer: %m");
1865 exit(1);
1866 }
1867 #else
1868 if (evSetTimer(evctx, tfunc, tp, due, evConsTime(0, 0), &tp->id)
1869 == -1) {
1870 syslog(LOG_ERR, "cannot set timer: %m");
1871 exit(1);
1872 }
1873 #endif
1874 return (tp);
1875 }
1876
1877 /*
1878 * Start a repeatable timer. When used with USE_LIBBEGEMOT the first argument
1879 * is currently ignored and the initial number of ticks is set to the
1880 * repeat number of ticks.
1881 */
1882 void *
timer_start_repeat(u_int ticks __unused,u_int repeat_ticks,void (* func)(void *),void * udata,struct lmodule * mod)1883 timer_start_repeat(u_int ticks __unused, u_int repeat_ticks,
1884 void (*func)(void *), void *udata, struct lmodule *mod)
1885 {
1886 struct timer *tp;
1887 #ifndef USE_LIBBEGEMOT
1888 struct timespec due;
1889 struct timespec inter;
1890 #endif
1891
1892 if ((tp = malloc(sizeof(struct timer))) == NULL) {
1893 syslog(LOG_CRIT, "out of memory for timer");
1894 exit(1);
1895 }
1896
1897 #ifndef USE_LIBBEGEMOT
1898 due = evAddTime(evNowTime(),
1899 evConsTime(ticks / 100, (ticks % 100) * 10000));
1900 inter = evConsTime(repeat_ticks / 100, (repeat_ticks % 100) * 10000);
1901 #endif
1902
1903 tp->udata = udata;
1904 tp->owner = mod;
1905 tp->func = func;
1906
1907 LIST_INSERT_HEAD(&timer_list, tp, link);
1908
1909 #ifdef USE_LIBBEGEMOT
1910 if ((tp->id = poll_start_timer(repeat_ticks * 10, 1, trfunc, tp)) < 0) {
1911 syslog(LOG_ERR, "cannot set timer: %m");
1912 exit(1);
1913 }
1914 #else
1915 if (evSetTimer(evctx, trfunc, tp, due, inter, &tp->id) == -1) {
1916 syslog(LOG_ERR, "cannot set timer: %m");
1917 exit(1);
1918 }
1919 #endif
1920 return (tp);
1921 }
1922
1923 /*
1924 * Stop a timer.
1925 */
1926 void
timer_stop(void * p)1927 timer_stop(void *p)
1928 {
1929 struct timer *tp = p;
1930
1931 LIST_REMOVE(tp, link);
1932 #ifdef USE_LIBBEGEMOT
1933 poll_stop_timer(tp->id);
1934 #else
1935 if (evClearTimer(evctx, tp->id) == -1) {
1936 syslog(LOG_ERR, "cannot stop timer: %m");
1937 exit(1);
1938 }
1939 #endif
1940 free(p);
1941 }
1942
1943 static void
timer_flush(struct lmodule * mod)1944 timer_flush(struct lmodule *mod)
1945 {
1946 struct timer *t, *t1;
1947
1948 t = LIST_FIRST(&timer_list);
1949 while (t != NULL) {
1950 t1 = LIST_NEXT(t, link);
1951 if (t->owner == mod)
1952 timer_stop(t);
1953 t = t1;
1954 }
1955 }
1956
1957 static void
snmp_printf_func(const char * fmt,...)1958 snmp_printf_func(const char *fmt, ...)
1959 {
1960 va_list ap;
1961 static char *pend = NULL;
1962 char *ret, *new;
1963
1964 va_start(ap, fmt);
1965 vasprintf(&ret, fmt, ap);
1966 va_end(ap);
1967
1968 if (ret == NULL)
1969 return;
1970 if (pend != NULL) {
1971 if ((new = realloc(pend, strlen(pend) + strlen(ret) + 1))
1972 == NULL) {
1973 free(ret);
1974 return;
1975 }
1976 pend = new;
1977 strcat(pend, ret);
1978 free(ret);
1979 } else
1980 pend = ret;
1981
1982 while ((ret = strchr(pend, '\n')) != NULL) {
1983 *ret = '\0';
1984 syslog(LOG_DEBUG, "%s", pend);
1985 if (strlen(ret + 1) == 0) {
1986 free(pend);
1987 pend = NULL;
1988 break;
1989 }
1990 strcpy(pend, ret + 1);
1991 }
1992 }
1993
1994 static void
snmp_error_func(const char * err,...)1995 snmp_error_func(const char *err, ...)
1996 {
1997 char errbuf[1000];
1998 va_list ap;
1999
2000 if (!(snmp_trace & LOG_SNMP_ERRORS))
2001 return;
2002
2003 va_start(ap, err);
2004 snprintf(errbuf, sizeof(errbuf), "SNMP: ");
2005 vsnprintf(errbuf + strlen(errbuf),
2006 sizeof(errbuf) - strlen(errbuf), err, ap);
2007 va_end(ap);
2008
2009 syslog(LOG_ERR, "%s", errbuf);
2010 }
2011
2012 static void
snmp_debug_func(const char * err,...)2013 snmp_debug_func(const char *err, ...)
2014 {
2015 char errbuf[1000];
2016 va_list ap;
2017
2018 va_start(ap, err);
2019 snprintf(errbuf, sizeof(errbuf), "SNMP: ");
2020 vsnprintf(errbuf+strlen(errbuf), sizeof(errbuf)-strlen(errbuf),
2021 err, ap);
2022 va_end(ap);
2023
2024 syslog(LOG_DEBUG, "%s", errbuf);
2025 }
2026
2027 static void
asn_error_func(const struct asn_buf * b,const char * err,...)2028 asn_error_func(const struct asn_buf *b, const char *err, ...)
2029 {
2030 char errbuf[1000];
2031 va_list ap;
2032 u_int i;
2033
2034 if (!(snmp_trace & LOG_ASN1_ERRORS))
2035 return;
2036
2037 va_start(ap, err);
2038 snprintf(errbuf, sizeof(errbuf), "ASN.1: ");
2039 vsnprintf(errbuf + strlen(errbuf),
2040 sizeof(errbuf) - strlen(errbuf), err, ap);
2041 va_end(ap);
2042
2043 if (b != NULL) {
2044 snprintf(errbuf + strlen(errbuf),
2045 sizeof(errbuf) - strlen(errbuf), " at");
2046 for (i = 0; b->asn_len > i; i++)
2047 snprintf(errbuf + strlen(errbuf),
2048 sizeof(errbuf) - strlen(errbuf),
2049 " %02x", b->asn_cptr[i]);
2050 }
2051
2052 syslog(LOG_ERR, "%s", errbuf);
2053 }
2054
2055 /*
2056 * Create a new community
2057 */
2058 struct community*
comm_define_ordered(u_int priv,const char * descr,struct asn_oid * idx,struct lmodule * owner,const char * str)2059 comm_define_ordered(u_int priv, const char *descr, struct asn_oid *idx,
2060 struct lmodule *owner, const char *str)
2061 {
2062 struct community *c, *p;
2063 u_int ncomm;
2064
2065 ncomm = idx->subs[idx->len - 1];
2066
2067 /* check that community doesn't already exist */
2068 TAILQ_FOREACH(c, &community_list, link)
2069 if (c->value == ncomm)
2070 return (c);
2071
2072 if ((c = malloc(sizeof(struct community))) == NULL) {
2073 syslog(LOG_ERR, "%s: %m", __func__);
2074 return (NULL);
2075 }
2076 c->owner = owner;
2077 c->value = ncomm;
2078 c->descr = descr;
2079 c->string = NULL;
2080 c->private = priv;
2081
2082 if (str != NULL) {
2083 if((c->string = malloc(strlen(str)+1)) == NULL) {
2084 free(c);
2085 return (NULL);
2086 }
2087 strcpy(c->string, str);
2088 }
2089 /*
2090 * Insert ordered
2091 */
2092 c->index = *idx;
2093 TAILQ_FOREACH(p, &community_list, link) {
2094 if (asn_compare_oid(&p->index, &c->index) > 0) {
2095 TAILQ_INSERT_BEFORE(p, c, link);
2096 break;
2097 }
2098 }
2099 if (p == NULL)
2100 TAILQ_INSERT_TAIL(&community_list, c, link);
2101 return (c);
2102 }
2103
2104 u_int
comm_define(u_int priv,const char * descr,struct lmodule * owner,const char * str)2105 comm_define(u_int priv, const char *descr, struct lmodule *owner,
2106 const char *str)
2107 {
2108 struct asn_oid idx, *p;
2109 struct community *c;
2110 u_int ncomm;
2111
2112 /* generate an identifier */
2113 do {
2114 if ((ncomm = next_community_index++) == UINT_MAX)
2115 next_community_index = 1;
2116 TAILQ_FOREACH(c, &community_list, link)
2117 if (c->value == ncomm)
2118 break;
2119 } while (c != NULL);
2120
2121 /* make index */
2122 if (owner != NULL)
2123 p = &owner->index;
2124 else {
2125 p = &idx;
2126 p->len = 1;
2127 p->subs[0] = 0;
2128 }
2129 p->subs[p->len++] = ncomm;
2130 c = comm_define_ordered(priv, descr, p, owner, str);
2131 if (c == NULL)
2132 return (0);
2133 return (c->value);
2134 }
2135
2136 const char *
comm_string(u_int ncomm)2137 comm_string(u_int ncomm)
2138 {
2139 struct community *p;
2140
2141 TAILQ_FOREACH(p, &community_list, link)
2142 if (p->value == ncomm)
2143 return (p->string);
2144 return (NULL);
2145 }
2146
2147 /*
2148 * Delete all communities allocated by a module
2149 */
2150 static void
comm_flush(struct lmodule * mod)2151 comm_flush(struct lmodule *mod)
2152 {
2153 struct community *p, *p1;
2154
2155 p = TAILQ_FIRST(&community_list);
2156 while (p != NULL) {
2157 p1 = TAILQ_NEXT(p, link);
2158 if (p->owner == mod) {
2159 free(p->string);
2160 TAILQ_REMOVE(&community_list, p, link);
2161 free(p);
2162 }
2163 p = p1;
2164 }
2165 }
2166
2167 /*
2168 * Request ID handling.
2169 *
2170 * Allocate a new range of request ids. Use a first fit algorithm.
2171 */
2172 u_int
reqid_allocate(int size,struct lmodule * mod)2173 reqid_allocate(int size, struct lmodule *mod)
2174 {
2175 u_int type;
2176 struct idrange *r, *r1;
2177
2178 if (size <= 0 || size > INT32_MAX) {
2179 syslog(LOG_CRIT, "%s: size out of range: %d", __func__, size);
2180 return (0);
2181 }
2182 /* allocate a type id */
2183 do {
2184 if ((type = next_idrange++) == UINT_MAX)
2185 next_idrange = 1;
2186 TAILQ_FOREACH(r, &idrange_list, link)
2187 if (r->type == type)
2188 break;
2189 } while(r != NULL);
2190
2191 /* find a range */
2192 if (TAILQ_EMPTY(&idrange_list))
2193 r = NULL;
2194 else {
2195 r = TAILQ_FIRST(&idrange_list);
2196 if (r->base < size) {
2197 while((r1 = TAILQ_NEXT(r, link)) != NULL) {
2198 if (r1->base - (r->base + r->size) >= size)
2199 break;
2200 r = r1;
2201 }
2202 r = r1;
2203 }
2204 if (r == NULL) {
2205 r1 = TAILQ_LAST(&idrange_list, idrange_list);
2206 if (INT32_MAX - size + 1 < r1->base + r1->size) {
2207 syslog(LOG_ERR, "out of id ranges (%u)", size);
2208 return (0);
2209 }
2210 }
2211 }
2212
2213 /* allocate structure */
2214 if ((r1 = malloc(sizeof(struct idrange))) == NULL) {
2215 syslog(LOG_ERR, "%s: %m", __FUNCTION__);
2216 return (0);
2217 }
2218
2219 r1->type = type;
2220 r1->size = size;
2221 r1->owner = mod;
2222 if (TAILQ_EMPTY(&idrange_list) || r == TAILQ_FIRST(&idrange_list)) {
2223 r1->base = 0;
2224 TAILQ_INSERT_HEAD(&idrange_list, r1, link);
2225 } else if (r == NULL) {
2226 r = TAILQ_LAST(&idrange_list, idrange_list);
2227 r1->base = r->base + r->size;
2228 TAILQ_INSERT_TAIL(&idrange_list, r1, link);
2229 } else {
2230 r = TAILQ_PREV(r, idrange_list, link);
2231 r1->base = r->base + r->size;
2232 TAILQ_INSERT_AFTER(&idrange_list, r, r1, link);
2233 }
2234 r1->next = r1->base;
2235
2236 return (type);
2237 }
2238
2239 int32_t
reqid_next(u_int type)2240 reqid_next(u_int type)
2241 {
2242 struct idrange *r;
2243 int32_t id;
2244
2245 TAILQ_FOREACH(r, &idrange_list, link)
2246 if (r->type == type)
2247 break;
2248 if (r == NULL) {
2249 syslog(LOG_CRIT, "wrong idrange type");
2250 abort();
2251 }
2252 if ((id = r->next++) == r->base + (r->size - 1))
2253 r->next = r->base;
2254 return (id);
2255 }
2256
2257 int32_t
reqid_base(u_int type)2258 reqid_base(u_int type)
2259 {
2260 struct idrange *r;
2261
2262 TAILQ_FOREACH(r, &idrange_list, link)
2263 if (r->type == type)
2264 return (r->base);
2265 syslog(LOG_CRIT, "wrong idrange type");
2266 abort();
2267 }
2268
2269 u_int
reqid_type(int32_t reqid)2270 reqid_type(int32_t reqid)
2271 {
2272 struct idrange *r;
2273
2274 TAILQ_FOREACH(r, &idrange_list, link)
2275 if (reqid >= r->base && reqid <= r->base + (r->size - 1))
2276 return (r->type);
2277 return (0);
2278 }
2279
2280 int
reqid_istype(int32_t reqid,u_int type)2281 reqid_istype(int32_t reqid, u_int type)
2282 {
2283 return (reqid_type(reqid) == type);
2284 }
2285
2286 /*
2287 * Delete all communities allocated by a module
2288 */
2289 static void
reqid_flush(struct lmodule * mod)2290 reqid_flush(struct lmodule *mod)
2291 {
2292 struct idrange *p, *p1;
2293
2294 p = TAILQ_FIRST(&idrange_list);
2295 while (p != NULL) {
2296 p1 = TAILQ_NEXT(p, link);
2297 if (p->owner == mod) {
2298 TAILQ_REMOVE(&idrange_list, p, link);
2299 free(p);
2300 }
2301 p = p1;
2302 }
2303 }
2304
2305 /*
2306 * Merge the given tree for the given module into the main tree.
2307 */
2308 static int
compare_node(const void * v1,const void * v2)2309 compare_node(const void *v1, const void *v2)
2310 {
2311 const struct snmp_node *n1 = v1;
2312 const struct snmp_node *n2 = v2;
2313
2314 return (asn_compare_oid(&n1->oid, &n2->oid));
2315 }
2316 static int
tree_merge(const struct snmp_node * ntree,u_int nsize,struct lmodule * mod)2317 tree_merge(const struct snmp_node *ntree, u_int nsize, struct lmodule *mod)
2318 {
2319 struct snmp_node *xtree;
2320 u_int i;
2321
2322 xtree = realloc(tree, sizeof(*tree) * (tree_size + nsize));
2323 if (xtree == NULL) {
2324 syslog(LOG_ERR, "tree_merge: %m");
2325 return (-1);
2326 }
2327 tree = xtree;
2328 memcpy(&tree[tree_size], ntree, sizeof(*tree) * nsize);
2329
2330 for (i = 0; i < nsize; i++)
2331 tree[tree_size + i].tree_data = mod;
2332
2333 tree_size += nsize;
2334
2335 qsort(tree, tree_size, sizeof(tree[0]), compare_node);
2336
2337 return (0);
2338 }
2339
2340 /*
2341 * Remove all nodes belonging to the loadable module
2342 */
2343 static void
tree_unmerge(struct lmodule * mod)2344 tree_unmerge(struct lmodule *mod)
2345 {
2346 u_int s, d;
2347
2348 for(s = d = 0; s < tree_size; s++)
2349 if (tree[s].tree_data != mod) {
2350 if (s != d)
2351 tree[d] = tree[s];
2352 d++;
2353 }
2354 tree_size = d;
2355 }
2356
2357 /*
2358 * Loadable modules
2359 */
2360 struct lmodule *
lm_load(const char * path,const char * section)2361 lm_load(const char *path, const char *section)
2362 {
2363 struct lmodule *m;
2364 int err;
2365 int i;
2366 char *av[MAX_MOD_ARGS + 1];
2367 int ac;
2368 u_int u;
2369
2370 if ((m = malloc(sizeof(*m))) == NULL) {
2371 syslog(LOG_ERR, "lm_load: %m");
2372 return (NULL);
2373 }
2374 m->handle = NULL;
2375 m->flags = 0;
2376 strlcpy(m->section, section, sizeof(m->section));
2377
2378 if ((m->path = strdup(path)) == NULL) {
2379 syslog(LOG_ERR, "lm_load: %m");
2380 goto err;
2381 }
2382
2383 /*
2384 * Make index
2385 */
2386 m->index.subs[0] = strlen(section);
2387 m->index.len = m->index.subs[0] + 1;
2388 for (u = 0; u < m->index.subs[0]; u++)
2389 m->index.subs[u + 1] = section[u];
2390
2391 /*
2392 * Load the object file and locate the config structure
2393 */
2394 if ((m->handle = dlopen(m->path, RTLD_NOW|RTLD_GLOBAL)) == NULL) {
2395 syslog(LOG_ERR, "lm_load: open %s", dlerror());
2396 goto err;
2397 }
2398
2399 if ((m->config = dlsym(m->handle, "config")) == NULL) {
2400 syslog(LOG_ERR, "lm_load: no 'config' symbol %s", dlerror());
2401 goto err;
2402 }
2403
2404 /*
2405 * Insert it into the right place
2406 */
2407 INSERT_OBJECT_OID(m, &lmodules);
2408
2409 /* preserve order */
2410 if (community == COMM_INITIALIZE) {
2411 m->flags |= LM_ONSTARTLIST;
2412 TAILQ_INSERT_TAIL(&modules_start, m, start);
2413 }
2414
2415 /*
2416 * make the argument vector.
2417 */
2418 ac = 0;
2419 for (i = 0; i < nprogargs; i++) {
2420 if (strlen(progargs[i]) >= strlen(section) + 1 &&
2421 strncmp(progargs[i], section, strlen(section)) == 0 &&
2422 progargs[i][strlen(section)] == ':') {
2423 if (ac == MAX_MOD_ARGS) {
2424 syslog(LOG_WARNING, "too many arguments for "
2425 "module '%s", section);
2426 break;
2427 }
2428 av[ac++] = &progargs[i][strlen(section)+1];
2429 }
2430 }
2431 av[ac] = NULL;
2432
2433 /*
2434 * Run the initialization function
2435 */
2436 if ((err = (*m->config->init)(m, ac, av)) != 0) {
2437 syslog(LOG_ERR, "lm_load: init failed: %d", err);
2438 TAILQ_REMOVE(&lmodules, m, link);
2439 goto err;
2440 }
2441
2442 return (m);
2443
2444 err:
2445 if ((m->flags & LM_ONSTARTLIST) != 0)
2446 TAILQ_REMOVE(&modules_start, m, start);
2447 if (m->handle)
2448 dlclose(m->handle);
2449 free(m->path);
2450 free(m);
2451 return (NULL);
2452 }
2453
2454 /*
2455 * Start a module
2456 */
2457 void
lm_start(struct lmodule * mod)2458 lm_start(struct lmodule *mod)
2459 {
2460 const struct lmodule *m;
2461
2462 /*
2463 * Merge tree. If this fails, unload the module.
2464 */
2465 if (tree_merge(mod->config->tree, mod->config->tree_size, mod)) {
2466 lm_unload(mod);
2467 return;
2468 }
2469
2470 /*
2471 * Read configuration
2472 */
2473 if (read_config(config_file, mod)) {
2474 syslog(LOG_ERR, "error in config file");
2475 lm_unload(mod);
2476 return;
2477 }
2478 if (mod->config->start)
2479 (*mod->config->start)();
2480
2481 mod->flags |= LM_STARTED;
2482
2483 /*
2484 * Inform other modules
2485 */
2486 TAILQ_FOREACH(m, &lmodules, link)
2487 if (m->config->loading)
2488 (*m->config->loading)(mod, 1);
2489 }
2490
2491
2492 /*
2493 * Unload a module.
2494 */
2495 void
lm_unload(struct lmodule * m)2496 lm_unload(struct lmodule *m)
2497 {
2498 int err;
2499 const struct lmodule *mod;
2500
2501 TAILQ_REMOVE(&lmodules, m, link);
2502 if (m->flags & LM_ONSTARTLIST)
2503 TAILQ_REMOVE(&modules_start, m, start);
2504 tree_unmerge(m);
2505
2506 if ((m->flags & LM_STARTED) && m->config->fini &&
2507 (err = (*m->config->fini)()) != 0)
2508 syslog(LOG_WARNING, "lm_unload(%s): fini %d", m->section, err);
2509
2510 comm_flush(m);
2511 reqid_flush(m);
2512 timer_flush(m);
2513 fd_flush(m);
2514
2515 dlclose(m->handle);
2516 free(m->path);
2517
2518 /*
2519 * Inform other modules
2520 */
2521 TAILQ_FOREACH(mod, &lmodules, link)
2522 if (mod->config->loading)
2523 (*mod->config->loading)(m, 0);
2524
2525 free(m);
2526 }
2527
2528 /*
2529 * Register an object resource and return the index (or 0 on failures)
2530 */
2531 u_int
or_register(const struct asn_oid * or,const char * descr,struct lmodule * mod)2532 or_register(const struct asn_oid *or, const char *descr, struct lmodule *mod)
2533 {
2534 struct objres *objres, *or1;
2535 u_int idx;
2536
2537 /* find a free index */
2538 idx = 1;
2539 for (objres = TAILQ_FIRST(&objres_list);
2540 objres != NULL;
2541 objres = TAILQ_NEXT(objres, link)) {
2542 if ((or1 = TAILQ_NEXT(objres, link)) == NULL ||
2543 or1->index > objres->index + 1) {
2544 idx = objres->index + 1;
2545 break;
2546 }
2547 }
2548
2549 if ((objres = malloc(sizeof(*objres))) == NULL)
2550 return (0);
2551
2552 objres->index = idx;
2553 objres->oid = *or;
2554 strlcpy(objres->descr, descr, sizeof(objres->descr));
2555 objres->uptime = (uint32_t)(get_ticks() - start_tick);
2556 objres->module = mod;
2557
2558 INSERT_OBJECT_INT(objres, &objres_list);
2559
2560 systemg.or_last_change = objres->uptime;
2561
2562 return (idx);
2563 }
2564
2565 void
or_unregister(u_int idx)2566 or_unregister(u_int idx)
2567 {
2568 struct objres *objres;
2569
2570 TAILQ_FOREACH(objres, &objres_list, link)
2571 if (objres->index == idx) {
2572 TAILQ_REMOVE(&objres_list, objres, link);
2573 free(objres);
2574 return;
2575 }
2576 }
2577
2578 /*
2579 * RFC 3414 User-based Security Model support
2580 */
2581
2582 struct snmpd_usmstat *
bsnmpd_get_usm_stats(void)2583 bsnmpd_get_usm_stats(void)
2584 {
2585 return (&snmpd_usmstats);
2586 }
2587
2588 void
bsnmpd_reset_usm_stats(void)2589 bsnmpd_reset_usm_stats(void)
2590 {
2591 memset(&snmpd_usmstats, 0, sizeof(snmpd_usmstats));
2592 }
2593
2594 struct usm_user *
usm_first_user(void)2595 usm_first_user(void)
2596 {
2597 return (SLIST_FIRST(&usm_userlist));
2598 }
2599
2600 struct usm_user *
usm_next_user(struct usm_user * uuser)2601 usm_next_user(struct usm_user *uuser)
2602 {
2603 if (uuser == NULL)
2604 return (NULL);
2605
2606 return (SLIST_NEXT(uuser, up));
2607 }
2608
2609 struct usm_user *
usm_find_user(uint8_t * engine,uint32_t elen,char * uname)2610 usm_find_user(uint8_t *engine, uint32_t elen, char *uname)
2611 {
2612 struct usm_user *uuser;
2613
2614 SLIST_FOREACH(uuser, &usm_userlist, up)
2615 if (uuser->user_engine_len == elen &&
2616 memcmp(uuser->user_engine_id, engine, elen) == 0 &&
2617 strlen(uuser->suser.sec_name) == strlen(uname) &&
2618 strcmp(uuser->suser.sec_name, uname) == 0)
2619 break;
2620
2621 return (uuser);
2622 }
2623
2624 static int
usm_compare_user(struct usm_user * u1,struct usm_user * u2)2625 usm_compare_user(struct usm_user *u1, struct usm_user *u2)
2626 {
2627 uint32_t i;
2628
2629 if (u1->user_engine_len < u2->user_engine_len)
2630 return (-1);
2631 if (u1->user_engine_len > u2->user_engine_len)
2632 return (1);
2633
2634 for (i = 0; i < u1->user_engine_len; i++) {
2635 if (u1->user_engine_id[i] < u2->user_engine_id[i])
2636 return (-1);
2637 if (u1->user_engine_id[i] > u2->user_engine_id[i])
2638 return (1);
2639 }
2640
2641 if (strlen(u1->suser.sec_name) < strlen(u2->suser.sec_name))
2642 return (-1);
2643 if (strlen(u1->suser.sec_name) > strlen(u2->suser.sec_name))
2644 return (1);
2645
2646 for (i = 0; i < strlen(u1->suser.sec_name); i++) {
2647 if (u1->suser.sec_name[i] < u2->suser.sec_name[i])
2648 return (-1);
2649 if (u1->suser.sec_name[i] > u2->suser.sec_name[i])
2650 return (1);
2651 }
2652
2653 return (0);
2654 }
2655
2656 struct usm_user *
usm_new_user(uint8_t * eid,uint32_t elen,char * uname)2657 usm_new_user(uint8_t *eid, uint32_t elen, char *uname)
2658 {
2659 int cmp;
2660 struct usm_user *uuser, *temp, *prev;
2661
2662 for (uuser = usm_first_user(); uuser != NULL;
2663 (uuser = usm_next_user(uuser))) {
2664 if (uuser->user_engine_len == elen &&
2665 strlen(uname) == strlen(uuser->suser.sec_name) &&
2666 strcmp(uname, uuser->suser.sec_name) == 0 &&
2667 memcmp(eid, uuser->user_engine_id, elen) == 0)
2668 return (NULL);
2669 }
2670
2671 if ((uuser = (struct usm_user *)malloc(sizeof(*uuser))) == NULL)
2672 return (NULL);
2673
2674 memset(uuser, 0, sizeof(*uuser));
2675 strlcpy(uuser->suser.sec_name, uname, SNMP_ADM_STR32_SIZ);
2676 memcpy(uuser->user_engine_id, eid, elen);
2677 uuser->user_engine_len = elen;
2678
2679 if ((prev = SLIST_FIRST(&usm_userlist)) == NULL ||
2680 usm_compare_user(uuser, prev) < 0) {
2681 SLIST_INSERT_HEAD(&usm_userlist, uuser, up);
2682 return (uuser);
2683 }
2684
2685 SLIST_FOREACH(temp, &usm_userlist, up) {
2686 if ((cmp = usm_compare_user(uuser, temp)) <= 0)
2687 break;
2688 prev = temp;
2689 }
2690
2691 if (temp == NULL || cmp < 0)
2692 SLIST_INSERT_AFTER(prev, uuser, up);
2693 else if (cmp > 0)
2694 SLIST_INSERT_AFTER(temp, uuser, up);
2695 else {
2696 syslog(LOG_ERR, "User %s exists", uuser->suser.sec_name);
2697 free(uuser);
2698 return (NULL);
2699 }
2700
2701 return (uuser);
2702 }
2703
2704 void
usm_delete_user(struct usm_user * uuser)2705 usm_delete_user(struct usm_user *uuser)
2706 {
2707 SLIST_REMOVE(&usm_userlist, uuser, usm_user, up);
2708 free(uuser);
2709 }
2710
2711 void
usm_flush_users(void)2712 usm_flush_users(void)
2713 {
2714 struct usm_user *uuser;
2715
2716 while ((uuser = SLIST_FIRST(&usm_userlist)) != NULL) {
2717 SLIST_REMOVE_HEAD(&usm_userlist, up);
2718 free(uuser);
2719 }
2720
2721 SLIST_INIT(&usm_userlist);
2722 }
2723
2724 /*
2725 * RFC 3415 View-based Access Control Model support
2726 */
2727 struct vacm_user *
vacm_first_user(void)2728 vacm_first_user(void)
2729 {
2730 return (SLIST_FIRST(&vacm_userlist));
2731 }
2732
2733 struct vacm_user *
vacm_next_user(struct vacm_user * vuser)2734 vacm_next_user(struct vacm_user *vuser)
2735 {
2736 if (vuser == NULL)
2737 return (NULL);
2738
2739 return (SLIST_NEXT(vuser, vvu));
2740 }
2741
2742 static int
vacm_compare_user(struct vacm_user * v1,struct vacm_user * v2)2743 vacm_compare_user(struct vacm_user *v1, struct vacm_user *v2)
2744 {
2745 uint32_t i;
2746
2747 if (v1->sec_model < v2->sec_model)
2748 return (-1);
2749 if (v1->sec_model > v2->sec_model)
2750 return (1);
2751
2752 if (strlen(v1->secname) < strlen(v2->secname))
2753 return (-1);
2754 if (strlen(v1->secname) > strlen(v2->secname))
2755 return (1);
2756
2757 for (i = 0; i < strlen(v1->secname); i++) {
2758 if (v1->secname[i] < v2->secname[i])
2759 return (-1);
2760 if (v1->secname[i] > v2->secname[i])
2761 return (1);
2762 }
2763
2764 return (0);
2765 }
2766
2767 struct vacm_user *
vacm_new_user(int32_t smodel,char * uname)2768 vacm_new_user(int32_t smodel, char *uname)
2769 {
2770 int cmp;
2771 struct vacm_user *user, *temp, *prev;
2772
2773 SLIST_FOREACH(user, &vacm_userlist, vvu)
2774 if (strcmp(uname, user->secname) == 0 &&
2775 smodel == user->sec_model)
2776 return (NULL);
2777
2778 if ((user = (struct vacm_user *)malloc(sizeof(*user))) == NULL)
2779 return (NULL);
2780
2781 memset(user, 0, sizeof(*user));
2782 user->group = &vacm_default_group;
2783 SLIST_INSERT_HEAD(&vacm_default_group.group_users, user, vvg);
2784 user->sec_model = smodel;
2785 strlcpy(user->secname, uname, sizeof(user->secname));
2786
2787 if ((prev = SLIST_FIRST(&vacm_userlist)) == NULL ||
2788 vacm_compare_user(user, prev) < 0) {
2789 SLIST_INSERT_HEAD(&vacm_userlist, user, vvu);
2790 return (user);
2791 }
2792
2793 SLIST_FOREACH(temp, &vacm_userlist, vvu) {
2794 if ((cmp = vacm_compare_user(user, temp)) <= 0)
2795 break;
2796 prev = temp;
2797 }
2798
2799 if (temp == NULL || cmp < 0)
2800 SLIST_INSERT_AFTER(prev, user, vvu);
2801 else if (cmp > 0)
2802 SLIST_INSERT_AFTER(temp, user, vvu);
2803 else {
2804 syslog(LOG_ERR, "User %s exists", user->secname);
2805 free(user);
2806 return (NULL);
2807 }
2808
2809 return (user);
2810 }
2811
2812 int
vacm_delete_user(struct vacm_user * user)2813 vacm_delete_user(struct vacm_user *user)
2814 {
2815 if (user->group != NULL && user->group != &vacm_default_group) {
2816 SLIST_REMOVE(&user->group->group_users, user, vacm_user, vvg);
2817 if (SLIST_EMPTY(&user->group->group_users)) {
2818 SLIST_REMOVE(&vacm_grouplist, user->group,
2819 vacm_group, vge);
2820 free(user->group);
2821 }
2822 }
2823
2824 SLIST_REMOVE(&vacm_userlist, user, vacm_user, vvu);
2825 free(user);
2826
2827 return (0);
2828 }
2829
2830 int
vacm_user_set_group(struct vacm_user * user,u_char * octets,u_int len)2831 vacm_user_set_group(struct vacm_user *user, u_char *octets, u_int len)
2832 {
2833 struct vacm_group *group;
2834
2835 if (len >= SNMP_ADM_STR32_SIZ)
2836 return (-1);
2837
2838 SLIST_FOREACH(group, &vacm_grouplist, vge)
2839 if (strlen(group->groupname) == len &&
2840 memcmp(octets, group->groupname, len) == 0)
2841 break;
2842
2843 if (group == NULL) {
2844 if ((group = (struct vacm_group *)malloc(sizeof(*group))) == NULL)
2845 return (-1);
2846 memset(group, 0, sizeof(*group));
2847 memcpy(group->groupname, octets, len);
2848 group->groupname[len] = '\0';
2849 SLIST_INSERT_HEAD(&vacm_grouplist, group, vge);
2850 }
2851
2852 SLIST_REMOVE(&user->group->group_users, user, vacm_user, vvg);
2853 SLIST_INSERT_HEAD(&group->group_users, user, vvg);
2854 user->group = group;
2855
2856 return (0);
2857 }
2858
2859 void
vacm_groups_init(void)2860 vacm_groups_init(void)
2861 {
2862 SLIST_INSERT_HEAD(&vacm_grouplist, &vacm_default_group, vge);
2863 }
2864
2865 struct vacm_access *
vacm_first_access_rule(void)2866 vacm_first_access_rule(void)
2867 {
2868 return (TAILQ_FIRST(&vacm_accesslist));
2869 }
2870
2871 struct vacm_access *
vacm_next_access_rule(struct vacm_access * acl)2872 vacm_next_access_rule(struct vacm_access *acl)
2873 {
2874 if (acl == NULL)
2875 return (NULL);
2876
2877 return (TAILQ_NEXT(acl, vva));
2878 }
2879
2880 static int
vacm_compare_access_rule(struct vacm_access * v1,struct vacm_access * v2)2881 vacm_compare_access_rule(struct vacm_access *v1, struct vacm_access *v2)
2882 {
2883 uint32_t i;
2884
2885 if (strlen(v1->group->groupname) < strlen(v2->group->groupname))
2886 return (-1);
2887 if (strlen(v1->group->groupname) > strlen(v2->group->groupname))
2888 return (1);
2889
2890 for (i = 0; i < strlen(v1->group->groupname); i++) {
2891 if (v1->group->groupname[i] < v2->group->groupname[i])
2892 return (-1);
2893 if (v1->group->groupname[i] > v2->group->groupname[i])
2894 return (1);
2895 }
2896
2897 if (strlen(v1->ctx_prefix) < strlen(v2->ctx_prefix))
2898 return (-1);
2899 if (strlen(v1->ctx_prefix) > strlen(v2->ctx_prefix))
2900 return (1);
2901
2902 for (i = 0; i < strlen(v1->ctx_prefix); i++) {
2903 if (v1->ctx_prefix[i] < v2->ctx_prefix[i])
2904 return (-1);
2905 if (v1->ctx_prefix[i] > v2->ctx_prefix[i])
2906 return (1);
2907 }
2908
2909 if (v1->sec_model < v2->sec_model)
2910 return (-1);
2911 if (v1->sec_model > v2->sec_model)
2912 return (1);
2913
2914 if (v1->sec_level < v2->sec_level)
2915 return (-1);
2916 if (v1->sec_level > v2->sec_level)
2917 return (1);
2918
2919 return (0);
2920 }
2921
2922 struct vacm_access *
vacm_new_access_rule(char * gname,char * cprefix,int32_t smodel,int32_t slevel)2923 vacm_new_access_rule(char *gname, char *cprefix, int32_t smodel, int32_t slevel)
2924 {
2925 struct vacm_group *group;
2926 struct vacm_access *acl, *temp;
2927
2928 TAILQ_FOREACH(acl, &vacm_accesslist, vva) {
2929 if (acl->group == NULL)
2930 continue;
2931 if (strcmp(gname, acl->group->groupname) == 0 &&
2932 strcmp(cprefix, acl->ctx_prefix) == 0 &&
2933 acl->sec_model == smodel && acl->sec_level == slevel)
2934 return (NULL);
2935 }
2936
2937 /* Make sure the group exists */
2938 SLIST_FOREACH(group, &vacm_grouplist, vge)
2939 if (strcmp(gname, group->groupname) == 0)
2940 break;
2941
2942 if (group == NULL)
2943 return (NULL);
2944
2945 if ((acl = (struct vacm_access *)malloc(sizeof(*acl))) == NULL)
2946 return (NULL);
2947
2948 memset(acl, 0, sizeof(*acl));
2949 acl->group = group;
2950 strlcpy(acl->ctx_prefix, cprefix, sizeof(acl->ctx_prefix));
2951 acl->sec_model = smodel;
2952 acl->sec_level = slevel;
2953
2954 if ((temp = TAILQ_FIRST(&vacm_accesslist)) == NULL ||
2955 vacm_compare_access_rule(acl, temp) < 0) {
2956 TAILQ_INSERT_HEAD(&vacm_accesslist, acl, vva);
2957 return (acl);
2958 }
2959
2960 TAILQ_FOREACH(temp, &vacm_accesslist, vva)
2961 if (vacm_compare_access_rule(acl, temp) < 0) {
2962 TAILQ_INSERT_BEFORE(temp, acl, vva);
2963 return (acl);
2964 }
2965
2966 TAILQ_INSERT_TAIL(&vacm_accesslist, acl, vva);
2967
2968 return (acl);
2969 }
2970
2971 int
vacm_delete_access_rule(struct vacm_access * acl)2972 vacm_delete_access_rule(struct vacm_access *acl)
2973 {
2974 TAILQ_REMOVE(&vacm_accesslist, acl, vva);
2975 free(acl);
2976
2977 return (0);
2978 }
2979
2980 struct vacm_view *
vacm_first_view(void)2981 vacm_first_view(void)
2982 {
2983 return (SLIST_FIRST(&vacm_viewlist));
2984 }
2985
2986 struct vacm_view *
vacm_next_view(struct vacm_view * view)2987 vacm_next_view(struct vacm_view *view)
2988 {
2989 if (view == NULL)
2990 return (NULL);
2991
2992 return (SLIST_NEXT(view, vvl));
2993 }
2994
2995 static int
vacm_compare_view(struct vacm_view * v1,struct vacm_view * v2)2996 vacm_compare_view(struct vacm_view *v1, struct vacm_view *v2)
2997 {
2998 uint32_t i;
2999
3000 if (strlen(v1->viewname) < strlen(v2->viewname))
3001 return (-1);
3002 if (strlen(v1->viewname) > strlen(v2->viewname))
3003 return (1);
3004
3005 for (i = 0; i < strlen(v1->viewname); i++) {
3006 if (v1->viewname[i] < v2->viewname[i])
3007 return (-1);
3008 if (v1->viewname[i] > v2->viewname[i])
3009 return (1);
3010 }
3011
3012 return (asn_compare_oid(&v1->subtree, &v2->subtree));
3013 }
3014
3015 struct vacm_view *
vacm_new_view(char * vname,struct asn_oid * oid)3016 vacm_new_view(char *vname, struct asn_oid *oid)
3017 {
3018 int cmp;
3019 struct vacm_view *view, *temp, *prev;
3020
3021 SLIST_FOREACH(view, &vacm_viewlist, vvl)
3022 if (strcmp(vname, view->viewname) == 0)
3023 return (NULL);
3024
3025 if ((view = (struct vacm_view *)malloc(sizeof(*view))) == NULL)
3026 return (NULL);
3027
3028 memset(view, 0, sizeof(*view));
3029 strlcpy(view->viewname, vname, sizeof(view->viewname));
3030 asn_append_oid(&view->subtree, oid);
3031
3032 if ((prev = SLIST_FIRST(&vacm_viewlist)) == NULL ||
3033 vacm_compare_view(view, prev) < 0) {
3034 SLIST_INSERT_HEAD(&vacm_viewlist, view, vvl);
3035 return (view);
3036 }
3037
3038 SLIST_FOREACH(temp, &vacm_viewlist, vvl) {
3039 if ((cmp = vacm_compare_view(view, temp)) <= 0)
3040 break;
3041 prev = temp;
3042 }
3043
3044 if (temp == NULL || cmp < 0)
3045 SLIST_INSERT_AFTER(prev, view, vvl);
3046 else if (cmp > 0)
3047 SLIST_INSERT_AFTER(temp, view, vvl);
3048 else {
3049 syslog(LOG_ERR, "View %s exists", view->viewname);
3050 free(view);
3051 return (NULL);
3052 }
3053
3054 return (view);
3055 }
3056
3057 int
vacm_delete_view(struct vacm_view * view)3058 vacm_delete_view(struct vacm_view *view)
3059 {
3060 SLIST_REMOVE(&vacm_viewlist, view, vacm_view, vvl);
3061 free(view);
3062
3063 return (0);
3064 }
3065
3066 struct vacm_context *
vacm_first_context(void)3067 vacm_first_context(void)
3068 {
3069 return (SLIST_FIRST(&vacm_contextlist));
3070 }
3071
3072 struct vacm_context *
vacm_next_context(struct vacm_context * vacmctx)3073 vacm_next_context(struct vacm_context *vacmctx)
3074 {
3075 if (vacmctx == NULL)
3076 return (NULL);
3077
3078 return (SLIST_NEXT(vacmctx, vcl));
3079 }
3080
3081 struct vacm_context *
vacm_add_context(char * ctxname,int regid)3082 vacm_add_context(char *ctxname, int regid)
3083 {
3084 int cmp;
3085 struct vacm_context *ctx, *temp, *prev;
3086
3087 SLIST_FOREACH(ctx, &vacm_contextlist, vcl)
3088 if (strcmp(ctxname, ctx->ctxname) == 0) {
3089 syslog(LOG_ERR, "Context %s exists", ctx->ctxname);
3090 return (NULL);
3091 }
3092
3093 if ((ctx = (struct vacm_context *)malloc(sizeof(*ctx))) == NULL)
3094 return (NULL);
3095
3096 memset(ctx, 0, sizeof(*ctx));
3097 strlcpy(ctx->ctxname, ctxname, sizeof(ctx->ctxname));
3098 ctx->regid = regid;
3099
3100 if ((prev = SLIST_FIRST(&vacm_contextlist)) == NULL ||
3101 strlen(ctx->ctxname) < strlen(prev->ctxname) ||
3102 strcmp(ctx->ctxname, prev->ctxname) < 0) {
3103 SLIST_INSERT_HEAD(&vacm_contextlist, ctx, vcl);
3104 return (ctx);
3105 }
3106
3107 SLIST_FOREACH(temp, &vacm_contextlist, vcl) {
3108 if (strlen(ctx->ctxname) < strlen(temp->ctxname) ||
3109 strcmp(ctx->ctxname, temp->ctxname) < 0) {
3110 cmp = -1;
3111 break;
3112 }
3113 prev = temp;
3114 }
3115
3116 if (temp == NULL || cmp < 0)
3117 SLIST_INSERT_AFTER(prev, ctx, vcl);
3118 else if (cmp > 0)
3119 SLIST_INSERT_AFTER(temp, ctx, vcl);
3120 else {
3121 syslog(LOG_ERR, "Context %s exists", ctx->ctxname);
3122 free(ctx);
3123 return (NULL);
3124 }
3125
3126 return (ctx);
3127 }
3128
3129 void
vacm_flush_contexts(int regid)3130 vacm_flush_contexts(int regid)
3131 {
3132 struct vacm_context *ctx, *temp;
3133
3134 SLIST_FOREACH_SAFE(ctx, &vacm_contextlist, vcl, temp)
3135 if (ctx->regid == regid) {
3136 SLIST_REMOVE(&vacm_contextlist, ctx, vacm_context, vcl);
3137 free(ctx);
3138 }
3139 }
3140