![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to snmpd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / snmp|
Return to snmpd.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / snmp |
1.1 root 1: /* snmpd.c - SNMP agent for 4BSD/ISODE */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/snmp/RCS/snmpd.c,v 7.35 90/07/09 14:49:04 mrose Exp $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/snmp/RCS/snmpd.c,v 7.35 90/07/09 14:49:04 mrose Exp $
9: *
10: * Contributed by NYSERNet Inc. This work was partially supported by the
11: * U.S. Defense Advanced Research Projects Agency and the Rome Air Development
12: * Center of the U.S. Air Force Systems Command under contract number
13: * F30602-88-C-0016.
14: *
15: *
16: * $Log: snmpd.c,v $
17: * Revision 7.35 90/07/09 14:49:04 mrose
18: * sync
19: *
20: * Revision 7.34 90/07/01 21:07:26 mrose
21: * pepsy
22: *
23: * Revision 7.33 90/06/23 17:07:38 mrose
24: * loopback
25: *
26: * Revision 7.32 90/06/23 17:01:24 mrose
27: * update
28: *
29: * Revision 7.31 90/06/23 01:33:12 mrose
30: * proxy again
31: *
32: * Revision 7.30 90/06/21 21:27:14 mrose
33: * proxy and snmpt
34: *
35: * Revision 7.29 90/06/20 23:52:57 mrose
36: * again
37: *
38: * Revision 7.28 90/06/20 21:38:33 mrose
39: * update
40: *
41: * Revision 7.27 90/06/15 16:58:39 mrose
42: * update
43: *
44: * Revision 7.26 90/06/13 17:58:44 mrose
45: * defaultView
46: *
47: * Revision 7.25 90/06/12 05:19:03 mrose
48: * again
49: *
50: * Revision 7.24 90/06/12 02:21:43 mrose
51: * again
52: *
53: * Revision 7.23 90/06/12 02:05:33 mrose
54: * views ...
55: *
56: * Revision 7.22 90/06/05 20:47:10 mrose
57: * touch-up
58: *
59: * Revision 7.21 90/05/21 10:07:39 mrose
60: * bug-fix
61: *
62: * Revision 7.20 90/05/15 16:56:20 mrose
63: * bump COMM_RDWRITE
64: *
65: * Revision 7.19 90/05/14 19:55:48 mrose
66: * optimize views
67: *
68: * Revision 7.18 90/05/13 18:13:46 mrose
69: * update
70: *
71: * Revision 7.17 90/05/13 17:54:39 mrose
72: * views again
73: *
74: * Revision 7.16 90/05/13 16:18:17 mrose
75: * views
76: *
77: * Revision 7.15 90/04/18 08:51:53 mrose
78: * oid_normalize
79: *
80: * Revision 7.14 90/04/09 08:50:16 mrose
81: * update
82: *
83: * Revision 7.13 90/02/27 18:49:55 mrose
84: * unix stuff
85: *
86: * Revision 7.12 90/02/23 17:47:49 mrose
87: * update
88: *
89: * Revision 7.11 90/02/19 16:25:56 mrose
90: * typo
91: *
92: * Revision 7.10 90/02/19 15:38:50 mrose
93: * one more time
94: *
95: * Revision 7.9 90/02/17 17:18:48 mrose
96: * touch-up
97: *
98: * Revision 7.8 90/01/11 18:34:33 mrose
99: * real-sync
100: *
101: * Revision 7.7 89/12/19 22:01:52 mrose
102: * touch-up
103: *
104: * Revision 7.6 89/12/19 16:18:23 mrose
105: * dgram
106: *
107: * Revision 7.5 89/12/11 16:22:29 mrose
108: * more clts
109: *
110: * Revision 7.4 89/12/09 21:07:41 mrose
111: * touch-up
112: *
113: * Revision 7.3 89/12/08 14:20:27 mrose
114: * touch-up
115: *
116: * Revision 7.2 89/12/07 22:15:12 mrose
117: * touch-up
118: *
119: * Revision 7.1 89/12/01 10:42:15 mrose
120: * clts
121: *
122: * Revision 7.0 89/11/23 22:23:26 mrose
123: * Release 6.0
124: *
125: */
126:
127: /*
128: * NOTICE
129: *
130: * Acquisition, use, and distribution of this module and related
131: * materials are subject to the restrictions of a license agreement.
132: * Consult the Preface in the User's Manual for the full terms of
133: * this agreement.
134: *
135: */
136:
137:
138: #include <errno.h>
139: #include <signal.h>
140: #include <stdio.h>
141: #include <varargs.h>
142: #include "mib.h"
143: #include <sys/ioctl.h>
144: #ifdef BSD42
145: #include <sys/file.h>
146: #endif
147: #ifdef SYS5
148: #include <fcntl.h>
149: #endif
150: #include <sys/stat.h>
151: #include "tailor.h"
152:
153: #include "dgram.h"
154: #include "tsap.h"
155: #ifdef TCP
156: #define SMUX
157: #include "internet.h"
158: #endif
159: #ifdef X25
160: #include "x25.h"
161: #define COTS
162: #endif
163: #ifdef TP4
164: #include "tp4.h"
165: #if !defined(CLTS) && !defined(COTS)
166: #define COTS
167: #endif
168: #endif
169:
170: #ifdef SNMPT
171: #undef SMUX
172: #endif
173:
174:
175: #define IDLE_TIME (3 * 60)
176:
177: /* DATA */
178:
179: int debug = 0;
180: static int nbits = FD_SETSIZE;
181: #ifndef SNMPT
182: static int rflag = 0;
183: #endif
184:
185:
186: #define LLOG_XXX (LLOG_PDUS | LLOG_DEBUG)
187:
188: static LLog _pgm_log = {
189: #ifndef SNMPT
190: "snmpd.log",
191: #else
192: "snmpt.log",
193: #endif
194: NULLCP, NULLCP, LLOG_FATAL | LLOG_EXCEPTIONS | LLOG_NOTICE,
195: LLOG_FATAL, -1, LLOGCLS | LLOGCRT | LLOGZER, NOTOK
196: };
197: static LLog *pgm_log = &_pgm_log;
198:
199: #ifndef SNMPT
200: static char *myname = "snmpd";
201: #else
202: static char *myname = "snmpt";
203: #endif
204:
205: static int tcpservice = 1;
206: static int x25service = 1;
207: static int tp4service = 1;
208:
209:
210: #define NTADDRS FD_SETSIZE
211:
212: static fd_set ifds;
213:
214: static struct TSAPaddr *tz;
215: static struct TSAPaddr tas[NTADDRS];
216:
217: #ifdef COTS
218: static fd_set cfds;
219: static struct TSAPaddr taddrs[FD_SETSIZE];
220: static struct timeval lru[FD_SETSIZE];
221: #endif
222: static char source[BUFSIZ];
223:
224:
225: void adios (), advise ();
226: void ts_advise ();
227:
228:
229: extern int errno;
230:
231: /* */
232:
233: int nd = NOTOK;
234:
235: #ifdef TCP
236: static int udp = NOTOK;
237: #ifndef SNMPT
238: static int udport;
239: static int traport;
240: #endif
241: #endif
242:
243: #ifdef CLTS
244: static int clts = NOTOK;
245: #endif
246:
247: /* */
248:
249: #ifndef SNMPT
250: int quantum = 0;
251:
252:
253: struct subtree {
254: struct subtree *s_forw; /* doubly-linked list */
255: struct subtree *s_back; /* doubly-linked list */
256:
257: OID s_subtree; /* subtree */
258: };
259:
260:
261: struct view {
262: struct view *v_forw; /* doubly-linked list */
263: struct view *v_back; /* .. */
264:
265: OID v_name; /* view name */
266: u_long v_mask; /* view mask */
267:
268: struct subtree v_subtree; /* list of subtrees */
269:
270: struct qbuf *v_community; /* for proxy, traps... */
271: struct sockaddr v_sa;
272: };
273:
274: static struct view viewque;
275: static struct view *VHead = &viewque;
276:
277: static int viewmask = 0x1;
278: static OID localAgent = NULLOID;
279: static OID rfc1157Domain = NULLOID;
280:
281:
282: struct community {
283: struct community *c_forw; /* doubly-linked list */
284: struct community *c_back; /* .. */
285:
286: char *c_name; /* community name */
287: struct NSAPaddr c_addr; /* network address */
288:
289: int c_permission; /* same as ot_access */
290: #define OT_YYY 0x08
291:
292: OID c_vu; /* associated view */
293: struct view *c_view; /* .. */
294:
295: unsigned int *c_instance; /* object instance */
296: int c_insize; /* .. */
297: struct community *c_next; /* next in lexi-order */
298: };
299:
300: static struct community commque;
301: static struct community *CHead = &commque;
302: static struct community *CLex;
303:
304: struct community *str2comm ();
305:
306:
307: struct trap {
308: struct trap *t_forw; /* doubly-linked list */
309: struct trap *t_back; /* .. */
310:
311: char *t_name; /* trap name */
312:
313: struct view t_vu; /* associated view */
314: struct view *t_view; /* .. */
315:
316: u_long t_generics; /* generic traps enabled */
317: };
318:
319: static struct trap trapque;
320: static struct trap *UHead = &trapque;
321:
322: static OID trapview = NULLOID;
323: #ifdef TCP
324: static struct type_SNMP_Message *trap = NULL;
325: #endif
326: #ifdef SMUX
327: static struct qbuf *loopback_addr = NULL;
328: #endif
329:
330:
331: #define NPQ 10
332:
333: static struct proxyque {
334: integer pq_quantum;
335: int pq_age;
336:
337: int pq_fd;
338: IFP pq_closefnx;
339: PS pq_ps;
340:
341: struct qbuf pq_community;
342: integer pq_request;
343: } pips[NPQ];
344:
345: static int pqs = 0;
346:
347: static struct proxyque *pqr = NULL;
348:
349: /* */
350:
351: struct snmpstat {
352: integer s_inpkts;
353: integer s_outpkts;
354: integer s_badversions;
355: integer s_badcommunitynames;
356: integer s_badcommunityuses;
357: integer s_asnparseerrs;
358: integer s_badtypes;
359: integer s_totalreqvars;
360: integer s_totalsetvars;
361: integer s_ingetrequests;
362: integer s_ingetnexts;
363: integer s_insetrequests;
364: integer s_ingetresponses;
365: integer s_intraps;
366: integer s_outgetresponses;
367: integer s_outtraps;
368: integer s_toobigs;
369: integer s_nosuchnames;
370: integer s_badvalues;
371: integer s_readonlys;
372: integer s_generrs;
373: integer s_enableauthtraps;
374: #define TRAPS_ENABLED 1 /* snmpEnableAuthTraps */
375: #define TRAPS_DISABLED 2 /* .. */
376: };
377:
378:
379: static struct snmpstat snmpstat;
380:
381:
382: static int unix_netstat = 1;
383:
384: #else /* SNMPT */
385:
386: /* */
387:
388: static PS audit = NULLPS;
389:
390: #endif /* SNMPT */
391:
392: /* */
393:
394: #ifdef SMUX
395: static int smux_enabled = 1;
396: static int smux = NOTOK;
397:
398: static fd_set sfds;
399:
400:
401: struct smuxPeer {
402: struct smuxPeer *pb_forw; /* doubly-linked list */
403: struct smuxPeer *pb_back; /* .. */
404:
405: int pb_fd; /* smuxPindex */
406: struct sockaddr_in pb_address;
407: char pb_source[30];
408:
409: OID pb_identity; /* smuxPidentity */
410: char *pb_description; /* smuxPdescription */
411:
412: PS pb_ps;
413:
414: int pb_priority; /* minimum allowed priority */
415: };
416:
417: static struct smuxPeer peerque;
418: static struct smuxPeer *PHead = &peerque;
419:
420:
421: struct smuxTree {
422: struct smuxTree *tb_forw; /* doubly-linked list */
423: struct smuxTree *tb_back; /* .. */
424:
425: #define TB_SIZE 30 /* object instance */
426: unsigned int tb_instance[TB_SIZE + 1];
427: int tb_insize;
428:
429: OT tb_subtree; /* smuxTsubtree */
430: int tb_priority; /* smuxTpriority */
431: struct smuxPeer *tb_peer; /* smuxTindex */
432:
433: struct smuxTree *tb_next; /* linked list for ot_smux */
434: };
435:
436: static struct smuxTree treeque;
437: static struct smuxTree *THead = &treeque;
438:
439: static struct smuxReserved {
440: char *rb_text;
441: OID rb_name;
442: } reserved[] = {
443: "snmp", NULLOID,
444: "smux", NULLOID,
445:
446: NULL
447: };
448: #endif
449:
450: /* MAIN */
451:
452: /* ARGSUSED */
453:
454: main (argc, argv, envp)
455: int argc;
456: char **argv,
457: **envp;
458: {
459: int failed,
460: listening,
461: nfds;
462: register struct TSAPaddr *ta;
463: struct TSAPdisconnect tds;
464: register struct TSAPdisconnect *td = &tds;
465:
466: arginit (argv);
467: envinit ();
468:
469: failed = listening = 0;
470: nfds = 0;
471: FD_ZERO (&ifds);
472:
473: for (ta = tas; ta < tz; ta++) {
474: if (ta -> ta_naddr == 0) {
475: if (!tp4service)
476: continue;
477: #ifdef CLTS
478: goto do_clts;
479: #endif
480: }
481: else {
482: register struct NSAPaddr *na = ta -> ta_addrs;
483:
484: switch (na -> na_stack) {
485: case NA_TCP:
486: if (!tcpservice)
487: continue;
488: #ifdef TCP
489: {
490: struct sockaddr_in lo_socket;
491: register struct sockaddr_in *lsock = &lo_socket;
492:
493: bzero ((char *) lsock, sizeof *lsock);
494: lsock -> sin_family = AF_INET;
495: lsock -> sin_port = na -> na_port;
496:
497: if ((udp = start_udp_server (lsock, 0, 0, 0))
498: == NOTOK) {
499: advise (LLOG_EXCEPTIONS, "failed",
500: "start_udp_server");
501: failed++;
502: continue;
503: }
504: if (udp >= nfds)
505: nfds = udp + 1;
506: FD_SET (udp, &ifds);
507: if (nd == NOTOK)
508: nd = udp;
509:
510: advise (LLOG_NOTICE, NULLCP,
511: "listening on UDP port %d",
512: (int) ntohs (na -> na_port));
513: listening++;
514: continue;
515: }
516: #else
517: advise (LLOG_EXCEPTIONS, NULLCP,
518: "UDP support not configured");
519: failed++;
520: continue;
521: #endif
522:
523: case NA_X25:
524: if (!x25service)
525: continue;
526: break;
527:
528: case NA_NSAP:
529: if (!tp4service)
530: continue;
531: #ifdef CLTS
532: do_clts: ;
533: {
534: union sockaddr_osi lo_socket;
535: register union sockaddr_osi *lsock = &lo_socket;
536:
537: (void) gen2tp4 (ta, lsock);
538: if ((clts = start_clts_server (lsock, 0, 0, 0))
539: == NOTOK) {
540: advise (LLOG_EXCEPTIONS, "failed",
541: "start_clts_server");
542: failed++;
543: continue;
544: }
545: if (clts >= nfds)
546: nfds = clts + 1;
547: FD_SET (clts, &ifds);
548: if (nd == NOTOK)
549: nd = clts;
550:
551: advise (LLOG_NOTICE, NULLCP,
552: "listening on %s", taddr2str (ta));
553: listening++;
554: continue;
555: }
556: #else
557: break;
558: #endif
559:
560: default:
561: adios (NULLCP, "unknown network type 0x%x", na -> na_stack);
562: /* NOT REACHED */
563: }
564: }
565:
566: advise (LLOG_NOTICE, NULLCP, "listening on %s", taddr2str (ta));
567:
568: if (TNetListen (ta, td) == NOTOK) {
569: ts_advise (td, LLOG_EXCEPTIONS, "listen failed");
570: failed++;
571: }
572: else
573: listening++;
574: }
575:
576: if (!listening)
577: adios (NULLCP, failed ? "no successful listens"
578: : "no network services selected");
579:
580: #ifndef SNMPT
581: do_trap (int_SNMP_generic__trap_coldStart, 0,
582: (struct type_SNMP_VarBindList *) 0);
583: #endif
584:
585: #ifdef SMUX
586: {
587: struct sockaddr_in lo_socket;
588: register struct sockaddr_in *lsock = &lo_socket;
589: register struct servent *sp;
590: register struct smuxReserved *sr;
591: OT ot;
592:
593: PHead -> pb_forw = PHead -> pb_back = PHead;
594: THead -> tb_forw = THead -> tb_back = THead;
595: for (sr = reserved; sr -> rb_text; sr++)
596: if (ot = text2obj (sr -> rb_text))
597: sr -> rb_name = ot -> ot_name;
598:
599: bzero ((char *) lsock, sizeof *lsock);
600: lsock -> sin_family = AF_INET;
601: lsock -> sin_port = (sp = getservbyname ("smux", "tcp"))
602: ? sp -> s_port
603: : htons ((u_short) 199);
604:
605: if (smux_enabled) {
606: if ((smux = start_tcp_server (lsock, SOMAXCONN, 0, 0)) == NOTOK)
607: adios ("failed", "start_tcp_server for SMUX");
608: if (smux >= nfds)
609: nfds = smux + 1;
610: FD_SET (smux, &ifds);
611: }
612: }
613:
614: FD_ZERO (&sfds);
615: #endif
616:
617: #ifdef COTS
618: FD_ZERO (&cfds);
619: #endif
620:
621: for (;;) {
622: int fd,
623: secs;
624: #ifdef COTS
625: struct timeval tvs;
626: register struct timeval *tv = &tvs;
627: #endif
628: int vecp;
629: fd_set rfds;
630: char *vec[4];
631:
632: secs = NOTOK;
633: #ifdef COTS
634: for (fd = 0; fd < nfds; fd++)
635: if (FD_ISSET (fd, &cfds)) {
636: secs = IDLE_TIME + 10;
637: break;
638: }
639: #endif
640:
641: rfds = ifds; /* struct copy */
642: if (TNetAcceptAux (&vecp, vec, &fd, NULLTA, nfds, &rfds, NULLFD,
643: NULLFD, secs, td) == NOTOK) {
644: ts_advise (td, LLOG_EXCEPTIONS, "TNetAccept failed");
645: continue;
646: }
647:
648: #ifdef TCP
649: if (udp != NOTOK && FD_ISSET (udp, &rfds))
650: doit_udp (udp);
651: #endif
652:
653: #ifdef SMUX
654: if (smux != NOTOK
655: && FD_ISSET (smux, &rfds)
656: && (fd = start_smux ()) != NOTOK) {
657: if (fd >= nfds)
658: nfds = fd + 1;
659: FD_SET (fd, &ifds);
660: FD_SET (fd, &sfds);
661: }
662:
663: for (fd = 0; fd < nfds; fd++)
664: if (FD_ISSET (fd, &rfds) && FD_ISSET (fd, &sfds))
665: doit_smux (fd);
666: #endif
667:
668: #ifdef CLTS
669: if (clts != NOTOK && FD_ISSET (clts, &rfds))
670: doit_clts (clts);
671: #endif
672:
673: #ifdef COTS
674: if (vecp > 0 && (fd = start_tsap (vecp, vec)) != NOTOK) {
675: if (fd >= nfds)
676: nfds = fd + 1;
677: FD_SET (fd, &ifds);
678: FD_SET (fd, &cfds);
679: }
680:
681: for (fd = 0; fd < nfds; fd++)
682: if (FD_ISSET (fd, &rfds) && FD_ISSET (fd, &cfds))
683: doit_cots (fd);
684:
685: (void) gettimeofday (tv, (struct timezone *) 0);
686: tv -> tv_sec -= (long) IDLE_TIME;
687:
688: for (fd = 0; fd < nfds; fd++)
689: if (FD_ISSET (fd, &cfds)) {
690: if (timercmp (tv, &lru[fd], >)) {
691: advise (LLOG_EXCEPTIONS, NULLCP,
692: "clearing connection from %d: %s", fd,
693: taddr2str (taddrs + fd));
694: (void) TDiscRequest (fd, NULLCP, 0, td);
695:
696: FD_CLR (fd, &ifds);
697: FD_CLR (fd, &cfds);
698: proxy_clear (fd);
699: }
700: }
701:
702: for (fd = nfds - 1; fd >= 0; fd--)
703: if (FD_ISSET (fd, &ifds))
704: break;
705: nfds = fd + 1;
706: #endif
707: }
708: }
709:
710: /* */
711:
712: static void ts_advise (td, code, event)
713: register struct TSAPdisconnect *td;
714: int code;
715: char *event;
716: {
717: char buffer[BUFSIZ];
718:
719: if (td -> td_cc > 0)
720: (void) sprintf (buffer, "[%s] %*.*s",
721: TErrString (td -> td_reason),
722: td -> td_cc, td -> td_cc, td -> td_data);
723: else
724: (void) sprintf (buffer, "[%s]", TErrString (td -> td_reason));
725:
726: advise (code, NULLCP, "%s: %s", event, buffer);
727: }
728:
729: /* DOIT */
730:
731: #ifdef TCP
732: static doit_udp (pd)
733: int pd;
734: {
735: int fd;
736: char *cp;
737: struct sockaddr_in in_socket;
738: register struct sockaddr_in *isock = &in_socket;
739: struct NSAPaddr nas;
740: register struct NSAPaddr *na = &nas;
741:
742: if ((fd = join_udp_client (pd, isock)) == NOTOK) {
743: if (errno == EWOULDBLOCK)
744: return;
745: adios ("failed", "join_udp_client");
746: }
747:
748: (void) sprintf (source, "Internet=%s+%d+2",
749: cp = inet_ntoa (isock -> sin_addr),
750: (int) ntohs (isock -> sin_port));
751:
752: bzero ((char *) na, sizeof *na);
753: na -> na_stack = NA_TCP;
754: na -> na_community = ts_comm_tcp_default;
755: (void) strncpy (na -> na_domain, cp, sizeof na -> na_domain - 1);
756: na -> na_port = isock -> sin_port;
757:
758: doit_aux (fd, na, read_udp_socket, write_udp_socket);
759: #ifndef SNMPT
760: if (pqr)
761: pqr -> pq_fd = fd, pqr -> pq_closefnx = close_udp_socket;
762: else
763: #endif
764: (void) close_udp_socket (fd);
765: }
766: #endif
767:
768: /* */
769:
770: #ifdef CLTS
771: static doit_clts (pd)
772: int pd;
773: {
774: int fd;
775: char *cp;
776: union sockaddr_osi in_socket;
777: register union sockaddr_osi *isock = &in_socket;
778: struct TSAPaddr tas;
779: register struct TSAPaddr *ta = &tas;
780:
781: if ((fd = join_clts_client (pd, isock)) == NOTOK) {
782: if (errno == EWOULDBLOCK)
783: return;
784: adios ("failed", "join_tcp_client");
785: }
786: (void) tp42gen (ta, isock);
787:
788: (void) strcpy (source, taddr2str (ta));
789:
790: doit_aux (fd, ta -> ta_addrs, read_clts_socket, write_clts_socket);
791: #ifndef SNMPT
792: if (pqr)
793: pqr -> pq_fd = fd, pqr -> pq_closefnx = close_clts_socket;
794: else
795: #endif
796: (void) close_clts_socket (fd);
797: }
798: #endif
799:
800: /* */
801:
802: #ifdef COTS
803: static int start_tsap (vecp, vec)
804: int vecp;
805: char **vec;
806: {
807: struct TSAPstart tss;
808: register struct TSAPstart *ts = &tss;
809: struct TSAPdisconnect tds;
810: register struct TSAPdisconnect *td = &tds;
811:
812: if (TInit (vecp, vec, ts, td) == NOTOK) {
813: ts_advise (td, LLOG_EXCEPTIONS, "T-CONNECT.INDICATION");
814: return NOTOK;
815: }
816:
817: advise (LLOG_XXX, NULLCP,
818: "T-CONNECT.INDICATION: <%d, %s, %s, %d, %d>",
819: ts -> ts_sd,
820: taddr2str (&ts -> ts_calling), taddr2str (&ts -> ts_called),
821: ts -> ts_expedited, ts -> ts_tsdusize);
822:
823: if (TConnResponse (ts -> ts_sd, NULLTA, 0, NULLCP, 0, NULLQOS, td)
824: == NOTOK) {
825: ts_advise (td, LLOG_EXCEPTIONS, "T-CONNECT.RESPONSE");
826: return NOTOK;
827: }
828:
829: taddrs[ts -> ts_sd] = ts -> ts_calling; /* struct copy */
830: (void) gettimeofday (lru + ts -> ts_sd, (struct timezone *) 0);
831:
832: return ts -> ts_sd;
833: }
834:
835: /* */
836:
837: static doit_cots (fd)
838: int fd;
839: {
840: (void) strcpy (source, taddr2str (taddrs + fd));
841: doit_aux (fd, &(taddrs[fd].ta_addrs[0]), ts_read, ts_write);
842: #ifndef SNMPT
843: if (pqr)
844: pqr -> pq_fd = fd, pqr -> pq_closefnx = NULLIFP;
845: #endif
846:
847: (void) gettimeofday (lru + fd, (struct timezone *) 0);
848: }
849: #endif
850:
851: /* */
852:
853: static doit_aux (fd, na, rfx, wfx)
854: int fd;
855: struct NSAPaddr *na;
856: IFP rfx,
857: wfx;
858: {
859: int result;
860: PE pe;
861: PS ps;
862: struct type_SNMP_Message *msg;
863:
864: result = NOTOK;
865: pe = NULLPE;
866: msg = NULL;
867: #ifndef SNMPT
868: pqr = NULL;
869: #endif
870: if ((ps = ps_alloc (dg_open)) == NULLPS
871: || dg_setup (ps, fd, MAXDGRAM, rfx, wfx) == NOTOK) {
872: if (ps == NULLPS)
873: advise (LLOG_EXCEPTIONS, NULLCP, "ps_alloc: out of memory (%s)",
874: source);
875: else
876: advise (LLOG_EXCEPTIONS, NULLCP, "dg_setup: %s (%s)",
877: ps_error (ps -> ps_errno), source);
878:
879: goto out;
880: }
881:
882: if ((pe = ps2pe (ps)) == NULLPE) {
883: #ifdef COTS
884: if (rfx == ts_read) {
885: FD_CLR (fd, &ifds);
886: FD_CLR (fd, &cfds);
887: proxy_clear (fd);
888:
889: if (ps -> ps_errno == PS_ERR_NONE) {
890: advise (LLOG_XXX, NULLCP,
891: "T-DISCONNECT.INDICATION: %d (%s)", fd, source);
892: goto out;
893: }
894: }
895: #endif
896: advise (LLOG_EXCEPTIONS, NULLCP, "ps2pe: %s (%s)",
897: ps_error (ps -> ps_errno), source);
898: #ifndef SNMPT
899: snmpstat.s_inpkts++;
900: snmpstat.s_asnparseerrs++;
901: #endif
902: goto out;
903: }
904: #ifdef COTS
905: if (rfx == ts_read)
906: advise (LLOG_XXX, NULLCP, "T-DATA.INDICATION: %d (%s)", fd, source);
907: else
908: #endif
909: advise (LLOG_XXX, NULLCP, "packet from %s", source);
910:
911: #ifndef SNMPT
912: snmpstat.s_inpkts++;
913: #endif
914:
915: if (decode_SNMP_Message (pe, 1, NULLIP, NULLVP, &msg) == NOTOK) {
916: advise (LLOG_EXCEPTIONS, NULLCP, "decode_SNMP_Message: %s (%s)",
917: PY_pepy, source);
918: #ifndef SNMPT
919: snmpstat.s_asnparseerrs++;
920: #endif
921: #ifdef COTS
922: if (rfx == ts_read) {
923: struct TSAPdisconnect tds;
924:
925: advise (LLOG_EXCEPTIONS, NULLCP,
926: "clearing connection from %d: %s", fd,
927: taddr2str (taddrs + fd));
928: (void) TDiscRequest (fd, NULLCP, 0, &tds);
929:
930: FD_CLR (fd, &ifds);
931: FD_CLR (fd, &cfds);
932: proxy_clear (fd);
933: }
934: #endif
935: goto out;
936: }
937:
938: PLOGP (pgm_log,SNMP_Message, pe, "Message", 1);
939:
940: result = process (ps, msg, na);
941:
942: out: ;
943: if (msg)
944: free_SNMP_Message (msg);
945: if (pe)
946: pe_free (pe);
947: if (result != OK && ps)
948: ps_free (ps);
949: }
950:
951: /* PROCESS */
952:
953: #ifndef SNMPT
954: static int process (ps, msg, na)
955: PS ps;
956: register struct type_SNMP_Message *msg;
957: struct NSAPaddr *na;
958: {
959: int result;
960: char *commname;
961: struct community *comm;
962: PE pe;
963:
964: if (msg -> version != int_SNMP_version_version__1) {
965: advise (LLOG_EXCEPTIONS, NULLCP, "badVersion: %d (%s)",
966: msg -> version, source);
967: snmpstat.s_badversions++;
968: return DONE;
969: }
970:
971: if ((commname = qb2str (msg -> community)) == NULLCP) {
972: advise (LLOG_EXCEPTIONS, NULLCP, "qb2str: out of memory (%s)", source);
973: return DONE;
974: }
975:
976: result = NOTOK;
977: if ((comm = str2comm (commname, na)) == NULL) {
978: advise (LLOG_EXCEPTIONS, NULLCP, "badCommunity: %s (%s)",
979: commname, source);
980: snmpstat.s_badcommunitynames++;
981: if (snmpstat.s_enableauthtraps == TRAPS_ENABLED)
982: do_trap (int_SNMP_generic__trap_authenticationFailure, 0,
983: (struct type_SNMP_VarBindList *) 0);
984: goto out;
985: }
986:
987: if ((result = do_operation (ps, msg, comm)) != DONE)
988: goto out;
989:
990: pe = NULLPE;
991:
992: if (encode_SNMP_Message (&pe, 1, 0, NULLCP, msg) != NOTOK) {
993: PLOGP (pgm_log,SNMP_Message, pe, "Message", 0);
994:
995: if (pe2ps (ps, pe) == NOTOK)
996: advise (LLOG_EXCEPTIONS, NULLCP, "pe2ps: %s (%s)",
997: ps_error (ps -> ps_errno), source);
998: else
999: snmpstat.s_outpkts++;
1000: }
1001: else
1002: advise (LLOG_EXCEPTIONS, NULLCP, "encode_SNMP_Message: %s (%s)",
1003: PY_pepy, source);
1004:
1005: if (pe)
1006: pe_free (pe);
1007:
1008: out: ;
1009: free (commname);
1010:
1011: return result;
1012: }
1013:
1014: /* */
1015:
1016: static int do_operation (ps, msg, comm)
1017: PS ps;
1018: struct type_SNMP_Message *msg;
1019: struct community *comm;
1020: {
1021: int idx,
1022: offset,
1023: status;
1024: object_instance ois;
1025: struct view *vu = comm -> c_view;
1026: register struct type_SNMP_PDUs *pdu = msg -> data;
1027: register struct type_SNMP_VarBindList *vp;
1028: register struct type_SNMP_GetResponse__PDU *parm = pdu -> un.get__response;
1029:
1030: idx = 0;
1031: switch (pdu -> offset) {
1032: case type_SNMP_PDUs_get__request:
1033: snmpstat.s_ingetrequests++;
1034: if (vu == NULL || !(comm -> c_permission & OT_RDONLY)) {
1035: access_denied: ;
1036: advise (LLOG_EXCEPTIONS, NULLCP,
1037: "authorizationFailure: %d (%s)", pdu -> offset,
1038: source);
1039: /* no trap for this... */
1040: idx = 0;
1041: offset = pdu -> offset;
1042: pdu -> offset = type_SNMP_PDUs_get__response;
1043: parm -> error__status = int_SNMP_error__status_noSuchName;
1044: goto out;
1045: }
1046: break;
1047: case type_SNMP_PDUs_get__next__request:
1048: snmpstat.s_ingetnexts++;
1049: if (vu == NULL || !(comm -> c_permission & OT_RDONLY))
1050: goto access_denied;
1051: break;
1052:
1053: case type_SNMP_PDUs_set__request:
1054: snmpstat.s_insetrequests++;
1055: if (vu == NULL || !(comm -> c_permission & OT_WRONLY))
1056: goto access_denied;
1057: break;
1058:
1059: case type_SNMP_PDUs_get__response:
1060: snmpstat.s_ingetresponses++;
1061: if (vu == NULL)
1062: goto access_denied;
1063: if ((comm -> c_permission & OT_YYY) && proxy2 (msg) != OK)
1064: return NOTOK;
1065: /* else fall... */
1066: case type_SNMP_PDUs_trap:
1067: snmpstat.s_intraps++;
1068: if (vu == NULL)
1069: goto access_denied;
1070: advise (LLOG_EXCEPTIONS, NULLCP,
1071: "unexpectedOperation: %d (%s)", pdu -> offset, source);
1072: snmpstat.s_badtypes++;
1073: return NOTOK;
1074:
1075: default:
1076: if (vu == NULL)
1077: goto access_denied;
1078: advise (LLOG_EXCEPTIONS, NULLCP,
1079: "badOperation: %d (%s)", pdu -> offset, source);
1080: snmpstat.s_badtypes++;
1081: return NOTOK;
1082: }
1083:
1084: if (vu -> v_community)
1085: return proxy1 (ps, msg, comm);
1086:
1087: offset = pdu -> offset;
1088: pdu -> offset = type_SNMP_PDUs_get__response;
1089:
1090: quantum++;
1091: for (vp = msg -> data -> un.get__request -> variable__bindings;
1092: vp;
1093: vp = vp -> next) {
1094: register OI oi;
1095: register OT ot;
1096: register struct type_SNMP_VarBind *v = vp -> VarBind;
1097:
1098: idx++;
1099:
1100: if (offset == type_SNMP_PDUs_get__next__request) {
1101: if ((oi = name2inst (v -> name)) == NULLOI
1102: && (oi = next2inst (v -> name)) == NULLOI)
1103: goto no_name;
1104:
1105: if ((ot = oi -> oi_type) -> ot_getfnx == NULLIFP
1106: && ot -> ot_smux == NULL)
1107: goto get_next;
1108: }
1109: else
1110: if ((oi = name2inst (v -> name)) == NULLOI
1111: || ((ot = oi -> oi_type) -> ot_getfnx == NULLIFP
1112: && ot -> ot_smux == NULL)) {
1113: no_name: ;
1114: parm -> error__status = int_SNMP_error__status_noSuchName;
1115: goto out;
1116: }
1117:
1118: try_again: ;
1119: switch (offset) {
1120: case type_SNMP_PDUs_get__request:
1121: if (!(vu -> v_mask & ot -> ot_views)) {
1122: snmpstat.s_badcommunityuses++;
1123: parm -> error__status = int_SNMP_error__status_noSuchName;
1124: goto out;
1125: }
1126: break;
1127:
1128: case type_SNMP_PDUs_get__next__request:
1129: if (!(vu -> v_mask & ot -> ot_views))
1130: goto get_next;
1131: break;
1132:
1133: case type_SNMP_PDUs_set__request:
1134: if (!(vu -> v_mask & ot -> ot_views)) {
1135: snmpstat.s_badcommunityuses++;
1136: parm -> error__status = int_SNMP_error__status_readOnly;
1137: goto out;
1138: }
1139: break;
1140: }
1141:
1142: #ifdef SMUX
1143: if (ot -> ot_smux)
1144: status = smux_getfnx (pdu, ot,
1145: ((struct smuxTree *) ot -> ot_smux)
1146: -> tb_peer,
1147: v, offset);
1148: else
1149: #endif
1150: status = (*ot -> ot_getfnx) (oi, v, offset);
1151:
1152: switch (status) {
1153: case NOTOK: /* get-next wants a bump */
1154: get_next: ;
1155: oi = &ois;
1156: for (;;) {
1157: if ((ot = ot -> ot_next) == NULLOT) {
1158: parm -> error__status =
1159: int_SNMP_error__status_noSuchName;
1160: goto out;
1161: }
1162: oi -> oi_name = (oi -> oi_type = ot) -> ot_name;
1163: if (ot -> ot_getfnx || ot -> ot_smux)
1164: goto try_again;
1165: }
1166:
1167: case int_SNMP_error__status_noError:
1168: break;
1169:
1170: default:
1171: parm -> error__status = status;
1172: goto out;
1173: }
1174: }
1175: idx = 0;
1176:
1177: out: ;
1178: parm -> error__index = idx;
1179: switch (parm -> error__status) {
1180: case int_SNMP_error__status_noError:
1181: idx = 0;
1182: for (vp = msg -> data -> un.get__request -> variable__bindings;
1183: vp;
1184: vp = vp -> next)
1185: idx++;
1186: switch (offset) {
1187: case type_SNMP_PDUs_get__request:
1188: case type_SNMP_PDUs_get__next__request:
1189: snmpstat.s_totalreqvars += idx;
1190: break;
1191:
1192: case type_SNMP_PDUs_set__request:
1193: snmpstat.s_totalsetvars += idx;
1194: break;
1195: }
1196: break;
1197:
1198: case int_SNMP_error__status_tooBig:
1199: snmpstat.s_toobigs++;
1200: break;
1201:
1202: case int_SNMP_error__status_noSuchName:
1203: snmpstat.s_nosuchnames++;
1204: break;
1205:
1206: case int_SNMP_error__status_badValue:
1207: snmpstat.s_badvalues++;
1208: break;
1209:
1210: case int_SNMP_error__status_readOnly:
1211: snmpstat.s_readonlys++;
1212: break;
1213:
1214: case int_SNMP_error__status_genErr:
1215: snmpstat.s_generrs++;
1216: break;
1217:
1218: default:
1219: break;
1220: }
1221: snmpstat.s_outgetresponses++;
1222:
1223: return DONE;
1224: }
1225:
1226: /* PROXY */
1227:
1228: static int proxy1 (psp, msg, comm)
1229: PS psp;
1230: struct type_SNMP_Message *msg;
1231: struct community *comm;
1232: {
1233: int result;
1234: register struct view *v = comm -> c_view;
1235: register struct proxyque *pq;
1236: PE pe;
1237: PS ps;
1238:
1239: if (qb_pullup (msg -> community) == NOTOK) {
1240: advise (LLOG_EXCEPTIONS, NULLCP, "qb_pullup: out of memory (proxy %s)",
1241: source);
1242: return NOTOK;
1243: }
1244: if (pqs >= NPQ) {
1245: register struct proxyque *qp;
1246:
1247: for (qp = (pq = pips) + NPQ; pq < qp; pq++)
1248: if (pq -> pq_age < quantum) {
1249: advise (LLOG_NOTICE, NULLCP, "proxy flush");
1250: if (pq -> pq_closefnx) {
1251: ps_free (pq -> pq_ps);
1252: (void) (*pq -> pq_closefnx) (pq -> pq_fd);
1253: }
1254: QBFREE (&pq -> pq_community);
1255: break;
1256: }
1257: if (pq >= qp) {
1258: advise (LLOG_EXCEPTIONS, NULLCP,
1259: "proxy for view %s, but no proxyque slots available (%s)",
1260: oid2ode (v -> v_name), source);
1261: return NOTOK;
1262: }
1263: }
1264: else
1265: pq = pips + pqs++;
1266:
1267: pq -> pq_quantum = quantum;
1268: pq -> pq_age = quantum + 20; /* who knows what a good value is?!? */
1269: pq -> pq_ps = psp;
1270: pq -> pq_community.qb_forw = pq -> pq_community.qb_back
1271: = &pq -> pq_community;
1272: insque (msg -> community -> qb_forw, &pq -> pq_community);
1273: free ((char *) msg -> community);
1274: pq -> pq_request = msg -> data -> un.get__request -> request__id;
1275:
1276: msg -> community = v -> v_community;
1277: msg -> data -> un.get__request -> request__id = pq -> pq_quantum;
1278:
1279: result = NOTOK;
1280: pe = NULLPE;
1281: if (encode_SNMP_Message (&pe, 1, 0, NULLCP, msg) == NOTOK) {
1282: advise (LLOG_EXCEPTIONS, NULLCP, "encode_SNMP_Message: %s (proxy %s)",
1283: PY_pepy, source);
1284: if (pe)
1285: pe_free (pe);
1286: goto out;
1287: }
1288: PLOGP (pgm_log,SNMP_Message, pe, "Message", 0);
1289:
1290: if ((ps = ps_alloc (dg_open)) == NULLPS
1291: || dg_setup (ps, udp, MAXDGRAM, read_udp_socket, write_udp_socket)
1292: == NOTOK) {
1293: if (ps == NULLPS)
1294: advise (LLOG_EXCEPTIONS, NULLCP,
1295: "ps_alloc: out of memory (proxy %s)", source);
1296: else
1297: advise (LLOG_EXCEPTIONS, NULLCP, "dg_setup: %s (proxy %s)",
1298: ps_error (ps -> ps_errno), source);
1299: }
1300: else
1301: if (hack_dgram_socket (udp, &v -> v_sa) == NOTOK)
1302: advise (LLOG_EXCEPTIONS, "failed",
1303: "hack_dgram_socket(1) (proxy %s)", source);
1304: else
1305: if (pe2ps (ps, pe) == NOTOK)
1306: advise (LLOG_EXCEPTIONS, NULLCP, "pe2ps: %s (proxy %s)",
1307: ps_error (ps -> ps_errno), source);
1308: else {
1309: result = OK;
1310:
1311: if (hack_dgram_socket (udp, (struct sockaddr *) NULL) == NOTOK)
1312: advise (LLOG_EXCEPTIONS, "failed",
1313: "hack_dgram_socket(2) (proxy %s)", source);
1314: }
1315:
1316: pe_free (pe);
1317:
1318: if (ps)
1319: ps_free (ps);
1320:
1321: out: ;
1322: msg -> community = NULL;
1323: if (result == NOTOK) {
1324: register struct proxyque *qp = pips + --pqs;
1325:
1326: if (pq -> pq_closefnx) {
1327: ps_free (pq -> pq_ps);
1328: (void) (*pq -> pq_closefnx) (pq -> pq_fd);
1329: }
1330: QBFREE (&pq -> pq_community);
1331:
1332: if (pq != qp)
1333: *pq = *qp; /* struct copy */
1334: }
1335: else
1336: pqr = pq;
1337:
1338: return result;
1339: }
1340:
1341: /* */
1342:
1343: static int proxy2 (msg)
1344: struct type_SNMP_Message *msg;
1345: {
1346: integer request;
1347: register struct proxyque *pq,
1348: *qp;
1349: PE pe;
1350:
1351: request = msg -> data -> un.get__request -> request__id;
1352: for (qp = (pq = pips) + pqs; pq < qp; pq++)
1353: if (pq -> pq_quantum == request)
1354: break;
1355: if (pq >= qp)
1356: return OK;
1357:
1358: qb_free (msg -> community);
1359: msg -> community = &pq -> pq_community;
1360: msg -> data -> un.get__request -> request__id = pq -> pq_request;
1361:
1362: pe = NULLPE;
1363: if (encode_SNMP_Message (&pe, 1, 0, NULLCP, msg) == NOTOK) {
1364: advise (LLOG_EXCEPTIONS, NULLCP, "encode_SNMP_Message: %s (proxy %s)",
1365: PY_pepy, source);
1366: if (pe)
1367: pe_free (pe);
1368: goto out;
1369: }
1370: PLOGP (pgm_log,SNMP_Message, pe, "Message", 0);
1371:
1372: if (pe2ps (pq -> pq_ps, pe) == NOTOK)
1373: advise (LLOG_EXCEPTIONS, NULLCP, "pe2ps: %s (proxy %s)",
1374: ps_error (pq -> pq_ps -> ps_errno), source);
1375: snmpstat.s_outgetresponses++;
1376:
1377: pe_free (pe);
1378:
1379: out: ;
1380: msg -> community = NULL;
1381:
1382: qp = pips + --pqs;
1383:
1384: if (pq -> pq_closefnx) {
1385: ps_free (pq -> pq_ps);
1386: (void) (*pq -> pq_closefnx) (pq -> pq_fd);
1387: }
1388: QBFREE (&pq -> pq_community);
1389:
1390: if (pq != qp)
1391: *pq = *qp; /* struct copy */
1392:
1393: return DONE;
1394: }
1395:
1396: /* */
1397:
1398: #ifdef COTS
1399: static proxy_clear (fd)
1400: int fd;
1401: {
1402: register struct proxyque *pq,
1403: *qp;
1404:
1405: again: ;
1406: for (qp = (pq = pips) + pqs; pq < qp; pq++)
1407: if (pq -> pq_fd == fd) {
1408: qp = pips + --pqs;
1409:
1410: if (pq -> pq_closefnx) {
1411: ps_free (pq -> pq_ps);
1412: (void) (*pq -> pq_closefnx) (pq -> pq_fd);
1413: }
1414: QBFREE (&pq -> pq_community);
1415:
1416: if (pq != qp)
1417: *pq = *qp;
1418: goto again;
1419: }
1420: }
1421: #endif
1422:
1423: /* SMUX */
1424:
1425: #ifdef SMUX
1426: #include "smux.h"
1427:
1428:
1429: static int start_smux ()
1430: {
1431: int fd;
1432: struct sockaddr_in in_socket;
1433: register struct sockaddr_in *isock = &in_socket;
1434: register struct smuxPeer *pb,
1435: *qb;
1436:
1437: if ((fd = join_tcp_client (smux, isock)) == NOTOK) {
1438: if (errno == EWOULDBLOCK)
1439: return NOTOK;
1440: adios ("failed", "join_tcp_client");
1441: }
1442:
1443: if ((pb = (struct smuxPeer *) calloc (1, sizeof *pb)) == NULL) {
1444: advise (LLOG_EXCEPTIONS, NULLCP, "doit_smux: out of memory");
1445: out: ;
1446: (void) close_tcp_socket (fd);
1447: return NOTOK;
1448: }
1449:
1450: pb -> pb_address = *isock; /* struct copy */
1451: (void) sprintf (pb -> pb_source, "%s/%d",
1452: inet_ntoa (pb -> pb_address.sin_addr),
1453: (int) ntohs (pb -> pb_address.sin_port));
1454: (void) strcpy (source, pb -> pb_source);
1455:
1456: if ((pb -> pb_ps = ps_alloc (fdx_open)) == NULLPS
1457: || fdx_setup (pb -> pb_ps, fd) == NOTOK) {
1458: if (pb -> pb_ps == NULLPS)
1459: advise (LLOG_EXCEPTIONS, NULLCP,
1460: "ps_alloc: out of memory (SMUX %s)", source);
1461: else
1462: advise (LLOG_EXCEPTIONS, NULLCP, "fdx_setup: %s (SMUX %s)",
1463: ps_error (pb -> pb_ps -> ps_errno), source);
1464:
1465: pb_free (pb);
1466: goto out;
1467: }
1468:
1469: for (qb = PHead -> pb_forw; qb != PHead; qb = qb -> pb_forw)
1470: if (qb -> pb_fd > fd)
1471: break;
1472: insque (pb, qb != PHead ? qb -> pb_forw : qb -> pb_back);
1473:
1474: return (pb -> pb_fd = fd);
1475: }
1476:
1477: /* */
1478:
1479: static int doit_smux (fd)
1480: int fd;
1481: {
1482: PE pe;
1483: register struct smuxPeer *pb;
1484: struct type_SNMP_SMUX__PDUs *pdu;
1485:
1486: for (pb = PHead -> pb_forw; pb != PHead; pb = pb -> pb_forw)
1487: if (pb -> pb_fd == fd)
1488: break;
1489: if (pb == PHead) {
1490: advise (LLOG_EXCEPTIONS, NULLCP, "lost smuxPeer block for %d", fd);
1491: FD_CLR (fd, &ifds);
1492: FD_CLR (fd, &sfds);
1493:
1494: return;
1495: }
1496:
1497: (void) strcpy (source, pb -> pb_source);
1498:
1499: if ((pe = ps2pe (pb -> pb_ps)) == NULLPE) {
1500: advise (LLOG_EXCEPTIONS, NULLCP, "ps2pe: %s (SMUX %s)",
1501: ps_error (pb -> pb_ps -> ps_errno), source);
1502:
1503: out: ;
1504: if (pe)
1505: pe_free (pe);
1506: pb_free (pb);
1507: return;
1508: }
1509:
1510: advise (LLOG_XXX, NULLCP, "SMUX packet from %s", source);
1511:
1512: pdu = NULL;
1513:
1514: if (decode_SNMP_SMUX__PDUs (pe, 1, NULLIP, NULLVP, &pdu) == NOTOK) {
1515: advise (LLOG_EXCEPTIONS, NULLCP,
1516: "decode_SNMP_SMUX__PDUs: %s (SMUX %s)", PY_pepy, source);
1517: goto out;
1518: }
1519:
1520: PLOGP (pgm_log,SNMP_SMUX__PDUs, pe, "SMUX Message", 1);
1521:
1522: if (smux_process (pb, pdu) == NOTOK)
1523: pb_free (pb);
1524:
1525: if (pdu)
1526: free_SNMP_SMUX__PDUs (pdu);
1527: if (pe)
1528: pe_free (pe);
1529: }
1530:
1531: /* */
1532:
1533: static smux_process (pb, pdu)
1534: register struct smuxPeer *pb;
1535: struct type_SNMP_SMUX__PDUs *pdu;
1536: {
1537: int result = OK;
1538:
1539: switch (pdu -> offset) {
1540: case type_SNMP_SMUX__PDUs_simple:
1541: if (pb -> pb_identity)
1542: goto unexpected;
1543: {
1544: register struct type_SNMP_SimpleOpen *simple =
1545: pdu -> un.simple;
1546: register struct smuxEntry *se;
1547:
1548: if (simple -> version != int_SNMP_version_version__1) {
1549: advise (LLOG_EXCEPTIONS, NULLCP,
1550: "badVersion: %d (SMUX %s)",
1551: simple -> version, source);
1552: return NOTOK;
1553: }
1554:
1555: pb -> pb_identity = simple -> identity;
1556: simple -> identity = NULL;
1557:
1558: if ((pb -> pb_description = qb2str (simple -> description))
1559: == NULL) {
1560: advise (LLOG_EXCEPTIONS, NULLCP,
1561: "qb2str: out of memory (SMUX %s)", source);
1562: return NOTOK;
1563: }
1564:
1565: if (qb_pullup (simple -> password) == NOTOK) {
1566: advise (LLOG_EXCEPTIONS, NULLCP,
1567: "qb_pullup: out of memory (SMUX %s)", source);
1568: return NOTOK;
1569: }
1570:
1571: if ((se = getsmuxEntrybyidentity (pb -> pb_identity)) == NULL
1572: || strcmp (se -> se_password,
1573: simple -> password -> qb_forw -> qb_data)) {
1574: advise (LLOG_EXCEPTIONS, NULLCP,
1575: "%s: %s (SMUX %s)",
1576: se ? "badPassword" : "badIdentity",
1577: oid2ode (simple -> identity), source);
1578: if (snmpstat.s_enableauthtraps == TRAPS_ENABLED)
1579: do_trap (int_SNMP_generic__trap_authenticationFailure,
1580: 0, (struct type_SNMP_VarBindList *) 0);
1581: return NOTOK;
1582: }
1583:
1584: if ((pb -> pb_priority = se -> se_priority) < 0)
1585: pb -> pb_priority = 0;
1586:
1587: advise (LLOG_NOTICE, NULLCP,
1588: "SMUX open: %d %s \"%s\" (%s)",
1589: pb -> pb_fd, oid2ode (pb -> pb_identity),
1590: pb -> pb_description, source);
1591: }
1592: break;
1593:
1594: case type_SNMP_SMUX__PDUs_close:
1595: if (!pb -> pb_identity)
1596: goto unexpected;
1597: advise (LLOG_NOTICE, NULLCP,
1598: "SMUX close: %s (%s)",
1599: smux_error (pdu -> un.close -> parm), source);
1600: return NOTOK;
1601:
1602: case type_SNMP_SMUX__PDUs_registerRequest:
1603: if (!pb -> pb_identity)
1604: goto unexpected;
1605: {
1606: register struct type_SNMP_RReqPDU *rreq =
1607: pdu -> un.registerRequest;
1608: struct type_SNMP_RRspPDU rrsp;
1609: struct type_SNMP_SMUX__PDUs rsp;
1610: register struct smuxReserved *sr;
1611: register struct smuxTree *tb = NULL;
1612: register struct smuxTree *qb;
1613: register OID oid = rreq -> subtree;
1614: OT ot = NULLOT;
1615: PE pe;
1616:
1617: for (sr = reserved; sr -> rb_text; sr++)
1618: if (sr -> rb_name
1619: && bcmp ((char *) sr -> rb_name -> oid_elements,
1620: (char *) oid -> oid_elements,
1621: (sr -> rb_name -> oid_nelem
1622: <= oid -> oid_nelem
1623: ? sr -> rb_name -> oid_nelem
1624: : oid -> oid_nelem)
1625: * sizeof oid -> oid_elements[0])
1626: == 0) {
1627: advise (LLOG_EXCEPTIONS, NULLCP,
1628: "reservedSubTree: %s %s %s (SMUX %s)",
1629: oid2ode (oid),
1630: sr -> rb_name -> oid_nelem
1631: <= oid -> oid_nelem
1632: ? "under" : "contains",
1633: sr -> rb_text, source);
1634: goto no_dice;
1635: }
1636:
1637: if ((ot = name2obj (oid)) == NULLOT) {
1638: if (rreq -> operation == int_SNMP_operation_delete) {
1639: advise (LLOG_EXCEPTIONS, NULLCP,
1640: "noSuchSubTree: %s (SMUX %s)",
1641: oid2ode (oid), source);
1642: goto no_dice;
1643: }
1644:
1645: if ((ot = (OT) calloc (1, sizeof *ot)) == NULL
1646: || (ot -> ot_text = ot -> ot_id =
1647: strdup (sprintoid (oid)))
1648: == NULL) {
1649: advise (LLOG_EXCEPTIONS, NULLCP,
1650: "out of memory (SMUX %s)", source);
1651: if (ot)
1652: free ((char *) ot);
1653: return NOTOK;
1654: }
1655: ot -> ot_name = rreq -> subtree;
1656: rreq -> subtree = NULL;
1657: ot -> ot_access = rreq -> operation;
1658: ot -> ot_status = OT_OPTIONAL;
1659: export_view (ot);
1660:
1661: add_objects (ot);
1662: }
1663: else {
1664: if (rreq -> operation == int_SNMP_operation_delete) {
1665: for (tb = (struct smuxTree *) ot -> ot_smux;
1666: tb;
1667: tb = tb -> tb_next)
1668: if (tb -> tb_peer == pb
1669: && (rreq -> priority < 0
1670: || rreq -> priority
1671: == tb -> tb_priority))
1672: break;
1673: if (tb)
1674: tb_free (tb);
1675: else {
1676: advise (LLOG_EXCEPTIONS, NULLCP,
1677: "noSuchRegistration: %s (SMUX %s)",
1678: oid2ode (oid), source);
1679: ot = NULLOT;
1680: }
1681: goto no_dice;
1682: }
1683:
1684: if (ot -> ot_name -> oid_nelem > oid -> oid_nelem) {
1685: advise (LLOG_EXCEPTIONS, NULLCP,
1686: "badSubTree: %s (SMUX %s)",
1687: oid2ode (oid), source);
1688: ot = NULL;
1689: goto no_dice;
1690: }
1691: }
1692:
1693: if ((tb = (struct smuxTree *) calloc (1, sizeof *tb))
1694: == NULL) {
1695: advise (LLOG_EXCEPTIONS, NULLCP,
1696: "out of memory (SMUX %s)", source);
1697: return NOTOK;
1698: }
1699:
1700: if ((tb -> tb_priority = rreq -> priority) < pb -> pb_priority)
1701: tb -> tb_priority = pb -> pb_priority;
1702: for (qb = (struct smuxTree *) ot -> ot_smux;
1703: qb;
1704: qb = qb -> tb_next)
1705: if (qb -> tb_priority > tb -> tb_priority)
1706: break;
1707: else
1708: if (qb -> tb_priority == tb -> tb_priority)
1709: tb -> tb_priority++;
1710:
1711: tb -> tb_peer = pb;
1712:
1713: no_dice: ;
1714: bzero ((char *) &rsp, sizeof rsp);
1715: rsp.offset = type_SNMP_SMUX__PDUs_registerResponse;
1716: rsp.un.registerResponse = &rrsp;
1717:
1718: bzero ((char *) &rrsp, sizeof rrsp);
1719: rrsp.parm = tb ? tb -> tb_priority
1720: : int_SNMP_RRspPDU_failure;
1721:
1722: pe = NULLPE;
1723:
1724: if (encode_SNMP_SMUX__PDUs (&pe, 1, 0, NULLCP, &rsp)
1725: != NOTOK) {
1726: PLOGP (pgm_log,SNMP_SMUX__PDUs, pe, "SMUX Message", 0);
1727:
1728: if (pe2ps (pb -> pb_ps, pe) == NOTOK) {
1729: advise (LLOG_EXCEPTIONS, NULLCP, "pe2ps: %s (SMUX %s)",
1730: ps_error (pb -> pb_ps -> ps_errno), source);
1731: result = NOTOK;
1732: }
1733: else {
1734: if (ot)
1735: advise (LLOG_NOTICE, NULLCP,
1736: "SMUX register: %s %s in=%d out=%d (%s)",
1737: rreq -> operation
1738: == int_SNMP_operation_delete ? "delete"
1739: : rreq -> operation
1740: == int_SNMP_operation_readOnly
1741: ? "readOnly" : "readWrite",
1742: oid2ode (ot -> ot_name),
1743: rreq -> priority,
1744: tb ? tb -> tb_priority : -1, source);
1745:
1746: if (tb
1747: && rreq -> operation
1748: != int_SNMP_operation_delete) {
1749: register int i;
1750: register unsigned int *ip,
1751: *jp;
1752: register struct smuxTree **qpp;
1753:
1754: tb -> tb_subtree = ot;
1755:
1756: for (qb = ot -> ot_smux
1757: ? (struct smuxTree *) ot -> ot_smux
1758: : THead -> tb_forw;
1759: qb != THead;
1760: qb = qb -> tb_forw)
1761: if ((i = oid_cmp (qb -> tb_subtree -> ot_name,
1762: ot -> ot_name)) > 0
1763: || (i == 0
1764: && qb -> tb_priority
1765: > tb -> tb_priority))
1766: break;
1767: insque (tb, qb != THead ? qb -> tb_forw
1768: : qb -> tb_back);
1769:
1770: for (qpp = (struct smuxTree **) &ot -> ot_smux;
1771: qb = *qpp;
1772: qpp = &qb -> tb_next)
1773: if (qb -> tb_priority > tb -> tb_priority)
1774: break;
1775: tb -> tb_next = qb;
1776: *qpp = tb;
1777:
1778: ip = tb -> tb_instance;
1779: jp = ot -> ot_name -> oid_elements;
1780: for (*ip++ = (i = ot -> ot_name -> oid_nelem);
1781: i > 0;
1782: i--)
1783: *ip++ = *jp++;
1784: *ip++ = tb -> tb_priority;
1785: tb -> tb_insize = ip - tb -> tb_instance;
1786: }
1787: }
1788: }
1789: else {
1790: advise (LLOG_EXCEPTIONS, NULLCP,
1791: "encode_SNMP_SMUX__PDUs: %s (SMUX %s)",
1792: PY_pepy, source);
1793: result = NOTOK;
1794: }
1795:
1796: if (pe)
1797: pe_free (pe);
1798: }
1799: break;
1800:
1801: case type_SNMP_SMUX__PDUs_trap:
1802: if (!pb -> pb_identity)
1803: goto unexpected;
1804: {
1805: struct qbuf *qb;
1806: struct type_SNMP_Message msgs;
1807: register struct type_SNMP_Message *msg = &msgs;
1808: struct type_SNMP_PDUs datas;
1809: register struct type_SNMP_PDUs *data = &datas;
1810: register struct type_SNMP_Trap__PDU *parm = pdu -> un.trap;
1811:
1812: advise (LLOG_NOTICE, NULLCP,
1813: "SMUX trap: %d %d (%s)",
1814: parm -> generic__trap, parm -> specific__trap, source);
1815:
1816: bzero ((char *) msg, sizeof *msg);
1817: msg -> version = int_SNMP_version_version__1;
1818: msg -> data = data;
1819:
1820: bzero ((char *) data, sizeof *data);
1821: data -> offset = type_SNMP_PDUs_trap;
1822: data -> un.trap = parm;
1823:
1824: if (loopback_addr
1825: && qb_pullup (qb = parm -> agent__addr) != NOTOK
1826: && qb -> qb_len == loopback_addr -> qb_len
1827: && bcmp (qb -> qb_forw -> qb_data,
1828: loopback_addr -> qb_forw -> qb_data,
1829: qb -> qb_len) == 0)
1830: parm -> agent__addr = trap -> data -> un.trap->agent__addr;
1831: do_traps (msg, parm -> generic__trap, parm -> specific__trap);
1832: parm -> agent__addr = qb;
1833: }
1834: break;
1835:
1836: case type_SNMP_SMUX__PDUs_registerResponse:
1837: case type_SNMP_SMUX__PDUs_get__request:
1838: case type_SNMP_SMUX__PDUs_get__next__request:
1839: case type_SNMP_SMUX__PDUs_get__response:
1840: case type_SNMP_SMUX__PDUs_set__request:
1841: unexpected: ;
1842: advise (LLOG_EXCEPTIONS, NULLCP,
1843: "unexpectedOperation: %d (SMUX %s)", pdu -> offset,
1844: source);
1845: return NOTOK;
1846:
1847: default:
1848: advise (LLOG_EXCEPTIONS, NULLCP,
1849: "badOperation: %d (SMUX %s)", pdu -> offset, source);
1850: return NOTOK;
1851: }
1852:
1853: return result;
1854: }
1855:
1856: /* */
1857:
1858: static int smux_getfnx (pdu, ot, pb, v, offset)
1859: struct type_SNMP_PDUs *pdu;
1860: OT ot;
1861: register struct smuxPeer *pb;
1862: register struct type_SNMP_VarBind *v;
1863: int offset;
1864: {
1865: int status,
1866: orig_id;
1867: struct type_SNMP_VarBindList *orig_bindings,
1868: vps;
1869: struct type_SNMP_SMUX__PDUs req,
1870: *rsp;
1871: register struct type_SNMP_GetResponse__PDU *get;
1872: PE pe;
1873:
1874: status = int_SNMP_error__status_noError;
1875: orig_id = pdu -> un.get__request -> request__id;
1876: orig_bindings = pdu -> un.get__request -> variable__bindings;
1877:
1878: bzero ((char *) &req, sizeof req);
1879: req.offset = offset == type_SNMP_PDUs_get__request
1880: ? type_SNMP_SMUX__PDUs_get__request
1881: : type_SNMP_SMUX__PDUs_get__next__request;
1882: req.un.get__request = pdu -> un.get__request;
1883:
1884: pdu -> un.get__request -> request__id = quantum;
1885:
1886: bzero ((char *) &vps, sizeof vps);
1887: vps.VarBind = v;
1888: pdu -> un.get__request -> variable__bindings = &vps;
1889:
1890: pe = NULLPE;
1891:
1892: if (encode_SNMP_SMUX__PDUs (&pe, 1, 0, NULLCP, &req) != NOTOK) {
1893: PLOGP (pgm_log,SNMP_SMUX__PDUs, pe, "SMUX Message", 0);
1894:
1895: if (pe2ps (pb -> pb_ps, pe) == NOTOK) {
1896: advise (LLOG_EXCEPTIONS, NULLCP, "pe2ps: %s (%s, SMUX %s)",
1897: ps_error (pb -> pb_ps -> ps_errno), source,
1898: pb -> pb_source);
1899:
1900: lost_peer: ;
1901: pb_free (pb);
1902: status = int_SNMP_error__status_genErr;
1903: }
1904: }
1905: else {
1906: advise (LLOG_EXCEPTIONS, NULLCP,
1907: "encode_SNMP_SMUX__PDUs: %s (%s)", PY_pepy, source);
1908: status = int_SNMP_error__status_genErr;
1909: }
1910:
1911: if (pe)
1912: pe_free (pe);
1913:
1914: pdu -> un.get__request -> request__id = orig_id;
1915: pdu -> un.get__request -> variable__bindings = orig_bindings;
1916:
1917: if (status != int_SNMP_error__status_noError)
1918: return status;
1919:
1920: if ((pe = ps2pe (pb -> pb_ps)) == NULLPE) {
1921: advise (LLOG_EXCEPTIONS, NULLCP, "ps2pe: %s (%s, SMUX %s)",
1922: ps_error (pb -> pb_ps -> ps_errno), source,
1923: pb -> pb_source);
1924:
1925: goto lost_peer;
1926: }
1927:
1928:
1929: rsp = NULL;
1930:
1931: if (decode_SNMP_SMUX__PDUs (pe, 1, NULLIP, NULLVP, &rsp) == NOTOK) {
1932: advise (LLOG_EXCEPTIONS, NULLCP,
1933: "decode_SNMP_SMUX__PDUs: %s (%s, SMUX %s)", PY_pepy, source,
1934: pb -> pb_source);
1935:
1936: lost_peer_again: ;
1937: pb_free (pb);
1938: status = int_SNMP_error__status_genErr;
1939: goto out;
1940: }
1941:
1942: PLOGP (pgm_log,SNMP_SMUX__PDUs, pe, "SMUX Message", 1);
1943:
1944: if (rsp -> offset != type_SNMP_SMUX__PDUs_get__response) {
1945: advise (LLOG_EXCEPTIONS, NULLCP,
1946: "unexpectedOperation: %d (%s, SMUX %s)", rsp -> offset,
1947: source, pb -> pb_source);
1948:
1949: goto lost_peer_again;
1950: }
1951: get = rsp -> un.get__response;
1952:
1953: switch (status = get -> error__status) {
1954: case int_SNMP_error__status_noError:
1955: {
1956: register struct type_SNMP_VarBindList *vp;
1957: register struct type_SNMP_VarBind *v2;
1958:
1959: if ((vp = get -> variable__bindings) == NULL) {
1960: advise (LLOG_EXCEPTIONS, NULLCP,
1961: "missing variable in get response (%s, SMUX %s)",
1962: source, pb -> pb_source);
1963:
1964: goto lost_peer_again;
1965: }
1966: v2 = vp -> VarBind;
1967:
1968: if (offset == type_SNMP_PDUs_get__next__request
1969: && (ot -> ot_name -> oid_nelem
1970: > v2 -> name -> oid_nelem
1971: || bcmp ((char *) ot -> ot_name ->oid_elements,
1972: (char *) v2 -> name -> oid_elements,
1973: ot -> ot_name -> oid_nelem
1974: * sizeof ot -> ot_name ->
1975: oid_elements[0]))) {
1976: status = NOTOK;
1977: break;
1978: }
1979: free_SNMP_ObjectName (v -> name);
1980: v -> name = v2 -> name;
1981: v2 -> name = NULL;
1982: free_SNMP_ObjectSyntax (v -> value);
1983: v -> value = v2 -> value;
1984: v2 -> value = NULL;
1985: }
1986: break;
1987:
1988: case int_SNMP_error__status_noSuchName:
1989: if (offset == type_SNMP_PDUs_get__next__request) {
1990: status = NOTOK;
1991: break;
1992: }
1993: /* else fall */
1994:
1995: default:
1996: break;
1997: }
1998:
1999: out: ;
2000: if (rsp)
2001: free_SNMP_SMUX__PDUs (rsp);
2002: if (pe)
2003: pe_free (pe);
2004:
2005: return status;
2006: }
2007:
2008: /* */
2009:
2010: static pb_free (pb)
2011: register struct smuxPeer *pb;
2012: {
2013: register struct smuxTree *tb,
2014: *ub;
2015:
2016: if (pb == NULL)
2017: return;
2018:
2019: for (tb = THead -> tb_forw; tb != THead; tb = ub) {
2020: ub = tb -> tb_forw;
2021:
2022: if (tb -> tb_peer == pb)
2023: tb_free (tb);
2024: }
2025:
2026: if (pb -> pb_ps)
2027: ps_free (pb -> pb_ps);
2028:
2029: if (pb -> pb_fd != NOTOK) {
2030: (void) close_tcp_socket (pb -> pb_fd);
2031: FD_CLR (pb -> pb_fd, &ifds);
2032: FD_CLR (pb -> pb_fd, &sfds);
2033: }
2034:
2035: if (pb -> pb_identity)
2036: oid_free (pb -> pb_identity);
2037: if (pb -> pb_description)
2038: free (pb -> pb_description);
2039:
2040: remque (pb);
2041:
2042: free ((char *) pb);
2043: }
2044:
2045: /* */
2046:
2047: static tb_free (tb)
2048: register struct smuxTree *tb;
2049: {
2050: register struct smuxTree *tp,
2051: **tpp;
2052:
2053: if (tb == NULL)
2054: return;
2055:
2056: for (tpp = (struct smuxTree **) &tb -> tb_subtree -> ot_smux;
2057: tp = *tpp;
2058: tpp = &tp -> tb_next)
2059: if (tp == tb) {
2060: *tpp = tb -> tb_next;
2061: break;
2062: }
2063:
2064: remque (tb);
2065:
2066: free ((char *) tb);
2067: }
2068: #endif
2069:
2070: /* SNMP GROUP */
2071:
2072: static init_snmp ()
2073: {
2074: register OT ot;
2075:
2076: if (ot = text2obj ("snmpInPkts"))
2077: ot -> ot_getfnx = o_generic,
2078: ot -> ot_info = (caddr_t) &snmpstat.s_inpkts;
2079: if (ot = text2obj ("snmpOutPkts"))
2080: ot -> ot_getfnx = o_generic,
2081: ot -> ot_info = (caddr_t) &snmpstat.s_outpkts;
2082: if (ot = text2obj ("snmpInBadVersions"))
2083: ot -> ot_getfnx = o_generic,
2084: ot -> ot_info = (caddr_t) &snmpstat.s_badversions;
2085: if (ot = text2obj ("snmpInBadCommunityNames"))
2086: ot -> ot_getfnx = o_generic,
2087: ot -> ot_info = (caddr_t) &snmpstat.s_badcommunitynames;
2088: if (ot = text2obj ("snmpInBadCommunityUses"))
2089: ot -> ot_getfnx = o_generic,
2090: ot -> ot_info = (caddr_t) &snmpstat.s_badcommunityuses;
2091: if (ot = text2obj ("snmpInASNParseErrs"))
2092: ot -> ot_getfnx = o_generic,
2093: ot -> ot_info = (caddr_t) &snmpstat.s_asnparseerrs;
2094: if (ot = text2obj ("snmpInBadTypes"))
2095: ot -> ot_getfnx = o_generic,
2096: ot -> ot_info = (caddr_t) &snmpstat.s_badtypes;
2097: if (ot = text2obj ("snmpInTotalReqVars"))
2098: ot -> ot_getfnx = o_generic,
2099: ot -> ot_info = (caddr_t) &snmpstat.s_totalreqvars;
2100: if (ot = text2obj ("snmpInTotalSetVars"))
2101: ot -> ot_getfnx = o_generic,
2102: ot -> ot_info = (caddr_t) &snmpstat.s_totalsetvars;
2103: if (ot = text2obj ("snmpInGetRequests"))
2104: ot -> ot_getfnx = o_generic,
2105: ot -> ot_info = (caddr_t) &snmpstat.s_ingetrequests;
2106: if (ot = text2obj ("snmpInGetNexts"))
2107: ot -> ot_getfnx = o_generic,
2108: ot -> ot_info = (caddr_t) &snmpstat.s_ingetnexts;
2109: if (ot = text2obj ("snmpInSetRequests"))
2110: ot -> ot_getfnx = o_generic,
2111: ot -> ot_info = (caddr_t) &snmpstat.s_insetrequests;
2112: if (ot = text2obj ("snmpInGetResponses"))
2113: ot -> ot_getfnx = o_generic,
2114: ot -> ot_info = (caddr_t) &snmpstat.s_ingetresponses;
2115: if (ot = text2obj ("snmpInTraps"))
2116: ot -> ot_getfnx = o_generic,
2117: ot -> ot_info = (caddr_t) &snmpstat.s_intraps;
2118: if (ot = text2obj ("snmpOutTooBigs"))
2119: ot -> ot_getfnx = o_generic,
2120: ot -> ot_info = (caddr_t) &snmpstat.s_toobigs;
2121: if (ot = text2obj ("snmpOutNoSuchNames"))
2122: ot -> ot_getfnx = o_generic,
2123: ot -> ot_info = (caddr_t) &snmpstat.s_nosuchnames;
2124: if (ot = text2obj ("snmpOutBadValues"))
2125: ot -> ot_getfnx = o_generic,
2126: ot -> ot_info = (caddr_t) &snmpstat.s_badvalues;
2127: if (ot = text2obj ("snmpOutReadOnlys"))
2128: ot -> ot_getfnx = o_generic,
2129: ot -> ot_info = (caddr_t) &snmpstat.s_readonlys;
2130: if (ot = text2obj ("snmpOutGenErrs"))
2131: ot -> ot_getfnx = o_generic,
2132: ot -> ot_info = (caddr_t) &snmpstat.s_generrs;
2133: if (ot = text2obj ("snmpOutGetResponses"))
2134: ot -> ot_getfnx = o_generic,
2135: ot -> ot_info = (caddr_t) &snmpstat.s_outgetresponses;
2136: if (ot = text2obj ("snmpOutTraps"))
2137: ot -> ot_getfnx = o_generic,
2138: ot -> ot_info = (caddr_t) &snmpstat.s_outtraps;
2139: if (ot = text2obj ("snmpEnableAuthTraps"))
2140: ot -> ot_getfnx = o_generic,
2141: ot -> ot_info = (caddr_t) &snmpstat.s_enableauthtraps;
2142:
2143: if (ot = text2obj ("unixNetstat"))
2144: ot -> ot_getfnx = o_generic,
2145: ot -> ot_info = (caddr_t) &unix_netstat;
2146: }
2147:
2148: /* SMUX GROUP */
2149:
2150: #ifdef SMUX
2151: #define smuxPindex 0
2152: #define smuxPidentity 1
2153: #define smuxPdescription 2
2154: #define smuxPstatus 3
2155:
2156: #define PB_VALID 1 /* smuxPstatus */
2157: #define PB_CONNECTING 2 /* .. */
2158:
2159:
2160: static int o_smuxPeer (oi, v, offset)
2161: OI oi;
2162: register struct type_SNMP_VarBind *v;
2163: int offset;
2164: {
2165: int ifnum,
2166: ifvar;
2167: register struct smuxPeer *pb;
2168: register OID oid = oi -> oi_name;
2169: register OT ot = oi -> oi_type;
2170:
2171: ifvar = (int) ot -> ot_info;
2172: switch (offset) {
2173: case type_SNMP_PDUs_get__request:
2174: if (oid -> oid_nelem != ot -> ot_name -> oid_nelem + 1)
2175: return int_SNMP_error__status_noSuchName;
2176: ifnum = oid -> oid_elements[oid -> oid_nelem - 1];
2177: for (pb = PHead -> pb_forw; pb != PHead; pb = pb -> pb_forw)
2178: if (pb -> pb_fd == ifnum)
2179: break;
2180: if (pb == PHead
2181: || ((ifvar == smuxPidentity || ifvar == smuxPdescription)
2182: && pb -> pb_identity == NULL))
2183: return int_SNMP_error__status_noSuchName;
2184: break;
2185:
2186: case type_SNMP_PDUs_get__next__request:
2187: again: ;
2188: if (oid -> oid_nelem == ot -> ot_name -> oid_nelem) {
2189: OID new;
2190:
2191: if ((pb = PHead -> pb_forw) == PHead)
2192: return NOTOK;
2193: ifnum = pb -> pb_fd;
2194:
2195: if ((new = oid_extend (oid, 1)) == NULLOID)
2196: return int_SNMP_error__status_genErr;
2197: new -> oid_elements[new -> oid_nelem - 1] = ifnum;
2198:
2199: if (v -> name)
2200: free_SNMP_ObjectName (v -> name);
2201: v -> name = new;
2202: }
2203: else {
2204: int i = ot -> ot_name -> oid_nelem;
2205:
2206: ifnum = oid -> oid_elements[i];
2207: for (pb = PHead -> pb_forw; pb != PHead; pb = pb -> pb_forw)
2208: if (pb -> pb_fd >= ifnum)
2209: break;
2210: if (pb == PHead
2211: || ((pb -> pb_fd == ifnum)
2212: && (pb = pb -> pb_forw) == PHead))
2213: return NOTOK;
2214: ifnum = pb -> pb_fd;
2215:
2216: oid -> oid_elements[i] = ifnum;
2217: oid -> oid_nelem = i + 1;
2218: }
2219: if ((ifvar == smuxPidentity || ifvar == smuxPdescription)
2220: && pb -> pb_identity == NULL)
2221: goto again;
2222: break;
2223:
2224: default:
2225: return int_SNMP_error__status_genErr;
2226: }
2227:
2228: switch (ifvar) {
2229: case smuxPindex:
2230: return o_integer (oi, v, pb -> pb_fd);
2231:
2232: case smuxPidentity:
2233: return o_specific (oi, v, (caddr_t) pb -> pb_identity);
2234:
2235: case smuxPdescription:
2236: return o_string (oi, v, pb -> pb_description,
2237: strlen (pb -> pb_description));
2238:
2239: case smuxPstatus:
2240: return o_integer (oi, v, pb -> pb_identity ? PB_VALID
2241: : PB_CONNECTING);
2242:
2243: default:
2244: return int_SNMP_error__status_noSuchName;
2245: }
2246: }
2247:
2248: /* */
2249:
2250: static struct smuxTree *get_tbent (ip, len, isnext)
2251: register unsigned int *ip;
2252: int len;
2253: int isnext;
2254: {
2255: register struct smuxTree *tb;
2256:
2257: for (tb = THead -> tb_forw; tb != THead; tb = tb -> tb_forw)
2258: switch (elem_cmp (tb -> tb_instance, tb -> tb_insize, ip, len)) {
2259: case 0:
2260: if (!isnext)
2261: return tb;
2262: if ((tb = tb -> tb_forw) == THead)
2263: return NULL;
2264: /* else fall... */
2265:
2266: case 1:
2267: return (isnext ? tb : NULL);
2268: }
2269:
2270: return NULL;
2271: }
2272:
2273: /* */
2274:
2275: #define smuxTsubtree 0
2276: #define smuxTpriority 1
2277: #define smuxTindex 2
2278: #define smuxTstatus 3
2279:
2280: #define TB_VALID 1 /* smuxTstatus */
2281:
2282:
2283: static int o_smuxTree (oi, v, offset)
2284: OI oi;
2285: register struct type_SNMP_VarBind *v;
2286: int offset;
2287: {
2288: int ifvar;
2289: register int i;
2290: register unsigned int *ip,
2291: *jp;
2292: register struct smuxTree *tb;
2293: register OID oid = oi -> oi_name;
2294: register OT ot = oi -> oi_type;
2295:
2296: ifvar = (int) ot -> ot_info;
2297: switch (offset) {
2298: case type_SNMP_PDUs_get__request:
2299: if (oid -> oid_nelem <= ot -> ot_name -> oid_nelem)
2300: return int_SNMP_error__status_noSuchName;
2301: if ((tb = get_tbent (oid -> oid_elements
2302: + ot -> ot_name -> oid_nelem,
2303: oid -> oid_nelem
2304: - ot -> ot_name -> oid_nelem, 0)) == NULL)
2305: return int_SNMP_error__status_noSuchName;
2306: break;
2307:
2308: case type_SNMP_PDUs_get__next__request:
2309: if (oid -> oid_nelem == ot -> ot_name -> oid_nelem) {
2310: OID new;
2311:
2312: if ((tb = THead -> tb_forw) == THead)
2313: return NOTOK;
2314:
2315: if ((new = oid_extend (oid, tb -> tb_insize)) == NULLOID)
2316: return int_SNMP_error__status_genErr;
2317: ip = new -> oid_elements + new -> oid_nelem - tb -> tb_insize;
2318: jp = tb -> tb_instance;
2319: for (i = tb -> tb_insize; i > 0; i--)
2320: *ip++ = *jp++;
2321:
2322: if (v -> name)
2323: free_SNMP_ObjectName (v -> name);
2324: v -> name = new;
2325: }
2326: else {
2327: int j;
2328:
2329: if ((tb = get_tbent (oid -> oid_elements
2330: + ot -> ot_name -> oid_nelem,
2331: j = oid -> oid_nelem
2332: - ot -> ot_name -> oid_nelem, 1))
2333: == NULL)
2334: return NOTOK;
2335:
2336: if ((i = j - tb -> tb_insize) < 0) {
2337: OID new;
2338:
2339: if ((new = oid_extend (oid, -i)) == NULLOID)
2340: return int_SNMP_error__status_genErr;
2341: if (v -> name)
2342: free_SNMP_ObjectName (v -> name);
2343: v -> name = new;
2344:
2345: oid = new;
2346: }
2347: else
2348: if (i > 0)
2349: oid -> oid_nelem -= i;
2350:
2351: ip = oid -> oid_elements + ot -> ot_name -> oid_nelem;
2352: jp = tb -> tb_instance;
2353: for (i = tb -> tb_insize; i > 0; i--)
2354: *ip++ = *jp++;
2355: }
2356: break;
2357:
2358: default:
2359: return int_SNMP_error__status_genErr;
2360: }
2361:
2362: switch (ifvar) {
2363: case smuxTsubtree:
2364: return o_specific (oi, v, (caddr_t) tb -> tb_subtree -> ot_name);
2365:
2366: case smuxTpriority:
2367: return o_integer (oi, v, tb -> tb_priority);
2368:
2369: case smuxTindex:
2370: return o_integer (oi, v, tb -> tb_peer -> pb_fd);
2371:
2372: case smuxTstatus:
2373: return o_integer (oi, v, TB_VALID);
2374:
2375: default:
2376: return int_SNMP_error__status_noSuchName;
2377: }
2378: }
2379:
2380: /* */
2381:
2382: static init_smux ()
2383: {
2384: register OT ot;
2385:
2386: if (ot = text2obj ("smuxPindex"))
2387: ot -> ot_getfnx = o_smuxPeer,
2388: ot -> ot_info = (caddr_t) smuxPindex;
2389: if (ot = text2obj ("smuxPidentity"))
2390: ot -> ot_getfnx = o_smuxPeer,
2391: ot -> ot_info = (caddr_t) smuxPidentity;
2392: if (ot = text2obj ("smuxPdescription"))
2393: ot -> ot_getfnx = o_smuxPeer,
2394: ot -> ot_info = (caddr_t) smuxPdescription;
2395: if (ot = text2obj ("smuxPstatus"))
2396: ot -> ot_getfnx = o_smuxPeer,
2397: ot -> ot_info = (caddr_t) smuxPstatus;
2398:
2399: if (ot = text2obj ("smuxTsubtree"))
2400: ot -> ot_getfnx = o_smuxTree,
2401: ot -> ot_info = (caddr_t) smuxTsubtree;
2402: if (ot = text2obj ("smuxTpriority"))
2403: ot -> ot_getfnx = o_smuxTree,
2404: ot -> ot_info = (caddr_t) smuxTpriority;
2405: if (ot = text2obj ("smuxTindex"))
2406: ot -> ot_getfnx = o_smuxTree,
2407: ot -> ot_info = (caddr_t) smuxTindex;
2408: if (ot = text2obj ("smuxTstatus"))
2409: ot -> ot_getfnx = o_smuxTree,
2410: ot -> ot_info = (caddr_t) smuxTstatus;
2411: }
2412: #endif
2413:
2414: /* VIEW MIB */
2415:
2416: #define viewPrimName 0
2417: #define viewPrimTDomain 1
2418: #define viewPrimTAddr 2
2419: #define viewPrimUser 3
2420: #define viewPrimCommunity 4
2421: #define viewPrimType 5
2422:
2423: #define P_VALID 1 /* viewPrimType */
2424:
2425:
2426: struct view *get_prent ();
2427:
2428:
2429: static int o_viewPrim (oi, v, offset)
2430: OI oi;
2431: register struct type_SNMP_VarBind *v;
2432: int offset;
2433: {
2434: int ifvar;
2435: register int i;
2436: register unsigned int *ip,
2437: *jp;
2438: register struct view *vu;
2439: register OID oid = oi -> oi_name;
2440: register OT ot = oi -> oi_type;
2441:
2442: ifvar = (int) ot -> ot_info;
2443: switch (offset) {
2444: case type_SNMP_PDUs_get__request:
2445: if (oid -> oid_nelem <= ot -> ot_name -> oid_nelem)
2446: return int_SNMP_error__status_noSuchName;
2447: if ((vu = get_prent (oid -> oid_elements
2448: + ot -> ot_name -> oid_nelem,
2449: oid -> oid_nelem
2450: - ot -> ot_name -> oid_nelem, 0)) == NULL)
2451: return int_SNMP_error__status_noSuchName;
2452: break;
2453:
2454: case type_SNMP_PDUs_get__next__request:
2455: if (oid -> oid_nelem == ot -> ot_name -> oid_nelem) {
2456: OID new;
2457:
2458: if ((vu = VHead -> v_forw) == VHead)
2459: return NOTOK;
2460:
2461: i = vu -> v_name -> oid_nelem + 1;
2462: if ((new = oid_extend (oid, i)) == NULLOID)
2463: return int_SNMP_error__status_genErr;
2464: ip = new -> oid_elements + new -> oid_nelem - i;
2465: jp = vu -> v_name -> oid_elements;
2466: *ip++ = i;
2467: for (i--; i > 0; i--)
2468: *ip++ = *jp++;
2469:
2470: if (v -> name)
2471: free_SNMP_ObjectName (v -> name);
2472: v -> name = new;
2473: }
2474: else {
2475: int j,
2476: k;
2477:
2478: if ((vu = get_prent (oid -> oid_elements
2479: + ot -> ot_name -> oid_nelem,
2480: j = oid -> oid_nelem
2481: - ot -> ot_name -> oid_nelem, 1))
2482: == NULL)
2483: return NOTOK;
2484:
2485: k = vu -> v_name -> oid_nelem + 1;
2486: if ((i = j - k) < 0) {
2487: OID new;
2488:
2489: if ((new = oid_extend (oid, -i)) == NULLOID)
2490: return int_SNMP_error__status_genErr;
2491: if (v -> name)
2492: free_SNMP_ObjectName (v -> name);
2493: v -> name = new;
2494:
2495: oid = new;
2496: }
2497: else
2498: if (i > 0)
2499: oid -> oid_nelem -= i;
2500:
2501: ip = oid -> oid_elements + ot -> ot_name -> oid_nelem;
2502: jp = vu -> v_name -> oid_elements;
2503: *ip++ = k;
2504: for (k--; k > 0; k--)
2505: *ip++ = *jp++;
2506: }
2507: break;
2508:
2509: default:
2510: return int_SNMP_error__status_genErr;
2511: }
2512:
2513: switch (ifvar) {
2514: case viewPrimName:
2515: return o_specific (oi, v, (caddr_t) vu -> v_name);
2516:
2517: case viewPrimTDomain:
2518: return o_specific (oi, v,
2519: (caddr_t) (vu -> v_community ? rfc1157Domain
2520: : localAgent));
2521:
2522: case viewPrimTAddr:
2523: #ifdef TCP
2524: if (vu -> v_community) {
2525: struct sockaddr_in *sin = (struct sockaddr_in *) &vu -> v_sa;
2526:
2527: return o_string (oi, v, (char *) &sin -> sin_addr, 4);
2528: }
2529: else
2530: #endif
2531: return o_string (oi, v, NULLCP, 0);
2532:
2533: case viewPrimUser:
2534: #ifdef TCP
2535: if (vu -> v_community)
2536: return o_qbstring (oi, v,
2537: trap -> data -> un.trap -> agent__addr);
2538: else
2539: #endif
2540: return o_string (oi, v, NULLCP, 0);
2541:
2542: case viewPrimCommunity:
2543: if (vu -> v_community)
2544: return o_qbstring (oi, v, vu -> v_community);
2545: else
2546: return o_string (oi, v, NULLCP, 0);
2547:
2548: case viewPrimType:
2549: return o_integer (oi, v, P_VALID);
2550:
2551: default:
2552: return int_SNMP_error__status_noSuchName;
2553: }
2554: }
2555:
2556: /* */
2557:
2558: static struct view *get_prent (ip, len, isnext)
2559: register unsigned int *ip;
2560: int len;
2561: int isnext;
2562: {
2563: register struct view *v;
2564:
2565: ip++, len--;
2566: for (v = VHead -> v_forw; v != VHead; v = v -> v_forw)
2567: switch (elem_cmp (v -> v_name -> oid_elements,v -> v_name -> oid_nelem,
2568: ip, len)) {
2569: case 0:
2570: if (!isnext)
2571: return v;
2572: if ((v = v -> v_forw) == VHead)
2573: return NULL;
2574: /* else fall... */
2575:
2576: case 1:
2577: return (isnext ? v : NULL);
2578: }
2579:
2580: return NULL;
2581: }
2582:
2583: /* */
2584:
2585: #define viewAclView 0
2586: #define viewAclCommunity 1
2587: #define viewAclUser 2
2588: #define viewAclPrivileges 3
2589: #define viewAclType 4
2590:
2591: #define A_VALID 1 /* viewAclType */
2592:
2593:
2594: struct community *get_acent ();
2595:
2596:
2597: static int o_viewAcl (oi, v, offset)
2598: OI oi;
2599: register struct type_SNMP_VarBind *v;
2600: int offset;
2601: {
2602: int ifvar;
2603: register int i;
2604: register unsigned int *ip,
2605: *jp;
2606: register struct community *c;
2607: register OID oid = oi -> oi_name;
2608: register OT ot = oi -> oi_type;
2609:
2610: ifvar = (int) ot -> ot_info;
2611: switch (offset) {
2612: case type_SNMP_PDUs_get__request:
2613: if (oid -> oid_nelem <= ot -> ot_name -> oid_nelem)
2614: return int_SNMP_error__status_noSuchName;
2615: if ((c = get_acent (oid -> oid_elements
2616: + ot -> ot_name -> oid_nelem,
2617: oid -> oid_nelem
2618: - ot -> ot_name -> oid_nelem, 0)) == NULL)
2619: return int_SNMP_error__status_noSuchName;
2620: break;
2621:
2622: case type_SNMP_PDUs_get__next__request:
2623: if (oid -> oid_nelem == ot -> ot_name -> oid_nelem) {
2624: OID new;
2625:
2626: if ((c = CLex) == NULL)
2627: return NOTOK;
2628:
2629: if ((new = oid_extend (oid, c -> c_insize)) == NULLOID)
2630: return int_SNMP_error__status_genErr;
2631: ip = new -> oid_elements + new -> oid_nelem - c -> c_insize;
2632: jp = c -> c_instance;
2633: for (i = c -> c_insize; i > 0; i--)
2634: *ip++ = *jp++;
2635:
2636: if (v -> name)
2637: free_SNMP_ObjectName (v -> name);
2638: v -> name = new;
2639: }
2640: else {
2641: int j;
2642:
2643: if ((c = get_acent (oid -> oid_elements
2644: + ot -> ot_name -> oid_nelem,
2645: j = oid -> oid_nelem
2646: - ot -> ot_name -> oid_nelem, 1))
2647: == NULL)
2648: return NOTOK;
2649:
2650: if ((i = j - c -> c_insize) < 0) {
2651: OID new;
2652:
2653: if ((new = oid_extend (oid, -i)) == NULLOID)
2654: return int_SNMP_error__status_genErr;
2655: if (v -> name)
2656: free_SNMP_ObjectName (v -> name);
2657: v -> name = new;
2658:
2659: oid = new;
2660: }
2661: else
2662: if (i > 0)
2663: oid -> oid_nelem -= i;
2664:
2665: ip = oid -> oid_elements + ot -> ot_name -> oid_nelem;
2666: jp = c -> c_instance;
2667: for (i = c -> c_insize; i > 0; i--)
2668: *ip++ = *jp++;
2669: }
2670: break;
2671:
2672: default:
2673: return int_SNMP_error__status_genErr;
2674: }
2675:
2676: switch (ifvar) {
2677: case viewAclView:
2678: return o_specific (oi, v, (caddr_t) c -> c_view -> v_name);
2679:
2680: case viewAclCommunity:
2681: return o_string (oi, v, c -> c_name, strlen (c -> c_name));
2682:
2683: case viewAclUser:
2684: switch (c -> c_addr.na_type) {
2685: case NA_TCP:
2686: { /* hard to believe this is the easiest way of doing it */
2687: register char *bp,
2688: *ep;
2689: char buf[4];
2690:
2691: ip = c -> c_instance + 1 + strlen (c -> c_name) + 1;
2692: for (ep = (bp = buf + sizeof buf); bp < ep; )
2693: *bp++ = *ip++ & 0xff;
2694:
2695: return o_string (oi, v, buf, sizeof buf);
2696: }
2697:
2698: case NA_X25:
2699: return o_string (oi, v, c -> c_addr.na_dte,
2700: (int) c -> c_addr.na_dtelen);
2701:
2702: case NA_NSAP:
2703: return o_string (oi, v, c -> c_addr.na_address,
2704: (int) c -> c_addr.na_addrlen);
2705:
2706: default:
2707: return o_string (oi, v, NULLCP, 0);
2708: }
2709:
2710: case viewAclPrivileges:
2711: return o_integer (oi, v,
2712: ((c -> c_permission & OT_RDONLY) ? 3 : 0)
2713: + ((c -> c_permission & OT_WRONLY) ? 8 : 0)
2714: + ((c -> c_permission & OT_YYY) ? 4 : 0));
2715:
2716: case viewAclType:
2717: return o_integer (oi, v, A_VALID);
2718:
2719: default:
2720: return int_SNMP_error__status_noSuchName;
2721: }
2722: }
2723:
2724: /* */
2725:
2726: static struct community *get_acent (ip, len, isnext)
2727: register unsigned int *ip;
2728: int len;
2729: int isnext;
2730: {
2731: register struct community *c;
2732:
2733: for (c = CLex; c; c = c -> c_next)
2734: switch (elem_cmp (c -> c_instance, c -> c_insize, ip, len)) {
2735: case 0:
2736: return (isnext ? c -> c_next : c);
2737:
2738: case 1:
2739: return (isnext ? c : NULL);
2740: }
2741:
2742: return NULL;
2743: }
2744:
2745: /* */
2746:
2747: #define viewTrapView 0
2748: #define viewTrapGenerics 1
2749: #define viewTrapSpecifics 2
2750: #define viewTrapType 3
2751:
2752: #define T_VALID 1 /* viewTrapType */
2753:
2754:
2755: struct trap *get_trent ();
2756:
2757:
2758: static int o_viewTrap (oi, v, offset)
2759: OI oi;
2760: register struct type_SNMP_VarBind *v;
2761: int offset;
2762: {
2763: int ifvar;
2764: register int i;
2765: register unsigned int *ip,
2766: *jp;
2767: register struct trap *t;
2768: register OID oid = oi -> oi_name;
2769: register OT ot = oi -> oi_type;
2770:
2771: ifvar = (int) ot -> ot_info;
2772: switch (offset) {
2773: case type_SNMP_PDUs_get__request:
2774: if (oid -> oid_nelem <= ot -> ot_name -> oid_nelem)
2775: return int_SNMP_error__status_noSuchName;
2776: if ((t = get_trent (oid -> oid_elements
2777: + ot -> ot_name -> oid_nelem,
2778: oid -> oid_nelem
2779: - ot -> ot_name -> oid_nelem, 0)) == NULL)
2780: return int_SNMP_error__status_noSuchName;
2781: break;
2782:
2783: case type_SNMP_PDUs_get__next__request:
2784: if (oid -> oid_nelem == ot -> ot_name -> oid_nelem) {
2785: OID new;
2786:
2787: if ((t = UHead -> t_forw) == UHead)
2788: return NOTOK;
2789:
2790: i = t -> t_view -> v_name -> oid_nelem + 1;
2791: if ((new = oid_extend (oid, i)) == NULLOID)
2792: return int_SNMP_error__status_genErr;
2793: ip = new -> oid_elements + new -> oid_nelem - i;
2794: jp = t -> t_view -> v_name -> oid_elements;
2795: *ip++ = i;
2796: for (i--; i > 0; i--)
2797: *ip++ = *jp++;
2798:
2799: if (v -> name)
2800: free_SNMP_ObjectName (v -> name);
2801: v -> name = new;
2802: }
2803: else {
2804: int j,
2805: k;
2806:
2807: if ((t = get_trent (oid -> oid_elements
2808: + ot -> ot_name -> oid_nelem,
2809: j = oid -> oid_nelem
2810: - ot -> ot_name -> oid_nelem, 1))
2811: == NULL)
2812: return NOTOK;
2813:
2814: k = t -> t_view -> v_name -> oid_nelem + 1;
2815: if ((i = j - k) < 0) {
2816: OID new;
2817:
2818: if ((new = oid_extend (oid, -i)) == NULLOID)
2819: return int_SNMP_error__status_genErr;
2820: if (v -> name)
2821: free_SNMP_ObjectName (v -> name);
2822: v -> name = new;
2823:
2824: oid = new;
2825: }
2826: else
2827: if (i > 0)
2828: oid -> oid_nelem -= i;
2829:
2830: ip = oid -> oid_elements + ot -> ot_name -> oid_nelem;
2831: jp = t -> t_view -> v_name -> oid_elements;
2832: *ip++ = k;
2833: for (k--; k > 0; k--)
2834: *ip++ = *jp++;
2835: }
2836: break;
2837:
2838: default:
2839: return int_SNMP_error__status_genErr;
2840: }
2841:
2842: switch (ifvar) {
2843: case viewTrapView:
2844: return o_specific (oi, v, (caddr_t) t -> t_view -> v_name);
2845:
2846: case viewTrapGenerics:
2847: {
2848: char c = t -> t_generics & 0xff;
2849:
2850: return o_string (oi, v, &c, sizeof c);
2851: }
2852:
2853: case viewTrapSpecifics:
2854: return o_string (oi, v, NULLCP, 0);
2855:
2856: case viewTrapType:
2857: return o_integer (oi, v, T_VALID);
2858:
2859: default:
2860: return int_SNMP_error__status_noSuchName;
2861: }
2862: }
2863:
2864: /* */
2865:
2866: static struct trap *get_trent (ip, len, isnext)
2867: register unsigned int *ip;
2868: int len;
2869: int isnext;
2870: {
2871: register struct trap *t;
2872:
2873: ip++, len--;
2874: for (t = UHead -> t_forw; t != UHead; t = t -> t_forw)
2875: switch (elem_cmp (t -> t_view -> v_name -> oid_elements,
2876: t -> t_view -> v_name -> oid_nelem,
2877: ip, len)) {
2878: case 0:
2879: if (!isnext)
2880: return t;
2881: if ((t = t -> t_forw) == UHead)
2882: return NULL;
2883: /* else fall... */
2884:
2885: case 1:
2886: return (isnext ? t : NULL);
2887: }
2888:
2889: return NULL;
2890: }
2891:
2892: /* */
2893:
2894: static int view_compar (a, b)
2895: struct view **a,
2896: **b;
2897: {
2898: return oid_cmp ((*a) -> v_name, (*b) -> v_name);
2899:
2900: }
2901:
2902: static int comm_compar (a, b)
2903: struct community **a,
2904: **b;
2905: {
2906: return elem_cmp ((*a) -> c_instance, (*a) -> c_insize,
2907: (*b) -> c_instance, (*b) -> c_insize);
2908: }
2909:
2910: static int trap_compar (a, b)
2911: struct trap **a,
2912: **b;
2913: {
2914: return oid_cmp ((*a) -> t_view -> v_name, (*b) -> t_view -> v_name);
2915: }
2916:
2917:
2918: static init_view ()
2919: {
2920: register int i;
2921: register OT ot;
2922: register struct community *c;
2923: register struct view *v;
2924: register struct trap *t;
2925:
2926: if (ot = text2obj ("viewPrimName"))
2927: ot -> ot_getfnx = o_viewPrim,
2928: ot -> ot_info = (caddr_t) viewPrimName;
2929: if (ot = text2obj ("viewPrimTDomain"))
2930: ot -> ot_getfnx = o_viewPrim,
2931: ot -> ot_info = (caddr_t) viewPrimTDomain;
2932: if (ot = text2obj ("viewPrimTAddr"))
2933: ot -> ot_getfnx = o_viewPrim,
2934: ot -> ot_info = (caddr_t) viewPrimTAddr;
2935: if (ot = text2obj ("viewPrimUser"))
2936: ot -> ot_getfnx = o_viewPrim,
2937: ot -> ot_info = (caddr_t) viewPrimUser;
2938: if (ot = text2obj ("viewPrimCommunity"))
2939: ot -> ot_getfnx = o_viewPrim,
2940: ot -> ot_info = (caddr_t) viewPrimCommunity;
2941: if (ot = text2obj ("viewPrimType"))
2942: ot -> ot_getfnx = o_viewPrim,
2943: ot -> ot_info = (caddr_t) viewPrimType;
2944:
2945: if (ot = text2obj ("viewAclView"))
2946: ot -> ot_getfnx = o_viewAcl,
2947: ot -> ot_info = (caddr_t) viewAclView;
2948: if (ot = text2obj ("viewAclCommunity"))
2949: ot -> ot_getfnx = o_viewAcl,
2950: ot -> ot_info = (caddr_t) viewAclCommunity;
2951: if (ot = text2obj ("viewAclUser"))
2952: ot -> ot_getfnx = o_viewAcl,
2953: ot -> ot_info = (caddr_t) viewAclUser;
2954: if (ot = text2obj ("viewAclPrivileges"))
2955: ot -> ot_getfnx = o_viewAcl,
2956: ot -> ot_info = (caddr_t) viewAclPrivileges;
2957: if (ot = text2obj ("viewAclType"))
2958: ot -> ot_getfnx = o_viewAcl,
2959: ot -> ot_info = (caddr_t) viewAclType;
2960:
2961: if (ot = text2obj ("viewTrapView"))
2962: ot -> ot_getfnx = o_viewTrap,
2963: ot -> ot_info = (caddr_t) viewTrapView;
2964: if (ot = text2obj ("viewTrapGenerics"))
2965: ot -> ot_getfnx = o_viewTrap,
2966: ot -> ot_info = (caddr_t) viewTrapGenerics;
2967: if (ot = text2obj ("viewTrapSpecifics"))
2968: ot -> ot_getfnx = o_viewTrap,
2969: ot -> ot_info = (caddr_t) viewTrapSpecifics;
2970: if (ot = text2obj ("viewTrapType"))
2971: ot -> ot_getfnx = o_viewTrap,
2972: ot -> ot_info = (caddr_t) viewTrapType;
2973:
2974: i = 0;
2975: for (v = VHead -> v_forw; v != VHead; v = v -> v_forw)
2976: i++;
2977: if (i > 1) {
2978: register struct view **base,
2979: **bp,
2980: **ep;
2981:
2982: if ((base = (struct view **) malloc ((unsigned) (i * sizeof *base)))
2983: == NULL)
2984: adios (NULLCP, "out of memory");
2985: ep = base;
2986: for (v = VHead -> v_forw; v != VHead; v = v -> v_forw)
2987: remque (*ep++ = v);
2988: VHead -> v_forw = VHead -> v_back = VHead;
2989:
2990: qsort ((char *) base, i, sizeof *base, view_compar);
2991:
2992: bp = base;
2993: while (bp < ep)
2994: insque (*bp++, VHead -> v_back);
2995:
2996: free ((char *) base);
2997: }
2998:
2999: i = 0;
3000: for (c = CHead -> c_forw; c != CHead; c = c -> c_forw)
3001: i++;
3002: if (i > 0) {
3003: int j;
3004: register struct community **base,
3005: **bp,
3006: **ep;
3007:
3008: if ((base = (struct community **)
3009: malloc ((unsigned) (i * sizeof *base))) == NULL)
3010: adios (NULLCP, "out of memory");
3011: ep = base;
3012: for (c = CHead -> c_forw; c != CHead; c = c -> c_forw) {
3013: register char *cp,
3014: *dp;
3015: register unsigned int *ip;
3016:
3017: switch (c -> c_addr.na_stack) {
3018: case NA_TCP:
3019: j = 4;
3020: break;
3021:
3022: case NA_X25:
3023: j = c -> c_addr.na_dtelen;
3024: break;
3025:
3026: case NA_NSAP:
3027: j = c -> c_addr.na_addrlen;
3028: break;
3029:
3030: default:
3031: j = 0;
3032: break;
3033: }
3034:
3035: c -> c_insize = 1 + strlen (c -> c_name) + 1 + j;
3036: if ((c -> c_instance =
3037: (unsigned int *) calloc ((unsigned) c -> c_insize,
3038: sizeof *c -> c_instance)) == NULL)
3039: adios (NULLCP, "out of memory");
3040: ip = c -> c_instance;
3041:
3042: *ip++ = strlen (c -> c_name);
3043: for (cp = c -> c_name; *cp; cp++)
3044: *ip++ = *cp & 0xff;
3045:
3046: *ip++ = j;
3047: switch (c -> c_addr.na_stack) {
3048: case NA_TCP:
3049: (void) sscanf (c -> c_addr.na_domain, "%u.%u.%u.%u",
3050: ip, ip + 1, ip + 2, ip + 3);
3051: break;
3052:
3053: case NA_X25:
3054: dp = (cp = c -> c_addr.na_dte) + c -> c_addr.na_dtelen;
3055: goto stuff_it;
3056:
3057: case NA_NSAP:
3058: dp = (cp = c -> c_addr.na_address) + c ->c_addr.na_addrlen;
3059: stuff_it: ;
3060: while (cp < dp)
3061: *ip++ = *cp++ & 0xff;
3062: break;
3063:
3064: default:
3065: break;
3066: }
3067:
3068: *ep++ = c;
3069: }
3070:
3071: if (i > 1)
3072: qsort ((char *) base, i, sizeof *base, comm_compar);
3073:
3074: bp = base;
3075: c = CLex = *bp++;
3076: while (bp < ep) {
3077: c -> c_next = *bp;
3078: c = *bp++;
3079: }
3080: c -> c_next = NULL;
3081:
3082: free ((char *) base);
3083: }
3084: else
3085: CLex = NULL;
3086:
3087: i = 0;
3088: for (t = UHead -> t_forw; t != UHead; t = t -> t_forw)
3089: i++;
3090: if (i > 1) {
3091: register struct trap **base,
3092: **bp,
3093: **ep;
3094:
3095: if ((base = (struct trap **) malloc ((unsigned) (i * sizeof *base)))
3096: == NULL)
3097: adios (NULLCP, "out of memory");
3098: ep = base;
3099: for (t = UHead -> t_forw; t != UHead; t = t -> t_forw)
3100: remque (*ep++ = t);
3101: UHead -> t_forw = UHead -> t_back = UHead;
3102:
3103: qsort ((char *) base, i, sizeof *base, trap_compar);
3104:
3105: bp = base;
3106: while (bp < ep)
3107: insque (*bp++, UHead -> t_back);
3108:
3109: free ((char *) base);
3110: }
3111:
3112: if (debug) {
3113: fprintf (stderr, "///////\nprimitive view table\n");
3114: for (v = VHead -> v_forw; v != VHead; v = v -> v_forw) {
3115: fprintf (stderr, "name=%s ", sprintoid (v -> v_name));
3116: if (v -> v_community) {
3117: register char *cp,
3118: *ep;
3119: char *p;
3120: register struct qbuf *qb;
3121: #ifdef TCP
3122: struct qbuf *x = trap -> data -> un.trap -> agent__addr;
3123: struct sockaddr_in *sin = (struct sockaddr_in *) &v -> v_sa;
3124: #endif
3125:
3126: fprintf (stderr, "tDomain=%s tAddr=", sprintoid (rfc1157Domain));
3127: #ifdef TCP
3128: p = "0x";
3129: for (ep = (cp = (char *) &sin -> sin_addr) + 4; cp < ep; cp++) {
3130: fprintf (stderr, "%s%02x", p, *cp & 0xff);
3131: p = ":";
3132: }
3133: for (ep = (cp = (char *) &sin -> sin_port) + 2; cp < ep; cp++)
3134: fprintf (stderr, ":%02x", *cp & 0xff);
3135: #else
3136: fprintf (stderr, "\"\"");
3137: #endif
3138: fprintf (stderr, " user=");
3139: #ifdef TCP
3140: p = "0x";
3141: for (qb = x -> qb_forw; qb != x; qb = qb -> qb_forw)
3142: for (ep = (cp = qb -> qb_data) + qb -> qb_len; cp < ep; cp++) {
3143: fprintf (stderr, "%s%02x", p, *cp & 0xff);
3144: p = ":";
3145: }
3146: #else
3147: fprintf (stderr, "\"\"");
3148: #endif
3149: fprintf (stderr," community=\"");
3150: for (qb = v -> v_community -> qb_forw;
3151: qb != v -> v_community;
3152: qb = qb -> qb_forw)
3153: fprintf (stderr, "%*.*s", qb -> qb_len, qb -> qb_len,
3154: qb -> qb_data);
3155: fprintf (stderr, "\"");
3156: }
3157: else
3158: fprintf (stderr, "tDomain=%s ...", sprintoid (localAgent));
3159: fprintf (stderr, "\n");
3160: }
3161: fprintf(stderr,"\nview access table\n");
3162: for (c = CLex; c; c = c -> c_next) {
3163: OIDentifier oids;
3164: oids.oid_elements = c -> c_instance, oids.oid_nelem = c -> c_insize;
3165: fprintf (stderr,"acl=%s ", sprintoid (&oids));
3166: fprintf (stderr, "view=%s community=%s user=%s privileges=%d\n",
3167: sprintoid (c -> c_view -> v_name), c -> c_name,
3168: na2str (&c -> c_addr),
3169: ((c -> c_permission & OT_RDONLY) ? 3 : 0)
3170: + ((c -> c_permission & OT_WRONLY) ? 8 : 0)
3171: + ((c -> c_permission & OT_YYY) ? 4 : 0));
3172: }
3173: fprintf(stderr,"\ntrap table\n");
3174: for (t = UHead -> t_forw; t != UHead; t = t -> t_forw) {
3175: v = t -> t_view;
3176: fprintf (stderr, "view=%s generics=0x%x specifics=null\n",
3177: sprintoid (v -> v_name), t -> t_generics);
3178: }
3179: fprintf(stderr,"///////\n");
3180: compat_log -> ll_events |= LLOG_TRACE;
3181: compat_log -> ll_stat |= LLOGTTY;
3182: }
3183: }
3184:
3185: /* VIEWS */
3186:
3187: static initview () {
3188: register OT ot;
3189:
3190: for (ot = text2obj ("ccitt"); ot; ot = ot -> ot_next)
3191: if (ot -> ot_getfnx != NULL && ot -> ot_access != OT_NONE)
3192: export_view (ot);
3193: }
3194:
3195: /* */
3196:
3197: #define inSubtree(tree,object) \
3198: ((tree) -> oid_nelem <= (object) -> oid_nelem \
3199: && bcmp ((char *) (tree) -> oid_elements, \
3200: (char *) (object) -> oid_elements, \
3201: (tree) -> oid_nelem \
3202: * sizeof ((tree) -> oid_elements[0])) == 0)
3203:
3204:
3205: static export_view (ot)
3206: register OT ot;
3207: {
3208: register struct subtree *s;
3209: register struct view *v;
3210: OID name = ot -> ot_name;
3211:
3212: ot -> ot_views = 0;
3213: for (v = VHead -> v_forw; v != VHead; v = v -> v_forw)
3214: if ((s = v -> v_subtree.s_forw) != &v -> v_subtree) {
3215: for (; s != &v -> v_subtree; s = s -> s_forw)
3216: if (inSubtree (s -> s_subtree, name))
3217: goto mark_it;
3218: }
3219: else {
3220: mark_it: ;
3221: ot -> ot_views |= v -> v_mask;
3222: }
3223: }
3224:
3225: /* COMMUNITIES */
3226:
3227: struct community *str2comm (name, na)
3228: char *name;
3229: register struct NSAPaddr *na;
3230: {
3231: register struct community *c,
3232: *d;
3233:
3234: d = NULL;
3235: for (c = CHead -> c_forw; c != CHead; c = c -> c_forw)
3236: if (strcmp (c -> c_name, name) == 0) {
3237: if (c -> c_addr.na_stack == NA_TCP
3238: && strcmp (c -> c_addr.na_domain, "0.0.0.0") == 0) {
3239: d = c;
3240: continue;
3241: }
3242: else {
3243: if (c -> c_addr.na_stack != na -> na_stack)
3244: continue;
3245: switch (na -> na_stack) {
3246: case NA_TCP:
3247: if (strcmp (c -> c_addr.na_domain, na -> na_domain))
3248: continue;
3249: break;
3250:
3251: case NA_X25:
3252: if (c -> c_addr.na_dtelen != na -> na_dtelen
3253: || bcmp (c -> c_addr.na_dte,
3254: na -> na_dte, na -> na_dtelen))
3255: continue;
3256: break;
3257:
3258: case NA_NSAP:
3259: if (c -> c_addr.na_addrlen != na -> na_addrlen
3260: || bcmp (c -> c_addr.na_address,
3261: na -> na_address, na -> na_addrlen))
3262: continue;
3263: break;
3264:
3265: default:
3266: adios (NULLCP,
3267: "unknown network type (0x%x) for community \"%s\"",
3268: na -> na_stack, name);
3269: /* NOTREACHED */
3270: }
3271: }
3272:
3273: d = c;
3274: break;
3275: }
3276:
3277: if (d) {
3278: remque (d);
3279: insque (d, CHead);
3280: }
3281:
3282: return d;
3283: }
3284:
3285: /* TRAPS */
3286:
3287: static initrap () {
3288: #ifdef TCP
3289: char myhost[BUFSIZ];
3290: register struct hostent *hp;
3291: struct type_SNMP_Message *msg;
3292: register struct type_SNMP_PDUs *pdu;
3293: register struct type_SNMP_Trap__PDU *parm;
3294:
3295: if ((msg = (struct type_SNMP_Message *) calloc (1, sizeof *msg)) == NULL) {
3296: no_mem: ;
3297: advise (LLOG_EXCEPTIONS, NULLCP,
3298: "unable to initialize trap structure: out of memory");
3299: out: ;
3300: if (msg)
3301: free_SNMP_Message (msg);
3302:
3303: return;
3304: }
3305: msg -> version = int_SNMP_version_version__1;
3306:
3307: if ((pdu = (struct type_SNMP_PDUs *) calloc (1, sizeof *pdu)) == NULL)
3308: goto no_mem;
3309: msg -> data = pdu;
3310:
3311: pdu -> offset = type_SNMP_PDUs_trap;
3312:
3313: if ((parm = (struct type_SNMP_Trap__PDU *) calloc (1, sizeof *parm))
3314: == NULL)
3315: goto no_mem;
3316: pdu -> un.trap = parm;
3317:
3318: (void) strcpy (myhost, TLocalHostName ());
3319: if (hp = gethostbystring (myhost)) {
3320: struct sockaddr_in sin;
3321:
3322: inaddr_copy (hp, &sin);
3323: if ((parm -> agent__addr = str2qb ((char *) &sin.sin_addr, 4, 1))
3324: == NULL)
3325: goto no_mem;
3326: }
3327: else {
3328: advise (LLOG_EXCEPTIONS, NULLCP,
3329: "%s: unknown host, so no traps", myhost);
3330: goto out;
3331: }
3332:
3333: if ((parm -> time__stamp = (struct type_SNMP_TimeTicks *)
3334: calloc (1, sizeof *parm -> time__stamp)) == NULL)
3335: goto no_mem;
3336:
3337: trap = msg;
3338:
3339: #ifdef SMUX
3340: if (hp = gethostbystring ("localhost")) {
3341: struct sockaddr_in sin;
3342:
3343: inaddr_copy (hp, &sin);
3344: if ((loopback_addr = str2qb ((char *) &sin.sin_addr, 4, 1)) == NULL)
3345: advise (LLOG_EXCEPTIONS, NULLCP,
3346: "unable to initialize loopback address: out of memory");
3347: }
3348: #endif
3349: #endif
3350: }
3351:
3352: /* */
3353:
3354: #ifndef TCP
3355: /* ARGSUSED */
3356: #endif
3357:
3358: static do_trap (generic, specific, bindings)
3359: int generic,
3360: specific;
3361: struct type_SNMP_VarBindList *bindings;
3362: {
3363: #ifdef TCP
3364: struct type_SNMP_Message *msg;
3365: register struct type_SNMP_Trap__PDU *parm;
3366: OT ot;
3367:
3368: if ((msg = trap) == NULL)
3369: return;
3370: parm = msg -> data -> un.trap;
3371:
3372: if ((ot = text2obj ("sysObjectID")) == NULLOT) {
3373: advise (LLOG_EXCEPTIONS, NULLCP,
3374: "unable to send trap: no such object: \"%s\"",
3375: "sysObjectID");
3376: return;
3377: }
3378: if ((parm -> enterprise = (OID) ot -> ot_info) == NULLOID) {
3379: advise (LLOG_EXCEPTIONS, NULLCP,
3380: "unable to send trap: no value defined for object \"%s\"",
3381: "sysObjectID");
3382: return;
3383: }
3384:
3385: parm -> generic__trap = generic;
3386: parm -> specific__trap = specific;
3387: {
3388: struct timeval boottime,
3389: now;
3390:
3391: if (getkmem (nl + N_BOOTTIME, (caddr_t) &boottime, sizeof boottime)
3392: == NOTOK) {
3393: advise (LLOG_EXCEPTIONS, NULLCP,
3394: "unable to send trap: read of boottime failed");
3395: return;
3396: }
3397: if (gettimeofday (&now, (struct timezone *) 0) == NOTOK) {
3398: advise (LLOG_EXCEPTIONS, "failed", "gettimeofday");
3399: return;
3400: }
3401:
3402: parm -> time__stamp -> parm = (now.tv_sec - boottime.tv_sec) * 100
3403: + ((now.tv_usec - boottime.tv_usec)
3404: / 10000);
3405: }
3406: parm -> variable__bindings = bindings;
3407:
3408: do_traps (msg, generic, specific);
3409: #endif
3410: }
3411:
3412: /* */
3413:
3414: #ifdef TCP
3415: static do_traps (msg, generic, specific)
3416: register struct type_SNMP_Message *msg;
3417: int generic,
3418: specific;
3419: {
3420: int mask = 1 << 7 - generic;
3421: register struct trap *t;
3422:
3423: for (t = UHead -> t_forw; t != UHead; t = t -> t_forw) {
3424: register struct view *v = t -> t_view;
3425: PE pe;
3426: PS ps;
3427:
3428: if (specific == 0 && !(t -> t_generics & mask))
3429: continue;
3430:
3431: msg -> community = v -> v_community;
3432:
3433: pe = NULLPE;
3434: if (encode_SNMP_Message (&pe, 1, 0, NULLCP, msg) == NOTOK) {
3435: advise (LLOG_EXCEPTIONS, NULLCP,
3436: "encode_SNMP_Message: %s", PY_pepy);
3437: if (pe)
3438: pe_free (pe);
3439: continue;
3440: }
3441: PLOGP (pgm_log,SNMP_Message, pe, "Message", 0);
3442:
3443: if ((ps = ps_alloc (dg_open)) == NULLPS
3444: || dg_setup (ps, udp, MAXDGRAM, read_udp_socket,
3445: write_udp_socket) == NOTOK) {
3446: if (ps == NULLPS)
3447: advise (LLOG_EXCEPTIONS, NULLCP, "ps_alloc: out of memory");
3448: else
3449: advise (LLOG_EXCEPTIONS, NULLCP, "dg_setup: %s",
3450: ps_error (ps -> ps_errno));
3451: }
3452: else
3453: if (hack_dgram_socket (udp, &v -> v_sa)
3454: == NOTOK)
3455: advise (LLOG_EXCEPTIONS, "failed", "hack_dgram_socket(1)");
3456: else
3457: if (pe2ps (ps, pe) == NOTOK)
3458: advise (LLOG_EXCEPTIONS, NULLCP, "pe2ps: %s",
3459: ps_error (ps -> ps_errno));
3460: else {
3461: snmpstat.s_outpkts++, snmpstat.s_outtraps++;
3462:
3463: if (hack_dgram_socket (udp, (struct sockaddr *) NULL)
3464: == NOTOK)
3465: advise (LLOG_EXCEPTIONS, "failed",
3466: "hack_dgram_socket(2)");
3467: }
3468:
3469: pe_free (pe);
3470:
3471: if (ps)
3472: ps_free (ps);
3473: else
3474: break;
3475: }
3476: }
3477: #endif
3478: #else /* SNMPT */
3479:
3480: /* */
3481:
3482: /* ARGSUSED */
3483:
3484: static int process (ps, msg, na)
3485: PS ps;
3486: register struct type_SNMP_Message *msg;
3487: struct NSAPaddr *na;
3488: {
3489: char *cp;
3490: long now;
3491: PE pe,
3492: p;
3493: register struct type_SNMP_PDUs *pdu = msg -> data;
3494: register struct tm *tm;
3495: struct UTCtime uts;
3496: register struct UTCtime *ut = &uts;
3497: register struct type_SNMP_Audit *au;
3498:
3499: if (msg -> version != int_SNMP_version_version__1) {
3500: advise (LLOG_EXCEPTIONS, NULLCP, "badVersion: %d (%s)",
3501: msg -> version, source);
3502: return NOTOK;
3503: }
3504:
3505: if (pdu -> offset != type_SNMP_PDUs_trap) {
3506: advise (LLOG_EXCEPTIONS, NULLCP,
3507: "unexpectedOperation: %d (%s)", pdu -> offset, source);
3508: return NOTOK;
3509: }
3510:
3511: pe = p = NULLPE;
3512: au = NULL;
3513:
3514: if (encode_SNMP_Message (&p, 1, 0, NULLCP, msg) == NOTOK) {
3515: advise (LLOG_EXCEPTIONS, NULLCP, "encode_SNMP_Message: %s (%s)",
3516: PY_pepy, source);
3517: goto out;
3518: }
3519:
3520: if ((au = (struct type_SNMP_Audit *) calloc (1, sizeof *au)) == NULL)
3521: goto no_mem;
3522: au -> sizeOfEncodingWhichFollows = ps_get_abs (p);
3523:
3524: if ((au -> source = str2qb (source, strlen (source), 1)) == NULL) {
3525: no_mem: ;
3526: advise (LLOG_EXCEPTIONS, NULLCP, "out of memory for audit (%s)",
3527: source);
3528: goto out;
3529: }
3530: (void) time (&now);
3531:
3532: if (tm = gmtime (&now))
3533: tm2ut (tm, ut);
3534: else {
3535: advise (LLOG_EXCEPTIONS, NULLCP, "gmtime failed");
3536:
3537: bzero ((char *) ut, sizeof *ut);
3538: }
3539:
3540: if ((cp = gent2str (ut)) == NULL
3541: || (au -> dateAndTime = str2qb (cp, strlen (cp), 1)) == NULL)
3542: goto no_mem;
3543:
3544: if (encode_SNMP_Audit (&pe, 1, 0, NULLCP, au) != NOTOK) {
3545: PLOGP (pgm_log,SNMP_Audit, pe, "Audit", 0);
3546: PLOGP (pgm_log,SNMP_Message, p, "Message", 0);
3547:
3548: if (pe2ps (audit, pe) == NOTOK || pe2ps (audit, p) == NOTOK)
3549: advise (LLOG_EXCEPTIONS, NULLCP, "pe2ps: %s (%s)",
3550: ps_error (audit -> ps_errno), source);
3551:
3552: (void) ps_flush (audit);
3553: }
3554: else
3555: advise (LLOG_EXCEPTIONS, NULLCP, "encode_SNMP_Audit: %s (%s)",
3556: PY_pepy, source);
3557:
3558: out: ;
3559: if (au)
3560: free_SNMP_Audit (au);
3561: if (pe)
3562: pe_free (pe);
3563: if (p)
3564: pe_free (p);
3565:
3566: return DONE;
3567: }
3568: #endif /* SNMPT */
3569:
3570: /* MISCELLANY */
3571:
3572: static arginit (vec)
3573: char **vec;
3574: {
3575: register char *ap;
3576: #ifdef SNMPT
3577: char *file = "snmp.traps";
3578: FILE *fp;
3579: #endif
3580: #ifdef TCP
3581: int port;
3582: struct NSAPaddr *tcp_na;
3583: register struct servent *sp;
3584: #endif
3585: #ifdef X25
3586: struct NSAPaddr *x25_na;
3587: #endif
3588:
3589: if (myname = rindex (*vec, '/'))
3590: myname++;
3591: if (myname == NULL || *myname == NULL)
3592: myname = *vec;
3593:
3594: isodetailor (myname, 0);
3595: ll_hdinit (pgm_log, myname);
3596:
3597: bzero ((char *) tas, sizeof tas);
3598: tz = tas;
3599:
3600: #ifdef TCP
3601: if (!(ts_stacks & TS_TCP))
3602: tcpservice = 0;
3603: if ((sp = getservbyname ("snmp", "udp")) == NULL)
3604: advise (LLOG_EXCEPTIONS, NULLCP, "udp/snmp: unknown service");
3605:
3606: tcp_na = tz -> ta_addrs;
3607: tcp_na -> na_stack = NA_TCP;
3608: tcp_na -> na_community = ts_comm_tcp_default;
3609: tcp_na -> na_domain[0] = NULL;
3610: #ifndef SNMPT
3611: tcp_na -> na_port = sp ? sp -> s_port : htons ((u_short) 161);
3612: udport = tcp_na -> na_port;
3613: #endif
3614: tz -> ta_naddr = 1;
3615:
3616: tz++;
3617:
3618: if ((sp = getservbyname ("snmp-trap", "udp")) == NULL)
3619: advise (LLOG_EXCEPTIONS, NULLCP, "udp/snmp-trap: unknown service");
3620: #ifndef SNMPT
3621: traport = sp ? sp -> s_port : htons ((u_short) 162);
3622: #else
3623: tcp_na -> na_port = sp ? sp -> s_port : htons ((u_short) 162);
3624: #endif
3625: #endif
3626:
3627: #ifdef COTS
3628: bzero ((char *) taddrs, sizeof taddrs);
3629: bzero ((char *) lru, sizeof lru);
3630: #endif
3631:
3632: #ifdef X25
3633: if (!(ts_stacks & TS_X25))
3634: x25service = 0;
3635:
3636: x25_na = tz -> ta_addrs;
3637: x25_na -> na_stack = NA_X25;
3638: x25_na -> na_community = ts_c_x25_default;
3639: if (x25_local_dte && *x25_local_dte) {
3640: (void) strcpy (x25_na -> na_dte, x25_local_dte);
3641: x25_na -> na_dtelen = strlen (x25_na -> na_dte);
3642: }
3643: #ifndef SNMPT
3644: x25_na -> na_pidlen = str2sel ("03018200", -1, x25_na -> na_pid, NPSIZE);
3645: #else
3646: x25_na -> na_pidlen = str2sel ("03019000", -1, x25_na -> na_pid, NPSIZE);
3647: #endif
3648: tz -> ta_naddr = 1;
3649:
3650: tz++;
3651: #endif
3652:
3653: #ifdef TP4
3654: if (!(ts_stacks & TS_TP4))
3655: tp4service = 0;
3656:
3657: #ifndef SNMPT
3658: bcopy ("snmp", tz -> ta_selector, tz -> ta_selectlen = sizeof "snmp" - 1);
3659: #else
3660: bcopy ("snmp-trap", tz -> ta_selector,
3661: tz -> ta_selectlen = sizeof "snmp-trap" - 1);
3662: #endif
3663: tz -> ta_naddr = 0;
3664:
3665: tz++;
3666: #endif
3667:
3668: for (vec++; ap = *vec; vec++) {
3669: if (*ap == '-')
3670: switch (*++ap) {
3671: case 'd':
3672: debug++;
3673: continue;
3674:
3675: #ifndef SNMPT
3676: case 's':
3677: #ifdef SMUX
3678: smux_enabled = 0;
3679: #endif
3680: continue;
3681: #endif
3682:
3683: case 't':
3684: ts_stacks = TS_TCP;
3685: tcpservice = 1;
3686: x25service = tp4service = 0;
3687: continue;
3688:
3689: case 'x':
3690: ts_stacks = TS_X25;
3691: x25service = 1;
3692: tcpservice = tp4service = 0;
3693: continue;
3694:
3695: case 'z':
3696: ts_stacks = TS_TP4;
3697: tp4service = 1;
3698: tcpservice = x25service = 0;
3699: continue;
3700:
3701: #ifndef SNMPT
3702: case 'r':
3703: rflag = 1;
3704: continue;
3705: #else
3706: case 'f':
3707: if ((file = *++vec) == NULL || *file == '-')
3708: adios (NULLCP, "usage: %s -f audit-file", myname);
3709: continue;
3710: #endif
3711:
3712: #ifdef TCP
3713: case 'p':
3714: if ((ap = *++vec) == NULL
3715: || *ap == '-'
3716: || (port = atoi (ap)) <= 0)
3717: adios (NULLCP, "usage: %s -p portno", myname);
3718: tcp_na -> na_port = htons ((u_short) port);
3719: continue;
3720: #endif
3721:
3722: #ifdef X25
3723: /* This permits listening on a specific subaddress. */
3724: case 'a':
3725: if ((ap = *++vec) == NULL || *ap == '-')
3726: adios (NULLCP, "usage: %s -a x121address", myname);
3727: (void) strcpy (x25_na -> na_dte, ap);
3728: x25_na -> na_dtelen = strlen (ap);
3729: continue;
3730:
3731: /* This permits listening on a specific protocol id.
3732: In fact, SunLink X.25 lets you listen on a protocol
3733: id mask, but let's keep it simple. */
3734: case 'i':
3735: if ((ap = *++vec) == NULL || *ap == '-' )
3736: adios (NULLCP, "usage: %s -i pid", myname);
3737: x25_na -> na_pidlen =
3738: str2sel (ap, -1, x25_na -> na_pid, NPSIZE);
3739: continue;
3740: #endif
3741:
3742: default:
3743: adios (NULLCP, "-%s: unknown switch", ap);
3744: }
3745:
3746: adios (NULLCP, "usage: %s [switches]", myname);
3747: }
3748:
3749: ps_len_strategy = PS_LEN_LONG;
3750:
3751: #ifdef SNMPT
3752: file = _isodefile (isodelogpath, file);
3753: if ((fp = fopen (file, "a")) == NULL)
3754: adios (file, "unable to append to");
3755: if ((audit = ps_alloc (std_open)) == NULLPS)
3756: adios (NULLCP, "ps_alloc(std_open): you lose");
3757: if (std_setup (audit, fp) == NOTOK)
3758: adios (NULLCP, "std_setup: %s", ps_error (audit -> ps_errno));
3759: #endif
3760: }
3761:
3762: /* */
3763:
3764: static envinit () {
3765: int i,
3766: sd;
3767: char file[BUFSIZ];
3768: FILE *fp;
3769:
3770: nbits = getdtablesize ();
3771:
3772: if (debug == 0 && !(debug = isatty (2))) {
3773: for (i = 0; i < 5; i++) {
3774: switch (fork ()) {
3775: case NOTOK:
3776: sleep (5);
3777: continue;
3778:
3779: case OK:
3780: break;
3781:
3782: default:
3783: _exit (0);
3784: }
3785: break;
3786: }
3787:
3788: (void) chdir ("/");
3789:
3790: if ((sd = open ("/dev/null", O_RDWR)) == NOTOK)
3791: adios ("/dev/null", "unable to read");
3792: if (sd != 0)
3793: (void) dup2 (sd, 0), (void) close (sd);
3794: (void) dup2 (0, 1);
3795: (void) dup2 (0, 2);
3796:
3797: #ifdef SETSID
3798: if (setsid () == NOTOK)
3799: advise (LLOG_EXCEPTIONS, "failed", "setsid");
3800: #endif
3801: #ifdef TIOCNOTTY
3802: if ((sd = open ("/dev/tty", O_RDWR)) != NOTOK) {
3803: (void) ioctl (sd, TIOCNOTTY, NULLCP);
3804: (void) close (sd);
3805: }
3806: #else
3807: #ifdef SYS5
3808: (void) setpgrp ();
3809: (void) signal (SIGINT, SIG_IGN);
3810: (void) signal (SIGQUIT, SIG_IGN);
3811: #endif
3812: #endif
3813: }
3814: else
3815: ll_dbinit (pgm_log, myname);
3816:
3817: #ifndef sun /* damn YP... */
3818: for (sd = 3; sd < nbits; sd++)
3819: if (pgm_log -> ll_fd != sd)
3820: (void) close (sd);
3821: #endif
3822:
3823: (void) signal (SIGPIPE, SIG_IGN);
3824:
3825: ll_hdinit (pgm_log, myname);
3826:
3827: #ifndef SNMPT
3828: if (readobjects ("snmpd.defs") == NOTOK)
3829: adios (NULLCP, "readobjects: %s", PY_pepy);
3830:
3831: readmib ();
3832: readconfig ();
3833:
3834: init_snmp ();
3835: #ifdef SMUX
3836: init_smux ();
3837: #endif
3838: init_view ();
3839:
3840: initrap ();
3841: initview ();
3842: checkmib ();
3843:
3844: o_advise = (IFP) advise;
3845: #endif
3846:
3847: (void) sprintf (file, "/etc/%s.pid", myname);
3848: if (fp = fopen (file, "w")) {
3849: (void) fprintf (fp, "%d\n", getpid ());
3850: (void) fclose (fp);
3851: }
3852:
3853: advise (LLOG_NOTICE, NULLCP, "starting");
3854: }
3855:
3856: /* CONFIG */
3857:
3858: #ifndef SNMPT
3859:
3860: int f_community (), f_logging (), f_proxy (), f_trap (), f_variable (),
3861: f_view ();
3862:
3863: static struct pair {
3864: char *p_name; /* runcom directive */
3865: IFP p_handler; /* dispatch */
3866: } pairs[] = {
3867: "community", f_community,
3868: "logging", f_logging,
3869: "proxy", f_proxy,
3870: "trap", f_trap,
3871: "variable", f_variable,
3872: "view", f_view,
3873:
3874: NULL
3875: };
3876:
3877:
3878: static struct wired {
3879: char *w_args1;
3880: char *w_args2;
3881: } wired[] = {
3882: "defViewWholeRW", NULL,
3883: "defViewWholeRO", NULL,
3884: "defViewStandardRW", "mgmt",
3885: "defViewStandardRO", "mgmt",
3886:
3887: NULL
3888: };
3889:
3890: static readconfig () {
3891: register char *cp;
3892: char buffer[BUFSIZ],
3893: line[BUFSIZ],
3894: *vec[NVEC + NSLACK + 1];
3895: register struct community *c;
3896: register struct view *v;
3897: register struct pair *p;
3898: register struct wired *w;
3899: struct stat st;
3900: FILE *fp;
3901:
3902: CHead -> c_forw = CHead -> c_back = CHead;
3903: UHead -> t_forw = UHead -> t_back = UHead;
3904: VHead -> v_forw = VHead -> v_back = VHead;
3905:
3906: if ((localAgent = text2oid ("localAgent")) == NULLOID)
3907: adios (NULLCP, "unknown OID \"localAgent\"");
3908: if ((rfc1157Domain = text2oid ("rfc1157Domain")) == NULLOID)
3909: adios (NULLCP, "unknown OID \"rfc1157Domain\"");
3910:
3911: vec[0] = "view";
3912: for (w = wired; w -> w_args1; w++) {
3913: vec[1] = w -> w_args1;
3914: if (vec[2] = w -> w_args2)
3915: vec[3] = NULL;
3916:
3917: if (f_view (vec) == NOTOK)
3918: adios (NULLCP, "you lose");
3919: }
3920:
3921: (void) strcpy (buffer, "defViewTrapDest.0");
3922: if ((trapview = text2oid (buffer)) == NULLOID)
3923: adios (NULLCP, "unknown OID \"defViewTrapDest.0\" for traps");
3924: trapview -> oid_nelem--;
3925:
3926: bzero ((char *) &snmpstat, sizeof snmpstat);
3927: snmpstat.s_enableauthtraps = TRAPS_ENABLED;
3928:
3929: if ((fp = fopen (cp = "snmpd.rc", "r")) == NULL
3930: && (fp = fopen (cp = isodefile ("snmpd.rc", 0), "r")) == NULL)
3931: adios (cp, "unable to read");
3932:
3933: if (!rflag
3934: && getuid () == 0
3935: && fstat (fileno (fp), &st) != NOTOK
3936: && st.st_uid != 0)
3937: adios (NULLCP, "%s not owned by root", cp);
3938:
3939: while (fgets (buffer, sizeof buffer, fp)) {
3940: if (*buffer == '#')
3941: continue;
3942: if (cp = index (buffer, '\n'))
3943: *cp = NULL;
3944: (void) strcpy (line, buffer);
3945:
3946: bzero ((char *) vec, sizeof vec);
3947: if (str2vec (buffer, vec) < 1)
3948: continue;
3949: for (p = pairs; p -> p_name; p++)
3950: if (lexequ (p -> p_name, vec[0]) == 0) {
3951: if ((*p -> p_handler) (vec) == NOTOK)
3952: advise (LLOG_EXCEPTIONS, NULLCP,
3953: "malformed directive: \"%s\"", line);
3954: break;
3955: }
3956: if (!p -> p_name)
3957: advise (LLOG_EXCEPTIONS, NULLCP, "unknown directive: \"%s\"",
3958: line);
3959: }
3960:
3961: (void) fclose (fp);
3962:
3963: if (CHead -> c_forw == CHead) {
3964: vec[0] = "community";
3965: vec[1] = "public";
3966: vec[2] = NULL;
3967:
3968: (void) f_community (vec);
3969: }
3970:
3971: for (c = CHead -> c_forw; c != CHead; c = c -> c_forw) {
3972: for (v = VHead -> v_forw; v != VHead; v = v -> v_forw)
3973: if (oid_cmp (v -> v_name, c -> c_vu) == 0) {
3974: c -> c_view = v;
3975: break;
3976: }
3977: if (v == VHead)
3978: advise (LLOG_EXCEPTIONS, NULLCP,
3979: "no such view as %s for community \"%s\"",
3980: sprintoid (c -> c_vu), c -> c_name);
3981: }
3982: }
3983:
3984: /* */
3985:
3986: static int f_community (vec)
3987: char **vec;
3988: {
3989: register struct community *c;
3990: register struct NSAPaddr *na;
3991:
3992: vec++;
3993:
3994: if ((c = (struct community *) calloc (1, sizeof *c)) == NULL
3995: || (c -> c_name = strdup (*vec)) == NULL)
3996: adios (NULLCP, "out of memory");
3997: vec++;
3998:
3999: na = &c -> c_addr;
4000: if (*vec) {
4001: if (str2sa (*vec, na, (struct sockaddr *) NULL, 0) == NOTOK)
4002: adios (NULLCP, "unknown address \"%s\" for community \"%s\"",
4003: *vec, c -> c_name);
4004:
4005: vec++;
4006: }
4007: else {
4008: na -> na_stack = NA_TCP;
4009: na -> na_community = ts_comm_tcp_default;
4010: (void) strcpy (na -> na_domain, "0.0.0.0");
4011: }
4012:
4013: if (*vec) {
4014: if (lexequ (*vec, "readOnly") == 0)
4015: c -> c_permission = OT_RDONLY;
4016: else
4017: if (lexequ (*vec, "readWrite") == 0)
4018: c -> c_permission = OT_RDWRITE;
4019: else
4020: if (lexequ (*vec, "writeOnly") == 0)
4021: c -> c_permission = OT_WRONLY;
4022: else
4023: if (lexequ (*vec, "none")) {
4024: advise (LLOG_EXCEPTIONS, NULLCP,
4025: "invalid access mode \"%s\"", *vec);
4026: goto you_lose;
4027: }
4028:
4029: vec++;
4030: }
4031: else
4032: c -> c_permission = OT_RDONLY;
4033:
4034: if (*vec) {
4035: char buffer[BUFSIZ];
4036:
4037: (void) strcpy (buffer, *vec);
4038: if ((c -> c_vu = text2oid (buffer)) == NULLOID) {
4039: advise (LLOG_EXCEPTIONS, NULLCP, "unknown OID \"%s\"", *vec);
4040: goto you_lose;
4041: }
4042:
4043: if (*++vec)
4044: goto you_lose;
4045: }
4046: else
4047: if ((c -> c_vu = text2oid ("defViewWholeRO")) == NULL) {
4048: advise (LLOG_EXCEPTIONS, NULLCP, "unknown OID \"defViewWholeRO\"");
4049: goto you_lose;
4050: }
4051:
4052: insque (c, CHead -> c_back);
4053:
4054: return OK;
4055:
4056: you_lose: ;
4057: free (c -> c_name);
4058: free ((char *) c);
4059:
4060: return NOTOK;
4061: }
4062:
4063: /* */
4064:
4065: static int f_logging (vec)
4066: char **vec;
4067: {
4068: register char **vp;
4069:
4070: for (vp = ++vec; *vp; vp++)
4071: continue;
4072:
4073: log_tai (pgm_log, vec, vp - vec);
4074:
4075: return OK;
4076: }
4077:
4078: /* */
4079:
4080: static int f_proxy (vec)
4081: char **vec;
4082: {
4083: char buffer[BUFSIZ];
4084: register struct community *c;
4085: register struct view *v,
4086: *u;
4087: register struct NSAPaddr *na;
4088:
4089: if ((v = (struct view *) calloc (1, sizeof *v)) == NULL)
4090: adios (NULLCP, "out of memory");
4091: v -> v_subtree.s_forw = v -> v_subtree.s_back = &v -> v_subtree;
4092: if ((c = (struct community *) calloc (1, sizeof *c)) == NULL)
4093: adios (NULLCP, "out of memory");
4094: c -> c_permission = OT_YYY;
4095: vec++;
4096:
4097: (void) strcpy (buffer, *vec);
4098: if ((v -> v_name = text2oid (buffer)) == NULL) {
4099: advise (LLOG_EXCEPTIONS, NULLCP, "unknown OID \"%s\"", *vec);
4100: goto you_lose;
4101: }
4102: c -> c_vu = v -> v_name;
4103: if (trapview && inSubtree (trapview, v -> v_name)) {
4104: advise (LLOG_EXCEPTIONS, NULLCP, "view \"%s\" is for traps", *vec);
4105: goto you_lose;
4106: }
4107: for (u = VHead -> v_forw; u != VHead; u = u -> v_forw)
4108: if (oid_cmp (u -> v_name, v -> v_name) == 0) {
4109: advise (LLOG_EXCEPTIONS, NULLCP, "duplicate view \"%s\"", *vec);
4110: goto you_lose;
4111: }
4112: vec++;
4113:
4114: if (lexequ (*vec, "rfc1157")) {
4115: advise (LLOG_EXCEPTIONS, NULLCP, "unsupported proxy domain \"%s\"",
4116: *vec);
4117: goto you_lose;
4118: }
4119: vec++;
4120:
4121: na = &c -> c_addr;
4122: if (*vec) {
4123: if (str2sa (*vec, na, &v -> v_sa, 1) == NOTOK)
4124: adios (NULLCP, "unknown address \"%s\" for proxy %s",
4125: *vec, oid2ode (v -> v_name));
4126:
4127: vec++;
4128: }
4129: else
4130: goto you_lose;
4131:
4132: if (*vec) {
4133: if ((v -> v_community = str2qb (*vec, strlen (*vec), 1)) == NULL)
4134: adios (NULLCP, "out of memory");
4135: if ((c -> c_name = strdup (*vec)) == NULL)
4136: adios (NULLCP, "out of memory");
4137:
4138: if (*++vec)
4139: goto you_lose;
4140: }
4141: else
4142: goto you_lose;
4143:
4144: insque (v, VHead -> v_back);
4145: insque (c, CHead -> c_back);
4146:
4147: return OK;
4148:
4149: you_lose: ;
4150: if (c -> c_name)
4151: free (c -> c_name);
4152: free ((char *) c);
4153: if (v -> v_name)
4154: oid_free (v -> v_name);
4155: if (v -> v_community)
4156: qb_free (v -> v_community);
4157: free ((char *) v);
4158:
4159: return NOTOK;
4160: }
4161:
4162: /* */
4163:
4164: static int f_trap (vec)
4165: char **vec;
4166: {
4167: register struct trap *t;
4168: register struct view *v;
4169: struct NSAPaddr nas;
4170: register struct NSAPaddr *na = &nas;
4171: static int trapno = 1;
4172:
4173: vec++;
4174:
4175: if ((t = (struct trap *) calloc (1, sizeof *t)) == NULL
4176: || (t -> t_name = strdup (*vec)) == NULL)
4177: adios (NULLCP, "out of memory");
4178: v = t -> t_view = &t -> t_vu;
4179: v -> v_subtree.s_forw = v -> v_subtree.s_back = &v -> v_subtree;
4180: t -> t_generics = 0xfe;
4181: vec++;
4182:
4183: trapview -> oid_elements[trapview -> oid_nelem++] = trapno;
4184: v -> v_name = oid_cpy (trapview);
4185: trapview -> oid_nelem--;
4186: if (v -> v_name == NULLOID)
4187: adios (NULLCP, "out of memory");
4188:
4189: if ((v -> v_community = str2qb (t -> t_name, strlen (t -> t_name), 1))
4190: == NULL)
4191: adios (NULLCP, "out of memory");
4192:
4193: bzero ((char *) na, sizeof *na);
4194: if (*vec) {
4195: if (str2sa (*vec, na, &v -> v_sa, 0) == NOTOK)
4196: adios (NULLCP, "unknown address \"%s\" for trap sink \"%s\"",
4197: *vec, t -> t_name);
4198:
4199: vec++;
4200: }
4201: else
4202: goto you_lose;
4203:
4204: if (*vec) {
4205: char buffer[BUFSIZ];
4206: OID name;
4207: register struct view *u;
4208:
4209: (void) strcpy (buffer, *vec);
4210: if ((name = text2oid (buffer)) == NULL) {
4211: advise (LLOG_EXCEPTIONS, NULLCP, "unknown OID \"%s\"", *vec);
4212: goto you_lose;
4213: }
4214: oid_free (v -> v_name);
4215: v -> v_name = name;
4216:
4217: for (u = VHead -> v_forw; u != VHead; u = u -> v_forw)
4218: if (oid_cmp (u -> v_name, v -> v_name) == 0) {
4219: advise (LLOG_EXCEPTIONS, NULLCP,
4220: "duplicate view \"%s\" for trap sink \"%s\"",
4221: *vec, t -> t_name);
4222: goto you_lose;
4223: }
4224:
4225: vec++;
4226: }
4227: else
4228: trapno++;
4229:
4230: if (*vec) {
4231: if (sscanf (*vec, "%lx", &t -> t_generics) != 1)
4232: goto you_lose;
4233:
4234: if (*++vec)
4235: goto you_lose;
4236: }
4237:
4238: insque (t, UHead -> t_back);
4239: insque (v, VHead -> v_back);
4240:
4241: return OK;
4242:
4243: you_lose: ;
4244: oid_free (v -> v_name);
4245: qb_free (v -> v_community);
4246: free (t -> t_name);
4247: free ((char *) t);
4248:
4249: return NOTOK;
4250: }
4251:
4252: /* */
4253:
4254: static int f_variable (vec)
4255: char **vec;
4256: {
4257: if (*++vec == NULL)
4258: return NOTOK;
4259:
4260: if (lexequ (*vec, "interface") == 0) {
4261: char *name;
4262:
4263: if ((name = *++vec) == NULL)
4264: return NOTOK;
4265: for (vec++; *vec; vec++)
4266: if (index (*vec, '='))
4267: set_interface (name, *vec);
4268: else
4269: return NOTOK;
4270:
4271: return OK;
4272: }
4273:
4274: if (lexequ (*vec, "snmpEnableAuthTraps") == 0) {
4275: ++vec;
4276:
4277: if (lexequ (*vec, "enabled") == 0)
4278: snmpstat.s_enableauthtraps = TRAPS_ENABLED;
4279: else
4280: if (lexequ (*vec, "disabled") == 0)
4281: snmpstat.s_enableauthtraps = TRAPS_DISABLED;
4282:
4283: return OK;
4284: }
4285:
4286: if (!vec[0] || !vec[1] || vec[2])
4287: return NOTOK;
4288:
4289: set_variable (vec[0], vec[1]);
4290:
4291: return OK;
4292: }
4293:
4294: /* */
4295:
4296: static int f_view (vec)
4297: char **vec;
4298: {
4299: char buffer[BUFSIZ];
4300: register struct subtree *s,
4301: *x,
4302: *y;
4303: register struct view *v,
4304: *u;
4305:
4306: if (viewmask == 0) {
4307: advise (LLOG_EXCEPTIONS, NULLCP,
4308: "too many views starting with \"%s\"", *vec);
4309: return NOTOK;
4310: }
4311:
4312: if ((v = (struct view *) calloc (1, sizeof *v)) == NULL)
4313: adios (NULLCP, "out of memory");
4314: s = &v -> v_subtree;
4315: v -> v_subtree.s_forw = v -> v_subtree.s_back = s;
4316: vec++;
4317:
4318: (void) strcpy (buffer, *vec);
4319: if ((v -> v_name = text2oid (buffer)) == NULL) {
4320: advise (LLOG_EXCEPTIONS, NULLCP, "unknown OID \"%s\"", *vec);
4321: goto you_lose;
4322: }
4323: if (trapview && inSubtree (trapview, v -> v_name)) {
4324: advise (LLOG_EXCEPTIONS, NULLCP, "view \"%s\" is for traps", *vec);
4325: goto you_lose;
4326: }
4327: for (u = VHead -> v_forw; u != VHead; u = u -> v_forw)
4328: if (oid_cmp (u -> v_name, v -> v_name) == 0) {
4329: advise (LLOG_EXCEPTIONS, NULLCP, "duplicate view \"%s\"", *vec);
4330: goto you_lose;
4331: }
4332:
4333: for (vec++; *vec; vec++) {
4334: register struct subtree *z;
4335: OID name;
4336:
4337: (void) strcpy (buffer, *vec);
4338: if ((name = text2oid (buffer)) == NULLOID) {
4339: advise (LLOG_EXCEPTIONS, NULLCP, "unknown OID \"%s\"", *vec);
4340: goto you_lose;
4341: }
4342:
4343: for (x = s -> s_forw; x != s; x = y) {
4344: register int i,
4345: j;
4346: y = x -> s_forw;
4347:
4348: if (bcmp ((char *) x -> s_subtree -> oid_elements,
4349: (char *) name -> oid_elements,
4350: ((i = x -> s_subtree -> oid_nelem)
4351: <= (j = name -> oid_nelem) ? i : j)
4352: * sizeof name -> oid_elements[0]) == 0) {
4353: advise (LLOG_EXCEPTIONS, NULLCP,
4354: "%s %s %s",
4355: *vec,
4356: i <= j ? "already under" : "superceding",
4357: oid2ode (x -> s_subtree));
4358: if (i <= j)
4359: goto another;
4360:
4361: remque (x);
4362: oid_free (x -> s_subtree);
4363: free ((char *) x);
4364: }
4365: }
4366:
4367: if ((z = (struct subtree *) calloc (1, sizeof *z)) == NULL)
4368: adios (NULLCP, "out of memory");
4369: z -> s_subtree = name;
4370:
4371: insque (z, s -> s_back);
4372: another: ;
4373: }
4374:
4375: v -> v_mask = viewmask;
4376: viewmask <<= 1;
4377: insque (v, VHead -> v_back);
4378:
4379: return OK;
4380:
4381: you_lose: ;
4382: for (x = s -> s_forw; x != s; x = y) {
4383: y = x -> s_forw;
4384:
4385: remque (x);
4386: oid_free (x -> s_subtree);
4387: free ((char *) x);
4388: }
4389: if (v -> v_name)
4390: oid_free (v -> v_name);
4391: free ((char *) v);
4392:
4393: return NOTOK;
4394: }
4395:
4396: /* */
4397:
4398: static int str2sa (s, na, sock, proxy)
4399: char *s;
4400: struct NSAPaddr *na;
4401: struct sockaddr *sock;
4402: int proxy;
4403: {
4404: #ifdef TCP
4405: register struct hostent *hp;
4406: #endif
4407: struct TSAPaddr *ta;
4408:
4409: #ifdef TCP
4410: if (hp = gethostbystring (s)) {
4411: struct sockaddr_in sin;
4412:
4413: na -> na_stack = NA_TCP;
4414: na -> na_community = ts_comm_tcp_default;
4415: inaddr_copy (hp, &sin);
4416: (void) strncpy (na -> na_domain, inet_ntoa (sin.sin_addr),
4417: sizeof na -> na_domain - 1);
4418: }
4419: else
4420: #endif
4421: if ((ta = str2taddr (s)) && ta -> ta_naddr > 0) {
4422: *na = ta -> ta_addrs[0]; /* struct copy */
4423: }
4424: else
4425: return NOTOK;
4426:
4427: if (sock == NULL)
4428: return OK;
4429:
4430: switch (na -> na_stack) {
4431: #ifdef TCP
4432: case NA_TCP:
4433: if (!tcpservice)
4434: goto you_lose;
4435: {
4436: struct sockaddr_in sin;
4437:
4438: sin.sin_port = na -> na_port ? na -> na_port
4439: : proxy ? udport : traport;
4440:
4441: if ((hp = gethostbystring (na -> na_domain)) == NULL)
4442: return NOTOK;
4443:
4444: sin.sin_family = hp -> h_addrtype;
4445: inaddr_copy (hp, &sin);
4446:
4447: *((struct sockaddr_in *) sock) = sin; /* struct copy */
4448: }
4449: break;
4450: #endif
4451:
4452: default:
4453: you_lose: ;
4454: advise (LLOG_EXCEPTIONS, NULLCP, "address type unsupported");
4455: return NOTOK;
4456: }
4457:
4458: return OK;
4459: }
4460: #endif /* SNMPT */
4461:
4462: /* ERRORS */
4463:
4464: #ifndef lint
4465: void adios (va_alist)
4466: va_dcl
4467: {
4468: va_list ap;
4469:
4470: va_start (ap);
4471:
4472: _ll_log (pgm_log, LLOG_FATAL, ap);
4473:
4474: va_end (ap);
4475:
4476: _exit (1);
4477: }
4478: #else
4479: /* VARARGS */
4480:
4481: void adios (what, fmt)
4482: char *what,
4483: *fmt;
4484: {
4485: adios (what, fmt);
4486: }
4487: #endif
4488:
4489:
4490: #ifndef lint
4491: void advise (va_alist)
4492: va_dcl
4493: {
4494: int code;
4495: va_list ap;
4496:
4497: va_start (ap);
4498:
4499: code = va_arg (ap, int);
4500:
4501: _ll_log (pgm_log, code, ap);
4502:
4503: va_end (ap);
4504: }
4505: #else
4506: /* VARARGS */
4507:
4508: void advise (code, what, fmt)
4509: char *what,
4510: *fmt;
4511: int code;
4512: {
4513: advise (code, what, fmt);
4514: }
4515: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.