add /etc/ppp/peers
[ppp.git] / pppd / ipxcp.c
1 /*
2  * ipxcp.c - PPP IPX Control Protocol.
3  *
4  * Copyright (c) 1989 Carnegie Mellon University.
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms are permitted
8  * provided that the above copyright notice and this paragraph are
9  * duplicated in all such forms and that any documentation,
10  * advertising materials, and other materials related to such
11  * distribution and use acknowledge that the software was developed
12  * by Carnegie Mellon University.  The name of the
13  * University may not be used to endorse or promote products derived
14  * from this software without specific prior written permission.
15  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
16  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
17  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
18  */
19
20 #ifdef IPX_CHANGE
21 #ifndef lint
22 static char rcsid[] = "$Id: ipxcp.c,v 1.2 1996/07/01 01:14:25 paulus Exp $";
23 #endif
24
25 /*
26  * TODO:
27  */
28
29 #include <stdio.h>
30 #include <string.h>
31 #include <syslog.h>
32 #include <sys/types.h>
33 #include <sys/socket.h>
34 #include <netinet/in.h>
35
36 #include "pppd.h"
37 #include "fsm.h"
38 #include "ipxcp.h"
39 #include "pathnames.h"
40
41 /* global vars */
42 ipxcp_options ipxcp_wantoptions[NUM_PPP];       /* Options that we want to request */
43 ipxcp_options ipxcp_gotoptions[NUM_PPP];        /* Options that peer ack'd */
44 ipxcp_options ipxcp_allowoptions[NUM_PPP];      /* Options we allow peer to request */
45 ipxcp_options ipxcp_hisoptions[NUM_PPP];        /* Options that we ack'd */
46
47 #define wo (&ipxcp_wantoptions[0])
48 #define ao (&ipxcp_allowoptions[0])
49 #define go (&ipxcp_gotoptions[0])
50 #define ho (&ipxcp_hisoptions[0])
51
52 /*
53  * Callbacks for fsm code.  (CI = Configuration Information)
54  */
55 static void ipxcp_resetci __P((fsm *)); /* Reset our CI */
56 static int  ipxcp_cilen __P((fsm *));           /* Return length of our CI */
57 static void ipxcp_addci __P((fsm *, u_char *, int *)); /* Add our CI */
58 static int  ipxcp_ackci __P((fsm *, u_char *, int));    /* Peer ack'd our CI */
59 static int  ipxcp_nakci __P((fsm *, u_char *, int));    /* Peer nak'd our CI */
60 static int  ipxcp_rejci __P((fsm *, u_char *, int));    /* Peer rej'd our CI */
61 static int  ipxcp_reqci __P((fsm *, u_char *, int *, int)); /* Rcv CI */
62 static void ipxcp_up __P((fsm *));              /* We're UP */
63 static void ipxcp_down __P((fsm *));            /* We're DOWN */
64 static void ipxcp_script __P((fsm *, char *)); /* Run an up/down script */
65
66 fsm ipxcp_fsm[NUM_PPP];         /* IPXCP fsm structure */
67
68 static fsm_callbacks ipxcp_callbacks = { /* IPXCP callback routines */
69     ipxcp_resetci,              /* Reset our Configuration Information */
70     ipxcp_cilen,                /* Length of our Configuration Information */
71     ipxcp_addci,                /* Add our Configuration Information */
72     ipxcp_ackci,                /* ACK our Configuration Information */
73     ipxcp_nakci,                /* NAK our Configuration Information */
74     ipxcp_rejci,                /* Reject our Configuration Information */
75     ipxcp_reqci,                /* Request peer's Configuration Information */
76     ipxcp_up,                   /* Called when fsm reaches OPENED state */
77     ipxcp_down,                 /* Called when fsm leaves OPENED state */
78     NULL,                       /* Called when we want the lower layer up */
79     NULL,                       /* Called when we want the lower layer down */
80     NULL,                       /* Called when Protocol-Reject received */
81     NULL,                       /* Retransmission is necessary */
82     NULL,                       /* Called to handle protocol-specific codes */
83     "IPXCP"                     /* String name of protocol */
84 };
85
86 /*
87  * Protocol entry points.
88  */
89
90 static void ipxcp_init __P((int));
91 static void ipxcp_open __P((int));
92 static void ipxcp_close __P((int, char *));
93 static void ipxcp_lowerup __P((int));
94 static void ipxcp_lowerdown __P((int));
95 static void ipxcp_input __P((int, u_char *, int));
96 static void ipxcp_protrej __P((int));
97 static int  ipxcp_printpkt __P((u_char *, int,
98                                 void (*) __P((void *, char *, ...)), void *));
99
100 struct protent ipxcp_protent = {
101     PPP_IPXCP,
102     ipxcp_init,
103     ipxcp_input,
104     ipxcp_protrej,
105     ipxcp_lowerup,
106     ipxcp_lowerdown,
107     ipxcp_open,
108     ipxcp_close,
109     ipxcp_printpkt,
110     NULL,
111     0,
112     "IPXCP",
113     NULL,
114     NULL,
115     NULL
116 };
117
118
119 /*
120  * Lengths of configuration options.
121  */
122
123 #define CILEN_VOID      2
124 #define CILEN_COMPLETE  2       /* length of complete option */
125 #define CILEN_NETN      6       /* network number length option */
126 #define CILEN_NODEN     8       /* node number length option */
127 #define CILEN_PROTOCOL  4       /* Minimum length of routing protocol */
128 #define CILEN_NAME      3       /* Minimum length of router name */
129 #define CILEN_COMPRESS  4       /* Minimum length of compression protocol */
130
131 #define CODENAME(x)     ((x) == CONFACK ? "ACK" : \
132                          (x) == CONFNAK ? "NAK" : "REJ")
133
134 /* Used in printing the node number */
135 #define NODE(base) base[0], base[1], base[2], base[3], base[4], base[5]
136
137 /* Used to generate the proper bit mask */
138 #define BIT(num)   (1 << (num))
139
140 /*
141  * Make a string representation of a network IP address.
142  */
143
144 char *
145 ipx_ntoa(ipxaddr)
146 u_int32_t ipxaddr;
147 {
148     static char b[64];
149     sprintf(b, "%lx", ipxaddr);
150     return b;
151 }
152
153
154 /*
155  * ipxcp_init - Initialize IPXCP.
156  */
157 static void
158 ipxcp_init(unit)
159     int unit;
160 {
161     fsm *f = &ipxcp_fsm[unit];
162
163     f->unit      = unit;
164     f->protocol  = PPP_IPXCP;
165     f->callbacks = &ipxcp_callbacks;
166     fsm_init(&ipxcp_fsm[unit]);
167
168     memset (wo->name,     0, sizeof (wo->name));
169     memset (wo->our_node, 0, sizeof (wo->our_node));
170     memset (wo->his_node, 0, sizeof (wo->his_node));
171
172     wo->neg_nn         = 1;
173     wo->neg_complete   = 1;
174     wo->network        = 0;
175
176     ao->neg_node       = 1;
177     ao->neg_nn         = 1;
178     ao->neg_name       = 1;
179     ao->neg_complete   = 1;
180     ao->neg_router     = 1;
181
182     ao->accept_local   = 0;
183     ao->accept_remote  = 0;
184     ao->accept_network = 0;
185 }
186
187 /*
188  * Copy the node number
189  */
190
191 static void
192 copy_node (src, dst)
193 u_char *src, *dst;
194 {
195     memcpy (dst, src, sizeof (ipxcp_wantoptions[0].our_node));
196 }
197
198 /*
199  * Compare node numbers
200  */
201
202 static int
203 compare_node (src, dst)
204 u_char *src, *dst;
205 {
206     return memcmp (dst, src, sizeof (ipxcp_wantoptions[0].our_node)) == 0;
207 }
208
209 /*
210  * Is the node number zero?
211  */
212
213 static int
214 zero_node (node)
215 u_char *node;
216 {
217     int indx;
218     for (indx = 0; indx < sizeof (ipxcp_wantoptions[0].our_node); ++indx)
219         if (node [indx] != 0)
220             return 0;
221     return 1;
222 }
223
224 /*
225  * Increment the node number
226  */
227
228 static void
229 inc_node (node)
230 u_char *node;
231 {
232     u_char   *outp;
233     u_int32_t magic_num;
234
235     outp      = node;
236     magic_num = magic();
237     *outp++   = '\0';
238     *outp++   = '\0';
239     PUTLONG (magic_num, outp);
240 }
241
242 /*
243  * ipxcp_open - IPXCP is allowed to come up.
244  */
245 static void
246 ipxcp_open(unit)
247     int unit;
248 {
249     fsm_open(&ipxcp_fsm[unit]);
250 }
251
252 /*
253  * ipxcp_close - Take IPXCP down.
254  */
255 static void
256 ipxcp_close(unit, reason)
257     int unit;
258     char *reason;
259 {
260     fsm_close(&ipxcp_fsm[unit], reason);
261 }
262
263
264 /*
265  * ipxcp_lowerup - The lower layer is up.
266  */
267 static void
268 ipxcp_lowerup(unit)
269     int unit;
270 {
271     fsm_lowerup(&ipxcp_fsm[unit]);
272 }
273
274
275 /*
276  * ipxcp_lowerdown - The lower layer is down.
277  */
278 static void
279 ipxcp_lowerdown(unit)
280     int unit;
281 {
282     fsm_lowerdown(&ipxcp_fsm[unit]);
283 }
284
285
286 /*
287  * ipxcp_input - Input IPXCP packet.
288  */
289 static void
290 ipxcp_input(unit, p, len)
291     int unit;
292     u_char *p;
293     int len;
294 {
295     fsm_input(&ipxcp_fsm[unit], p, len);
296 }
297
298
299 /*
300  * ipxcp_protrej - A Protocol-Reject was received for IPXCP.
301  *
302  * Pretend the lower layer went down, so we shut up.
303  */
304 static void
305 ipxcp_protrej(unit)
306     int unit;
307 {
308     fsm_lowerdown(&ipxcp_fsm[unit]);
309 }
310
311
312 /*
313  * ipxcp_resetci - Reset our CI.
314  */
315 static void
316 ipxcp_resetci(f)
317     fsm *f;
318 {
319     u_int32_t network;
320     int unit = f->unit;
321
322     wo->req_node = wo->neg_node && ao->neg_node;
323     wo->req_nn   = wo->neg_nn   && ao->neg_nn;
324
325     if (wo->our_network == 0) {
326         wo->neg_node       = 1;
327         ao->accept_network = 1;
328     }
329 /*
330  * If our node number is zero then change it.
331  */
332     if (zero_node (wo->our_node)) {
333         inc_node (wo->our_node);
334         ao->accept_local = 1;
335         wo->neg_node     = 1;
336     }
337 /*
338  * If his node number is zero then change it.
339  */
340     if (zero_node (wo->his_node)) {
341         inc_node (wo->his_node);
342         ao->accept_remote = 1;
343     }
344 /*
345  * Unless router protocol is suppressed then assume that we can do RIP.
346  */
347     if (! (wo->router & BIT(0)))
348         wo->router |= BIT(2);
349 /*
350  * Router protocol is only negotiated if requested. Others force the
351  * negotiation.
352  */
353     if (wo->router & (BIT(2) | BIT(4)))
354         wo->neg_router = 1;
355 /*
356  * Start with these default values
357  */
358     *go = *wo;
359 }
360
361 /*
362  * ipxcp_cilen - Return length of our CI.
363  */
364 static int
365 ipxcp_cilen(f)
366     fsm *f;
367 {
368     int unit = f->unit;
369     int len;
370
371     len  = go->neg_nn       ? CILEN_NETN     : 0;
372     len += go->neg_node     ? CILEN_NODEN    : 0;
373     len += go->neg_name     ? CILEN_NAME + strlen (go->name) - 1 : 0;
374     len += go->neg_complete ? CILEN_COMPLETE : 0;
375 /*
376  * Router protocol 0 is mutually exclusive with the others.
377  */
378     if (go->neg_router) {
379         if (go->router & BIT(0))
380             len += CILEN_PROTOCOL;
381         else {
382             if (go->router & BIT(2))
383                 len += CILEN_PROTOCOL;
384             if (go->router & BIT(4))
385                 len += CILEN_PROTOCOL;
386         }
387     }
388
389     return (len);
390 }
391
392
393 /*
394  * ipxcp_addci - Add our desired CIs to a packet.
395  */
396 static void
397 ipxcp_addci(f, ucp, lenp)
398     fsm *f;
399     u_char *ucp;
400     int *lenp;
401 {
402     int len = *lenp;
403     int unit = f->unit;
404 /*
405  * Add the options to the record.
406  */
407     if (go->neg_nn) {
408         PUTCHAR (IPX_NETWORK_NUMBER, ucp);
409         PUTCHAR (CILEN_NETN, ucp);
410         PUTLONG (go->our_network, ucp);
411     }
412
413     if (go->neg_node) {
414         int indx;
415         PUTCHAR (IPX_NODE_NUMBER, ucp);
416         PUTCHAR (CILEN_NODEN, ucp);
417         for (indx = 0; indx < sizeof (go->our_node); ++indx)
418             PUTCHAR (go->our_node[indx], ucp);
419     }
420
421     if (go->neg_name) {
422         int cilen = strlen (go->name);
423         int indx;
424         PUTCHAR (IPX_ROUTER_NAME, ucp);
425         PUTCHAR (CILEN_NAME + cilen - 1, ucp);
426         for (indx = 0; indx < cilen; ++indx)
427             PUTCHAR (go->name [indx], ucp);
428     }
429
430     if (go->neg_router && (go->router & (BIT(0) | BIT(2) | BIT(4)))) {
431         if (go->router & BIT(0)) {
432             PUTCHAR  (IPX_ROUTER_PROTOCOL, ucp);
433             PUTCHAR  (CILEN_PROTOCOL,      ucp);
434             PUTSHORT (0,                   ucp);
435         } else {
436             if (go->router & BIT(2)) {
437                 PUTCHAR  (IPX_ROUTER_PROTOCOL, ucp);
438                 PUTCHAR  (CILEN_PROTOCOL,      ucp);
439                 PUTSHORT (2,                   ucp);
440             }
441             
442             if (go->router & BIT(4)) {
443                 PUTCHAR  (IPX_ROUTER_PROTOCOL, ucp);
444                 PUTCHAR  (CILEN_PROTOCOL,      ucp);
445                 PUTSHORT (4,                   ucp);
446             }
447         }
448     }
449
450     if (go->neg_complete) {
451         PUTCHAR (IPX_COMPLETE,   ucp);
452         PUTCHAR (CILEN_COMPLETE, ucp);
453     }
454 }
455
456 /*
457  * ipxcp_ackci - Ack our CIs.
458  *
459  * Returns:
460  *      0 - Ack was bad.
461  *      1 - Ack was good.
462  */
463 static int
464 ipxcp_ackci(f, p, len)
465     fsm *f;
466     u_char *p;
467     int len;
468 {
469     int unit = f->unit;
470     u_short cilen, citype, cishort;
471     u_char cichar;
472     u_int32_t cilong;
473
474 #define ACKCIVOID(opt, neg) \
475     if (neg) { \
476         if ((len -= CILEN_VOID) < 0) \
477             break; \
478         GETCHAR(citype, p); \
479         GETCHAR(cilen, p); \
480         if (cilen != CILEN_VOID || \
481             citype != opt) \
482             break; \
483     }
484
485 #define ACKCICOMPLETE(opt,neg)  ACKCIVOID(opt, neg)
486
487 #define ACKCICHARS(opt, neg, val, cnt) \
488     if (neg) { \
489         int indx, count = cnt; \
490         len -= (count + 2); \
491         if (len < 0) \
492             break; \
493         GETCHAR(citype, p); \
494         GETCHAR(cilen, p); \
495         if (cilen != (count + 2) || \
496             citype != opt) \
497             break; \
498         for (indx = 0; indx < count; ++indx) {\
499             GETCHAR(cichar, p); \
500             if (cichar != ((u_char *) &val)[indx]) \
501                break; \
502         }\
503         if (indx != count) \
504             break; \
505     }
506
507 #define ACKCINODE(opt,neg,val) ACKCICHARS(opt,neg,val,sizeof(val))
508 #define ACKCINAME(opt,neg,val) ACKCICHARS(opt,neg,val,strlen(val))
509
510 #define ACKCINETWORK(opt, neg, val) \
511     if (neg) { \
512         if ((len -= CILEN_NETN) < 0) \
513             break; \
514         GETCHAR(citype, p); \
515         GETCHAR(cilen, p); \
516         if (cilen != CILEN_NETN || \
517             citype != opt) \
518             break; \
519         GETLONG(cilong, p); \
520         if (cilong != val) \
521             break; \
522     }
523
524 #define ACKCIPROTO(opt, neg, val, bit) \
525     if (neg && (val & BIT(bit))) \
526       { \
527         if (len < 2) \
528             break; \
529         GETCHAR(citype, p); \
530         GETCHAR(cilen, p); \
531         if (cilen != CILEN_PROTOCOL || citype != opt) \
532             break; \
533         len -= cilen; \
534         if (len < 0) \
535             break; \
536         GETSHORT(cishort, p); \
537         if (cishort != (bit)) \
538             break; \
539       }
540 /*
541  * Process the ACK frame in the order in which the frame was assembled
542  */
543     do {
544         ACKCINETWORK  (IPX_NETWORK_NUMBER,  go->neg_nn,     go->our_network);
545         ACKCINODE     (IPX_NODE_NUMBER,     go->neg_node,   go->our_node);
546         ACKCINAME     (IPX_ROUTER_NAME,     go->neg_name,   go->name);
547         ACKCIPROTO    (IPX_ROUTER_PROTOCOL, go->neg_router, go->router, 0);
548         ACKCIPROTO    (IPX_ROUTER_PROTOCOL, go->neg_router, go->router, 2);
549         ACKCIPROTO    (IPX_ROUTER_PROTOCOL, go->neg_router, go->router, 4);
550         ACKCICOMPLETE (IPX_COMPLETE,        go->neg_complete);
551 /*
552  * This is the end of the record.
553  */
554         if (len == 0)
555             return (1);
556     } while (0);
557 /*
558  * The frame is invalid
559  */
560     IPXCPDEBUG((LOG_INFO, "ipxcp_ackci: received bad Ack!"));
561     return (0);
562 }
563
564 /*
565  * ipxcp_nakci - Peer has sent a NAK for some of our CIs.
566  * This should not modify any state if the Nak is bad
567  * or if IPXCP is in the OPENED state.
568  *
569  * Returns:
570  *      0 - Nak was bad.
571  *      1 - Nak was good.
572  */
573
574 static int
575 ipxcp_nakci(f, p, len)
576     fsm *f;
577     u_char *p;
578     int len;
579 {
580     int unit = f->unit;
581     u_char citype, cilen, *next;
582     u_short s;
583     u_int32_t l;
584     ipxcp_options no;           /* options we've seen Naks for */
585     ipxcp_options try;          /* options to request next time */
586
587     BZERO(&no, sizeof(no));
588     try = *go;
589
590     while (len > CILEN_VOID) {
591         GETCHAR (citype, p);
592         GETCHAR (cilen,  p);
593         len -= cilen;
594         if (len < 0)
595             goto bad;
596         next = &p [cilen - CILEN_VOID];
597
598         switch (citype) {
599         case IPX_NETWORK_NUMBER:
600             if (!go->neg_nn || no.neg_nn || (cilen != CILEN_NETN))
601                 goto bad;
602             no.neg_nn = 1;
603
604             GETLONG(l, p);
605             IPXCPDEBUG((LOG_INFO, "local IP address %d", l));
606             if (l && ao->accept_network)
607                 try.our_network = l;
608             break;
609
610         case IPX_NODE_NUMBER:
611             if (!go->neg_node || no.neg_node || (cilen != CILEN_NODEN))
612                 goto bad;
613             no.neg_node = 1;
614
615             IPXCPDEBUG((LOG_INFO,
616                         "local node number %02X%02X%02X%02X%02X%02X",
617                         NODE(p)));
618
619             if (!zero_node (p) && ao->accept_local &&
620                 ! compare_node (p, ho->his_node))
621                 copy_node (p, try.our_node);
622             break;
623
624             /* These have never been sent. Ignore the NAK frame */
625         case IPX_COMPRESSION_PROTOCOL:
626             goto bad;
627
628         case IPX_ROUTER_PROTOCOL:
629             if (!go->neg_router || (cilen < CILEN_PROTOCOL))
630                 goto bad;
631
632             GETSHORT (s, p);
633             if ((s != 0) && (s != 2) && (s != 4))
634                 goto bad;
635
636             if (no.router & BIT(s))
637                 goto bad;
638
639             if (no.router == 0) /* Reset on first NAK only */
640                 try.router = 0;
641             no.router      |= BIT(s);
642             try.router     |= BIT(s);
643             try.neg_router  = 1;
644
645             IPXCPDEBUG((LOG_INFO, "Router protocol number %d", s));
646             break;
647
648             /* These, according to the RFC, must never be NAKed. */
649         case IPX_ROUTER_NAME:
650         case IPX_COMPLETE:
651             goto bad;
652
653             /* These are for options which we have not seen. */
654         default:
655             break;
656         }
657         p = next;
658     }
659
660     /* If there is still anything left, this packet is bad. */
661     if (len != 0)
662         goto bad;
663
664     /*
665      * Do not permit the peer to force a router protocol which we do not
666      * support.
667      */
668     try.router &= go->router;
669     if (try.router == 0 && go->router != 0) {
670         try.neg_router = 1;
671         try.router     = BIT(0);
672     }
673     
674     /*
675      * OK, the Nak is good.  Now we can update state.
676      */
677     if (f->state != OPENED)
678         *go = try;
679
680     return 1;
681
682 bad:
683     IPXCPDEBUG((LOG_INFO, "ipxcp_nakci: received bad Nak!"));
684     return 0;
685 }
686
687 /*
688  * ipxcp_rejci - Reject some of our CIs.
689  */
690 static int
691 ipxcp_rejci(f, p, len)
692     fsm *f;
693     u_char *p;
694     int len;
695 {
696     int unit = f->unit;
697     u_short cilen, citype, cishort;
698     u_char cichar;
699     u_int32_t cilong;
700     ipxcp_options try;          /* options to request next time */
701
702 #define REJCINETWORK(opt, neg, val) \
703     if (neg) { \
704         neg = 0; \
705         if ((len -= CILEN_NETN) < 0) \
706             break; \
707         GETCHAR(citype, p); \
708         GETCHAR(cilen, p); \
709         if (cilen != CILEN_NETN || \
710             citype != opt) \
711             break; \
712         GETLONG(cilong, p); \
713         if (cilong != val) \
714             break; \
715         IPXCPDEBUG((LOG_INFO,"ipxcp_rejci rejected long opt %d", opt)); \
716     }
717
718 #define REJCICHARS(opt, neg, val, cnt) \
719     if (neg) { \
720         int indx, count = cnt; \
721         neg = 0; \
722         len -= (count + 2); \
723         if (len < 0) \
724             break; \
725         GETCHAR(citype, p); \
726         GETCHAR(cilen, p); \
727         if (cilen != (count + 2) || \
728             citype != opt) \
729             break; \
730         for (indx = 0; indx < count; ++indx) {\
731             GETCHAR(cichar, p); \
732             if (cichar != ((u_char *) &val)[indx]) \
733                break; \
734         }\
735         if (indx != count) \
736             break; \
737         IPXCPDEBUG((LOG_INFO,"ipxcp_rejci rejected opt %d", opt)); \
738     }
739
740 #define REJCINODE(opt,neg,val) REJCICHARS(opt,neg,val,sizeof(val))
741 #define REJCINAME(opt,neg,val) REJCICHARS(opt,neg,val,strlen(val))
742
743 #define REJCIVOID(opt, neg) \
744     if (neg) { \
745         neg = 0; \
746         if ((len -= CILEN_VOID) < 0) \
747             break; \
748         GETCHAR(citype, p); \
749         GETCHAR(cilen, p); \
750         if (cilen != CILEN_VOID || citype != opt) \
751             break; \
752         IPXCPDEBUG((LOG_INFO, "ipxcp_rejci rejected void opt %d", opt)); \
753     }
754
755 #define REJCIPROTO(opt, neg, val, bit) \
756     if (neg && (val & BIT(bit))) \
757       { \
758         if (len < 2) \
759             break; \
760         GETCHAR(citype, p); \
761         GETCHAR(cilen, p); \
762         if (cilen != CILEN_PROTOCOL || citype != opt) \
763             break; \
764         len -= cilen; \
765         if (len < 0) \
766             break; \
767         GETSHORT(cishort, p); \
768         if (cishort != (bit)) \
769             break; \
770         IPXCPDEBUG((LOG_INFO, "ipxcp_rejci rejected router proto %d", bit)); \
771         val &= ~BIT(bit); \
772         if (val == 0) \
773             neg = 0; \
774       }
775
776 /*
777  * Any Rejected CIs must be in exactly the same order that we sent.
778  * Check packet length and CI length at each step.
779  * If we find any deviations, then this packet is bad.
780  */
781     try = *go;
782
783     do {
784         REJCINETWORK (IPX_NETWORK_NUMBER,  try.neg_nn,     try.our_network);
785         REJCINODE    (IPX_NODE_NUMBER,     try.neg_node,   try.our_node);
786         REJCIPROTO   (IPX_ROUTER_PROTOCOL, try.neg_router, try.router, 0);
787         REJCIPROTO   (IPX_ROUTER_PROTOCOL, try.neg_router, try.router, 2);
788         REJCIPROTO   (IPX_ROUTER_PROTOCOL, try.neg_router, try.router, 4);
789         REJCINAME    (IPX_ROUTER_NAME,     try.neg_name,   try.name);
790         REJCIVOID    (IPX_COMPLETE,        try.neg_complete);
791 /*
792  * This is the end of the record.
793  */
794         if (len == 0) {
795             if (f->state != OPENED)
796                 *go = try;
797             return (1);
798         }
799     } while (0);
800 /*
801  * The frame is invalid at this point.
802  */
803     IPXCPDEBUG((LOG_INFO, "ipxcp_rejci: received bad Reject!"));
804     return 0;
805 }
806
807 /*
808  * ipxcp_reqci - Check the peer's requested CIs and send appropriate response.
809  *
810  * Returns: CONFACK, CONFNAK or CONFREJ and input packet modified
811  * appropriately.  If reject_if_disagree is non-zero, doesn't return
812  * CONFNAK; returns CONFREJ if it can't return CONFACK.
813  */
814 static int
815 ipxcp_reqci(f, inp, len, reject_if_disagree)
816     fsm *f;
817     u_char *inp;                /* Requested CIs */
818     int *len;                   /* Length of requested CIs */
819     int reject_if_disagree;
820 {
821     int unit = f->unit;
822     u_char *cip, *next;         /* Pointer to current and next CIs */
823     u_short cilen, citype;      /* Parsed len, type */
824     u_short cishort, ts;        /* Parsed short value */
825     u_int32_t tl, cinetwork, outnet;/* Parsed address values */
826     int rc = CONFACK;           /* Final packet return code */
827     int orc;                    /* Individual option return code */
828     u_char *p;                  /* Pointer to next char to parse */
829     u_char *ucp = inp;          /* Pointer to current output char */
830     int l = *len;               /* Length left */
831     u_char maxslotindex, cflag;
832
833     /*
834      * Reset all his options.
835      */
836     BZERO(ho, sizeof(*ho));
837     
838     /*
839      * Process all his options.
840      */
841     next = inp;
842     while (l) {
843         orc = CONFACK;                  /* Assume success */
844         cip = p = next;                 /* Remember begining of CI */
845         if (l < 2 ||                    /* Not enough data for CI header or */
846             p[1] < 2 ||                 /*  CI length too small or */
847             p[1] > l) {                 /*  CI length too big? */
848             IPXCPDEBUG((LOG_INFO, "ipxcp_reqci: bad CI length!"));
849             orc = CONFREJ;              /* Reject bad CI */
850             cilen = l;                  /* Reject till end of packet */
851             l = 0;                      /* Don't loop again */
852             goto endswitch;
853         }
854         GETCHAR(citype, p);             /* Parse CI type */
855         GETCHAR(cilen, p);              /* Parse CI length */
856         l -= cilen;                     /* Adjust remaining length */
857         next += cilen;                  /* Step to next CI */
858
859         switch (citype) {               /* Check CI type */
860 /*
861  * The network number must match. Choose the larger of the two.
862  */
863         case IPX_NETWORK_NUMBER:
864             IPXCPDEBUG((LOG_INFO, "ipxcp: received Network Number request"));
865             
866             /* if we wont negotiate the network number or the length is wrong
867                then reject the option */
868             if ( !ao->neg_nn || cilen != CILEN_NETN ) {
869                 orc = CONFREJ;
870                 break;          
871             }
872             GETLONG(cinetwork, p);
873             IPXCPDEBUG((LOG_INFO,"Remote proposed IPX network number is %8Lx",tl));
874
875             /* If the network numbers match then acknowledge them. */
876             if (cinetwork != 0) {
877                 ho->his_network = cinetwork;
878                 ho->neg_nn      = 1;
879                 if (wo->our_network == cinetwork)
880                     break;
881 /*
882  * If the network number is not given or we don't accept their change or
883  * the network number is too small then NAK it.
884  */
885                 if (! ao->accept_network || cinetwork < wo->our_network) {
886                     DECPTR (sizeof (u_int32_t), p);
887                     PUTLONG (wo->our_network, p);
888                     orc = CONFNAK;
889                 }
890                 break;
891             }
892 /*
893  * The peer sent '0' for the network. Give it ours if we have one.
894  */
895             if (go->our_network != 0) {
896                 DECPTR (sizeof (u_int32_t), p);
897                 PUTLONG (wo->our_network, p);
898                 orc = CONFNAK;
899 /*
900  * We don't have one. Reject the value.
901  */
902             } else
903                 orc = CONFREJ;
904
905             break;
906 /*
907  * The node number is required
908  */
909         case IPX_NODE_NUMBER:
910             IPXCPDEBUG((LOG_INFO, "ipxcp: received Node Number request"));
911
912             /* if we wont negotiate the node number or the length is wrong
913                then reject the option */
914             if ( cilen != CILEN_NODEN ) {
915                 orc = CONFREJ;
916                 break;
917             }
918
919             copy_node (p, ho->his_node);
920             ho->neg_node = 1;
921 /*
922  * If the remote does not have a number and we do then NAK it with the value
923  * which we have for it. (We never have a default value of zero.)
924  */
925             if (zero_node (ho->his_node)) {
926                 orc = CONFNAK;
927                 copy_node (wo->his_node, p);
928                 INCPTR (sizeof (wo->his_node), p);
929                 break;
930             }
931 /*
932  * If you have given me the expected network node number then I'll accept
933  * it now.
934  */
935             if (compare_node (wo->his_node, ho->his_node)) {
936                 orc = CONFACK;
937                 ho->neg_node = 1;
938                 INCPTR (sizeof (wo->his_node), p);
939                 break;
940             }
941 /*
942  * If his node number is the same as ours then ask him to try the next
943  * value.
944  */
945             if (compare_node (ho->his_node, go->our_node)) {
946                 inc_node (ho->his_node);
947                 orc = CONFNAK;
948                 copy_node (ho->his_node, p);
949                 INCPTR (sizeof (wo->his_node), p);
950                 break;
951             }
952 /*
953  * If we don't accept a new value then NAK it.
954  */
955             if (! ao->accept_remote) {
956                 copy_node (wo->his_node, p);
957                 INCPTR (sizeof (wo->his_node), p);
958                 orc = CONFNAK;
959                 break;
960             }
961             orc = CONFACK;
962             ho->neg_node = 1;
963             INCPTR (sizeof (wo->his_node), p);
964             break;
965 /*
966  * Compression is not desired at this time. It is always rejected.
967  */
968         case IPX_COMPRESSION_PROTOCOL:
969             IPXCPDEBUG((LOG_INFO, "ipxcp: received Compression Protocol request "));
970             orc = CONFREJ;
971             break;
972 /*
973  * The routing protocol is a bitmask of various types. Any combination
974  * of the values 2 and 4 are permissible. '0' for no routing protocol must
975  * be specified only once.
976  */
977         case IPX_ROUTER_PROTOCOL:
978             if ( !ao->neg_router || cilen < CILEN_PROTOCOL ) {
979                 orc = CONFREJ;
980                 break;          
981             }
982
983             GETSHORT (cishort, p);
984             IPXCPDEBUG((LOG_INFO,
985                         "Remote router protocol number %d",
986                         cishort));
987
988             if ((cishort == 0 && ho->router != 0) || (ho->router & BIT(0))) {
989                 orc = CONFREJ;
990                 break;          
991             }
992
993             if (cishort != 0 && cishort != 2 && cishort != 4) {
994                 orc = CONFREJ;
995                 break;
996             }
997
998             if (ho->router & BIT (cishort)) {
999                 orc = CONFREJ;
1000                 break;
1001             }
1002
1003             ho->router    |= BIT (cishort);
1004             ho->neg_router = 1;
1005             break;
1006 /*
1007  * The router name is advisorary. Just accept it if it is not too large.
1008  */
1009         case IPX_ROUTER_NAME:
1010             IPXCPDEBUG((LOG_INFO, "ipxcp: received Router Name request"));
1011             if (cilen >= CILEN_NAME) {
1012                 int name_size = cilen - CILEN_NAME;
1013                 if (name_size > sizeof (ho->name))
1014                     name_size = sizeof (ho->name) - 1;
1015                 memset (ho->name, 0, sizeof (ho->name));
1016                 memcpy (ho->name, p, name_size);
1017                 ho->name [name_size] = '\0';
1018                 ho->neg_name = 1;
1019                 orc = CONFACK;
1020                 break;
1021             }
1022             orc = CONFREJ;
1023             break;
1024 /*
1025  * This is advisorary.
1026  */
1027         case IPX_COMPLETE:
1028             IPXCPDEBUG((LOG_INFO, "ipxcp: received Complete request"));
1029             if (cilen != CILEN_COMPLETE)
1030                 orc = CONFREJ;
1031             else {
1032                 ho->neg_complete = 1;
1033                 orc = CONFACK;
1034             }
1035             break;
1036 /*
1037  * All other entries are not known at this time.
1038  */
1039         default:
1040             IPXCPDEBUG((LOG_INFO, "ipxcp: received Complete request"));
1041             orc = CONFREJ;
1042             break;
1043         }
1044
1045 endswitch:
1046         IPXCPDEBUG((LOG_INFO, " (%s)\n", CODENAME(orc)));
1047
1048         if (orc == CONFACK &&           /* Good CI */
1049             rc != CONFACK)              /*  but prior CI wasnt? */
1050             continue;                   /* Don't send this one */
1051
1052         if (orc == CONFNAK) {           /* Nak this CI? */
1053             if (reject_if_disagree)     /* Getting fed up with sending NAKs? */
1054                 orc = CONFREJ;          /* Get tough if so */
1055             if (rc == CONFREJ)          /* Rejecting prior CI? */
1056                 continue;               /* Don't send this one */
1057             if (rc == CONFACK) {        /* Ack'd all prior CIs? */
1058                 rc  = CONFNAK;          /* Not anymore... */
1059                 ucp = inp;              /* Backup */
1060             }
1061         }
1062
1063         if (orc == CONFREJ &&           /* Reject this CI */
1064             rc != CONFREJ) {            /*  but no prior ones? */
1065             rc = CONFREJ;
1066             ucp = inp;                  /* Backup */
1067         }
1068
1069         /* Need to move CI? */
1070         if (ucp != cip)
1071             BCOPY(cip, ucp, cilen);     /* Move it */
1072
1073         /* Update output pointer */
1074         INCPTR(cilen, ucp);
1075     }
1076
1077     /*
1078      * If we aren't rejecting this packet, and we want to negotiate
1079      * their address, and they didn't send their address, then we
1080      * send a NAK with a IPX_NODE_NUMBER option appended. We assume the
1081      * input buffer is long enough that we can append the extra
1082      * option safely.
1083      */
1084
1085     if (rc != CONFREJ && !ho->neg_node &&
1086         wo->req_nn && !reject_if_disagree) {
1087         u_char *ps;
1088         if (rc == CONFACK) {
1089             rc = CONFNAK;
1090             wo->req_nn = 0;             /* don't ask again */
1091             ucp = inp;                  /* reset pointer */
1092         }
1093
1094         if (zero_node (wo->his_node))
1095             inc_node (wo->his_node);
1096
1097         PUTCHAR (IPX_NODE_NUMBER, ucp);
1098         PUTCHAR (CILEN_NODEN, ucp);
1099         copy_node (wo->his_node, ucp);
1100         INCPTR (sizeof (wo->his_node), ucp);
1101     }
1102
1103     *len = ucp - inp;                   /* Compute output length */
1104     IPXCPDEBUG((LOG_INFO, "ipxcp: returning Configure-%s", CODENAME(rc)));
1105     return (rc);                        /* Return final code */
1106 }
1107
1108 /*
1109  * ipxcp_up - IPXCP has come UP.
1110  *
1111  * Configure the IP network interface appropriately and bring it up.
1112  */
1113
1114 static void
1115 ipxcp_up(f)
1116     fsm *f;
1117 {
1118     int unit = f->unit;
1119
1120     IPXCPDEBUG((LOG_INFO, "ipxcp: up"));
1121
1122     if (!ho->neg_nn)
1123         ho->his_network = wo->his_network;
1124
1125     if (!ho->neg_node)
1126         copy_node (wo->his_node, ho->his_node);
1127
1128     if (!wo->neg_node && !go->neg_node)
1129         copy_node (wo->our_node, go->our_node);
1130
1131     if (zero_node (go->our_node)) {
1132         IPXCPDEBUG((LOG_ERR, "Could not determine local IPX node address"));
1133         ipxcp_close(f->unit, "Could not determine local IPX node address");
1134         return;
1135     }
1136
1137     go->network = go->our_network;
1138     if (ho->his_network != 0 && ho->his_network > go->network)
1139         go->network = ho->his_network;
1140
1141     if (go->network == 0) {
1142         IPXCPDEBUG((LOG_ERR, "Could not determine network number"));
1143         ipxcp_close (unit, "Could not determine network number");
1144         return;
1145     }
1146
1147     /* bring the interface up */
1148     if (!sifup(unit)) {
1149         IPXCPDEBUG((LOG_WARNING, "sifup failed"));
1150         ipxcp_close(unit, "Interface configuration failed");
1151         return;
1152     }
1153
1154     /* set the network number for IPX */
1155     if (!sipxfaddr(unit, go->network, go->our_node)) {
1156         IPXCPDEBUG((LOG_WARNING, "sipxfaddr failed"));
1157         ipxcp_close(unit, "Interface configuration failed");
1158         return;
1159     }
1160
1161     /*
1162      * Execute the ipx-up script, like this:
1163      *  /etc/ppp/ipx-up interface tty speed local-IPX remote-IPX
1164      */
1165
1166     ipxcp_script (f, "/etc/ppp/ipx-up");
1167 }
1168
1169 /*
1170  * ipxcp_down - IPXCP has gone DOWN.
1171  *
1172  * Take the IP network interface down, clear its addresses
1173  * and delete routes through it.
1174  */
1175
1176 static void
1177 ipxcp_down(f)
1178     fsm *f;
1179 {
1180     u_int32_t ournn, network;
1181
1182     IPXCPDEBUG((LOG_INFO, "ipxcp: down"));
1183
1184     cipxfaddr (f->unit);
1185     sifdown(f->unit);
1186     ipxcp_script (f, "/etc/ppp/ipx-down");
1187 }
1188
1189
1190 /*
1191  * ipxcp_script - Execute a script with arguments
1192  * interface-name tty-name speed local-IPX remote-IPX networks.
1193  */
1194 static void
1195 ipxcp_script(f, script)
1196     fsm *f;
1197     char *script;
1198 {
1199     int  unit = f->unit;
1200     char strspeed[32],   strlocal[32],     strremote[32];
1201     char strnetwork[32], strpid[32];
1202     char *argv[14],      strproto_lcl[32], strproto_rmt[32];
1203
1204     sprintf (strpid,   "%d", getpid());
1205     sprintf (strspeed, "%d", baud_rate);
1206
1207     strproto_lcl[0] = '\0';
1208     if (go->neg_router) {
1209         if (go->router & BIT(2))
1210             strcpy (strproto_lcl, "RIP ");
1211         if (go->router & BIT(4))
1212             strcpy (strproto_lcl, "NLSP ");
1213     }
1214
1215     if (strproto_lcl[0] == '\0')
1216         strcpy (strproto_lcl, "NONE ");
1217
1218     strproto_lcl[strlen (strproto_lcl)-1] = '\0';
1219
1220     strproto_rmt[0] = '\0';
1221     if (ho->neg_router) {
1222         if (ho->router & BIT(2))
1223             strcpy (strproto_rmt, "RIP ");
1224         if (ho->router & BIT(4))
1225             strcpy (strproto_rmt, "NLSP ");
1226     }
1227
1228     if (strproto_rmt[0] == '\0')
1229         strcpy (strproto_rmt, "NONE ");
1230
1231     strproto_rmt[strlen (strproto_rmt)-1] = '\0';
1232
1233     strcpy (strnetwork, ipx_ntoa (go->network));
1234
1235     sprintf (strlocal,
1236              "%02X%02X%02X%02X%02X%02X",
1237              NODE(go->our_node));
1238
1239     sprintf (strremote,
1240              "%02X%02X%02X%02X%02X%02X",
1241              NODE(ho->his_node));
1242
1243     argv[0]  = script;
1244     argv[1]  = ifname;
1245     argv[2]  = devnam;
1246     argv[3]  = strspeed;
1247     argv[4]  = strnetwork;
1248     argv[5]  = strlocal;
1249     argv[6]  = strremote;
1250     argv[7]  = strproto_lcl;
1251     argv[8]  = strproto_rmt;
1252     argv[9]  = go->name;
1253     argv[10] = ho->name;
1254     argv[11] = ipparam;
1255     argv[12] = strpid;
1256     argv[13] = NULL;
1257     run_program(script, argv, 0);
1258 }
1259
1260 /*
1261  * ipxcp_printpkt - print the contents of an IPXCP packet.
1262  */
1263 static char *ipxcp_codenames[] = {
1264     "ConfReq", "ConfAck", "ConfNak", "ConfRej",
1265     "TermReq", "TermAck", "CodeRej"
1266 };
1267
1268 static int
1269 ipxcp_printpkt(p, plen, printer, arg)
1270     u_char *p;
1271     int plen;
1272     void (*printer)();
1273     void *arg;
1274 {
1275     int code, id, len, olen;
1276     u_char *pstart, *optend;
1277     u_short cishort;
1278     u_int32_t cilong;
1279
1280     if (plen < HEADERLEN)
1281         return 0;
1282     pstart = p;
1283     GETCHAR(code, p);
1284     GETCHAR(id, p);
1285     GETSHORT(len, p);
1286     if (len < HEADERLEN || len > plen)
1287         return 0;
1288
1289     if (code >= 1 && code <= sizeof(ipxcp_codenames) / sizeof(char *))
1290         printer(arg, " %s", ipxcp_codenames[code-1]);
1291     else
1292         printer(arg, " code=0x%x", code);
1293     printer(arg, " id=0x%x", id);
1294     len -= HEADERLEN;
1295     switch (code) {
1296     case CONFREQ:
1297     case CONFACK:
1298     case CONFNAK:
1299     case CONFREJ:
1300         /* print option list */
1301         while (len >= 2) {
1302             GETCHAR(code, p);
1303             GETCHAR(olen, p);
1304             p -= 2;
1305             if (olen < CILEN_VOID || olen > len) {
1306                 break;
1307             }
1308             printer(arg, " <");
1309             len -= olen;
1310             optend = p + olen;
1311             switch (code) {
1312             case IPX_NETWORK_NUMBER:
1313                 if (olen == CILEN_NETN) {
1314                     p += CILEN_VOID;
1315                     GETLONG(cilong, p);
1316                     printer (arg, "network %s", ipx_ntoa (cilong));
1317                 }
1318                 break;
1319             case IPX_NODE_NUMBER:
1320                 if (olen == CILEN_NODEN) {
1321                     p += CILEN_VOID;
1322                     printer (arg, "node ");
1323                     while (p < optend) {
1324                         GETCHAR(code, p);
1325                         printer(arg, "%.2x", code);
1326                     }
1327                 }
1328                 break;
1329             case IPX_COMPRESSION_PROTOCOL:
1330                 if (olen == CILEN_COMPRESS) {
1331                     p += CILEN_VOID;
1332                     GETSHORT (cishort, p);
1333                     printer (arg, "compression %d", cishort);
1334                 }
1335                 break;
1336             case IPX_ROUTER_PROTOCOL:
1337                 if (olen == CILEN_PROTOCOL) {
1338                     p += CILEN_VOID;
1339                     GETSHORT (cishort, p);
1340                     printer (arg, "router proto %d", cishort);
1341                 }
1342                 break;
1343             case IPX_ROUTER_NAME:
1344                 if (olen >= CILEN_NAME) {
1345                     p += CILEN_VOID;
1346                     printer (arg, "router name \"");
1347                     while (p < optend) {
1348                         GETCHAR(code, p);
1349                         if (code >= 0x20 && code < 0x7E)
1350                             printer (arg, "%c", code);
1351                         else
1352                             printer (arg, " \\%.2x", code);
1353                     }
1354                     printer (arg, "\"");
1355                 }
1356                 break;
1357             case IPX_COMPLETE:
1358                 if (olen == CILEN_COMPLETE) {
1359                     p += CILEN_VOID;
1360                     printer (arg, "complete");
1361                 }
1362                 break;
1363             default:
1364                 break;
1365             }
1366
1367             while (p < optend) {
1368                 GETCHAR(code, p);
1369                 printer(arg, " %.2x", code);
1370             }
1371             printer(arg, ">");
1372         }
1373         break;
1374
1375     case TERMACK:
1376     case TERMREQ:
1377         if (len > 0 && *p >= ' ' && *p < 0x7f) {
1378             printer(arg, " ");
1379             print_string(p, len, printer, arg);
1380             p += len;
1381             len = 0;
1382         }
1383         break;
1384     }
1385
1386     /* print the rest of the bytes in the packet */
1387     for (; len > 0; --len) {
1388         GETCHAR(code, p);
1389         printer(arg, " %.2x", code);
1390     }
1391
1392     return p - pstart;
1393 }
1394 #endif /* ifdef IPX_CHANGE */