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