![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to snmpi.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 snmpi.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / snmp |
1.1 root 1: /* snmpi.c - really minimal SNMP initiator */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/snmp/RCS/snmpi.c,v 7.13 90/07/09 14:49:34 mrose Exp $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/snmp/RCS/snmpi.c,v 7.13 90/07/09 14:49:34 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: snmpi.c,v $
17: * Revision 7.13 90/07/09 14:49:34 mrose
18: * sync
19: *
20: * Revision 7.12 90/06/23 18:25:14 mrose
21: * now
22: *
23: * Revision 7.11 90/06/23 17:01:55 mrose
24: * update
25: *
26: * Revision 7.10 90/05/12 17:02:09 mrose
27: * sync
28: *
29: * Revision 7.9 90/02/23 17:47:59 mrose
30: * update
31: *
32: * Revision 7.8 90/02/19 19:17:05 mrose
33: * again
34: *
35: * Revision 7.7 90/01/27 08:22:04 mrose
36: * touch-up
37: *
38: * Revision 7.6 90/01/11 18:34:43 mrose
39: * real-sync
40: *
41: * Revision 7.5 89/12/19 17:57:56 mrose
42: * touch-up
43: *
44: * Revision 7.4 89/12/19 16:18:26 mrose
45: * dgram
46: *
47: * Revision 7.3 89/12/12 16:13:47 mrose
48: * touch-up
49: *
50: * Revision 7.2 89/12/11 16:22:33 mrose
51: * more clts
52: *
53: * Revision 7.1 89/12/01 10:42:18 mrose
54: * clts
55: *
56: * Revision 7.0 89/11/23 22:23:30 mrose
57: * Release 6.0
58: *
59: */
60:
61: /*
62: * NOTICE
63: *
64: * Acquisition, use, and distribution of this module and related
65: * materials are subject to the restrictions of a license agreement.
66: * Consult the Preface in the User's Manual for the full terms of
67: * this agreement.
68: *
69: */
70:
71:
72: #include <setjmp.h>
73: #include <signal.h>
74: #include <stdio.h>
75: #include <varargs.h>
76: #include "SNMP-types.h"
77: #include "objects.h"
78: #include <sys/ioctl.h>
79: #include "tailor.h"
80:
81: #include "dgram.h"
82: #include "tsap.h"
83: #ifdef TCP
84: #include "internet.h"
85: #endif
86: #ifdef X25
87: #include "x25.h"
88: #define COTS
89: #endif
90: #ifdef TP4
91: #include "tp4.h"
92: #if !defined(CLTS) && !defined(COTS)
93: #define COTS
94: #endif
95: #endif
96:
97: /* DATA */
98:
99: int debug = 0;
100: static int verbose = 0;
101: static int watch = 0;
102:
103: static char *myname = "snmp";
104:
105: static char **op = NULLVP;
106:
107: static int ontty;
108: static int armed;
109: static jmp_buf intrenv;
110: static int interrupted;
111:
112: static SFP istat;
113:
114: SFD intrser ();
115:
116:
117: static char *defs = NULLCP;
118:
119: static PS ps;
120: static char *community = "public";
121:
122: static int sd;
123: static struct TSAPaddr snmp_ta;
124:
125: char *snmp_error ();
126: struct type_SNMP_Message *new_message ();
127:
128:
129: void adios (), advise ();
130:
131: /* */
132:
133: struct dispatch {
134: char *ds_name; /* command name */
135: IFP ds_fnx; /* dispatch */
136:
137: char *ds_help; /* help string */
138: };
139: struct dispatch *getds ();
140:
141:
142: int f_audit ();
143: int f_dump ();
144: int f_get (), f_get_next (), f_set ();
145: int f_help (), f_quit (), f_status ();
146:
147: static struct dispatch dispatches[] = {
148: "audit", f_audit, "audit traps",
149:
150: "dump", f_dump, "dump a portion of the MIB",
151:
152: "get", f_get, "perform get operation",
153:
154: "help", f_help, "print help information",
155:
156: "next", f_get_next, "perform powerful get-next operation",
157:
158: "quit", f_quit, "terminate program",
159:
160: "set", f_set, "perform set operation",
161:
162: "status", f_status, "report status",
163:
164: NULL
165: };
166:
167:
168: static int helpwidth;
169:
170:
171: #ifndef SYS5
172: long random ();
173: #endif
174: long time ();
175:
176: /* MAIN */
177:
178: /* ARGSUSED */
179:
180: main (argc, argv, envp)
181: int argc;
182: char **argv,
183: **envp;
184: {
185: int eof,
186: status,
187: vecp;
188: char buffer[BUFSIZ],
189: *vec[NVEC + 1];
190:
191: arginit (argv);
192:
193: status = 0;
194: if (op) {
195: vecp = 0;
196: while (*op)
197: vec[vecp++] = *op++;
198: vec[vecp] = NULL;
199:
200: if (snmploop (vec, NOTOK) == NOTOK)
201: status = 1;
202:
203: goto were_out_of_here;
204: }
205:
206: istat = signal (SIGINT, intrser);
207:
208: eof = 0;
209: for (interrupted = 0;; interrupted = 0) {
210: if (getline ("%s> ", buffer) == NOTOK) {
211: if (eof)
212: break;
213:
214: eof = 1;
215: continue;
216: }
217: eof = 0;
218:
219: bzero ((char *) vec, sizeof vec);
220: if ((vecp = str2vec (buffer, vec)) < 1)
221: continue;
222:
223: switch (snmploop (vec, OK)) {
224: case NOTOK:
225: status = 1;
226: break;
227:
228: case OK:
229: default:
230: continue;
231:
232: case DONE:
233: status = 0;
234: break;
235: }
236: break;
237: }
238:
239: (void) signal (SIGINT, istat);
240:
241: were_out_of_here: ;
242: #ifdef COTS
243: if (snmp_ta.ta_addrs -> na_stack != NA_TCP) {
244: struct TSAPdisconnect tds;
245:
246: #ifdef CLTS
247: if (snmp_ta.ta_addrs -> na_stack != NA_NSAP)
248: #endif
249: (void) TDiscRequest (sd, NULLCP, 0, &tds);
250: }
251: #endif
252:
253: exit (status); /* NOTREACHED */
254: }
255:
256: /* */
257:
258: static int snmploop (vec, error)
259: char **vec;
260: int error;
261: {
262: register struct dispatch *ds;
263:
264: if ((ds = getds (strcmp (*vec, "?") ? *vec : "help")) == NULL)
265: return error;
266: switch ((*ds -> ds_fnx) (vec)) {
267: case NOTOK:
268: return error;
269:
270: case OK:
271: default:
272: return OK;
273:
274: case DONE:
275: return DONE;
276: }
277: }
278:
279: /* */
280:
281: static struct dispatch *getds (name)
282: char *name;
283: {
284: register int longest,
285: nmatches;
286: register char *p,
287: *q;
288: char buffer[BUFSIZ];
289: register struct dispatch *ds,
290: *fs;
291:
292: longest = nmatches = 0;
293: for (ds = dispatches; p = ds -> ds_name; ds++) {
294: for (q = name; *q == *p++; q++)
295: if (*q == NULL)
296: return ds;
297:
298: if (*q == NULL)
299: if (q - name > longest) {
300: longest = q - name;
301: nmatches = 1;
302: fs = ds;
303: }
304: else
305: if (q - name == longest)
306: nmatches++;
307: }
308:
309: switch (nmatches) {
310: case 0:
311: advise (NULLCP, "unknown operation \"%s\"", name);
312: return NULL;
313:
314: case 1:
315: return fs;
316:
317: default:
318: for (ds = dispatches, p = buffer; q = ds -> ds_name; ds++)
319: if (strncmp (q, name, longest) == 0) {
320: (void) sprintf (p, "%s \"%s\"", p != buffer ? "," : "", q);
321: p += strlen (p);
322: }
323: advise (NULLCP, "ambiguous operation, it could be one of:%s",
324: buffer);
325: return NULL;
326: }
327: }
328:
329: /* OPERATIONS */
330:
331: static int f_audit (vec)
332: char **vec;
333: {
334: int follow,
335: forever,
336: i;
337: long longtimeago,
338: now;
339: char *cp,
340: *file;
341: PE pe,
342: p;
343: PS ps2;
344: struct type_SNMP_Audit *au;
345: FILE *fp;
346:
347: file = "snmp.traps";
348: if (*++vec != NULL && strcmp (*vec, "-help") == 0) {
349: printf ("audit [-f | -N | +N] [file]\n");
350: printf (" audit trap sink\n");
351: printf (" -f: endless loop\n");
352: printf (" -N: last N traps\n");
353: printf (" +N: first N traps\n");
354: printf (" file: trap file (default %s)", file);
355:
356: return OK;
357: }
358:
359: follow = forever = 0;
360: for (; cp = *vec; vec++)
361: switch (*cp) {
362: case '-':
363: if (strcmp (cp, "-f") == 0)
364: forever++, follow = 0;
365: else
366: follow = -atoi (++cp), forever = 0;
367: break;
368:
369: case '+':
370: follow = atoi (++cp), forever = 0;
371: break;
372:
373: default:
374: file = cp;
375: break;
376: }
377:
378: file = _isodefile (isodelogpath, file);
379: if ((fp = fopen (file, "r")) == NULL) {
380: advise (file, "unable to read");
381: return OK;
382: }
383:
384: pe = p = NULLPE, au = NULL;
385: if ((ps2 = ps_alloc (std_open)) == NULLPS) {
386: advise (NULLCP, "ps_alloc(std_open): you lose");
387: goto out;
388: }
389: if (std_setup (ps2, fp) == NOTOK) {
390: advise (NULLCP, "std_setup: %s", ps_error (ps2 -> ps_errno));
391: goto out;
392: }
393:
394: (void) time (&now);
395: longtimeago = now - 6L * 30L * 24L * 60L * 60L;
396:
397: if (follow < 0) {
398: register long offset,
399: *lp,
400: *ep;
401: long *opp;
402:
403: follow = -follow;
404: if ((opp = (long *) calloc ((unsigned) follow, sizeof *opp)) == NULL)
405: adios (NULLCP, "out of memory");
406: offset = ftell (fp);
407: for (ep = (lp = opp) + follow; lp < ep; lp++)
408: *lp = offset;
409: lp = opp;
410:
411: for (;;) {
412: if ((pe = ps2pe (ps2)) == NULLPE)
413: break;
414: if (decode_SNMP_Audit (pe, 1, NULLIP, NULLVP, &au) == NOTOK)
415: goto bad_audit;
416:
417: fseek (fp, (long) au -> sizeOfEncodingWhichFollows, 1);
418:
419: free_SNMP_Audit (au);
420:
421: *lp++ = offset;
422: if (lp >= ep)
423: lp = opp;
424: offset = ftell (fp);
425: }
426:
427: fseek (fp, *lp, 0);
428: free ((char *) opp);
429: follow = 0;
430: }
431:
432: for (i = 1;; i++) {
433: long mtime;
434: UTC ut;
435:
436: if (follow > 0 && i > follow)
437: break;
438:
439: if ((pe = ps2pe (ps2)) == NULLPE) {
440: if (ps2 -> ps_errno)
441: advise (NULLCP, "ps2pe: %s", ps_error (ps2 -> ps_errno));
442: else
443: if (forever) {
444: clearerr (fp);
445: ps2 -> ps_errno = PS_ERR_NONE;
446: sleep (1);
447: continue;
448: }
449: break;
450: }
451: if (decode_SNMP_Audit (pe, 1, NULLIP, NULLVP, &au) == NOTOK) {
452: bad_audit: ;
453: advise (NULLCP, "decode_SNMP_Audit: %s", PY_pepy);
454: break;
455: }
456:
457: if ((cp = qb2str (au -> dateAndTime)) == NULL) {
458: no_mem: ;
459: advise (NULLCP, "qb2str: out of memory");
460: break;
461: }
462: ut = str2gent (cp, strlen (cp));
463: free (cp);
464: if (ut == NULL) {
465: advise (NULLCP, "str2gent: you lose");
466: break;
467: }
468: mtime = gtime (ut2tm (ut));
469: cp = ctime (&mtime);
470: if (forever)
471: (void) time (&now);
472: if (mtime < longtimeago || mtime > now)
473: printf ("%-7.7s %-4.4s ", cp + 4, cp + 20);
474: else
475: printf ("%-12.12s ", cp + 4);
476:
477: if ((cp = qb2str (au -> source)) == NULL)
478: goto no_mem;
479: printf ("%s\n", cp);
480: free (cp);
481:
482: if ((p = ps2pe (ps2)) == NULLPE) {
483: if (ps2 -> ps_errno)
484: advise (NULLCP, "ps2pe: %s", ps_error (ps2 -> ps_errno));
485: break;
486: }
487: if (print_SNMP_Message (p, 1, NULLIP, NULLVP, NULLCP) == NOTOK)
488: printf ("\n");
489:
490: free_SNMP_Audit (au), au = NULL;
491: }
492:
493: out: ;
494: (void) fclose (fp);
495: if (ps2)
496: ps_free (ps2);
497: if (pe)
498: pe_free (pe);
499: if (p)
500: pe_free (p);
501: if (au)
502: free_SNMP_Audit (au);
503:
504: return OK;
505: }
506:
507: /* */
508:
509: static int f_dump (vec)
510: char **vec;
511: {
512: int request_id;
513: char *nvec[3];
514: OID oid;
515: PE pe;
516: struct type_SNMP_Message *msg;
517: register struct type_SNMP_PDU *parm;
518: register struct type_SNMP_VarBindList *vp;
519:
520: if (*++vec != NULL && strcmp (*vec, "-help") == 0) {
521: printf ("dump [object]\n");
522: printf (" with no arguments, dump entire MIB\n");
523: printf (" with an argument, dump a portion of the MIB\n");
524:
525: return OK;
526: }
527:
528: nvec[0] = "dump";
529: nvec[1] = *vec ? *vec : "mib-2";
530: nvec[2] = NULL;
531:
532: if ((msg = new_message (type_SNMP_PDUs_get__next__request, nvec)) == NULL)
533: return OK;
534:
535: request_id = msg -> data -> un.get__response -> request__id = 0;
536:
537: if (*vec) {
538: if ((oid = oid_cpy (msg -> data -> un.get__next__request ->
539: variable__bindings -> VarBind -> name)) == NULLOID)
540: adios (NULLCP, "out of memory");
541: }
542: else
543: oid = NULLOID;
544:
545: again: ;
546: pe = NULLPE;
547:
548: if (encode_SNMP_Message (&pe, 1, 0, NULLCP, msg) != NOTOK) {
549: if (watch)
550: (void) print_SNMP_Message (pe, 1, NULLIP, NULLVP, NULLCP);
551:
552: if (pe2ps (ps, pe) == NOTOK) {
553: advise (NULLCP, "pe2ps: %s", ps_error (ps -> ps_errno));
554: goto out;
555: }
556: }
557: else
558: advise (NULLCP, "encode_SNMP_Message: %s", PY_pepy);
559:
560: try_again: ;
561: if (pe)
562: pe_free (pe);
563: pe = NULLPE;
564:
565: free_SNMP_Message (msg);
566: msg = NULL;
567:
568: if ((pe = ps2pe (ps)) == NULLPE) {
569: advise (NULLCP, "ps2pe: %s", ps_error (ps -> ps_errno));
570: goto out;
571: }
572:
573: if (decode_SNMP_Message (pe, 1, NULLIP, NULLVP, &msg) == NOTOK) {
574: advise (NULLCP, "decode_SNMP_Message: %s", PY_pepy);
575: goto out;
576: }
577:
578: if (watch)
579: (void) print_SNMP_Message (pe, 1, NULLIP, NULLVP, NULLCP);
580:
581: if (msg -> data -> offset != type_SNMP_PDUs_get__response) {
582: advise (NULLCP, "unexpected message type %d",
583: msg -> data -> offset);
584: goto out;
585: }
586:
587: if ((parm = msg -> data -> un.get__response) -> request__id
588: != request_id) {
589: fprintf (stderr, "request-id mismatch (got %d, wanted %d)\n",
590: parm -> request__id, request_id);
591: goto try_again;
592: }
593:
594: if (parm -> error__status != int_SNMP_error__status_noError) {
595: if (parm -> error__status != int_SNMP_error__status_noSuchName)
596: fprintf (stderr, "%s at position %d\n",
597: snmp_error (parm -> error__status), parm -> error__index);
598: goto out;
599: }
600:
601: for (vp = parm -> variable__bindings; vp; vp = vp -> next) {
602: caddr_t value;
603: register OI oi;
604: register OS os;
605: register struct type_SNMP_VarBind *v = vp -> VarBind;
606:
607: if (oid
608: && (oid -> oid_nelem > v -> name -> oid_nelem
609: || bcmp ((char *) oid -> oid_elements,
610: (char *) v -> name -> oid_elements,
611: oid -> oid_nelem
612: * sizeof oid -> oid_elements[0])))
613: goto out;
614:
615: printf ("%s=", oid2ode (vp -> VarBind -> name));
616: if ((oi = name2inst (v -> name)) == NULL
617: || (os = oi -> oi_type -> ot_syntax) == NULL
618: || (*os -> os_decode) (&value, v -> value) == NOTOK)
619: vunknown (v -> value);
620: else {
621: (*os -> os_print) (value, os);
622: printf ("\n");
623:
624: (*os -> os_free) (value);
625: }
626: }
627:
628: if (pe)
629: pe_free (pe);
630: msg -> data -> offset = type_SNMP_PDUs_get__next__request;
631: request_id = ++parm -> request__id;
632: goto again;
633:
634: out: ;
635: if (oid)
636: oid_free (oid);
637: if (pe)
638: pe_free (pe);
639: if (msg)
640: free_SNMP_Message (msg);
641:
642: return OK;
643: }
644:
645: /* */
646:
647: static int f_get (vec)
648: char **vec;
649: {
650: (void) process (new_message (type_SNMP_PDUs_get__request, vec));
651: }
652:
653: /* */
654:
655: static int f_get_next (vec)
656: char **vec;
657: {
658: (void) process (new_message (type_SNMP_PDUs_get__next__request, vec));
659: }
660:
661: /* */
662:
663: static int f_set (vec)
664: char **vec;
665: {
666: (void) process (new_message (type_SNMP_PDUs_set__request, vec));
667: }
668:
669: /* */
670:
671: static char *errors[] = {
672: "noError", "tooBig", "noSuchName", "badValue", "readOnly", "genErr"
673: };
674:
675:
676: static char *snmp_error (i)
677: int i;
678: {
679: static char buffer[BUFSIZ];
680:
681: if (0 < i && i < sizeof errors / sizeof errors[0])
682: return errors[i];
683: (void) sprintf (buffer, "error %d", i);
684:
685: return buffer;
686: }
687:
688: /* */
689:
690: static struct type_SNMP_Message *new_message (offset, vec)
691: int offset;
692: char **vec;
693: {
694: register struct type_SNMP_Message *msg;
695: register struct type_SNMP_PDUs *pdu;
696: register struct type_SNMP_PDU *parm;
697: register struct type_SNMP_VarBindList **vp;
698:
699: if ((msg = (struct type_SNMP_Message *) calloc (1, sizeof *msg)) == NULL)
700: adios (NULLCP, "out of memory");
701:
702: msg -> version = int_SNMP_version_version__1;
703:
704: if ((msg -> community = str2qb (community, strlen (community), 1)) == NULL)
705: adios (NULLCP, "out of memory");
706:
707: if ((pdu = (struct type_SNMP_PDUs *) calloc (1, sizeof *pdu)) == NULL)
708: adios (NULLCP, "out of memory");
709: msg -> data = pdu;
710:
711: pdu -> offset = offset;
712:
713: /* for now, always a PDU... */
714:
715: if ((parm = (struct type_SNMP_PDU *) calloc (1, sizeof *parm)) == NULL)
716: adios (NULLCP, "out of memory");
717: pdu -> un.get__request = parm;
718:
719: #ifndef SYS5
720: parm -> request__id = ((int) random ()) & 0x7fffffff;
721: #else
722: parm -> request__id = ((int) rand ()) & 0x7fffffff;
723: #endif
724:
725: vp = &parm -> variable__bindings;
726: for (vec++; *vec; vec++) {
727: register struct type_SNMP_VarBindList *bind;
728: register struct type_SNMP_VarBind *v;
729:
730: if ((bind = (struct type_SNMP_VarBindList *) calloc (1, sizeof *bind))
731: == NULL)
732: adios (NULLCP, "out of memory");
733: *vp = bind, vp = &bind -> next;
734:
735: if ((v = (struct type_SNMP_VarBind *) calloc (1, sizeof *v)) == NULL)
736: adios (NULLCP, "out of memory");
737: bind -> VarBind = v;
738:
739: if (get_ava (v, *vec, offset) == NOTOK) {
740: free_SNMP_Message (msg);
741: return NULL;
742: }
743: }
744:
745: return msg;
746: }
747:
748: /* */
749:
750: static int get_ava (v, ava, offset)
751: register struct type_SNMP_VarBind *v;
752: char *ava;
753: int offset;
754: {
755: int result;
756: caddr_t value;
757: register char *cp;
758: register OI oi;
759: register OT ot;
760: register OS os;
761: OID oid;
762:
763: if (cp = index (ava, '=')) {
764: if (offset != type_SNMP_PDUs_set__request)
765: advise (NULLCP, "value unnecessary for get operation");
766: *cp++ = NULL;
767: }
768: else
769: if (offset == type_SNMP_PDUs_set__request) {
770: advise (NULLCP, "need variable=value for set operation");
771: return NOTOK;
772: }
773:
774: if ((oi = text2inst (ava)) == NULL) {
775: if (cp || (oid = text2oid (ava)) == NULL) {
776: advise (NULLCP, "unknown variable \"%s\"", ava);
777: return NOTOK;
778: }
779:
780: ot = NULLOT;
781: }
782: else
783: ot = oi -> oi_type;
784:
785: if ((v -> name = oid_cpy (oi ? oi -> oi_name : oid)) == NULLOID)
786: adios (NULLCP, "out of memory");
787:
788: if (cp == NULL) {
789: if ((v -> value = pe_alloc (PE_CLASS_UNIV, PE_FORM_PRIM, PE_PRIM_NULL))
790: == NULLPE)
791: adios (NULLCP, "out of memory");
792: }
793: else {
794: if ((os = ot -> ot_syntax) == NULL) {
795: advise (NULLCP, "no syntax defined for object \"%s\"", ava);
796: return NOTOK;
797: }
798:
799: if ((*os -> os_parse) (&value, cp) == NOTOK) {
800: advise (NULLCP, "invalid value for variable \"%s\": \"%s\"",
801: ava, cp);
802: return NOTOK;
803: }
804: result = (*os -> os_encode) (value, &v -> value);
805: (*os -> os_free) (value);
806:
807: if (result == NOTOK) {
808: advise (NULLCP, "encoding error for variable \"%s\"", ava);
809: return NOTOK;
810: }
811: }
812:
813: if (oi == NULL)
814: oid_free (oid);
815:
816: return OK;
817: }
818:
819: /* */
820:
821: static int process (msg)
822: struct type_SNMP_Message *msg;
823: {
824: int request_id;
825: PE pe;
826: register struct type_SNMP_PDU *parm;
827: register struct type_SNMP_VarBindList *vp;
828:
829: if (msg == NULL)
830: return OK;
831:
832: request_id = msg -> data -> un.get__request -> request__id;
833: if (encode_SNMP_Message (&pe, 1, 0, NULLCP, msg) != NOTOK) {
834: if (watch)
835: (void) print_SNMP_Message (pe, 1, NULLIP, NULLVP, NULLCP);
836:
837: if (pe2ps (ps, pe) == NOTOK) {
838: advise (NULLCP, "pe2ps: %s", ps_error (ps -> ps_errno));
839: goto out;
840: }
841: }
842: else
843: advise (NULLCP, "encode_SNMP_Message: %s", PY_pepy);
844:
845: try_again: ;
846: if (pe)
847: pe_free (pe);
848: pe = NULLPE;
849:
850: free_SNMP_Message (msg);
851: msg = NULL;
852:
853: if ((pe = ps2pe (ps)) == NULLPE) {
854: advise (NULLCP, "ps2pe: %s", ps_error (ps -> ps_errno));
855: goto out;
856: }
857:
858: if (decode_SNMP_Message (pe, 1, NULLIP, NULLVP, &msg) == NOTOK) {
859: advise (NULLCP, "decode_SNMP_Message: %s", PY_pepy);
860: goto out;
861: }
862:
863: if (watch)
864: (void) print_SNMP_Message (pe, 1, NULLIP, NULLVP, NULLCP);
865:
866: if (msg -> data -> offset != type_SNMP_PDUs_get__response) {
867: advise (NULLCP, "unexpected message type %d",
868: msg -> data -> offset);
869: goto out;
870: }
871:
872: if ((parm = msg -> data -> un.get__response) -> request__id
873: != request_id) {
874: fprintf (stderr, "request-id mismatch (got %d, wanted %d)\n",
875: parm -> request__id, request_id);
876: goto try_again;
877: }
878:
879: if (parm -> error__status != int_SNMP_error__status_noError) {
880: fprintf (stderr, "%s at position %d\n",
881: snmp_error (parm -> error__status), parm -> error__index);
882: goto out;
883: }
884:
885: for (vp = parm -> variable__bindings; vp; vp = vp -> next) {
886: caddr_t value;
887: register OI oi;
888: register OS os;
889: register struct type_SNMP_VarBind *v = vp -> VarBind;
890:
891: if ((oi = name2inst (v -> name)) == NULL) {
892: advise (NULLCP, "unknown variable \"%s\"", oid2ode (v -> name));
893: no_dice: ;
894: printf ("%s=", oid2ode (v -> name));
895: vunknown (v -> value);
896: continue;
897: }
898: if ((os = oi -> oi_type -> ot_syntax) == NULL) {
899: advise (NULLCP, "unknown syntax for object \"%s\"",
900: oi -> oi_type -> ot_text);
901: goto no_dice;
902: }
903: if ((*os -> os_decode) (&value, v -> value) == NOTOK) {
904: advise (NULLCP, "decode error for variable \"%s\"",
905: oid2ode (v -> name));
906: goto no_dice;
907: }
908:
909: printf ("%s=", oid2ode (v -> name));
910: (*os -> os_print) (value, os);
911: printf ("\n");
912:
913: (*os -> os_free) (value);
914: }
915:
916: out: ;
917: if (pe)
918: pe_free (pe);
919: if (msg)
920: free_SNMP_Message (msg);
921:
922: return OK;
923: }
924:
925: /* */
926:
927: static int f_help (vec)
928: char **vec;
929: {
930: register int i,
931: j,
932: w;
933: int columns,
934: width,
935: lines;
936: register struct dispatch *ds,
937: *es;
938:
939: for (es = dispatches; es -> ds_name; es++)
940: continue;
941: width = helpwidth;
942:
943: if (*++vec == NULL) {
944: if ((columns = ncols (stdout) / (width = (width + 8) & ~7)) == 0)
945: columns = 1;
946: lines = ((es - dispatches) + columns - 1) / columns;
947:
948: printf ("Operations:\n");
949: for (i = 0; i < lines; i++)
950: for (j = 0; j < columns; j++) {
951: ds = dispatches + j * lines + i;
952: printf ("%s", ds -> ds_name);
953: if (ds + lines >= es) {
954: printf ("\n");
955: break;
956: }
957: for (w = strlen (ds -> ds_name); w < width; w = (w + 8) & ~7)
958: (void) putchar ('\t');
959: }
960: printf ("\n");
961:
962: return OK;
963: }
964:
965: if (strcmp (*vec, "-help") == 0) {
966: printf ("help [commands ...]\n");
967: printf (" with no arguments, lists operations which may be invoked\n");
968: printf (" otherwise prints help for each operation given\n");
969:
970: return OK;
971: }
972:
973: for (; *vec; vec++)
974: if (strcmp (*vec, "?") == 0) {
975: for (ds = dispatches; ds -> ds_name; ds++)
976: printf ("%-*s\t- %s\n", width, ds -> ds_name, ds -> ds_help);
977:
978: break;
979: }
980: else
981: if (ds = getds (*vec))
982: printf ("%-*s\t- %s\n", width, ds -> ds_name, ds -> ds_help);
983:
984: return OK;
985: }
986:
987: /* */
988:
989: static int f_quit (vec)
990: char **vec;
991: {
992: if (vec && *++vec != NULL && strcmp (*vec, "-help") == 0) {
993: printf ("quit\n");
994: printf (" terminate fred\n");
995:
996: return OK;
997: }
998:
999: return DONE;
1000: }
1001:
1002: /* */
1003:
1004: static int f_status (vec)
1005: char **vec;
1006: {
1007: if (*++vec != NULL && strcmp (*vec, "-help") == 0) {
1008: printf ("status\n");
1009: printf (" report status\n");
1010:
1011: return OK;
1012: }
1013:
1014: printf ("Connected to %s using community \"%s\"\n",
1015: taddr2str (&snmp_ta), community);
1016:
1017: return OK;
1018: }
1019:
1020: /* SYNTAX */
1021:
1022: static char *ifType[] = {
1023: "other", "regular1822", "hdh1822", "ddn-x25", "rfc877-x25",
1024: "ethernet-csmacd", "iso88023-csmacd", "iso88024-tokenBus",
1025: "iso88025-tokenRing", "iso88026-man", "starLan", "proteon-10Mbit",
1026: "proteon-80Mbit", "hyperchannel", "fddi", "lapb", "sdlc", "t1-carrier",
1027: "cept", "basicISDN", "primaryISDN", "propPointToPointSerial",
1028: "ppp", "softwareLoopback", "eon", "ethernet-3Mbit",
1029: "nsip", "slip"
1030: };
1031:
1032: static char *ifStatus[] = {
1033: "up", "down", "testing"
1034: };
1035:
1036: static char *ipForwarding[] = {
1037: "gateway", "host"
1038: };
1039:
1040: static char *routeType[] = {
1041: "other", "invalid", "direct", "remote"
1042: };
1043:
1044: static char *ipRouteProto[] = {
1045: "other", "local", "netmgmt", "icmp", "egp", "ggp", "hello", "rip", "is-is",
1046: "es-is", "ciscoIgrp", "bbnSpfIgp", "ospf", "bgp"
1047: };
1048:
1049: static char *netToMediaType[] = {
1050: "other", "invalid", "dynamic", "static"
1051: };
1052:
1053: static char *tcpRtoAlgorithm[] = {
1054: "other", "constant", "rsre", "vanj"
1055: };
1056:
1057: static char *tcpConnState[] = {
1058: "closed", "listen", "synSent", "synReceived", "established", "finWait1",
1059: "finWait2", "closeWait", "lastAck", "closing", "timewait"
1060: };
1061:
1062: static char *egpNeighState[] = {
1063: "idle", "acquisition", "down", "up", "cease"
1064: };
1065:
1066: static char *egpNeighMode[] = {
1067: "active", "passive"
1068: };
1069:
1070: static char *egpNeighEventTrigger[] = {
1071: "start", "stop"
1072: };
1073:
1074: static char *enabled[] = {
1075: "enabled", "disabled"
1076: };
1077:
1078: static char *clnpForwarding[] = {
1079: "is", "es"
1080: };
1081:
1082: static char *clnpRouteProto[] = {
1083: "other", "local", "netmgmt", "", "", "", "", "", "is-is", "",
1084: "ciscoIgrp", "bbnSpfIgp", "ospf", "bgp"
1085: };
1086:
1087:
1088: static char *status[] = {
1089: "valid", "invalid"
1090: };
1091:
1092: static char *smuxPstatus[] = {
1093: "valid", "invalid", "connecting"
1094: };
1095:
1096:
1097: static struct ivar {
1098: char *iv_object;
1099:
1100: char **iv_values;
1101: int iv_nvalue;
1102: } ivars[] = {
1103: "ifType", ifType,
1104: sizeof ifType / sizeof ifType[0],
1105:
1106: "ifAdminStatus", ifStatus,
1107: sizeof ifStatus / sizeof ifStatus[0],
1108:
1109: "ifOperStatus", ifStatus,
1110: sizeof ifStatus / sizeof ifStatus[0],
1111:
1112: "ipForwarding", ipForwarding,
1113: sizeof ipForwarding / sizeof ipForwarding[0],
1114:
1115: "ipRouteType", routeType,
1116: sizeof routeType / sizeof routeType[0],
1117:
1118: "ipRouteProto", ipRouteProto,
1119: sizeof ipRouteProto / sizeof ipRouteProto[0],
1120:
1121: "ipNetToMediaType", netToMediaType,
1122: sizeof netToMediaType / sizeof netToMediaType[0],
1123:
1124: "tcpRtoAlgorithm", tcpRtoAlgorithm,
1125: sizeof tcpRtoAlgorithm / sizeof tcpRtoAlgorithm[0],
1126:
1127: "tcpConnState", tcpConnState,
1128: sizeof tcpConnState / sizeof tcpConnState[0],
1129:
1130: "egpNeighState", egpNeighState,
1131: sizeof egpNeighState / sizeof egpNeighState[0],
1132:
1133: "egpNeighMode", egpNeighMode,
1134: sizeof egpNeighMode / sizeof egpNeighMode[0],
1135:
1136: "egpNeighEventTrigger", egpNeighEventTrigger,
1137: sizeof egpNeighEventTrigger / sizeof egpNeighEventTrigger[0],
1138:
1139: "snmpEnableAuthTraps", enabled,
1140: sizeof enabled / sizeof enabled[0],
1141:
1142: "clnpForwarding", clnpForwarding,
1143: sizeof clnpForwarding / sizeof clnpForwarding[0],
1144:
1145: "clnpRouteType", routeType,
1146: sizeof routeType / sizeof routeType[0],
1147:
1148: "clnpRouteProto", clnpRouteProto,
1149: sizeof clnpRouteProto / sizeof clnpRouteProto[0],
1150:
1151: "clnpNetToMediaType", netToMediaType,
1152: sizeof netToMediaType / sizeof netToMediaType[0],
1153:
1154: "clnpMediaToNetType", netToMediaType,
1155: sizeof netToMediaType / sizeof netToMediaType[0],
1156:
1157: "viewPrimType", status,
1158: sizeof status / sizeof status[0],
1159:
1160: "viewAclType", status,
1161: sizeof status / sizeof status[0],
1162:
1163: "viewTrapType", status,
1164: sizeof status / sizeof status[0],
1165:
1166: "viewTranType", status,
1167: sizeof status / sizeof status[0],
1168:
1169: "smuxPstatus", smuxPstatus,
1170: sizeof smuxPstatus / sizeof smuxPstatus[0],
1171:
1172: "smuxTstatus", status,
1173: sizeof status / sizeof status[0],
1174:
1175: "unixNetstat", enabled,
1176: sizeof enabled / sizeof enabled[0],
1177:
1178: NULL
1179: };
1180:
1181: /* */
1182:
1183: static int enum_print (x, os)
1184: integer *x;
1185: OS os;
1186: {
1187: int i = *x;
1188:
1189: if (i <= 0 || i > os -> os_data2)
1190: printf ("unknown(%d)", i);
1191: else
1192: printf ("%s(%d)", os -> os_data1[i - 1], i);
1193: }
1194:
1195:
1196: static moresyntax () {
1197: register struct ivar *iv;
1198: register OT ot;
1199: register OS os;
1200:
1201: for (iv = ivars; iv -> iv_object; iv++)
1202: if (ot = text2obj (iv -> iv_object)) {
1203: if ((os = ot -> ot_syntax) == NULL) {
1204: advise (NULLCP, "no syntax defined for object \"%s\"",
1205: iv -> iv_object);
1206: continue;
1207: }
1208:
1209: (void) add_syntax (iv -> iv_object, os -> os_encode,
1210: os -> os_decode, os -> os_free, os -> os_parse,
1211: enum_print);
1212: if ((os = text2syn (iv -> iv_object)) == NULL)
1213: adios (NULLCP, "lost syntax for object \"%s\"",
1214: iv -> iv_object);
1215: ot -> ot_syntax = os;
1216: os -> os_data1 = iv -> iv_values;
1217: os -> os_data2 = iv -> iv_nvalue;
1218: }
1219: else
1220: advise (NULLCP, "no \"%s\" object", iv -> iv_object);
1221: }
1222:
1223: /* MISCELLANY */
1224:
1225: static arginit (vec)
1226: char **vec;
1227: {
1228: int w;
1229: register char *ap,
1230: *pp;
1231: register struct dispatch *ds;
1232: #ifdef TCP
1233: int port;
1234: struct sockaddr_in in_socket;
1235: register struct sockaddr_in *isock = &in_socket;
1236: register struct hostent *hp;
1237: register struct servent *sp;
1238: #endif
1239: register struct TSAPaddr *ta = &snmp_ta,
1240: *tz;
1241: register struct NSAPaddr *na = ta -> ta_addrs;
1242:
1243: if (myname = rindex (*vec, '/'))
1244: myname++;
1245: if (myname == NULL || *myname == NULL)
1246: myname = *vec;
1247:
1248: isodetailor (myname, 1);
1249:
1250: if (ontty = isatty (fileno (stdin)))
1251: verbose++;
1252:
1253: if ((sp = getservbyname ("snmp", "udp")) == NULL)
1254: advise (NULLCP, "udp/snmp: unknown service");
1255:
1256: bzero ((char *) ta, sizeof *ta);
1257: #ifdef TCP
1258: na -> na_stack = NA_TCP;
1259: na -> na_community = ts_comm_tcp_default;
1260: (void) strncpy (na -> na_domain, getlocalhost (),
1261: sizeof na -> na_domain - 1);
1262: na -> na_port = sp ? sp -> s_port : htons ((u_short) 161);
1263: na -> na_tset = NA_TSET_UDP;
1264: ta -> ta_naddr = 1;
1265: #endif
1266:
1267: for (vec++; ap = *vec; vec++) {
1268: if (*ap == '-') {
1269: while (*++ap)
1270: switch (*ap) {
1271: case 'a': /* e.g., NS+0504030201 */
1272: if ((pp = *++vec) == NULL || *pp == '-')
1273: adios (NULLCP, "usage: %s -a agent", myname);
1274: #ifdef TCP
1275: if (hp = gethostbystring (pp)) {
1276: if (na -> na_stack != NA_TCP)
1277: adios (NULLCP, "use -a at most once...");
1278: inaddr_copy (hp, isock);
1279: (void) strncpy (na -> na_domain,
1280: inet_ntoa (isock -> sin_addr),
1281: sizeof na -> na_domain - 1);
1282: }
1283: else
1284: #endif
1285: if ((tz = str2taddr (pp)) && tz -> ta_naddr > 0) {
1286: *ta = *tz; /* struct copy */
1287: if (na -> na_stack == NA_TCP) {
1288: if (na -> na_port == 0)
1289: na -> na_port = sp ? sp -> s_port
1290: : htons ((u_short) 161);
1291: na -> na_tset = NA_TSET_UDP;
1292: }
1293: }
1294: else
1295: adios (NULLCP, "%s: unknown host", pp);
1296: break;
1297:
1298: #ifdef TCP
1299: case 'p':
1300: if ((pp = *++vec) == NULL
1301: || *pp == '-'
1302: || (port = atoi (pp)) <= 0)
1303: adios (NULLCP, "usage: %s -p portno", myname);
1304: if (na -> na_stack != NA_TCP)
1305: adios (NULLCP, "-p not allowed with %s",
1306: taddr2str (ta));
1307: na -> na_port = htons ((u_short) port);
1308: break;
1309: #endif
1310:
1311: case 'c':
1312: if ((pp = *++vec) == NULL || *pp == '-')
1313: adios (NULLCP, "usage: %s -c community", myname);
1314: community = pp;
1315: break;
1316:
1317: case 'd':
1318: debug++;
1319: break;
1320:
1321: case 'v':
1322: verbose++;
1323: break;
1324:
1325: case 'w':
1326: watch++;
1327: break;
1328:
1329: case 'f':
1330: if ((pp = *++vec) == NULL || *pp == '-')
1331: adios (NULLCP, "usage: %s -f file", myname);
1332: defs = pp;
1333: break;
1334:
1335: default:
1336: adios (NULLCP, "unknown switch -%c", *ap);
1337: }
1338: continue;
1339: }
1340: if (op == NULL) {
1341: op = vec;
1342: break;
1343: }
1344: }
1345:
1346: helpwidth = 0;
1347: for (ds = dispatches; ds -> ds_name; ds++)
1348: if ((w = strlen (ds -> ds_name)) > helpwidth)
1349: helpwidth = w;
1350:
1351: if (ta -> ta_naddr == 0)
1352: adios (NULLCP, "usage: %s -a string", myname);
1353: switch (na -> na_stack) {
1354: case NA_TCP:
1355: #ifdef TCP
1356: {
1357: struct sockaddr_in lo_socket;
1358: register struct sockaddr_in *lsock = &lo_socket;
1359:
1360: bzero ((char *) lsock, sizeof *lsock);
1361: if ((hp = gethostbystring (pp = getlocalhost ())) == NULL)
1362: adios (NULLCP, "%s: unknown host", pp);
1363: lsock -> sin_family = hp -> h_addrtype;
1364: inaddr_copy (hp, lsock);
1365: if ((sd = start_udp_client (lsock, 0, 0, 0)) == NOTOK)
1366: adios ("failed", "start_udp_client");
1367:
1368: bzero ((char *) isock, sizeof *isock);
1369: if ((hp = gethostbystring (na -> na_domain)) == NULL)
1370: adios (NULLCP, "%s: unknown host", na -> na_domain);
1371: isock -> sin_family = hp -> h_addrtype;
1372: isock -> sin_port = na -> na_port;
1373: inaddr_copy (hp, isock);
1374:
1375: if (join_udp_server (sd, isock) == NOTOK)
1376: adios ("failed", "join_udp_server");
1377:
1378: if ((ps = ps_alloc (dg_open)) == NULLPS
1379: || dg_setup (ps, sd, MAXDGRAM, read_udp_socket,
1380: write_udp_socket) == NOTOK) {
1381: if (ps == NULLPS)
1382: adios (NULLCP, "ps_alloc: out of memory");
1383: else
1384: adios (NULLCP, "dg_setup: %s",
1385: ps_error (ps -> ps_errno));
1386: }
1387: }
1388: break;
1389: #else
1390: adios (NULLCP, "UDP support not configured");
1391: #endif
1392:
1393: case NA_X25:
1394: #ifdef X25
1395: goto cots;
1396: #else
1397: adios (NULLCP, "X.25 support not configured");
1398: #endif
1399:
1400: case NA_NSAP:
1401: #ifdef CLTS
1402: {
1403: union sockaddr_osi lo_socket;
1404: register union sockaddr_osi *lsock = &lo_socket;
1405:
1406: bzero ((char *) lsock, sizeof *lsock);
1407: if ((sd = start_clts_client (lsock, 0, 0, 0)) == NOTOK)
1408: adios ("failed", "start_clts_client");
1409:
1410: (void) gen2tp4 (ta, lsock);
1411: if (join_clts_server (sd, lsock) == NOTOK)
1412: adios ("failed", "join_udp_server");
1413:
1414: if ((ps = ps_alloc (dg_open)) == NULLPS
1415: || dg_setup (ps, sd, MAXDGRAM, read_clts_socket,
1416: write_clts_socket) == NOTOK) {
1417: if (ps == NULLPS)
1418: adios (NULLCP, "ps_alloc: out of memory");
1419: else
1420: adios (NULLCP, "dg_setup: %s",
1421: ps_error (ps -> ps_errno));
1422: }
1423: }
1424: break;
1425: #else
1426: #ifdef TP4
1427: goto cots;
1428: #else
1429: adios (NULLCP, "TP4 support not configured");
1430: #endif
1431: #endif
1432:
1433: default:
1434: adios (NULLCP, "unknown network type 0x%x", na -> na_stack);
1435: /* NOT REACHED */
1436:
1437: #ifdef COTS
1438: cots: ;
1439: {
1440: struct TSAPconnect tcs;
1441: register struct TSAPconnect *tc = &tcs;
1442: struct TSAPdisconnect tds;
1443: register struct TSAPdisconnect *td = &tds;
1444:
1445: if (verbose) {
1446: fprintf (stderr, "%s... ", taddr2str (ta));
1447: (void) fflush (stderr);
1448: }
1449: if (TConnRequest (NULLTA, ta, 0, NULLCP, 0, NULLQOS, tc, td)
1450: == NOTOK) {
1451: if (verbose)
1452: fprintf (stderr," failed\n");
1453: adios (NULLCP, td -> td_cc > 0
1454: ? "T-CONNECT.REQUEST: [%s] %*.*s"
1455: : "T-CONNECT.REQUEST: [%s]",
1456: TErrString (td -> td_reason),
1457: td -> td_cc, td -> td_cc, td -> td_data);
1458: }
1459: fprintf (stderr, "connected\n");
1460:
1461: if ((ps = ps_alloc (dg_open)) == NULLPS
1462: || dg_setup (ps, sd = tc -> tc_sd, MAXDGRAM, ts_read,
1463: ts_write) == NOTOK) {
1464: if (ps == NULLPS)
1465: adios (NULLCP, "ps_alloc: out of memory");
1466: else
1467: adios (NULLCP, "dg_setup: %s",
1468: ps_error (ps -> ps_errno));
1469: }
1470: }
1471: break;
1472: #endif
1473: }
1474:
1475: #ifdef SYS5
1476: (void) srand ((unsigned int) time ((long *) 0));
1477: #else
1478: (void) srandom ((int) time ((long *) 0));
1479: #endif
1480:
1481: ps_len_strategy = PS_LEN_LONG;
1482:
1483: if (readobjects (defs) == NOTOK)
1484: adios (NULLCP, "readobjects: %s", PY_pepy);
1485: moresyntax ();
1486: }
1487:
1488: /* INTERACTIVE */
1489:
1490: static int getline (prompt, buffer)
1491: char *prompt,
1492: *buffer;
1493: {
1494: register int i;
1495: register char *cp,
1496: *ep;
1497: static int sticky = 0;
1498:
1499: if (interrupted) {
1500: interrupted = 0;
1501: return NOTOK;
1502: }
1503:
1504: if (sticky) {
1505: sticky = 0;
1506: return NOTOK;
1507: }
1508:
1509: switch (setjmp (intrenv)) {
1510: case OK:
1511: armed++;
1512: break;
1513:
1514: case NOTOK:
1515: if (ontty)
1516: printf ("\n"); /* and fall */
1517: default:
1518: armed = 0;
1519: return NOTOK;
1520: }
1521:
1522: if (ontty) {
1523: printf (prompt, myname);
1524: (void) fflush (stdout);
1525: }
1526:
1527: for (ep = (cp = buffer) + BUFSIZ - 1; (i = getchar ()) != '\n';) {
1528: if (i == EOF) {
1529: if (ontty)
1530: printf ("\n");
1531: clearerr (stdin);
1532: if (cp == buffer)
1533: longjmp (intrenv, DONE);
1534:
1535: sticky++;
1536: break;
1537: }
1538:
1539: if (cp < ep)
1540: *cp++ = i;
1541: }
1542: *cp = NULL;
1543:
1544: armed = 0;
1545:
1546: return OK;
1547: }
1548:
1549: /* */
1550:
1551: /* ARGSUSED */
1552:
1553: static SFD intrser (sig)
1554: int sig;
1555: {
1556: #ifndef BSDSIGS
1557: (void) signal (SIGINT, intrser);
1558: #endif
1559:
1560: if (armed)
1561: longjmp (intrenv, NOTOK);
1562:
1563: interrupted++;
1564: }
1565:
1566: /* */
1567:
1568: #ifndef TIOCGWINSZ
1569: /* ARGSUSED */
1570: #endif
1571:
1572: static int ncols (fp)
1573: FILE *fp;
1574: {
1575: #ifdef TIOCGWINSZ
1576: int i;
1577: struct winsize ws;
1578:
1579: if (ioctl (fileno (fp), TIOCGWINSZ, (char *) &ws) != NOTOK
1580: && (i = ws.ws_col) > 0)
1581: return i;
1582: #endif
1583:
1584: return 80;
1585: }
1586:
1587: /* ERRORS */
1588:
1589: #ifndef lint
1590: void _advise ();
1591:
1592:
1593: static void adios (va_alist)
1594: va_dcl
1595: {
1596: va_list ap;
1597:
1598: va_start (ap);
1599:
1600: _advise (ap);
1601:
1602: va_end (ap);
1603:
1604: _exit (1);
1605: }
1606: #else
1607: /* VARARGS */
1608:
1609: static void adios (what, fmt)
1610: char *what,
1611: *fmt;
1612: {
1613: adios (what, fmt);
1614: }
1615: #endif
1616:
1617:
1618: #ifndef lint
1619: static void advise (va_alist)
1620: va_dcl
1621: {
1622: va_list ap;
1623:
1624: va_start (ap);
1625:
1626: _advise (ap);
1627:
1628: va_end (ap);
1629: }
1630:
1631:
1632: static void _advise (ap)
1633: va_list ap;
1634: {
1635: char buffer[BUFSIZ];
1636:
1637: asprintf (buffer, ap);
1638:
1639: (void) fflush (stdout);
1640:
1641: fprintf (stderr, "%s: ", myname);
1642: (void) fputs (buffer, stderr);
1643: (void) fputc ('\n', stderr);
1644:
1645: (void) fflush (stderr);
1646: }
1647: #else
1648: /* VARARGS */
1649:
1650: static void advise (what, fmt)
1651: char *what,
1652: *fmt;
1653: {
1654: advise (what, fmt);
1655: }
1656: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.