e4206ca07297569745033e5bdb43aad358fccb83
[dragonfly.git] / sbin / atm / ilmid / ilmid.c
1 /*
2  *
3  * ===================================
4  * HARP  |  Host ATM Research Platform
5  * ===================================
6  *
7  *
8  * This Host ATM Research Platform ("HARP") file (the "Software") is
9  * made available by Network Computing Services, Inc. ("NetworkCS")
10  * "AS IS".  NetworkCS does not provide maintenance, improvements or
11  * support of any kind.
12  *
13  * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED,
14  * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
15  * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE
16  * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE.
17  * In no event shall NetworkCS be responsible for any damages, including
18  * but not limited to consequential damages, arising from or relating to
19  * any use of the Software or related support.
20  *
21  * Copyright 1994-1998 Network Computing Services, Inc.
22  *
23  * Copies of this Software may be made, however, the above copyright
24  * notice must be reproduced on all copies.
25  *
26  *      @(#) $FreeBSD: src/sbin/atm/ilmid/ilmid.c,v 1.6.2.2 2001/03/04 07:15:30 kris Exp $
27  *      @(#) $DragonFly: src/sbin/atm/ilmid/ilmid.c,v 1.8 2006/10/16 00:15:35 pavalos Exp $
28  */
29
30 /*
31  * User utilities
32  * --------------
33  *
34  * Implement very minimal ILMI address registration.
35  *
36  * Implement very crude and basic support for "cracking" and
37  * "encoding" SNMP PDU's to support ILMI prefix and NSAP address
38  * registration. Code is not robust nor is it meant to provide any
39  * "real" SNMP support. Much of the code expects predetermined values
40  * and will fail if anything else is found. Much of the "encoding" is
41  * done with pre-computed PDU's.
42  *
43  * See "The Simple Book", Marshall T. Rose, particularly chapter 5,
44  * for ASN and BER information.
45  *
46  */
47
48 #include <sys/param.h>
49 #include <sys/socket.h>
50 #include <sys/sockio.h>
51 #include <net/if.h>
52 #include <netinet/in.h>
53 #include <netatm/port.h>
54 #include <netatm/atm.h>
55 #include <netatm/atm_if.h>
56 #include <netatm/atm_sigmgr.h>
57 #include <netatm/atm_sap.h>
58 #include <netatm/atm_sys.h>
59 #include <netatm/atm_ioctl.h>
60 #include <dev/atm/hea/eni_stats.h>
61 #include <dev/atm/hfa/fore_aali.h>
62 #include <dev/atm/hfa/fore_slave.h>
63 #include <dev/atm/hfa/fore_stats.h>
64
65 #include <err.h>
66 #include <errno.h>
67 #include <libatm.h>
68 #include <stdio.h>
69 #include <stdlib.h>
70 #include <string.h>
71 #include <syslog.h>
72 #include <time.h>
73 #include <unistd.h>
74
75 #define MAX_LEN         9180
76
77 #define MAX_UNITS       8
78
79 /*
80  * Define some ASN types
81  */
82 #define ASN_INTEGER     0x02
83 #define ASN_OCTET       0x04
84 #define ASN_NULL        0x05
85 #define ASN_OBJID       0x06
86 #define ASN_SEQUENCE    0x30
87 #define ASN_IPADDR      0x40
88 #define ASN_TIMESTAMP   0x43
89
90 static const char *Var_Types[] = { "", "", "ASN_INTEGER", "", "ASN_OCTET", "ASN_NULL", "ASN_OBJID" };
91
92 /*
93  * Define SNMP PDU types
94  */
95 #define PDU_TYPE_GET            0xA0
96 #define PDU_TYPE_GETNEXT        0xA1
97 #define PDU_TYPE_GETRESP        0xA2
98 #define PDU_TYPE_SET            0xA3
99 #define PDU_TYPE_TRAP           0xA4
100
101 static const char *PDU_Types[] = { "GET REQUEST", "GETNEXT REQUEST", "GET RESPONSE", "SET REQUEST",
102         "TRAP" };
103
104 /*
105  * Define TRAP codes
106  */
107 #define TRAP_COLDSTART  0
108 #define TRAP_WARMSTART  1
109 #define TRAP_LINKDOWN   2
110 #define TRAP_LINKUP     3
111 #define TRAP_AUTHFAIL   4
112 #define TRAP_EGPLOSS    5
113 #define TRAP_ENTERPRISE 6
114
115 /*
116  * Define SNMP Version numbers
117  */
118 #define SNMP_VERSION_1  1
119 #define SNMP_VERSION_2  2
120
121 /*
122  * SNMP Error-status values
123  */
124 #define SNMP_ERR_NOERROR        0
125 #define SNMP_ERR_TOOBIG         1
126 #define SNMP_ERR_NOSUCHNAME     2
127 #define SNMP_ERR_BADVALUE       3
128 #define SNMP_ERR_READONLY       4
129 #define SNMP_ERR_GENERR         5
130
131 /*
132  * Max string length for Variable
133  */
134 #define STRLEN          128
135
136 /*
137  * Unknown variable
138  */
139 #define VAR_UNKNOWN     -1
140
141 /*
142  * Define our internal representation of an OBJECT IDENTIFIER
143  */
144 struct objid {
145         int     oid[128];
146 };
147 typedef struct objid Objid;
148
149 /*
150  * Define a Veriable classso that we can handle multiple GET/SET's
151  * per PDU.
152  */
153 typedef struct variable Variable;
154 struct variable {
155         Objid           oid;
156         int             type;
157         union {
158                 int             ival;           /* INTEGER/TIMESTAMP */
159                 Objid           oval;           /* OBJID */
160                 long            aval;           /* IPADDR */
161                 char            sval[STRLEN];   /* OCTET */
162         } var;
163         Variable        *next;
164 };
165
166 /*
167  * Every SNMP PDU has the first four fields of this header. The only type
168  * which doesn't have the last three fields is the TRAP type.
169  */
170 struct snmp_header {
171         int             pdulen;
172         int             version;
173         char            community[64];
174         int             pdutype;
175
176         /* GET/GETNEXT/GETRESP/SET */
177         int             reqid;
178         int             error;
179         int             erridx;
180
181         /* TRAP */
182         Objid           enterprise;
183         int             ipaddr;
184         int             generic_trap;
185         int             specific_trap;
186
187         int             varlen;
188         Variable        *head,
189                         *tail;
190 };
191 typedef struct snmp_header Snmp_Header;
192
193 Snmp_Header     *ColdStart_Header;
194 Snmp_Header     *PDU_Header;
195
196 /*
197  * Define some OBJET IDENTIFIERS that we'll try to reply to:
198  *
199  * sysUpTime: number of time ticks since this deamon came up
200  * netpfx_oid:  network prefix table
201  * unitype:     is this a PRIVATE or PUBLIC network link
202  * univer:      which version of UNI are we running
203  * devtype:     is this a USER or NODE ATM device
204  * setprefix:   used when the switch wants to tell us its NSAP prefix
205  * foresiggrp:  FORE specific Objid we see alot of (being connected to FORE
206  *                      switches...)
207  */
208 Objid   Objids[] = {
209 #define SYS_OBJID       0
210         {{  8, 43, 6, 1, 2, 1, 1, 2, 0 }},
211 #define UPTIME_OBJID    1
212         {{  8, 43, 6, 1, 2, 1,    1, 3, 0 }},
213 #define PORT_OBJID      2
214         {{ 12, 43, 6, 1, 4, 1,  353, 2, 1, 1, 1, 1, 0 }},
215 #define IPNM_OBJID      3
216         {{ 10, 43, 6, 1, 4, 1,  353, 2, 1, 2, 0 }},
217 #define LAYER_OBJID     4
218         {{ 12, 43, 6, 1, 4, 1,  353, 2, 2, 1, 1,  1, 0 }},
219 #define MAXVCC_OBJID    5
220         {{ 12, 43, 6, 1, 4, 1,  353, 2, 2, 1, 1,  3, 0 }},
221 #define UNITYPE_OBJID   6
222         {{ 12, 43, 6, 1, 4, 1,  353, 2, 2, 1, 1,  8, 0 }},
223 #define UNIVER_OBJID    7
224         {{ 12, 43, 6, 1, 4, 1,  353, 2, 2, 1, 1,  9, 0 }},
225 #define DEVTYPE_OBJID   8
226         {{ 12, 43, 6, 1, 4, 1,  353, 2, 2, 1, 1, 10, 0 }},
227 #define ADDRESS_OBJID   9
228         {{  8, 43, 6, 1, 4, 1,  353, 2, 6 }},
229 #define NETPFX_OBJID    10
230         {{  9, 43, 6, 1, 4, 1,  353, 2, 7, 1 }},
231 #define MY_OBJID        11
232         {{  7, 43, 6, 1, 4, 1, 9999, 1 }},
233 #define SETPFX_OBJID    12
234         {{ 12, 43, 6, 1, 4, 1,  353, 2, 7, 1, 1,  3, 0 }},
235 #define ENTERPRISE_OBJID 13
236         {{  8, 43, 6, 1, 4, 1,    3, 1, 1 }},
237 #define ATMF_PORTID     14
238         {{ 10, 43, 6, 1, 4, 1,  353, 2, 1, 4, 0 }},
239 #define ATMF_SYSID      15
240         {{ 12, 43, 6, 1, 4, 1,  353, 2, 1, 1, 1, 8, 0 }},
241 };
242
243 #define NUM_OIDS        (sizeof(Objids)/sizeof(Objid))
244
245 #define UNIVER_UNI20    1
246 #define UNIVER_UNI30    2
247 #define UNIVER_UNI31    3
248 #define UNIVER_UNI40    4
249 #define UNIVER_UNKNOWN  5
250
251 #define UNITYPE_PUBLIC  1
252 #define UNITYPE_PRIVATE 2
253
254 #define DEVTYPE_USER    1
255 #define DEVTYPE_NODE    2
256
257 /*
258  * ILMI protocol states
259  */
260 enum ilmi_states {
261         ILMI_UNKNOWN,                   /* Uninitialized */
262         ILMI_COLDSTART,                 /* We need to send a COLD_START trap */
263         ILMI_INIT,                      /* Ensure that switch has reset */
264         ILMI_REG,                       /* Looking for SET message */
265         ILMI_RUNNING                    /* Normal processing */
266 };
267
268 /*
269  * Our (incrementing) Request ID
270  */
271 int     Req_ID;
272
273 /*
274  * Temporary buffer for building response packets. Should help ensure
275  * that we aren't accidently overwriting some other memory.
276  */
277 u_char  Resp_Buf[1024];
278
279 /*
280  * Copy the reponse into a buffer we can modify without
281  * changing the original...
282  */
283 #define COPY_RESP(resp) \
284         UM_COPY ( (resp), Resp_Buf, (resp)[0] + 1 )
285
286 /*
287  * TRAP generic trap types
288  */
289 const char      *Traps[] = { "coldStart", "warmStart", "linkDown", "linkUp",
290                 "authenticationFailure", "egpNeighborLoss",
291                         "enterpriseSpecific" };
292
293
294 int                     NUnits;
295
296 /*
297  * fd for units which have seen a coldStart TRAP and are now exchaning SNMP requests
298  */
299 int                     ilmi_fd[MAX_UNITS + 1];
300 /*
301  * enum ilmi_states for this unit
302  */
303 int                     ilmi_state[MAX_UNITS + 1];
304 /*
305  * Local copy for HARP physical configuration information
306  */
307 struct air_cfg_rsp      Cfg[MAX_UNITS + 1];
308 /*
309  * Local copy for HARP interface configuration information
310  */
311 struct air_int_rsp      Intf[MAX_UNITS + 1];
312
313 /*
314  * addressEntry table
315  */
316 Objid                   addressEntry[MAX_UNITS + 1];
317
318 /*
319  * When this daemon started
320  */
321 struct timeval  starttime;
322
323 int     Debug_Level = 0;
324 int     foregnd = 0;    /* run in the foreground? */
325
326 char    *progname;
327 char    hostname[80];
328
329                                 /* File to write debug messages to */
330 #define LOG_FILE        "/var/log/ilmid"
331 FILE    *Log;                   /* File descriptor for log messages */
332
333 static const char       *Months[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
334                              "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
335
336 /*
337  * Write a syslog() style timestamp
338  *
339  * Write a syslog() style timestamp with month, day, time and hostname
340  * to the log file.
341  *
342  * Arguments:
343  *      none
344  *
345  * Returns:
346  *      none
347  *
348  */
349 static void
350 write_timestamp(void)
351 {
352         time_t          clk;
353         struct tm       *tm;
354
355         clk = time ( (time_t)NULL );
356         tm = localtime ( &clk );
357
358         if ( Log && Debug_Level > 1 )
359             if ( Log != stderr )
360                 fprintf ( Log, "%.3s %2d %.2d:%.2d:%.2d %s: ",
361                     Months[tm->tm_mon], tm->tm_mday, tm->tm_hour, tm->tm_min,
362                         tm->tm_sec, hostname );
363
364         return;
365
366 }
367
368 /*
369  * Utility to pretty print buffer as hex dumps
370  * 
371  * Arguments:
372  *      bp      - buffer pointer
373  *      len     - length to pretty print
374  *
375  * Returns:
376  *      none
377  *
378  */
379 static void
380 hexdump ( u_char *bp, int len )
381 {
382         int     i, j;
383
384         /*
385          * Print as 4 groups of four bytes. Each byte is separated
386          * by a space, each block of four is separated, and two blocks
387          * of eight are also separated.
388          */
389         for ( i = 0; i < len; i += 16 ) {
390                 if ( Log )
391                         write_timestamp();
392                 for ( j = 0; j < 4 && j + i < len; j++ )
393                     if ( Log )
394                         fprintf ( Log, "%.2x ", *bp++ );
395                 if ( Log )
396                     fprintf ( Log, " " );
397                 for ( ; j < 8 && j + i < len; j++ )
398                     if ( Log )
399                         fprintf ( Log, "%.2x ", *bp++ );
400                 if ( Log ) {
401                     fprintf ( Log, "  " );
402                     fflush ( Log );
403                 }
404                 for ( ; j < 12 && j + i < len; j++ )
405                     if ( Log )
406                         fprintf ( Log, "%.2x ", *bp++ );
407                 if ( Log )
408                     fprintf ( Log, " " );
409                 for ( ; j < 16 && j + i < len; j++ )
410                     if ( Log )
411                         fprintf ( Log, "%.2x ", *bp++ );
412                 if ( Log ) {
413                     fprintf ( Log, "\n" );
414                     fflush ( Log );
415                 }
416         }
417
418         return;
419
420 }
421
422 /*
423  * Get lengths from PDU encodings
424  *
425  * Lengths are sometimes encoded as a single byte if the length
426  * is less the 127 but are more commonly encoded as one byte with
427  * the high bit set and the lower seven bits indicating the nuber
428  * of bytes which make up the length value. Trailing data is (to my
429  * knowledge) not 7-bit encoded.
430  *
431  * Arguments:
432  *      bufp    - pointer to buffer pointer
433  *      plen    - pointer to PDU length or NULL if not a concern
434  *
435  * Returns: 
436  *      bufp    - updated buffer pointer
437  *      plen    - (possibly) adjusted pdu length
438  *      <len>   - decoded length
439  *
440  */
441 static int
442 asn_get_pdu_len ( u_char **bufp, int *plen )
443 {
444         u_char  *bp = *bufp;
445         int     len = 0;
446         int     i, b;
447
448         b = *bp++;
449         if ( plen )
450                 (*plen)--;
451          if ( b & 0x80 ) {
452                 for ( i = 0; i < (b & ~0x80); i++ ) {
453                         len = len * 256 + *bp++;
454                         if ( plen )
455                                 (*plen)--;
456                 }
457         } else
458                 len = b;
459
460         *bufp = bp;
461         return ( len );
462 }
463
464 /*
465  * Get an 7-bit encoded value.
466  *
467  * Get a value which is represented using a 7-bit encoding. The last
468  * byte in the stream has the high-bit clear.
469  *
470  * Arguments:
471  *      bufp    - pointer to the buffer pointer
472  *      len     - pointer to the buffer length
473  *
474  * Returns:
475  *      bufp    - updated buffer pointer
476  *      len     - updated buffer length
477  *      <val>   - value encoding represented
478  *
479  */
480 static int
481 asn_get_encoded ( u_char **bufp, int *len )
482 {
483         u_char  *bp = *bufp;
484         int     val = 0;
485         int     l = *len;
486
487         /*
488          * Keep going while high bit is set
489          */
490         do {
491                 /*
492                  * Each byte can represent 7 bits
493                  */
494                 val = ( val << 7 ) + ( *bp & ~0x80 );
495                 l--;
496         } while ( *bp++ & 0x80 );
497
498         *bufp = bp;             /* update buffer pointer */
499         *len = l;               /* update buffer length */
500
501         return ( val );
502 }
503
504 /*
505  * Get a BER encoded integer
506  *
507  * Intergers are encoded as one byte length followed by <length> data bytes
508  *
509  * Arguments:
510  *      bufp    - pointer to the buffer pointer
511  *      plen    - pointer to PDU length or NULL if not a concern
512  *
513  * Returns:
514  *      bufp    - updated buffer pointer 
515  *      plen    - (possibly) updated PDU length
516  *      <val>   - value of encoded integer
517  *
518  */
519 static int
520 asn_get_int ( u_char **bufp, int *plen )
521 {
522         int     i;
523         int     len;
524         int     v = 0;
525         u_char  *bp = *bufp;
526
527         len = *bp++;
528         if ( plen )
529                 (*plen)--;
530         for ( i = 0; i < len; i++ ) {
531                 v = (v * 256) + *bp++;
532                 if ( plen )
533                         (*plen)--;
534         }
535         *bufp = bp;
536         return ( v );
537 }
538
539 /*
540  * Set a BER encoded integer
541  *
542  * Arguments:
543  *      bufp    - pointer to buffer pointer where we are to set int in
544  *      val     - integer value to set
545  *
546  * Returns:
547  *      none
548  *      <bufp>  - updated buffer pointer
549  *
550  */
551 static void
552 asn_set_int ( u_char **bufp, int val )
553 {
554         union {
555                 int     i;
556                 u_char  c[4];
557         } u;
558         int     len = sizeof(int);
559         unsigned int    i = 0;
560         u_char  *bp = *bufp;
561
562         /* Check for special case where val == 0 */
563         if ( val == 0 ) {
564                 *bp++ = 1;
565                 *bp++ = 0;
566                 *bufp = bp;
567                 return;
568         }
569
570         u.i = htonl ( val );
571
572         while ( u.c[i] == 0  && i++ < sizeof(int) )
573                 len--;
574
575         if ( u.c[i] > 0x7f ) {
576                 i--;
577                 len++;
578         }
579
580         *bp++ = len;
581         UM_COPY ( (caddr_t)&u.c[sizeof(int)-len], bp, len );
582         bp += len;
583         *bufp = bp;
584
585         return;
586 }
587
588 /*
589  * Utility to print a object identifier
590  *
591  * Arguments:
592  *      objid   - pointer to objid representation
593  *
594  * Returns:
595  *      none
596  *
597  */
598 static void
599 print_objid ( Objid *objid )
600 {
601         int     i;
602
603         /*
604          * First oid coded as 40 * X + Y
605          */
606         if ( Log ) {
607             write_timestamp();
608             fprintf ( Log, ".%d.%d", objid->oid[1] / 40,
609                 objid->oid[1] % 40 );
610         }
611         for ( i = 2; i <= objid->oid[0]; i++ )
612             if ( Log )
613                 fprintf ( Log, ".%d", objid->oid[i] );
614         if ( Log )
615             fprintf ( Log, "\n" );
616
617         return;
618 }
619
620 /*
621  * Get Object Identifier
622  *
623  * Arguments:
624  *      bufp    - pointer to buffer pointer
625  *      objid   - pointer to objid buffer
626  *      plen    - pointer to PDU length or NULL of not a concern
627  *
628  * Returns:
629  *      bufp    - updated buffer pointer
630  *      objid   - internal representation of encoded objid
631  *      plen    - (possibly) adjusted PDU length
632  *
633  */
634 static void
635 asn_get_objid ( u_char **bufp, Objid *objid, int *plen )
636 {
637         int     len;
638         u_char  *bp = *bufp;
639         int     *ip = (int *)objid + 1; /* First byte will contain length */
640         int     oidlen = 0;
641
642         len = *bp++;
643         if ( plen )
644                 (*plen)--;
645         while ( len ) {
646                 *ip++ = asn_get_encoded ( &bp, &len );
647                 if ( plen )
648                         (*plen)--;
649                 oidlen++;
650         }
651         objid->oid[0] = oidlen;
652         *bufp = bp;
653
654         return;
655 }
656
657 /*
658  * Put OBJID - assumes elements <= 16383 for two byte coding
659  *
660  */
661 static int
662 asn_put_objid ( u_char **bufp, Objid *objid )
663 {
664         int     len = 0;
665         u_char  *bp = *bufp;
666         u_char  *cpp;
667         int     i;
668
669         cpp = bp;
670         *bp++ = objid->oid[0];
671         len++;
672         for ( i = 1; i <= objid->oid[0]; i++ ) {
673                 u_int   c = objid->oid[i];
674
675                 while ( c > 127 ) {
676                         *bp++ = ( ( c >> 7 ) & 0x7f ) | 0x80;
677                         len++;
678                         c &= 0x7f;              /* XXX - assumption of two bytes */
679                         (*cpp)++;
680                 }
681                 *bp++ = c;
682                 len++;
683         }
684
685         *bufp = bp;
686         return ( len );
687
688 }
689
690 /*
691  * Get OCTET STRING
692  *
693  * Octet strings are encoded as a 7-bit encoded length followed by <len>
694  * data bytes;
695  *
696  * Arguments:
697  *      bufp    - pointer to buffer pointer
698  *      octet   - pointer to octet buffer
699  *      plen    - pointer to PDU length
700  *
701  * Returns:
702  *      bufp    - updated buffer pointer
703  *      octet   - encoded Octet String
704  *      plen    - (possibly) adjusted PDU length
705  *
706  */ 
707 static void
708 asn_get_octet ( u_char **bufp, char *octet, int *plen )
709 {
710         u_char  *bp = *bufp;
711         int     i = 0;
712         int     len = 0;
713
714         /*
715          * &i is really a dummy value here as we don't keep track
716          * of the ongoing buffer length
717          */
718         len = asn_get_encoded ( &bp, &i );
719
720         for ( i = 0; i < len; i++ ) {
721                 *octet++ = *bp++;
722                 if ( plen )
723                         (*plen)--;
724         }
725
726         *bufp = bp;
727
728         return;
729
730 }
731
732 /*
733  * Utility to print SNMP PDU header information
734  *
735  * Arguments:
736  *      Hdr     - pointer to internal SNMP header structure
737  *
738  * Returns:
739  *      none
740  *
741  */
742 static void
743 print_header ( Snmp_Header *Hdr )
744 {
745         Variable        *var;
746
747         if ( Log ) {
748             write_timestamp();
749             fprintf ( Log,
750                 "Pdu len: %d Version: %d Community: \"%s\" Pdu Type: 0x%x %s\n",
751                     Hdr->pdulen, Hdr->version + 1, Hdr->community,
752                         Hdr->pdutype, PDU_Types[Hdr->pdutype - PDU_TYPE_GET] );
753             write_timestamp();
754             if ( Hdr->pdutype != PDU_TYPE_TRAP && Log )
755                 fprintf ( Log, "\tReq Id: 0x%x Error: %d Error Index: %d\n",
756                     Hdr->reqid, Hdr->error, Hdr->erridx );
757         }
758
759         var = Hdr->head;
760         while ( var ) {
761                 if ( Log ) {
762                         write_timestamp();
763                         fprintf ( Log, "    Variable Type: %d", var->type );
764                         if ( Var_Types[var->type] )
765                                 fprintf ( Log, " %s", Var_Types[var->type] );
766                         fprintf ( Log, "\n\tObject: " );
767                         print_objid ( &var->oid );
768                         fprintf ( Log, "\tValue: " );
769                         switch ( var->type ) {
770                         case ASN_INTEGER:
771                                 fprintf ( Log, "%d (0x%x)\n", var->var.ival, var->var.ival );
772                                 break;
773                         case ASN_NULL:
774                                 fprintf ( Log, "NULL" );
775                                 break;
776                         default:
777                                 fprintf ( Log, "[0x%x]", var->type );
778                                 break;
779                         }
780                         fprintf ( Log, "\n" );
781                 }
782                 var = var->next;
783         }
784
785         return;
786
787 }
788
789 /*
790  * Pull OID's from GET/SET message
791  *
792  * Arguments:
793  *      h       - pointer to Snmp_Header
794  *      bp      - pointer to input PDU
795  *
796  * Returns:
797  *      none
798  *
799  */
800 static void
801 parse_oids ( Snmp_Header *h, u_char **bp )
802 {
803         int             len = h->varlen;
804         int             sublen;
805         Variable        *var;
806         u_char          *bufp = *bp;
807
808         while ( len > 0 ) {
809             if ( *bufp++ == ASN_SEQUENCE ) {
810                 len--;
811
812                 /* Create new Variable instance */
813                 if ( ( var = (Variable *)UM_ALLOC(sizeof(Variable)) ) == NULL )
814                 {
815                         *bp = bufp;
816                         return;
817                 }
818                 /* Link to tail */
819                 if ( h->tail )
820                         h->tail->next = var;
821                 /* Set head iff NULL */
822                 if ( h->head == NULL ) {
823                         h->head = var;
824                 }
825                 /* Adjust tail */
826                 h->tail = var;
827
828                 /* Get length of variable sequence */
829                 sublen = asn_get_pdu_len ( &bufp, &len );
830                 /* Should be OBJID type */
831                 if ( *bufp++ != ASN_OBJID ) {
832                         *bp = bufp;
833                         return;
834                 }
835                 asn_get_objid ( &bufp, &var->oid, &len );
836                 var->type = *bufp++;
837                 len--;
838                 switch ( var->type ) {
839                 case ASN_INTEGER:
840                         var->var.ival = asn_get_int ( &bufp, &len );
841                         break;
842                 case ASN_NULL:
843                         bufp++;
844                         len--;
845                         break;
846                 case ASN_OBJID:
847                         asn_get_objid ( &bufp, &var->var.oval, &len );
848                         break;
849                 case ASN_OCTET:
850                         asn_get_octet ( &bufp, var->var.sval, &len );
851                         break;
852                 default:
853                         if ( Log ) {
854                                 write_timestamp();
855                                 fprintf ( Log, "Unknown variable type: %d\n",
856                                         var->type );
857                         }
858                         break;
859                 }
860                 var->next = NULL;
861             } else
862                 break;
863         }
864
865         *bp = bufp;
866         return;
867 }
868
869 /*
870  * Crack the SNMP header
871  *
872  * Pull the PDU length, SNMP version, SNMP community and PDU type.
873  * If present, also pull out the Request ID, Error status, and Error
874  * index values.
875  *
876  * Arguments:
877  *      bufp    - pointer to buffer pointer
878  *
879  * Returns:
880  *      bufp    - updated buffer pointer
881  *              - generated SNMP header
882  *
883  */
884 static Snmp_Header *
885 asn_get_header ( u_char **bufp )
886 {
887         Snmp_Header     *h;
888         u_char          *bp = *bufp;
889         int             len = 0;
890         int             dummy = 0;
891
892         /*
893          * Allocate memory to hold the SNMP header
894          */
895         if ( ( h = (Snmp_Header *)UM_ALLOC(sizeof(Snmp_Header)) ) == NULL )
896                 return ( NULL );
897
898         /*
899          * Ensure that we wipe the slate clean
900          */
901         UM_ZERO ( h, sizeof ( Snmp_Header ) );
902
903         /*
904          * PDU has to start as SEQUENCE OF
905          */
906         if ( *bp++ != ASN_SEQUENCE ) /* Class == Universial, f == 1, tag == SEQUENCE */
907                 return ( NULL );
908
909         /*
910          * Get the length of remaining PDU data
911          */
912         h->pdulen = asn_get_pdu_len ( &bp, NULL );
913
914         /*
915          * We expect to find an integer encoding Version-1
916          */
917         if ( *bp++ != ASN_INTEGER ) {
918                 return ( NULL );
919         }
920         h->version = asn_get_int ( &bp, NULL );
921
922         /*
923          * After the version, we need the community name
924          */
925         if ( *bp++ != ASN_OCTET ) {
926                 return ( NULL );
927         }
928         asn_get_octet ( &bp, h->community, NULL );
929
930         /*
931          * Single byte PDU type
932          */
933         h->pdutype = *bp++;
934
935         /*
936          * If this isn't a TRAP PDU, then look for the rest of the header
937          */
938         if ( h->pdutype != PDU_TYPE_TRAP ) {    /* TRAP uses different format */
939
940                 asn_get_pdu_len ( &bp, &dummy );
941
942                 /* Request ID */
943                 if ( *bp++ != ASN_INTEGER ) {
944                         UM_FREE ( h );
945                         return ( NULL );
946                 }
947                 h->reqid = asn_get_int ( &bp, NULL );
948
949                 /* Error Status */
950                 if ( *bp++ != ASN_INTEGER ) {
951                         UM_FREE ( h );
952                         return ( NULL );
953                 }
954                 h->error = asn_get_int ( &bp, NULL );
955
956                 /* Error Index */
957                 if ( *bp++ != ASN_INTEGER ) {
958                         UM_FREE ( h );
959                         return ( NULL );
960                 }
961                 h->erridx = asn_get_int ( &bp, NULL );
962
963                 /* Sequence of... */
964                 if ( *bp++ != ASN_SEQUENCE ) {
965                         UM_FREE ( h );
966                         return ( NULL );
967                 }
968                 h->varlen = ( asn_get_pdu_len ( &bp, &len ) - 1 );
969                 h->varlen += ( len - 1 );
970
971                 parse_oids ( h, &bp );
972         }
973
974         *bufp = bp;
975
976         if ( Log && Debug_Level )
977                 print_header ( h );
978
979         return ( h );
980
981 }
982
983 /*
984  * Compare two internal OID representations
985  *
986  * Arguments:
987  *      oid1    - Internal Object Identifier
988  *      oid2    - Internal Object Identifier
989  *
990  * Returns:
991  *      0       - Objid's match
992  *      1       - Objid's don't match
993  *
994  */
995 static int
996 oid_cmp ( Objid *oid1, Objid *oid2 )
997 {
998         int     i;
999         int     len;
1000
1001         /*
1002          * Compare lengths
1003          */
1004         if ( !(oid1->oid[0] == oid2->oid[0] ) )
1005                 /* Different lengths */
1006                 return ( 1 );
1007
1008         len = oid1->oid[0];
1009
1010         /*
1011          * value by value compare
1012          */
1013         for ( i = 1; i <= len; i++ ) {
1014                 if ( !(oid1->oid[i] == oid2->oid[i]) )
1015                         /* values don't match */
1016                         return ( 1 );
1017         }
1018
1019         /* Objid's are identical */
1020         return ( 0 );
1021 }
1022
1023 /*
1024  * Compare two internal OID representations
1025  *
1026  * Arguments:
1027  *      oid1    - Internal Object Identifier
1028  *      oid2    - Internal Object Identifier
1029  *      len     - Length of OID to compare
1030  *
1031  * Returns:
1032  *      0       - Objid's match
1033  *      1       - Objid's don't match
1034  *
1035  */
1036 static int
1037 oid_ncmp ( Objid *oid1, Objid *oid2, int len )
1038 {
1039         int     i;
1040
1041         /*
1042          * value by value compare
1043          */
1044         for ( i = 1; i <= len; i++ ) {
1045                 if ( !(oid1->oid[i] == oid2->oid[i]) )
1046                         /* values don't match */
1047                         return ( 1 );
1048         }
1049
1050         /* Objid's are identical */
1051         return ( 0 );
1052 }
1053
1054 /*
1055  * Find the index of a OBJID which matches this Variable instance 
1056  *
1057  * Arguments:
1058  *      var     - pointer to Variable instance
1059  *
1060  * Returns:
1061  *      idx     - index of matched Variable instance
1062  *      -1      - no matching Variable found
1063  *
1064  */
1065 static int
1066 find_var ( Variable *var )
1067 {
1068         unsigned int    i;
1069
1070         for ( i = 0; i < NUM_OIDS; i++ )
1071                 if ( oid_cmp ( &var->oid, &Objids[i] ) == 0 ) {
1072                         return ( i );
1073                 }
1074
1075         return ( -1 );
1076
1077 }
1078
1079 /*
1080  * Return the time process has been running as a number of ticks 
1081  *
1082  * Arguments:
1083  *      none
1084  *
1085  * Returns:
1086  *      number of ticks
1087  *
1088  */
1089 static int
1090 get_ticks(void)
1091 {
1092         struct timeval  timenow;
1093         struct timeval  timediff;
1094
1095         gettimeofday ( &timenow, NULL );
1096         /*
1097          * Adjust for subtraction
1098          */
1099         timenow.tv_sec--;
1100         timenow.tv_usec += 1000000;
1101
1102         /*
1103          * Compute time since 'starttime'
1104          */
1105         timediff.tv_sec = timenow.tv_sec - starttime.tv_sec;
1106         timediff.tv_usec = timenow.tv_usec - starttime.tv_usec;
1107
1108         /*
1109          * Adjust difference timeval
1110          */
1111         if ( timediff.tv_usec >= 1000000 ) {
1112                 timediff.tv_usec -= 1000000;
1113                 timediff.tv_sec++;
1114         }
1115
1116         /*
1117          * Compute number of ticks
1118          */
1119         return ( ( timediff.tv_sec * 100 ) + ( timediff.tv_usec / 10000 ) );
1120
1121 }
1122
1123 /*
1124  * Build a response PDU
1125  *
1126  * Arguments:
1127  *      hdr     - pointer to PDU Header with completed Variable list
1128  *
1129  * Returns:
1130  *      none
1131  *
1132  */
1133 static void
1134 build_pdu ( Snmp_Header *hdr, int type )
1135 {
1136         u_char          *bp = Resp_Buf;
1137         u_char          *vpp;
1138         u_char          *ppp;
1139         int             erridx = 0;
1140         int             varidx = 1;
1141         int             varlen = 0;
1142         int             pdulen = 0;
1143         int             traplen = 0;
1144         Variable        *var;
1145
1146         /*
1147          * Clear out the reply
1148          */
1149         UM_ZERO ( Resp_Buf, sizeof(Resp_Buf) );
1150
1151         /* [0] is reserved for overall length */
1152         bp++;
1153
1154         /* Start with SEQUENCE OF */
1155         *bp++ = ASN_SEQUENCE;
1156         /* - assume we can code length in two octets */
1157         *bp++ = 0x82;
1158         bp++;
1159         bp++;
1160         /* Version */
1161         *bp++ = ASN_INTEGER;
1162         asn_set_int ( &bp, hdr->version );
1163         /* Community name */
1164         *bp++ = ASN_OCTET;
1165         *bp++ = strlen ( hdr->community );
1166         UM_COPY ( hdr->community, bp, strlen ( hdr->community ) );
1167         bp += strlen ( hdr->community );
1168         /* PDU Type */
1169         *bp++ = type;
1170         ppp = bp;
1171         /* Length of OID data - assume it'll fit in one octet */
1172         bp++;
1173
1174         if ( type != PDU_TYPE_TRAP ) {
1175             /* Sequence ID */
1176             *bp++ = ASN_INTEGER;
1177             asn_set_int ( &bp, hdr->reqid );
1178             /*
1179              * Check to see if all the vaiables were resolved - we do this
1180              * by looking for something which still has a ASN_NULL value.
1181              */
1182             var = hdr->head;
1183             if ( type == PDU_TYPE_GETRESP ) {
1184                 while ( var && erridx == 0 ) {
1185                     if ( var->type != ASN_NULL ) {
1186                             varidx++;
1187                             var = var->next;
1188                     } else
1189                         erridx = varidx;
1190                 }
1191             }
1192
1193             /* Error status */
1194             *bp++ = ASN_INTEGER;
1195             *bp++ = 0x01;       /* length = 1 */
1196             if ( erridx )
1197                 *bp++ = SNMP_ERR_NOSUCHNAME;
1198             else
1199                 *bp++ = SNMP_ERR_NOERROR;
1200             /* Error Index */
1201             *bp++ = ASN_INTEGER;
1202             *bp++ = 0x01;       /* length = 1 */
1203             *bp++ = erridx;     /* index - 0 if no error */
1204         } else {
1205                 /* type == PDU_TYPE_TRAP */
1206
1207                 /* Fill in ENTERPRISE OBJID */
1208                 *bp++ = ASN_OBJID;
1209                 asn_put_objid ( &bp, &hdr->enterprise );
1210
1211                 /* Fill in IP address */
1212                 *bp++ = ASN_IPADDR;
1213                 *bp++ = sizeof ( hdr->ipaddr );
1214                 UM_COPY ( (caddr_t)&hdr->ipaddr, bp, sizeof(hdr->ipaddr) );
1215                 bp += sizeof(hdr->ipaddr);
1216
1217                 /* Fill in generic and specific trap types */
1218                 *bp++ = ASN_INTEGER;
1219                 asn_set_int ( &bp, hdr->generic_trap );
1220                 *bp++ = ASN_INTEGER;
1221                 asn_set_int ( &bp, hdr->specific_trap );
1222
1223                 /* Fill in time-stamp  - assume 0 for now */
1224                 *bp++ = ASN_TIMESTAMP;
1225                 asn_set_int ( &bp, 0 );
1226                 
1227                 /* encoded length */
1228                 traplen = ( bp - ppp - 1 );
1229
1230                 /* Continue with variable processing */
1231         }
1232
1233         /* SEQUENCE OF */
1234         *bp++ = ASN_SEQUENCE;
1235         *bp++ = 0x82;
1236         /* - assume we can code length in two octets */
1237         vpp = bp;
1238         varlen = 0;
1239         bp++;
1240         bp++;
1241
1242         /* Install Variables */
1243         var = hdr->head;
1244         varidx = 1;
1245         while ( var ) {
1246                 u_char *bpp;
1247                 int     len = 0;
1248
1249                 /* SEQUENCE OF */
1250                 *bp++ = ASN_SEQUENCE;
1251                 *bp++ = 0x82;
1252                 /* - assume we can code length in two octets */
1253                 bpp = bp;
1254                 bp++;
1255                 bp++;
1256                 /* OBJID */
1257                 *bp++ = ASN_OBJID;
1258                 len++;
1259                 len += asn_put_objid ( &bp, &var->oid );
1260
1261                 if ( erridx && varidx >= erridx ) {
1262                         /* Code this variable as NULL */
1263                         *bp++ = ASN_NULL;
1264                         len++;
1265                         bp++;
1266                         len++;
1267                 } else {
1268                         u_char *lpp;
1269                         /* Variable type */
1270                         *bp++ = var->type;
1271                         len++;
1272                         lpp = bp;
1273                         switch ( var->type ) {
1274                         case ASN_INTEGER:
1275                                 asn_set_int ( &bp, var->var.ival );
1276                                 len += ( *lpp + 1 );
1277                                 break;
1278                         case ASN_OCTET:
1279                                 *bp++ = var->var.sval[0];
1280                                 len++;
1281                                 UM_COPY ( (caddr_t)&var->var.sval[1],
1282                                         bp, var->var.sval[0] );
1283                                 len += var->var.sval[0];
1284                                 bp += var->var.sval[0];
1285                                 break;
1286                         case ASN_NULL:
1287                                 *bp++ = 0x00;
1288                                 len++;
1289                                 break;
1290                         case ASN_OBJID:
1291                                 len += asn_put_objid ( &bp, &var->var.oval );
1292                                 break;
1293                         case ASN_SEQUENCE:
1294                                 break;
1295                         case ASN_IPADDR:
1296                                 *bp++ = 4;
1297                                 len++;
1298                                 UM_COPY ( (caddr_t)&var->var.aval, bp, 4 );
1299                                 len += 4;
1300                                 bp += 4;
1301                                 break;
1302                         case ASN_TIMESTAMP:
1303                                 asn_set_int ( &bp, var->var.ival );
1304                                 len += ( *lpp + 1 );
1305                                 break;
1306                         default:
1307                                 break;
1308                         }
1309                 }
1310
1311                 /* Accumulate total Variable sequence length */
1312                 varlen += (len + 4);
1313
1314                 /* Fill in length of this sequence */
1315                 bpp[1] = len & 0xff;
1316                 bpp[0] = len >> 8;
1317
1318                 var = var->next;
1319         }
1320
1321
1322         /* Fill in length of Variable sequence */
1323         vpp[1] = varlen & 0xff;
1324         vpp[0] = varlen >> 8;
1325
1326         if ( type != PDU_TYPE_TRAP ) {
1327                 /* Fill in length of data AFTER PDU type */
1328                 *ppp = varlen + 12 + ppp[2];    /* + length of reqid */
1329         } else {
1330                 /* Fill in length of data AFTER PDU  type */
1331                 *ppp = varlen + traplen + 4;    /* + length of initial sequence of */
1332         }
1333
1334         /* Fill in overall sequence length */
1335         pdulen = *ppp + 7 + strlen ( hdr->community );
1336         Resp_Buf[4] = pdulen & 0x7f;
1337         Resp_Buf[3] = pdulen >> 8;
1338
1339         pdulen = bp - Resp_Buf - 1;
1340
1341         Resp_Buf[0] = pdulen;
1342
1343         hdr->pdutype = type;
1344
1345         return;
1346 }
1347
1348 static void
1349 free_pdu ( Snmp_Header *hdr )
1350 {
1351         Variable        *var;
1352
1353         while ( hdr->head ) {
1354                 var = hdr->head->next;          /* Save next link */
1355                 UM_FREE ( hdr->head );          /* Free current var */
1356                 hdr->head = var;                /* Set head to next link */
1357         }
1358
1359         UM_FREE ( hdr );                                /* Free fixed portion */
1360 }
1361
1362 #if 0
1363 /*
1364  * Set Request ID in PDU
1365  *
1366  * Arguments:
1367  *      resp    - Response PDU buffer
1368  *      reqid   - request id value
1369  *
1370  * Returns:
1371  *      none    - request id may/may not be set
1372  *
1373  */
1374 static void
1375 set_reqid ( u_char *resp, int reqid )
1376 {
1377         u_char          *bp = (u_char *)&resp[18];
1378         union {
1379                 int     i;
1380                 u_char  c[4];
1381         } u;    
1382
1383         u.i = htonl(reqid);
1384
1385         /*
1386          * Replace the current Request ID with the supplied value
1387          */
1388         UM_COPY ( (caddr_t)&u.c[4-resp[17]], bp, resp[17] );
1389
1390         return;
1391 }
1392 #endif
1393
1394 /*
1395  * Send a generic response packet
1396  *
1397  * Arguments:
1398  *      sd      - socket to send the reply on
1399  *      reqid   - original request ID from GET PDU
1400  *      resp    - pointer to the response to send
1401  *
1402  * Returns:
1403  *      none    - response sent
1404  *
1405  */
1406 static void
1407 send_resp ( int intf, Snmp_Header *Hdr, u_char *resp )
1408 {
1409         int     n;
1410
1411         if ( ilmi_fd[intf] > 0 ) {
1412             n = write ( ilmi_fd[intf], (caddr_t)&resp[1], resp[0] );
1413             if ( Log && Debug_Level > 1 ) {
1414                 write_timestamp();
1415                 fprintf ( Log, "===== Sent %d of %d bytes (%d) =====\n", n, resp[0], ilmi_fd[intf] );
1416                 print_header ( Hdr );
1417                 if ( Debug_Level > 2 )
1418                         hexdump ( (u_char *)&resp[1], resp[0] );
1419             }
1420         }
1421
1422         free_pdu ( Hdr );
1423         return;
1424 }
1425
1426 /*
1427  * Build a COLD_START TRAP PDU
1428  *
1429  */
1430 static Snmp_Header *
1431 build_cold_start(void)
1432 {
1433         Snmp_Header     *hdr;
1434         Variable        *var;
1435
1436         hdr = (Snmp_Header *)UM_ALLOC (sizeof(Snmp_Header));
1437
1438         hdr->pdulen = 0;
1439         hdr->version = SNMP_VERSION_1 - 1;
1440         snprintf ( hdr->community, sizeof(hdr->community), "ILMI" );
1441
1442         hdr->ipaddr = 0x0;      /* 0.0.0.0 */
1443         hdr->generic_trap = TRAP_COLDSTART;
1444         hdr->specific_trap = 0;
1445         UM_COPY ( (caddr_t)&Objids[ENTERPRISE_OBJID], (caddr_t)&hdr->enterprise,
1446                 sizeof(Objid) );
1447
1448         hdr->head = (Variable *)UM_ALLOC(sizeof(Variable));
1449         var = hdr->head;
1450         UM_COPY ( (caddr_t)&Objids[UPTIME_OBJID], (caddr_t)&var->oid,
1451                 sizeof(Objid) );
1452         var->type = ASN_NULL;
1453
1454         return ( hdr );
1455 }
1456
1457 /*
1458  * Build a Generic PDU Header
1459  *
1460  */
1461 static Snmp_Header *
1462 build_generic_header(void)
1463 {
1464         Snmp_Header     *hdr;
1465
1466         hdr = (Snmp_Header *)UM_ALLOC(sizeof(Snmp_Header));
1467
1468         hdr->pdulen = 0;
1469         hdr->version = SNMP_VERSION_1 - 1;
1470         snprintf ( hdr->community, sizeof(hdr->community), "ILMI" );
1471
1472         return ( hdr );
1473 }
1474
1475 /* 
1476  * Initialize information on what physical adapters HARP knows about
1477  *
1478  * Query the HARP subsystem about configuration and physical interface
1479  * information for any currently registered ATM adapters. Store the information
1480  * as arrays for easier indexing by SNMP port/index numbers.
1481  *      
1482  * Arguments:
1483  *      none
1484  *
1485  * Returns:
1486  *      none            Information from HARP available 
1487  *      
1488  */
1489 static void
1490 init_ilmi(void)  
1491 {
1492         struct  air_cfg_rsp     *cfg_info = NULL;
1493         struct  air_int_rsp    *intf_info = NULL;
1494         int                     buf_len;
1495
1496         /*
1497          * Get configuration info - what's available with 'atm sh config'
1498          */
1499         buf_len = get_cfg_info ( NULL, &cfg_info );
1500         /*
1501          * If error occurred, clear out everything
1502          */
1503         if ( buf_len <= 0 ) {
1504                 UM_ZERO ( Cfg, sizeof(Cfg) );
1505                 UM_ZERO ( Intf, sizeof(Intf) );
1506                 NUnits = 0;
1507                 return;
1508         }
1509
1510         /*
1511          * Move to local storage
1512          */
1513         UM_COPY ( cfg_info, (caddr_t)Cfg, buf_len );
1514         /*
1515          * Compute how many units information was returned for
1516          */
1517         NUnits = buf_len / sizeof(struct air_cfg_rsp);
1518         /* Housecleaning */
1519         UM_FREE ( cfg_info );
1520         cfg_info = NULL;
1521         /*
1522          * Get the per interface information
1523          */
1524         buf_len = get_intf_info ( NULL, &intf_info );
1525         /*
1526          * If error occurred, clear out Intf info
1527          */
1528         if ( buf_len <= 0 ) {
1529                 UM_ZERO ( Intf, sizeof(Intf) );
1530                 return;
1531         }
1532
1533         /*
1534          * Move to local storage
1535          */
1536         UM_COPY ( intf_info, (caddr_t)Intf, buf_len );
1537         /* Housecleaning */
1538         UM_FREE ( intf_info );
1539         intf_info = NULL;
1540
1541         return;
1542
1543 }
1544
1545 /*
1546  * Open a new SNMP session for ILMI
1547  *
1548  * Start by updating interface information, in particular, how many
1549  * interfaces are in the system. While we'll try to open sessons on
1550  * all interfaces, this deamon currently can only handle the first
1551  * interface.
1552  *
1553  * Arguments:
1554  *      none
1555  *
1556  * Returns:
1557  *      none
1558  *
1559  */
1560 static void
1561 ilmi_open (void)
1562 {
1563         struct sockaddr_atm     satm;
1564         struct t_atm_aal5       aal5;
1565         struct t_atm_traffic    traffic;
1566         struct t_atm_bearer     bearer;
1567         struct t_atm_qos        qos;
1568         struct t_atm_app_name   appname;
1569         Atm_addr                subaddr;
1570         char                    nifname[IFNAMSIZ];
1571         int                     optlen;
1572         int                     unit = 0;
1573         u_char                  sig_proto;
1574
1575         init_ilmi();
1576
1577         for ( unit = 0; unit < NUnits; unit++ ) {
1578
1579             /*
1580              * ILMI only makes sense for UNI signalling protocols
1581              */
1582             sig_proto = Intf[unit].anp_sig_proto;
1583             if ( sig_proto != ATM_SIG_UNI30 && sig_proto != ATM_SIG_UNI31 &&
1584                 sig_proto != ATM_SIG_UNI40 )
1585                     continue;
1586
1587             if ( ilmi_fd[unit] == -1 ) {
1588
1589                 ilmi_fd[unit] = socket ( AF_ATM, SOCK_SEQPACKET, ATM_PROTO_AAL5 );
1590
1591                 if ( ilmi_fd[unit] < 0 ) {
1592                     perror ( "open" );
1593                     continue;
1594                 }
1595
1596                 /*
1597                  * Set interface name. For now, we must have a netif to go on...
1598                  */
1599                 if ( Intf[unit].anp_nif_cnt == 0 ) {
1600                     if ( Debug_Level > 1 && Log ) {
1601                         write_timestamp();
1602                         fprintf ( Log, "No nif on unit %d\n", unit );
1603                     }
1604                     close ( ilmi_fd[unit] );
1605                     ilmi_fd[unit] = -1;
1606                     continue;
1607                 }
1608                 sprintf ( nifname, "%s0", Intf[unit].anp_nif_pref );
1609                 optlen = sizeof ( nifname );
1610                 if ( setsockopt ( ilmi_fd[unit], T_ATM_SIGNALING,
1611                     T_ATM_NET_INTF, (caddr_t)nifname, optlen ) < 0 ) {
1612                         perror ( "setsockopt" );
1613                         if ( Log ) {
1614                             write_timestamp();
1615                             fprintf ( Log,
1616                                 "Couldn't set interface name \"%s\"\n",
1617                                     nifname );
1618                         }
1619                         if ( Debug_Level > 1 && Log ) {
1620                             write_timestamp();
1621                             fprintf ( Log, "nifname: closing unit %d\n", unit );
1622                         }
1623                         close ( ilmi_fd[unit] );
1624                         ilmi_fd[unit] = -1;
1625                         continue;
1626                 }
1627
1628                 /*
1629                  * Set up destination SAP
1630                  */
1631                 UM_ZERO ( (caddr_t) &satm, sizeof(satm) );
1632                 satm.satm_family = AF_ATM;
1633 #if (defined(BSD) && (BSD >= 199103))
1634                 satm.satm_len = sizeof(satm);
1635 #endif
1636
1637                 satm.satm_addr.t_atm_sap_addr.SVE_tag_addr = T_ATM_PRESENT;
1638                 satm.satm_addr.t_atm_sap_addr.SVE_tag_selector = T_ATM_ABSENT;
1639                 satm.satm_addr.t_atm_sap_addr.address_format = T_ATM_PVC_ADDR;
1640                 satm.satm_addr.t_atm_sap_addr.address_length = sizeof(Atm_addr_pvc);
1641                 ATM_PVC_SET_VPI((Atm_addr_pvc *)satm.satm_addr.t_atm_sap_addr.address,
1642                     0 );
1643                 ATM_PVC_SET_VCI((Atm_addr_pvc *)satm.satm_addr.t_atm_sap_addr.address,
1644                     16 );
1645     
1646                 satm.satm_addr.t_atm_sap_layer2.SVE_tag = T_ATM_PRESENT;
1647                 satm.satm_addr.t_atm_sap_layer2.ID_type = T_ATM_SIMPLE_ID;
1648                 satm.satm_addr.t_atm_sap_layer2.ID.simple_ID = T_ATM_BLLI2_I8802;
1649
1650                 satm.satm_addr.t_atm_sap_layer3.SVE_tag = T_ATM_ABSENT;
1651
1652                 satm.satm_addr.t_atm_sap_appl.SVE_tag = T_ATM_ABSENT;
1653
1654                 /*
1655                  * Set up connection parameters
1656                  */
1657                 aal5.forward_max_SDU_size = MAX_LEN;
1658                 aal5.backward_max_SDU_size = MAX_LEN;
1659                 aal5.SSCS_type = T_ATM_NULL;
1660                 optlen = sizeof(aal5);
1661                 if ( setsockopt ( ilmi_fd[unit], T_ATM_SIGNALING, T_ATM_AAL5,
1662                 (caddr_t) &aal5, optlen ) < 0 ) {
1663                     perror ( "setsockopt(aal5)" );
1664                     if ( Debug_Level > 1 && Log ) {
1665                         write_timestamp();
1666                         fprintf ( Log, "aal5: closing unit %d\n", unit );
1667                     }
1668                     close ( ilmi_fd[unit] );
1669                     ilmi_fd[unit] = -1;
1670                     continue;
1671                 }
1672
1673                 traffic.forward.PCR_high_priority = T_ATM_ABSENT;
1674                 traffic.forward.PCR_all_traffic = 100000;
1675                 traffic.forward.SCR_high_priority = T_ATM_ABSENT;
1676                 traffic.forward.SCR_all_traffic = T_ATM_ABSENT;
1677                 traffic.forward.MBS_high_priority = T_ATM_ABSENT;
1678                 traffic.forward.MBS_all_traffic = T_ATM_ABSENT;
1679                 traffic.forward.tagging = T_NO;
1680                 traffic.backward.PCR_high_priority = T_ATM_ABSENT;
1681                 traffic.backward.PCR_all_traffic = 100000;
1682                 traffic.backward.SCR_high_priority = T_ATM_ABSENT;
1683                 traffic.backward.SCR_all_traffic = T_ATM_ABSENT;
1684                 traffic.backward.MBS_high_priority = T_ATM_ABSENT;
1685                 traffic.backward.MBS_all_traffic = T_ATM_ABSENT;
1686                 traffic.backward.tagging = T_NO;
1687                 traffic.best_effort = T_YES;
1688                 optlen = sizeof(traffic);
1689                 if (setsockopt(ilmi_fd[unit], T_ATM_SIGNALING, T_ATM_TRAFFIC,
1690                         (caddr_t)&traffic, optlen) < 0) {
1691                     perror("setsockopt(traffic)");
1692                 }
1693                 bearer.bearer_class = T_ATM_CLASS_X;
1694                 bearer.traffic_type = T_ATM_NULL;
1695                 bearer.timing_requirements = T_ATM_NULL;
1696                 bearer.clipping_susceptibility = T_NO;
1697                 bearer.connection_configuration = T_ATM_1_TO_1;
1698                 optlen = sizeof(bearer);
1699                 if (setsockopt(ilmi_fd[unit], T_ATM_SIGNALING, T_ATM_BEARER_CAP,
1700                         (caddr_t)&bearer, optlen) < 0) {
1701                     perror("setsockopt(bearer)");
1702                 }
1703
1704                 qos.coding_standard = T_ATM_NETWORK_CODING;
1705                 qos.forward.qos_class = T_ATM_QOS_CLASS_0;
1706                 qos.backward.qos_class = T_ATM_QOS_CLASS_0;
1707                 optlen = sizeof(qos);
1708                 if (setsockopt(ilmi_fd[unit], T_ATM_SIGNALING, T_ATM_QOS, (caddr_t)&qos,
1709                         optlen) < 0) {
1710                     perror("setsockopt(qos)");
1711                 }
1712
1713                 subaddr.address_format = T_ATM_ABSENT;
1714                 subaddr.address_length = 0;
1715                 optlen = sizeof(subaddr);
1716                 if (setsockopt(ilmi_fd[unit], T_ATM_SIGNALING, T_ATM_DEST_SUB,
1717                         (caddr_t)&subaddr, optlen) < 0) {
1718                     perror("setsockopt(dest_sub)");
1719                 }
1720
1721                 strncpy(appname.app_name, "ILMI", T_ATM_APP_NAME_LEN);
1722                 optlen = sizeof(appname);
1723                 if (setsockopt(ilmi_fd[unit], T_ATM_SIGNALING, T_ATM_APP_NAME,
1724                         (caddr_t)&appname, optlen) < 0) {
1725                     perror("setsockopt(appname)");
1726                 }
1727
1728                 /*
1729                  * Now try to connect to destination
1730                  */
1731                 if ( connect ( ilmi_fd[unit], (struct sockaddr *) &satm,
1732                     sizeof(satm)) < 0 ) {
1733                         perror ( "connect" );
1734                         if ( Debug_Level > 1 && Log ) {
1735                             write_timestamp();
1736                             fprintf ( Log, "connect: closing unit %d\n", unit );
1737                         }
1738                         close ( ilmi_fd[unit] );
1739                         ilmi_fd[unit] = -1;
1740                         continue;
1741                 }
1742
1743                 if ( Debug_Level && Log ) {
1744                     write_timestamp();
1745                     fprintf ( Log, "***** opened unit %d\n", unit );
1746                 }
1747
1748                 ilmi_state[unit] = ILMI_COLDSTART;
1749
1750             }
1751
1752         }
1753
1754         return;
1755
1756 }
1757
1758 /*
1759  * Get our local IP address for this interface
1760  *
1761  * Arguments:
1762  *      s       - socket to find address for
1763  *      aval    - pointer to variable to store address in
1764  *
1765  * Returns:
1766  *      none
1767  *
1768  */
1769 static void
1770 get_local_ip ( int s, long *aval )
1771 {
1772         char                    intf_name[IFNAMSIZ];
1773         int                     namelen = IFNAMSIZ;
1774         struct air_netif_rsp    *net_info = NULL;
1775         struct sockaddr_in      *sin;
1776
1777         /*
1778          * Get physical interface name
1779          */
1780         if ( getsockopt ( s, T_ATM_SIGNALING, T_ATM_NET_INTF,
1781             (caddr_t) intf_name, &namelen ) )
1782                 return;
1783
1784         /*
1785          * Get network interface information for this physical interface
1786          */
1787         get_netif_info ( intf_name, &net_info );
1788         if ( net_info == NULL )
1789                 return;
1790
1791         sin = (struct sockaddr_in *)&net_info->anp_proto_addr;
1792
1793         /*
1794          * Fill in answer
1795          */
1796         UM_COPY ( (caddr_t)&sin->sin_addr.s_addr, aval, 4 );
1797
1798         UM_FREE ( net_info );
1799
1800         return;
1801
1802 }
1803
1804 /*
1805  * Set local NSAP prefix and then reply with our full NSAP address.
1806  *
1807  * Switch will send a SET message with the NSAP prefix after a coldStart.
1808  * We'll set that prefix into HARP and then send a SET message of our own
1809  * with our full interface NSAP address.
1810  *
1811  * Arguments:
1812  *      oid     - objid from SET message
1813  *      hdr     - pointer to internal SNMP header
1814  *      buf     - pointer to SET buffer
1815  *      s       - socket to send messages on
1816  *
1817  * Returns:
1818  *      none
1819  *
1820  */
1821 static void
1822 set_prefix ( Objid *oid, __unused Snmp_Header *hdr, int intf )
1823 {
1824         struct atmsetreq        asr;
1825         Atm_addr                *aa;
1826         int                     fd;
1827         int                     i;
1828
1829         /*
1830          * Build IOCTL request to set prefix
1831          */
1832         asr.asr_opcode = AIOCS_SET_PRF;
1833         strncpy ( asr.asr_prf_intf, Intf[intf].anp_intf,
1834                 sizeof(asr.asr_prf_intf ) );
1835         /*
1836          * Pull prefix out of received Objid
1837          *      save in set_prefix IOCTL and addressEntry table
1838          */
1839         for ( i = 0; i < oid->oid[13]; i++ ) {
1840                 asr.asr_prf_pref[i] = oid->oid[i + 14];
1841         }
1842
1843         /*
1844          * Pass new prefix to the HARP kernel
1845          */
1846         fd = socket ( AF_ATM, SOCK_DGRAM, 0 );
1847         if ( fd < 0 ) 
1848                 return;
1849         if ( ioctl ( fd, AIOCSET, (caddr_t)&asr ) < 0 ) {
1850                 if ( errno != EALREADY ) {
1851                     syslog ( LOG_ERR, "ilmid: error setting prefix: %m" );
1852                     if ( Log ) {
1853                         write_timestamp();
1854                         fprintf ( Log, "errno %d setting prefix\n",
1855                             errno );
1856                     }
1857                     close ( fd );
1858                     return;
1859                 }
1860         }
1861         close ( fd );
1862
1863         /*
1864          * Reload the cfg/intf info with newly set prefix
1865          */
1866         init_ilmi();
1867
1868         aa = &Intf[intf].anp_addr;
1869
1870         /*
1871          * Copy our NSAP into addressEntry table
1872          */
1873
1874         addressEntry[intf].oid[0] = 0;
1875         for ( i = 0; i < aa->address_length; i++ ) {
1876                 addressEntry[intf].oid[0]++;    /* Increment length */
1877                 addressEntry[intf].oid[i + 1] = (int)((u_char *)(aa->address))[i];
1878
1879         }
1880
1881         return;
1882
1883 }
1884
1885 static void
1886 set_address ( __unused Snmp_Header *hdr, int intf )
1887 {
1888         Variable        *var;
1889         int             i, j;
1890
1891         PDU_Header = build_generic_header();
1892         PDU_Header->head = (Variable *)UM_ALLOC(sizeof(Variable));
1893         var = PDU_Header->head;
1894         /* Copy generic addressEntry OBJID */
1895         UM_COPY ( (caddr_t)&Objids[ADDRESS_OBJID], (caddr_t)&var->oid,
1896                 sizeof(Objid) );
1897         /* Set specific instance */
1898         i = var->oid.oid[0] + 1;                /* Get length */
1899         var->oid.oid[i++] = 1;
1900         var->oid.oid[i++] = 1;
1901         var->oid.oid[i++] = 3;
1902         var->oid.oid[i++] = 0;
1903
1904         /* Copy in address length */
1905         var->oid.oid[i++] = addressEntry[intf].oid[0];
1906
1907         /* Copy in address */
1908         for ( j = 0; j < addressEntry[intf].oid[0]; j++ )
1909                 var->oid.oid[i++] = addressEntry[intf].oid[j + 1];
1910         var->oid.oid[0] = i - 1;                /* Set new length */
1911
1912         /* Set == VALID */
1913         var->type = ASN_INTEGER;
1914         var->var.ival = 1;
1915
1916         build_pdu ( PDU_Header, PDU_TYPE_SET );
1917         send_resp ( intf, PDU_Header, Resp_Buf );
1918 }
1919
1920 /* 
1921  * Utility to strip off any leading path information from a filename
1922  *      
1923  * Arguments:
1924  *      path            pathname to strip
1925  *      
1926  * Returns:
1927  *      fname           striped filename
1928  * 
1929  */     
1930 static char *
1931 basename ( char *path )
1932 {  
1933         char *fname;
1934
1935         if ( ( fname = (char *)strrchr ( path, '/' ) ) != NULL )
1936                 fname++;
1937         else
1938                 fname = path;
1939
1940         return ( fname );
1941 }
1942
1943 /*
1944  * Increment Debug Level
1945  *
1946  * Catches SIGUSR1 signal and increments value of Debug_Level
1947  *
1948  * Arguments:
1949  *      sig     - signal number
1950  *
1951  * Returns:
1952  *      none    - Debug_Level incremented
1953  *
1954  */
1955 static void
1956 Increment_DL ( __unused int sig )
1957 {
1958         Debug_Level++;
1959         if ( Debug_Level && Log == NULL ) {
1960             if ( foregnd ) {
1961                 Log = stderr;
1962             } else {
1963                 if ( ( Log = fopen ( LOG_FILE, "a" ) ) == NULL ) 
1964                     Log = NULL;
1965             }
1966             if ( Log ) {
1967                 setbuf ( Log, NULL );
1968                 write_timestamp();
1969                 fprintf ( Log, "Raised Debug_Level to %d\n", Debug_Level );
1970             }
1971         }
1972         signal ( SIGUSR1, Increment_DL );
1973         return;
1974 }
1975
1976 /*
1977  * Decrement Debug Level
1978  *
1979  * Catches SIGUSR2 signal and decrements value of Debug_Level
1980  *
1981  * Arguments:
1982  *      sig     - signal number
1983  *
1984  * Returns:
1985  *      none    - Debug_Level decremented
1986  *
1987  */
1988 static void
1989 Decrement_DL ( __unused int sig )
1990 {
1991         Debug_Level--;
1992         if ( Debug_Level <= 0 ) {
1993             Debug_Level = 0;
1994             if ( Log ) {
1995                 write_timestamp();
1996                 fprintf ( Log, "Lowered Debug_Level to %d\n", Debug_Level );
1997                 if ( !foregnd )
1998                     fclose ( Log );
1999                 Log = NULL;
2000             }
2001         }
2002         signal ( SIGUSR2, Decrement_DL );
2003         return;
2004 }
2005
2006 /*
2007  * Loop through GET variable list looking for matches
2008  *
2009  */
2010 static void
2011 process_get ( Snmp_Header *hdr, int intf )
2012 {
2013         Variable        *var;
2014         int             idx;
2015
2016         var = hdr->head;
2017         while ( var ) {
2018                 idx = find_var ( var );
2019                 switch ( idx ) {
2020                 case SYS_OBJID:
2021                         var->type = ASN_OBJID;
2022                         UM_COPY ( (caddr_t)&Objids[MY_OBJID],
2023                             (caddr_t)&var->var.oval,
2024                                 sizeof(Objid) );
2025                         break;
2026                 case UPTIME_OBJID:
2027                         var->type = ASN_TIMESTAMP;
2028                         var->var.ival = get_ticks();
2029                         break;
2030                 case UNITYPE_OBJID:
2031                         var->type = ASN_INTEGER;
2032                         var->var.ival = UNITYPE_PRIVATE;
2033                         break;
2034                 case UNIVER_OBJID:
2035                         var->type = ASN_INTEGER;
2036                         switch ( Intf[intf].anp_sig_proto ) {
2037                         case ATM_SIG_UNI30:
2038                                 var->var.ival = UNIVER_UNI30;
2039                                 break;
2040                         case ATM_SIG_UNI31:
2041                                 var->var.ival = UNIVER_UNI31;
2042                                 break;
2043                         case ATM_SIG_UNI40:
2044                                 var->var.ival = UNIVER_UNI40;
2045                                 break;
2046                         default:
2047                                 var->var.ival = UNIVER_UNKNOWN;
2048                                 break;
2049                         }
2050                         break;
2051                 case DEVTYPE_OBJID:
2052                         var->type = ASN_INTEGER;
2053                         var->var.ival = DEVTYPE_USER;
2054                         break;
2055                 case MAXVCC_OBJID:
2056                         var->type = ASN_INTEGER;
2057                         var->var.ival = 1024;
2058                         break;
2059                 case PORT_OBJID:
2060                         var->type = ASN_INTEGER;
2061                         var->var.ival = intf + 1;
2062                         break;
2063                 case IPNM_OBJID:
2064                         var->type = ASN_IPADDR;
2065                         get_local_ip ( ilmi_fd[intf],
2066                             &var->var.aval );
2067                         break;
2068                 case ADDRESS_OBJID:
2069                         break;
2070                 case ATMF_PORTID:
2071                         var->type = ASN_INTEGER;
2072                         var->var.ival = 0x30 + intf;
2073                         break;
2074                 case ATMF_SYSID:
2075                         var->type = ASN_OCTET;
2076                         var->var.sval[0] = 6;
2077                         UM_COPY ( (caddr_t)&Cfg[intf].acp_macaddr,
2078                             (caddr_t)&var->var.sval[1], 6 );
2079                         break;
2080                 default:
2081                         /* NO_SUCH */
2082                         break;
2083                 }
2084                 var = var->next;
2085         }
2086         build_pdu ( hdr, PDU_TYPE_GETRESP );
2087         send_resp ( intf, hdr, Resp_Buf );
2088
2089 }
2090
2091 /*
2092  * ILMI State Processing Loop
2093  *
2094  *
2095  */
2096 static void
2097 ilmi_do_state (void)
2098 {
2099         struct timeval  tvp;
2100         fd_set          rfd;
2101         u_char          buf[1024];
2102         Variable        *var;
2103         int             intf;
2104         int             maxfd = 0;
2105
2106         /*
2107          * Loop forever
2108          */
2109         for ( ; ; ) {
2110             int         count;
2111             int         n;
2112             u_char      *bpp;
2113             Snmp_Header *Hdr;
2114
2115             /*
2116              * SunOS CC doesn't allow automatic aggregate initialization.
2117              * Initialize to zero which effects a poll operation.
2118              */
2119             tvp.tv_sec = 15;
2120             tvp.tv_usec = 0;
2121
2122             /*
2123              * Clear fd_set and initialize to check this interface
2124              */
2125             FD_ZERO ( &rfd );
2126             for ( intf = 0; intf < MAX_UNITS; intf++ )
2127                 if ( ilmi_fd[intf] > 0 ) {
2128                     FD_SET ( ilmi_fd[intf], &rfd );
2129                     maxfd = MAX ( maxfd, ilmi_fd[intf] );
2130                 }
2131
2132             /*
2133              * Check for new interfaces
2134              */
2135             ilmi_open();
2136
2137             for ( intf = 0; intf < MAX_UNITS; intf++ ) {
2138                 /*
2139                  * Do any pre-message state processing
2140                  */
2141                 switch ( ilmi_state[intf] ) {
2142                 case ILMI_COLDSTART:
2143                         /*
2144                          * Clear addressTable
2145                          */
2146                         UM_ZERO ( (caddr_t)&addressEntry[intf], sizeof(Objid) );
2147
2148                         /*
2149                          * Start by sending a COLD_START trap. This should cause the
2150                          * remote end to clear the associated prefix/address table(s).
2151                          */
2152                         /* Build ColdStart TRAP header */
2153                         ColdStart_Header = build_cold_start();
2154                         build_pdu ( ColdStart_Header, PDU_TYPE_TRAP );
2155                         send_resp ( intf, ColdStart_Header, Resp_Buf );
2156
2157                         /*
2158                          * Start a timeout so that if the next state fails, we re-enter
2159                          * ILMI_COLDSTART.
2160                          */
2161                         /* atm_timeout() */
2162         
2163                         /* Enter new state */
2164                         ilmi_state[intf] = ILMI_INIT;
2165                         /* fall into ILMI_INIT */
2166
2167                 case ILMI_INIT:
2168                         /*
2169                          * After a COLD_START, we need to check that the remote end has
2170                          * cleared any tables. Send a GET_NEXT request to check for this.
2171                          * In the event that the table is not empty, or that no reply is
2172                          * received, return to COLD_START state.
2173                          */
2174                         PDU_Header = build_generic_header();
2175                         PDU_Header->head = (Variable *)UM_ALLOC(sizeof(Variable));
2176                         var = PDU_Header->head;
2177                         UM_COPY ( (caddr_t)&Objids[ADDRESS_OBJID], (caddr_t)&var->oid,
2178                             sizeof(Objid) );
2179                         var->type = ASN_NULL;
2180                         var->next = NULL;
2181         
2182                         /*
2183                          * Send GETNEXT request looking for empty ATM Address Table
2184                          */
2185                         PDU_Header->reqid = Req_ID++;
2186                         build_pdu ( PDU_Header, PDU_TYPE_GETNEXT );
2187                         send_resp ( intf, PDU_Header, Resp_Buf );
2188         
2189                         /*
2190                          * Start a timeout while looking for SET message. If we don't receive
2191                          * a SET, then go back to COLD_START state.
2192                          */
2193                         /* atm_timeout() */
2194                         break;
2195         
2196                 case ILMI_RUNNING:
2197                         /* Normal SNMP processing */
2198                         break;
2199         
2200                 default:
2201                         break;
2202                 }
2203             }
2204
2205             count = select ( maxfd + 1, &rfd, NULL, NULL, &tvp );
2206
2207             for ( intf = 0; intf < MAX_UNITS; intf++ ) {
2208                 /*
2209                  * Check for received messages
2210                  */
2211                 if ( ilmi_fd[intf] > 0 && FD_ISSET ( ilmi_fd[intf], & rfd ) ) {
2212                 
2213                     n = read ( ilmi_fd[intf], (caddr_t)&buf[1], sizeof(buf) - 1 );
2214                     if ( n == -1 && ( errno == ECONNRESET || errno == EBADF ) ) {
2215                         ilmi_state[intf] = ILMI_COLDSTART;
2216                         close ( ilmi_fd[intf] );
2217                         ilmi_fd[intf] = -1;
2218                     } else {
2219                         if ( Log && Debug_Level > 1 ) fprintf ( Log, "***** state %d ***** read %d bytes from %d (%d) ***** %s *****\n",
2220                             ilmi_state[intf], n, intf, ilmi_fd[intf], PDU_Types[buf[14] - 0xA0] ); {
2221                                 if ( Debug_Level > 2 )
2222                                     hexdump ( (caddr_t)&buf[1], n );
2223                         }
2224                         bpp = (caddr_t)&buf[1];
2225                         if ( ( Hdr = asn_get_header ( &bpp ) ) == NULL )
2226                             continue;
2227         
2228                         /* What we do with this messages depends upon the state we're in */
2229                         switch ( ilmi_state[intf] ) {
2230                         case ILMI_COLDSTART:
2231                             /* We should never be in this state here */
2232                             free_pdu ( Hdr );
2233                             break;
2234                         case ILMI_INIT:
2235                             /* The only messages we care about are GETNEXTs, GETRESPs, and TRAPs */
2236                             switch ( Hdr->pdutype ) {
2237                             case PDU_TYPE_GETNEXT:
2238                                 /*
2239                                  * Should be because the remote side is attempting
2240                                  * to verify that our table is empty
2241                                  */
2242                                 if ( oid_ncmp ( &Hdr->head->oid,
2243                                     &Objids[ADDRESS_OBJID],
2244                                         Objids[ADDRESS_OBJID].oid[0] ) == 0 ) {
2245                                         if ( addressEntry[intf].oid[0] ) {
2246                                             /* XXX - FIXME */
2247                                             /* Our table is not empty - return address */
2248                                         }
2249                                 }
2250                                 build_pdu ( Hdr, PDU_TYPE_GETRESP );
2251                                 send_resp ( intf, Hdr, Resp_Buf );
2252                                 break;
2253                             case PDU_TYPE_GETRESP:
2254                                 /*
2255                                  * This should be in response to our GETNEXT.
2256                                  * Check the OIDs and go onto ILMI_RUNNING if
2257                                  * the address table is empty. We can cheat and
2258                                  * not check sequence numbers because we only send
2259                                  * the one GETNEXT request and ILMI says we shouldn't
2260                                  * have interleaved sessions.
2261                                  */
2262                                 /*
2263                                  * First look for empty table. If found, go to next state.
2264                                  */
2265                                 if ((Hdr->error == SNMP_ERR_NOSUCHNAME) ||
2266                                     ((Hdr->error == SNMP_ERR_NOERROR) &&
2267                                      ( oid_ncmp ( &Objids[ADDRESS_OBJID], &Hdr->head->oid,
2268                                       Objids[ADDRESS_OBJID].oid[0] ) == 1 ))) {
2269                                         ilmi_state[intf] = ILMI_RUNNING; /* ILMI_REG; */
2270                                 } else if (Hdr->error == SNMP_ERR_NOERROR) {
2271                                         /*
2272                                          * Check to see if this matches our address
2273                                          * and if so, that it's a VALID entry.
2274                                          */
2275                                         Atm_addr        *aa;
2276                                         int             l;
2277                                         int             match = 1;
2278
2279                                         aa = &Intf[intf].anp_addr;
2280                                         if ( aa->address_length == Hdr->head->oid.oid[13] ) {
2281                                             for ( l = 0; l < aa->address_length; l++ ) {
2282                                                 if ( (int)((u_char *)(aa->address))[l] !=
2283                                                     Hdr->head->oid.oid[14 + l] ) {
2284                                                         match = 0;
2285                                                 }
2286                                             }
2287                                         }
2288                                         if ( match ) {
2289                                             if ( Hdr->head->var.ival == 1 ) {
2290                                                 ilmi_state[intf] = ILMI_RUNNING;
2291                                             }
2292                                         }
2293                                 }
2294                                 free_pdu ( Hdr );
2295                                 break;
2296                             case PDU_TYPE_SET:
2297                                 /* Look for SET_PREFIX Objid */
2298                                 if ( oid_ncmp ( &Hdr->head->oid,
2299                                     &Objids[SETPFX_OBJID],
2300                                         Objids[SETPFX_OBJID].oid[0] ) == 0 ) {
2301                                             set_prefix ( &Hdr->head->oid, Hdr, intf );
2302                                             /* Reply to SET before sending our ADDRESS */
2303                                             build_pdu(Hdr, PDU_TYPE_GETRESP);
2304                                             send_resp( intf, Hdr, Resp_Buf );
2305                                             set_address ( Hdr, intf );
2306                                 } else {
2307                                         build_pdu(Hdr, PDU_TYPE_GETRESP);
2308                                         send_resp( intf, Hdr, Resp_Buf );
2309                                 }
2310                                 break;
2311                             case PDU_TYPE_TRAP:
2312                                 /* Remote side wants us to start fresh */
2313                                 free_pdu ( Hdr );
2314                                 break;
2315                             default:
2316                                 /* Ignore */
2317                                 free_pdu ( Hdr );
2318                                 break;
2319                             }
2320                             break;
2321                         case ILMI_REG:
2322                             break;
2323                         case ILMI_RUNNING:
2324                             /* We'll take anything here */
2325                             switch ( Hdr->pdutype ) {
2326                             case PDU_TYPE_GET:
2327                                 process_get ( Hdr, intf );
2328                                 break;
2329                             case PDU_TYPE_GETRESP:
2330                                 /* Ignore GETRESPs */
2331                                 free_pdu ( Hdr );
2332                                 break;
2333                             case PDU_TYPE_GETNEXT:
2334                                 build_pdu ( Hdr, PDU_TYPE_GETRESP );
2335                                 send_resp ( intf, Hdr, Resp_Buf );
2336                                 break;
2337                             case PDU_TYPE_SET:
2338                                 /* Look for SET_PREFIX Objid */
2339                                 if ( oid_ncmp ( &Hdr->head->oid,
2340                                     &Objids[SETPFX_OBJID],
2341                                         Objids[SETPFX_OBJID].oid[0] ) == 0 ) {
2342                                             set_prefix ( &Hdr->head->oid, Hdr, intf );
2343                                             /* Reply to SET before sending our ADDRESS */
2344                                             build_pdu(Hdr, PDU_TYPE_GETRESP);
2345                                             send_resp( intf, Hdr, Resp_Buf );
2346                                             set_address ( Hdr, intf );
2347                                 } else {
2348                                         build_pdu(Hdr, PDU_TYPE_GETRESP);
2349                                         send_resp( intf, Hdr, Resp_Buf );
2350                                 }
2351                                 break;
2352                             case PDU_TYPE_TRAP:
2353                                 free_pdu ( Hdr );
2354                                 break;
2355                             }
2356                             break;
2357                         default:
2358                             /* Unknown state */
2359                             free_pdu ( Hdr );
2360                             break;
2361                         }
2362                     }                   /* if n > 0 */
2363                 }               /* if received message */
2364             }           /* for each interface */
2365         }       /* for ever loop */
2366
2367 }
2368
2369 int
2370 main ( int argc, char *argv[] )
2371 {
2372         int     c;
2373         int     i;
2374         int     Reset = 0;      /* Should we send a coldStart and exit? */
2375
2376         /*
2377          * What are we running as? (argv[0])
2378          */
2379         progname = strdup ( (char *)basename ( argv[0] ) );
2380         /*
2381          * What host are we
2382          */
2383         gethostname ( hostname, sizeof ( hostname ) );
2384
2385         /*
2386          * Ilmid needs to run as root to set prefix
2387          */
2388         if ( getuid() != 0 ) {
2389                 fprintf ( stderr, "%s: needs to run as root.\n", progname );
2390                 exit ( -1 );
2391         }
2392
2393         /*
2394          * Parse arguments
2395          */
2396         while ( ( c = getopt ( argc, argv, "d:fr" ) ) != -1 )
2397             switch ( c ) {
2398                 case 'd':
2399                         Debug_Level = atoi ( optarg );
2400                         break;
2401                 case 'f':
2402                         foregnd++;
2403                         break;
2404                 case 'r':
2405                         Reset++;
2406                         break;
2407                 case '?':
2408                         fprintf ( stderr, "usage: %s [-d level] [-f] [-r]\n",
2409                                 progname );
2410                         exit ( -1 );
2411 /* NOTREACHED */
2412                         break;
2413             }
2414
2415         /*
2416          * If we're not doing debugging, run in the background
2417          */
2418         if ( foregnd == 0 ) {
2419                 if ( daemon ( 0, 0 ) )
2420                         err ( 1, "Can't fork" );
2421         }
2422
2423         signal ( SIGUSR1, Increment_DL );
2424         signal ( SIGUSR2, Decrement_DL );
2425
2426         /*
2427          * Open log file
2428          */
2429         if ( Debug_Level ) {
2430             if ( foregnd ) {
2431                 Log = stderr;
2432             } else {
2433                 if ( ( Log = fopen ( LOG_FILE, "a" ) ) == NULL )
2434                     Log = NULL;
2435             }
2436         }
2437         if ( Log )
2438             setbuf ( Log, NULL );
2439
2440         /*
2441          * Get our startup time
2442          */
2443         gettimeofday ( &starttime, NULL );
2444         starttime.tv_sec--;
2445         starttime.tv_usec += 1000000;
2446
2447         /* Randomize starting request ID */
2448         Req_ID = starttime.tv_sec;
2449
2450         /*
2451          * Reset all the interface descriptors
2452          */
2453         for ( i = 0; i < MAX_UNITS; i++ ) {
2454                 ilmi_fd[i] = -1;
2455         }
2456         /*
2457          * Try to open all the interfaces
2458          */
2459         ilmi_open ();
2460
2461         /*
2462          * If we're just sending a coldStart end exiting...
2463          */
2464         if ( Reset ) {
2465                 for ( i = 0; i < MAX_UNITS; i++ )
2466                         if ( ilmi_fd[i] >= 0 ) {
2467                             /* Build ColdStart TRAP header */
2468                             ColdStart_Header = build_cold_start();
2469                             build_pdu ( ColdStart_Header, PDU_TYPE_TRAP );
2470                             send_resp ( i, ColdStart_Header, Resp_Buf );
2471                             if ( Debug_Level > 1 && Log ) {
2472                                 write_timestamp();
2473                                 fprintf ( Log, "Close ilmi_fd[%d]: %d\n",
2474                                     i, ilmi_fd[i] );
2475                             }
2476                             close ( ilmi_fd[i] );
2477                         }
2478                 exit ( 2 );
2479         }
2480
2481         ilmi_do_state();
2482
2483         exit(0);
2484 }