pppd/ipcp.c

   1 /*
   2  * ipcp.c - PPP IP 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 #ifndef lint
  21 static char rcsid[] = "$Id: ipcp.c,v 1.22 1995/12/18 03:45:56 paulus Exp $";
  22 #endif
  23
  24 /*
  25  * TODO:
  26  */
  27
  28 #include <stdio.h>
  29 #include <string.h>
  30 #include <syslog.h>
  31 #include <sys/types.h>
  32 #include <sys/socket.h>
  33 #include <netinet/in.h>
  34
  35 #include "pppd.h"
  36 #include "fsm.h"
  37 #include "ipcp.h"
  38 #include "pathnames.h"
  39
  40 /* global vars */
  41 ipcp_options ipcp_wantoptions[NUM_PPP]; /* Options that we want to request */
  42 ipcp_options ipcp_gotoptions[NUM_PPP];  /* Options that peer ack'd */
  43 ipcp_options ipcp_allowoptions[NUM_PPP];        /* Options we allow peer to request */
  44 ipcp_options ipcp_hisoptions[NUM_PPP];  /* Options that we ack'd */
  45
  46 /* local vars */
  47 static int cis_received[NUM_PPP];               /* # Conf-Reqs received */
  48
  49 /*
  50  * Callbacks for fsm code.  (CI = Configuration Information)
  51  */
  52 static void ipcp_resetci __P((fsm *));  /* Reset our CI */
  53 static int  ipcp_cilen __P((fsm *));            /* Return length of our CI */
  54 static void ipcp_addci __P((fsm *, u_char *, int *)); /* Add our CI */
  55 static int  ipcp_ackci __P((fsm *, u_char *, int));     /* Peer ack'd our CI */
  56 static int  ipcp_nakci __P((fsm *, u_char *, int));     /* Peer nak'd our CI */
  57 static int  ipcp_rejci __P((fsm *, u_char *, int));     /* Peer rej'd our CI */
  58 static int  ipcp_reqci __P((fsm *, u_char *, int *, int)); /* Rcv CI */
  59 static void ipcp_up __P((fsm *));               /* We're UP */
  60 static void ipcp_down __P((fsm *));             /* We're DOWN */
  61 static void ipcp_script __P((fsm *, char *)); /* Run an up/down script */
  62
  63 fsm ipcp_fsm[NUM_PPP];          /* IPCP fsm structure */
  64
  65 static fsm_callbacks ipcp_callbacks = { /* IPCP callback routines */
  66     ipcp_resetci,               /* Reset our Configuration Information */
  67     ipcp_cilen,                 /* Length of our Configuration Information */
  68     ipcp_addci,                 /* Add our Configuration Information */
  69     ipcp_ackci,                 /* ACK our Configuration Information */
  70     ipcp_nakci,                 /* NAK our Configuration Information */
  71     ipcp_rejci,                 /* Reject our Configuration Information */
  72     ipcp_reqci,                 /* Request peer's Configuration Information */
  73     ipcp_up,                    /* Called when fsm reaches OPENED state */
  74     ipcp_down,                  /* Called when fsm leaves OPENED state */
  75     NULL,                       /* Called when we want the lower layer up */
  76     NULL,                       /* Called when we want the lower layer down */
  77     NULL,                       /* Called when Protocol-Reject received */
  78     NULL,                       /* Retransmission is necessary */
  79     NULL,                       /* Called to handle protocol-specific codes */
  80     "IPCP"                      /* String name of protocol */
  81 };
  82
  83 struct protent ipcp_protent = {
  84     PPP_IPCP, ipcp_init, ipcp_input, ipcp_protrej,
  85     ipcp_lowerup, ipcp_lowerdown, ipcp_open, ipcp_close,
  86     ipcp_printpkt, NULL, 1, "IPCP"
  87 };
  88
  89 /*
  90  * Lengths of configuration options.
  91  */
  92 #define CILEN_VOID      2
  93 #define CILEN_COMPRESS  4       /* min length for compression protocol opt. */
  94 #define CILEN_VJ        6       /* length for RFC1332 Van-Jacobson opt. */
  95 #define CILEN_ADDR      6       /* new-style single address option */
  96 #define CILEN_ADDRS     10      /* old-style dual address option */
  97
  98
  99 #define CODENAME(x)     ((x) == CONFACK ? "ACK" : \
 100                          (x) == CONFNAK ? "NAK" : "REJ")
 101
 102
 103 /*
 104  * Make a string representation of a network IP address.
 105  */
 106 char *
 107 ip_ntoa(ipaddr)
 108 u_int32_t ipaddr;
 109 {
 110     static char b[64];
 111
 112     ipaddr = ntohl(ipaddr);
 113
 114     sprintf(b, "%d.%d.%d.%d",
 115             (u_char)(ipaddr >> 24),
 116             (u_char)(ipaddr >> 16),
 117             (u_char)(ipaddr >> 8),
 118             (u_char)(ipaddr));
 119     return b;
 120 }
 121
 122
 123 /*
 124  * ipcp_init - Initialize IPCP.
 125  */
 126 void
 127 ipcp_init(unit)
 128     int unit;
 129 {
 130     fsm *f = &ipcp_fsm[unit];
 131     ipcp_options *wo = &ipcp_wantoptions[unit];
 132     ipcp_options *ao = &ipcp_allowoptions[unit];
 133
 134     f->unit = unit;
 135     f->protocol = PPP_IPCP;
 136     f->callbacks = &ipcp_callbacks;
 137     fsm_init(&ipcp_fsm[unit]);
 138
 139     memset(wo, 0, sizeof(*wo));
 140     memset(ao, 0, sizeof(*ao));
 141
 142     wo->neg_addr = 1;
 143     wo->neg_vj = 1;
 144     wo->vj_protocol = IPCP_VJ_COMP;
 145     wo->maxslotindex = MAX_STATES - 1; /* really max index */
 146     wo->cflag = 1;
 147
 148     /* max slots and slot-id compression are currently hardwired in */
 149     /* ppp_if.c to 16 and 1, this needs to be changed (among other */
 150     /* things) gmc */
 151
 152     ao->neg_addr = 1;
 153     ao->neg_vj = 1;
 154     ao->maxslotindex = MAX_STATES - 1;
 155     ao->cflag = 1;
 156
 157     /*
 158      * XXX These control whether the user may use the proxyarp
 159      * and defaultroute options.
 160      */
 161     ao->proxy_arp = 1;
 162     ao->default_route = 1;
 163 }
 164
 165
 166 /*
 167  * ipcp_open - IPCP is allowed to come up.
 168  */
 169 void
 170 ipcp_open(unit)
 171     int unit;
 172 {
 173     fsm_open(&ipcp_fsm[unit]);
 174 }
 175
 176
 177 /*
 178  * ipcp_close - Take IPCP down.
 179  */
 180 void
 181 ipcp_close(unit, reason)
 182     int unit;
 183     char *reason;
 184 {
 185     fsm_close(&ipcp_fsm[unit], reason);
 186 }
 187
 188
 189 /*
 190  * ipcp_lowerup - The lower layer is up.
 191  */
 192 void
 193 ipcp_lowerup(unit)
 194     int unit;
 195 {
 196     fsm_lowerup(&ipcp_fsm[unit]);
 197 }
 198
 199
 200 /*
 201  * ipcp_lowerdown - The lower layer is down.
 202  */
 203 void
 204 ipcp_lowerdown(unit)
 205     int unit;
 206 {
 207     fsm_lowerdown(&ipcp_fsm[unit]);
 208 }
 209
 210
 211 /*
 212  * ipcp_input - Input IPCP packet.
 213  */
 214 void
 215 ipcp_input(unit, p, len)
 216     int unit;
 217     u_char *p;
 218     int len;
 219 {
 220     fsm_input(&ipcp_fsm[unit], p, len);
 221 }
 222
 223
 224 /*
 225  * ipcp_protrej - A Protocol-Reject was received for IPCP.
 226  *
 227  * Pretend the lower layer went down, so we shut up.
 228  */
 229 void
 230 ipcp_protrej(unit)
 231     int unit;
 232 {
 233     fsm_lowerdown(&ipcp_fsm[unit]);
 234 }
 235
 236
 237 /*
 238  * ipcp_resetci - Reset our CI.
 239  */
 240 static void
 241 ipcp_resetci(f)
 242     fsm *f;
 243 {
 244     ipcp_options *wo = &ipcp_wantoptions[f->unit];
 245
 246     wo->req_addr = wo->neg_addr && ipcp_allowoptions[f->unit].neg_addr;
 247     if (wo->ouraddr == 0)
 248         wo->accept_local = 1;
 249     if (wo->hisaddr == 0)
 250         wo->accept_remote = 1;
 251     ipcp_gotoptions[f->unit] = *wo;
 252     cis_received[f->unit] = 0;
 253 }
 254
 255
 256 /*
 257  * ipcp_cilen - Return length of our CI.
 258  */
 259 static int
 260 ipcp_cilen(f)
 261     fsm *f;
 262 {
 263     ipcp_options *go = &ipcp_gotoptions[f->unit];
 264
 265 #define LENCIVJ(neg, old)       (neg ? (old? CILEN_COMPRESS : CILEN_VJ) : 0)
 266 #define LENCIADDR(neg, old)     (neg ? (old? CILEN_ADDRS : CILEN_ADDR) : 0)
 267
 268     return (LENCIADDR(go->neg_addr, go->old_addrs) +
 269             LENCIVJ(go->neg_vj, go->old_vj));
 270 }
 271
 272
 273 /*
 274  * ipcp_addci - Add our desired CIs to a packet.
 275  */
 276 static void
 277 ipcp_addci(f, ucp, lenp)
 278     fsm *f;
 279     u_char *ucp;
 280     int *lenp;
 281 {
 282     ipcp_options *wo = &ipcp_wantoptions[f->unit];
 283     ipcp_options *go = &ipcp_gotoptions[f->unit];
 284     ipcp_options *ho = &ipcp_hisoptions[f->unit];
 285     int len = *lenp;
 286
 287 #define ADDCIVJ(opt, neg, val, old, maxslotindex, cflag) \
 288     if (neg) { \
 289         int vjlen = old? CILEN_COMPRESS : CILEN_VJ; \
 290         if (len >= vjlen) { \
 291             PUTCHAR(opt, ucp); \
 292             PUTCHAR(vjlen, ucp); \
 293             PUTSHORT(val, ucp); \
 294             if (!old) { \
 295                 PUTCHAR(maxslotindex, ucp); \
 296                 PUTCHAR(cflag, ucp); \
 297             } \
 298             len -= vjlen; \
 299         } else \
 300             neg = 0; \
 301     }
 302
 303 #define ADDCIADDR(opt, neg, old, val1, val2) \
 304     if (neg) { \
 305         int addrlen = (old? CILEN_ADDRS: CILEN_ADDR); \
 306         if (len >= addrlen) { \
 307             u_int32_t l; \
 308             PUTCHAR(opt, ucp); \
 309             PUTCHAR(addrlen, ucp); \
 310             l = ntohl(val1); \
 311             PUTLONG(l, ucp); \
 312             if (old) { \
 313                 l = ntohl(val2); \
 314                 PUTLONG(l, ucp); \
 315             } \
 316             len -= addrlen; \
 317         } else \
 318             neg = 0; \
 319     }
 320
 321     /*
 322      * First see if we want to change our options to the old
 323      * forms because we have received old forms from the peer.
 324      */
 325     if (wo->neg_addr && !go->neg_addr && !go->old_addrs) {
 326         /* use the old style of address negotiation */
 327         go->neg_addr = 1;
 328         go->old_addrs = 1;
 329     }
 330     if (wo->neg_vj && !go->neg_vj && !go->old_vj) {
 331         /* try an older style of VJ negotiation */
 332         if (cis_received[f->unit] == 0) {
 333             /* keep trying the new style until we see some CI from the peer */
 334             go->neg_vj = 1;
 335         } else {
 336             /* use the old style only if the peer did */
 337             if (ho->neg_vj && ho->old_vj) {
 338                 go->neg_vj = 1;
 339                 go->old_vj = 1;
 340                 go->vj_protocol = ho->vj_protocol;
 341             }
 342         }
 343     }
 344
 345     ADDCIADDR((go->old_addrs? CI_ADDRS: CI_ADDR), go->neg_addr,
 346               go->old_addrs, go->ouraddr, go->hisaddr);
 347
 348     ADDCIVJ(CI_COMPRESSTYPE, go->neg_vj, go->vj_protocol, go->old_vj,
 349             go->maxslotindex, go->cflag);
 350
 351     *lenp -= len;
 352 }
 353
 354
 355 /*
 356  * ipcp_ackci - Ack our CIs.
 357  *
 358  * Returns:
 359  *      0 - Ack was bad.
 360  *      1 - Ack was good.
 361  */
 362 static int
 363 ipcp_ackci(f, p, len)
 364     fsm *f;
 365     u_char *p;
 366     int len;
 367 {
 368     ipcp_options *go = &ipcp_gotoptions[f->unit];
 369     u_short cilen, citype, cishort;
 370     u_int32_t cilong;
 371     u_char cimaxslotindex, cicflag;
 372
 373     /*
 374      * CIs must be in exactly the same order that we sent...
 375      * Check packet length and CI length at each step.
 376      * If we find any deviations, then this packet is bad.
 377      */
 378
 379 #define ACKCIVJ(opt, neg, val, old, maxslotindex, cflag) \
 380     if (neg) { \
 381         int vjlen = old? CILEN_COMPRESS : CILEN_VJ; \
 382         if ((len -= vjlen) < 0) \
 383             goto bad; \
 384         GETCHAR(citype, p); \
 385         GETCHAR(cilen, p); \
 386         if (cilen != vjlen || \
 387             citype != opt)  \
 388             goto bad; \
 389         GETSHORT(cishort, p); \
 390         if (cishort != val) \
 391             goto bad; \
 392         if (!old) { \
 393             GETCHAR(cimaxslotindex, p); \
 394             if (cimaxslotindex != maxslotindex) \
 395                 goto bad; \
 396             GETCHAR(cicflag, p); \
 397             if (cicflag != cflag) \
 398                 goto bad; \
 399         } \
 400     }
 401
 402 #define ACKCIADDR(opt, neg, old, val1, val2) \
 403     if (neg) { \
 404         int addrlen = (old? CILEN_ADDRS: CILEN_ADDR); \
 405         u_int32_t l; \
 406         if ((len -= addrlen) < 0) \
 407             goto bad; \
 408         GETCHAR(citype, p); \
 409         GETCHAR(cilen, p); \
 410         if (cilen != addrlen || \
 411             citype != opt) \
 412             goto bad; \
 413         GETLONG(l, p); \
 414         cilong = htonl(l); \
 415         if (val1 != cilong) \
 416             goto bad; \
 417         if (old) { \
 418             GETLONG(l, p); \
 419             cilong = htonl(l); \
 420             if (val2 != cilong) \
 421                 goto bad; \
 422         } \
 423     }
 424
 425     ACKCIADDR((go->old_addrs? CI_ADDRS: CI_ADDR), go->neg_addr,
 426               go->old_addrs, go->ouraddr, go->hisaddr);
 427
 428     ACKCIVJ(CI_COMPRESSTYPE, go->neg_vj, go->vj_protocol, go->old_vj,
 429             go->maxslotindex, go->cflag);
 430
 431     /*
 432      * If there are any remaining CIs, then this packet is bad.
 433      */
 434     if (len != 0)
 435         goto bad;
 436     return (1);
 437
 438 bad:
 439     IPCPDEBUG((LOG_INFO, "ipcp_ackci: received bad Ack!"));
 440     return (0);
 441 }
 442
 443 /*
 444  * ipcp_nakci - Peer has sent a NAK for some of our CIs.
 445  * This should not modify any state if the Nak is bad
 446  * or if IPCP is in the OPENED state.
 447  *
 448  * Returns:
 449  *      0 - Nak was bad.
 450  *      1 - Nak was good.
 451  */
 452 static int
 453 ipcp_nakci(f, p, len)
 454     fsm *f;
 455     u_char *p;
 456     int len;
 457 {
 458     ipcp_options *go = &ipcp_gotoptions[f->unit];
 459     u_char cimaxslotindex, cicflag;
 460     u_char citype, cilen, *next;
 461     u_short cishort;
 462     u_int32_t ciaddr1, ciaddr2, l;
 463     ipcp_options no;            /* options we've seen Naks for */
 464     ipcp_options try;           /* options to request next time */
 465
 466     BZERO(&no, sizeof(no));
 467     try = *go;
 468
 469     /*
 470      * Any Nak'd CIs must be in exactly the same order that we sent.
 471      * Check packet length and CI length at each step.
 472      * If we find any deviations, then this packet is bad.
 473      */
 474 #define NAKCIADDR(opt, neg, old, code) \
 475     if (go->neg && \
 476         len >= (cilen = (old? CILEN_ADDRS: CILEN_ADDR)) && \
 477         p[1] == cilen && \
 478         p[0] == opt) { \
 479         len -= cilen; \
 480         INCPTR(2, p); \
 481         GETLONG(l, p); \
 482         ciaddr1 = htonl(l); \
 483         if (old) { \
 484             GETLONG(l, p); \
 485             ciaddr2 = htonl(l); \
 486             no.old_addrs = 1; \
 487         } else \
 488             ciaddr2 = 0; \
 489         no.neg = 1; \
 490         code \
 491     }
 492
 493 #define NAKCIVJ(opt, neg, code) \
 494     if (go->neg && \
 495         ((cilen = p[1]) == CILEN_COMPRESS || cilen == CILEN_VJ) && \
 496         len >= cilen && \
 497         p[0] == opt) { \
 498         len -= cilen; \
 499         INCPTR(2, p); \
 500         GETSHORT(cishort, p); \
 501         no.neg = 1; \
 502         code \
 503     }
 504
 505     /*
 506      * Accept the peer's idea of {our,his} address, if different
 507      * from our idea, only if the accept_{local,remote} flag is set.
 508      */
 509     NAKCIADDR((go->old_addrs? CI_ADDRS: CI_ADDR), neg_addr, go->old_addrs,
 510               if (go->accept_local && ciaddr1) { /* Do we know our address? */
 511                   try.ouraddr = ciaddr1;
 512                   IPCPDEBUG((LOG_INFO, "local IP address %s",
 513                              ip_ntoa(ciaddr1)));
 514               }
 515               if (go->accept_remote && ciaddr2) { /* Does he know his? */
 516                   try.hisaddr = ciaddr2;
 517                   IPCPDEBUG((LOG_INFO, "remote IP address %s",
 518                              ip_ntoa(ciaddr2)));
 519               }
 520               );
 521
 522     /*
 523      * Accept the peer's value of maxslotindex provided that it
 524      * is less than what we asked for.  Turn off slot-ID compression
 525      * if the peer wants.  Send old-style compress-type option if
 526      * the peer wants.
 527      */
 528     NAKCIVJ(CI_COMPRESSTYPE, neg_vj,
 529             if (cilen == CILEN_VJ) {
 530                 GETCHAR(cimaxslotindex, p);
 531                 GETCHAR(cicflag, p);
 532                 if (cishort == IPCP_VJ_COMP) {
 533                     try.old_vj = 0;
 534                     if (cimaxslotindex < go->maxslotindex)
 535                         try.maxslotindex = cimaxslotindex;
 536                     if (!cicflag)
 537                         try.cflag = 0;
 538                 } else {
 539                     try.neg_vj = 0;
 540                 }
 541             } else {
 542                 if (cishort == IPCP_VJ_COMP || cishort == IPCP_VJ_COMP_OLD) {
 543                     try.old_vj = 1;
 544                     try.vj_protocol = cishort;
 545                 } else {
 546                     try.neg_vj = 0;
 547                 }
 548             }
 549             );
 550
 551     /*
 552      * There may be remaining CIs, if the peer is requesting negotiation
 553      * on an option that we didn't include in our request packet.
 554      * If they want to negotiate about IP addresses, we comply.
 555      * If they want us to ask for compression, we refuse.
 556      */
 557     while (len > CILEN_VOID) {
 558         GETCHAR(citype, p);
 559         GETCHAR(cilen, p);
 560         if( (len -= cilen) < 0 )
 561             goto bad;
 562         next = p + cilen - 2;
 563
 564         switch (citype) {
 565         case CI_COMPRESSTYPE:
 566             if (go->neg_vj || no.neg_vj ||
 567                 (cilen != CILEN_VJ && cilen != CILEN_COMPRESS))
 568                 goto bad;
 569             no.neg_vj = 1;
 570             break;
 571         case CI_ADDRS:
 572             if (go->neg_addr && go->old_addrs || no.old_addrs
 573                 || cilen != CILEN_ADDRS)
 574                 goto bad;
 575             try.neg_addr = 1;
 576             try.old_addrs = 1;
 577             GETLONG(l, p);
 578             ciaddr1 = htonl(l);
 579             if (ciaddr1 && go->accept_local)
 580                 try.ouraddr = ciaddr1;
 581             GETLONG(l, p);
 582             ciaddr2 = htonl(l);
 583             if (ciaddr2 && go->accept_remote)
 584                 try.hisaddr = ciaddr2;
 585             no.old_addrs = 1;
 586             break;
 587         case CI_ADDR:
 588             if (go->neg_addr || no.neg_addr || cilen != CILEN_ADDR)
 589                 goto bad;
 590             try.old_addrs = 0;
 591             GETLONG(l, p);
 592             ciaddr1 = htonl(l);
 593             if (ciaddr1 && go->accept_local)
 594                 try.ouraddr = ciaddr1;
 595             if (try.ouraddr != 0)
 596                 try.neg_addr = 1;
 597             no.neg_addr = 1;
 598             break;
 599         }
 600         p = next;
 601     }
 602
 603     /* If there is still anything left, this packet is bad. */
 604     if (len != 0)
 605         goto bad;
 606
 607     /*
 608      * OK, the Nak is good.  Now we can update state.
 609      */
 610     if (f->state != OPENED)
 611         *go = try;
 612
 613     return 1;
 614
 615 bad:
 616     IPCPDEBUG((LOG_INFO, "ipcp_nakci: received bad Nak!"));
 617     return 0;
 618 }
 619
 620
 621 /*
 622  * ipcp_rejci - Reject some of our CIs.
 623  */
 624 static int
 625 ipcp_rejci(f, p, len)
 626     fsm *f;
 627     u_char *p;
 628     int len;
 629 {
 630     ipcp_options *go = &ipcp_gotoptions[f->unit];
 631     u_char cimaxslotindex, ciflag, cilen;
 632     u_short cishort;
 633     u_int32_t cilong;
 634     ipcp_options try;           /* options to request next time */
 635
 636     try = *go;
 637     /*
 638      * Any Rejected CIs must be in exactly the same order that we sent.
 639      * Check packet length and CI length at each step.
 640      * If we find any deviations, then this packet is bad.
 641      */
 642 #define REJCIADDR(opt, neg, old, val1, val2) \
 643     if (go->neg && \
 644         len >= (cilen = old? CILEN_ADDRS: CILEN_ADDR) && \
 645         p[1] == cilen && \
 646         p[0] == opt) { \
 647         u_int32_t l; \
 648         len -= cilen; \
 649         INCPTR(2, p); \
 650         GETLONG(l, p); \
 651         cilong = htonl(l); \
 652         /* Check rejected value. */ \
 653         if (cilong != val1) \
 654             goto bad; \
 655         if (old) { \
 656             GETLONG(l, p); \
 657             cilong = htonl(l); \
 658             /* Check rejected value. */ \
 659             if (cilong != val2) \
 660                 goto bad; \
 661         } \
 662         try.neg = 0; \
 663     }
 664
 665 #define REJCIVJ(opt, neg, val, old, maxslot, cflag) \
 666     if (go->neg && \
 667         p[1] == (old? CILEN_COMPRESS : CILEN_VJ) && \
 668         len >= p[1] && \
 669         p[0] == opt) { \
 670         len -= p[1]; \
 671         INCPTR(2, p); \
 672         GETSHORT(cishort, p); \
 673         /* Check rejected value. */  \
 674         if (cishort != val) \
 675             goto bad; \
 676         if (!old) { \
 677            GETCHAR(cimaxslotindex, p); \
 678            if (cimaxslotindex != maxslot) \
 679              goto bad; \
 680            GETCHAR(ciflag, p); \
 681            if (ciflag != cflag) \
 682              goto bad; \
 683         } \
 684         try.neg = 0; \
 685      }
 686
 687     REJCIADDR((go->old_addrs? CI_ADDRS: CI_ADDR), neg_addr,
 688               go->old_addrs, go->ouraddr, go->hisaddr);
 689
 690     REJCIVJ(CI_COMPRESSTYPE, neg_vj, go->vj_protocol, go->old_vj,
 691             go->maxslotindex, go->cflag);
 692
 693     /*
 694      * If there are any remaining CIs, then this packet is bad.
 695      */
 696     if (len != 0)
 697         goto bad;
 698     /*
 699      * Now we can update state.
 700      */
 701     if (f->state != OPENED)
 702         *go = try;
 703     return 1;
 704
 705 bad:
 706     IPCPDEBUG((LOG_INFO, "ipcp_rejci: received bad Reject!"));
 707     return 0;
 708 }
 709
 710
 711 /*
 712  * ipcp_reqci - Check the peer's requested CIs and send appropriate response.
 713  *
 714  * Returns: CONFACK, CONFNAK or CONFREJ and input packet modified
 715  * appropriately.  If reject_if_disagree is non-zero, doesn't return
 716  * CONFNAK; returns CONFREJ if it can't return CONFACK.
 717  */
 718 static int
 719 ipcp_reqci(f, inp, len, reject_if_disagree)
 720     fsm *f;
 721     u_char *inp;                /* Requested CIs */
 722     int *len;                   /* Length of requested CIs */
 723     int reject_if_disagree;
 724 {
 725     ipcp_options *wo = &ipcp_wantoptions[f->unit];
 726     ipcp_options *ho = &ipcp_hisoptions[f->unit];
 727     ipcp_options *ao = &ipcp_allowoptions[f->unit];
 728     ipcp_options *go = &ipcp_gotoptions[f->unit];
 729     u_char *cip, *next;         /* Pointer to current and next CIs */
 730     u_short cilen, citype;      /* Parsed len, type */
 731     u_short cishort;            /* Parsed short value */
 732     u_int32_t tl, ciaddr1, ciaddr2;/* Parsed address values */
 733     int rc = CONFACK;           /* Final packet return code */
 734     int orc;                    /* Individual option return code */
 735     u_char *p;                  /* Pointer to next char to parse */
 736     u_char *ucp = inp;          /* Pointer to current output char */
 737     int l = *len;               /* Length left */
 738     u_char maxslotindex, cflag;
 739
 740     /*
 741      * Reset all his options.
 742      */
 743     BZERO(ho, sizeof(*ho));
 744
 745     /*
 746      * Process all his options.
 747      */
 748     next = inp;
 749     while (l) {
 750         orc = CONFACK;                  /* Assume success */
 751         cip = p = next;                 /* Remember begining of CI */
 752         if (l < 2 ||                    /* Not enough data for CI header or */
 753             p[1] < 2 ||                 /*  CI length too small or */
 754             p[1] > l) {                 /*  CI length too big? */
 755             IPCPDEBUG((LOG_INFO, "ipcp_reqci: bad CI length!"));
 756             orc = CONFREJ;              /* Reject bad CI */
 757             cilen = l;                  /* Reject till end of packet */
 758             l = 0;                      /* Don't loop again */
 759             goto endswitch;
 760         }
 761         GETCHAR(citype, p);             /* Parse CI type */
 762         GETCHAR(cilen, p);              /* Parse CI length */
 763         l -= cilen;                     /* Adjust remaining length */
 764         next += cilen;                  /* Step to next CI */
 765
 766         switch (citype) {               /* Check CI type */
 767         case CI_ADDRS:
 768             IPCPDEBUG((LOG_INFO, "ipcp: received ADDRS "));
 769             if (!ao->neg_addr ||
 770                 cilen != CILEN_ADDRS) { /* Check CI length */
 771                 orc = CONFREJ;          /* Reject CI */
 772                 break;
 773             }
 774
 775             /*
 776              * If he has no address, or if we both have his address but
 777              * disagree about it, then NAK it with our idea.
 778              * In particular, if we don't know his address, but he does,
 779              * then accept it.
 780              */
 781             GETLONG(tl, p);             /* Parse source address (his) */
 782             ciaddr1 = htonl(tl);
 783             IPCPDEBUG((LOG_INFO, "(%s:", ip_ntoa(ciaddr1)));
 784             if (ciaddr1 != wo->hisaddr
 785                 && (ciaddr1 == 0 || !wo->accept_remote)) {
 786                 orc = CONFNAK;
 787                 if (!reject_if_disagree) {
 788                     DECPTR(sizeof(u_int32_t), p);
 789                     tl = ntohl(wo->hisaddr);
 790                     PUTLONG(tl, p);
 791                 }
 792             } else if (ciaddr1 == 0 && wo->hisaddr == 0) {
 793                 /*
 794                  * If neither we nor he knows his address, reject the option.
 795                  */
 796                 orc = CONFREJ;
 797                 wo->req_addr = 0;       /* don't NAK with 0.0.0.0 later */
 798                 break;
 799             }
 800
 801             /*
 802              * If he doesn't know our address, or if we both have our address
 803              * but disagree about it, then NAK it with our idea.
 804              */
 805             GETLONG(tl, p);             /* Parse desination address (ours) */
 806             ciaddr2 = htonl(tl);
 807             IPCPDEBUG((LOG_INFO, "%s)", ip_ntoa(ciaddr2)));
 808             if (ciaddr2 != wo->ouraddr) {
 809                 if (ciaddr2 == 0 || !wo->accept_local) {
 810                     orc = CONFNAK;
 811                     if (!reject_if_disagree) {
 812                         DECPTR(sizeof(u_int32_t), p);
 813                         tl = ntohl(wo->ouraddr);
 814                         PUTLONG(tl, p);
 815                     }
 816                 } else {
 817                     go->ouraddr = ciaddr2;      /* accept peer's idea */
 818                 }
 819             }
 820
 821             ho->neg_addr = 1;
 822             ho->old_addrs = 1;
 823             ho->hisaddr = ciaddr1;
 824             ho->ouraddr = ciaddr2;
 825             break;
 826
 827         case CI_ADDR:
 828             IPCPDEBUG((LOG_INFO, "ipcp: received ADDR "));
 829
 830             if (!ao->neg_addr ||
 831                 cilen != CILEN_ADDR) {  /* Check CI length */
 832                 orc = CONFREJ;          /* Reject CI */
 833                 break;
 834             }
 835
 836             /*
 837              * If he has no address, or if we both have his address but
 838              * disagree about it, then NAK it with our idea.
 839              * In particular, if we don't know his address, but he does,
 840              * then accept it.
 841              */
 842             GETLONG(tl, p);     /* Parse source address (his) */
 843             ciaddr1 = htonl(tl);
 844             IPCPDEBUG((LOG_INFO, "(%s)", ip_ntoa(ciaddr1)));
 845             if (ciaddr1 != wo->hisaddr
 846                 && (ciaddr1 == 0 || !wo->accept_remote)) {
 847                 orc = CONFNAK;
 848                 if (!reject_if_disagree) {
 849                     DECPTR(sizeof(u_int32_t), p);
 850                     tl = ntohl(wo->hisaddr);
 851                     PUTLONG(tl, p);
 852                 }
 853             } else if (ciaddr1 == 0 && wo->hisaddr == 0) {
 854                 /*
 855                  * Don't ACK an address of 0.0.0.0 - reject it instead.
 856                  */
 857                 orc = CONFREJ;
 858                 wo->req_addr = 0;       /* don't NAK with 0.0.0.0 later */
 859                 break;
 860             }
 861
 862             ho->neg_addr = 1;
 863             ho->hisaddr = ciaddr1;
 864             break;
 865
 866 #ifdef USE_MS_DNS
 867         case CI_MS_DNS1:
 868             /* Microsoft primary DNS request */
 869             IPCPDEBUG((LOG_INFO, "ipcp: received DNS1 Request "));
 870
 871             /* If we do not have a DNS address then we cannot send it */
 872             if (ao->dnsaddr[0] == 0 ||
 873                 cilen != CILEN_ADDR) {  /* Check CI length */
 874                 orc = CONFREJ;          /* Reject CI */
 875                 break;
 876             }
 877             GETLONG(tl, p);
 878             if (htonl(tl) != ao->dnsaddr[0]) {
 879                 DECPTR(sizeof(u_int32_t), p);
 880                 tl = ntohl(ao->dnsaddr[0]);
 881                 PUTLONG(tl, p);
 882                 orc = CONFNAK;
 883             }
 884             break;
 885
 886         case CI_MS_DNS2:
 887             /* Microsoft secondary DNS request */
 888             IPCPDEBUG((LOG_INFO, "ipcp: received DNS2 Request "));
 889
 890             /* If we do not have a DNS address then we cannot send it */
 891             if (ao->dnsaddr[1] == 0 ||  /* Yes, this is the first one! */
 892                 cilen != CILEN_ADDR) {  /* Check CI length */
 893                 orc = CONFREJ;          /* Reject CI */
 894                 break;
 895             }
 896             GETLONG(tl, p);
 897             if (htonl(tl) != ao->dnsaddr[1]) { /* and this is the 2nd one */
 898                 DECPTR(sizeof(u_int32_t), p);
 899                 tl = ntohl(ao->dnsaddr[1]);
 900                 PUTLONG(tl, p);
 901                 orc = CONFNAK;
 902             }
 903             break;
 904 #endif
 905
 906         case CI_COMPRESSTYPE:
 907             IPCPDEBUG((LOG_INFO, "ipcp: received COMPRESSTYPE "));
 908             if (!ao->neg_vj ||
 909                 (cilen != CILEN_VJ && cilen != CILEN_COMPRESS)) {
 910                 orc = CONFREJ;
 911                 break;
 912             }
 913             GETSHORT(cishort, p);
 914             IPCPDEBUG((LOG_INFO, "(%d)", cishort));
 915
 916             if (!(cishort == IPCP_VJ_COMP ||
 917                   (cishort == IPCP_VJ_COMP_OLD && cilen == CILEN_COMPRESS))) {
 918                 orc = CONFREJ;
 919                 break;
 920             }
 921
 922             ho->neg_vj = 1;
 923             ho->vj_protocol = cishort;
 924             if (cilen == CILEN_VJ) {
 925                 GETCHAR(maxslotindex, p);
 926                 if (maxslotindex > ao->maxslotindex) {
 927                     orc = CONFNAK;
 928                     if (!reject_if_disagree){
 929                         DECPTR(1, p);
 930                         PUTCHAR(ao->maxslotindex, p);
 931                     }
 932                 }
 933                 GETCHAR(cflag, p);
 934                 if (cflag && !ao->cflag) {
 935                     orc = CONFNAK;
 936                     if (!reject_if_disagree){
 937                         DECPTR(1, p);
 938                         PUTCHAR(wo->cflag, p);
 939                     }
 940                 }
 941                 ho->maxslotindex = maxslotindex;
 942                 ho->cflag = cflag;
 943             } else {
 944                 ho->old_vj = 1;
 945                 ho->maxslotindex = MAX_STATES - 1;
 946                 ho->cflag = 1;
 947             }
 948             break;
 949
 950         default:
 951             orc = CONFREJ;
 952             break;
 953         }
 954
 955 endswitch:
 956         IPCPDEBUG((LOG_INFO, " (%s)\n", CODENAME(orc)));
 957
 958         if (orc == CONFACK &&           /* Good CI */
 959             rc != CONFACK)              /*  but prior CI wasnt? */
 960             continue;                   /* Don't send this one */
 961
 962         if (orc == CONFNAK) {           /* Nak this CI? */
 963             if (reject_if_disagree)     /* Getting fed up with sending NAKs? */
 964                 orc = CONFREJ;          /* Get tough if so */
 965             else {
 966                 if (rc == CONFREJ)      /* Rejecting prior CI? */
 967                     continue;           /* Don't send this one */
 968                 if (rc == CONFACK) {    /* Ack'd all prior CIs? */
 969                     rc = CONFNAK;       /* Not anymore... */
 970                     ucp = inp;          /* Backup */
 971                 }
 972             }
 973         }
 974
 975         if (orc == CONFREJ &&           /* Reject this CI */
 976             rc != CONFREJ) {            /*  but no prior ones? */
 977             rc = CONFREJ;
 978             ucp = inp;                  /* Backup */
 979         }
 980
 981         /* Need to move CI? */
 982         if (ucp != cip)
 983             BCOPY(cip, ucp, cilen);     /* Move it */
 984
 985         /* Update output pointer */
 986         INCPTR(cilen, ucp);
 987     }
 988
 989     /*
 990      * If we aren't rejecting this packet, and we want to negotiate
 991      * their address, and they didn't send their address, then we
 992      * send a NAK with a CI_ADDR option appended.  We assume the
 993      * input buffer is long enough that we can append the extra
 994      * option safely.
 995      */
 996     if (rc != CONFREJ && !ho->neg_addr &&
 997         wo->req_addr && !reject_if_disagree) {
 998         if (rc == CONFACK) {
 999             rc = CONFNAK;
1000             ucp = inp;                  /* reset pointer */
1001             wo->req_addr = 0;           /* don't ask again */
1002         }
1003         PUTCHAR(CI_ADDR, ucp);
1004         PUTCHAR(CILEN_ADDR, ucp);
1005         tl = ntohl(wo->hisaddr);
1006         PUTLONG(tl, ucp);
1007     }
1008
1009     *len = ucp - inp;                   /* Compute output length */
1010     IPCPDEBUG((LOG_INFO, "ipcp: returning Configure-%s", CODENAME(rc)));
1011     return (rc);                        /* Return final code */
1012 }
1013
1014
1015 /*
1016  * ipcp_up - IPCP has come UP.
1017  *
1018  * Configure the IP network interface appropriately and bring it up.
1019  */
1020 static void
1021 ipcp_up(f)
1022     fsm *f;
1023 {
1024     u_int32_t mask;
1025     ipcp_options *ho = &ipcp_hisoptions[f->unit];
1026     ipcp_options *go = &ipcp_gotoptions[f->unit];
1027
1028     IPCPDEBUG((LOG_INFO, "ipcp: up"));
1029     go->default_route = 0;
1030     go->proxy_arp = 0;
1031
1032     /*
1033      * We must have a non-zero IP address for both ends of the link.
1034      */
1035     if (!ho->neg_addr)
1036         ho->hisaddr = ipcp_wantoptions[f->unit].hisaddr;
1037
1038     if (ho->hisaddr == 0) {
1039         syslog(LOG_ERR, "Could not determine remote IP address");
1040         ipcp_close(f->unit, "Could not determine remote IP address");
1041         return;
1042     }
1043     if (go->ouraddr == 0) {
1044         syslog(LOG_ERR, "Could not determine local IP address");
1045         ipcp_close(f->unit, "Could not determine local IP address");
1046         return;
1047     }
1048
1049     /*
1050      * Check that the peer is allowed to use the IP address it wants.
1051      */
1052     if (!auth_ip_addr(f->unit, ho->hisaddr)) {
1053         syslog(LOG_ERR, "Peer is not authorized to use remote address %s",
1054                ip_ntoa(ho->hisaddr));
1055         ipcp_close(f->unit, "Unauthorized remote IP address");
1056         return;
1057     }
1058
1059     syslog(LOG_NOTICE, "local  IP address %s", ip_ntoa(go->ouraddr));
1060     syslog(LOG_NOTICE, "remote IP address %s", ip_ntoa(ho->hisaddr));
1061
1062     /*
1063      * Set IP addresses and (if specified) netmask.
1064      */
1065     mask = GetMask(go->ouraddr);
1066     if (!sifaddr(f->unit, go->ouraddr, ho->hisaddr, mask)) {
1067         IPCPDEBUG((LOG_WARNING, "sifaddr failed"));
1068         ipcp_close(f->unit, "Interface configuration failed");
1069         return;
1070     }
1071
1072     /* set tcp compression */
1073     sifvjcomp(f->unit, ho->neg_vj, ho->cflag, ho->maxslotindex);
1074
1075     /* bring the interface up for IP */
1076     if (!sifup(f->unit)) {
1077         IPCPDEBUG((LOG_WARNING, "sifup failed"));
1078         ipcp_close(f->unit, "Interface configuration failed");
1079         return;
1080     }
1081
1082     /* assign a default route through the interface if required */
1083     if (ipcp_wantoptions[f->unit].default_route)
1084         if (sifdefaultroute(f->unit, ho->hisaddr))
1085             go->default_route = 1;
1086
1087     /* Make a proxy ARP entry if requested. */
1088     if (ipcp_wantoptions[f->unit].proxy_arp)
1089         if (sifproxyarp(f->unit, ho->hisaddr))
1090             go->proxy_arp = 1;
1091
1092     /*
1093      * Execute the ip-up script, like this:
1094      *  /etc/ppp/ip-up interface tty speed local-IP remote-IP
1095      */
1096     ipcp_script(f, _PATH_IPUP);
1097
1098 }
1099
1100
1101 /*
1102  * ipcp_down - IPCP has gone DOWN.
1103  *
1104  * Take the IP network interface down, clear its addresses
1105  * and delete routes through it.
1106  */
1107 static void
1108 ipcp_down(f)
1109     fsm *f;
1110 {
1111     u_int32_t ouraddr, hisaddr;
1112
1113     IPCPDEBUG((LOG_INFO, "ipcp: down"));
1114
1115     ouraddr = ipcp_gotoptions[f->unit].ouraddr;
1116     hisaddr = ipcp_hisoptions[f->unit].hisaddr;
1117     if (ipcp_gotoptions[f->unit].proxy_arp)
1118         cifproxyarp(f->unit, hisaddr);
1119     if (ipcp_gotoptions[f->unit].default_route)
1120         cifdefaultroute(f->unit, hisaddr);
1121     sifdown(f->unit);
1122     cifaddr(f->unit, ouraddr, hisaddr);
1123
1124     /* Execute the ip-down script */
1125     ipcp_script(f, _PATH_IPDOWN);
1126 }
1127
1128
1129 /*
1130  * ipcp_script - Execute a script with arguments
1131  * interface-name tty-name speed local-IP remote-IP.
1132  */
1133 static void
1134 ipcp_script(f, script)
1135     fsm *f;
1136     char *script;
1137 {
1138     char strspeed[32], strlocal[32], strremote[32];
1139     char *argv[8];
1140
1141     sprintf(strspeed, "%d", baud_rate);
1142     strcpy(strlocal, ip_ntoa(ipcp_gotoptions[f->unit].ouraddr));
1143     strcpy(strremote, ip_ntoa(ipcp_hisoptions[f->unit].hisaddr));
1144
1145     argv[0] = script;
1146     argv[1] = ifname;
1147     argv[2] = devnam;
1148     argv[3] = strspeed;
1149     argv[4] = strlocal;
1150     argv[5] = strremote;
1151     argv[6] = ipparam;
1152     argv[7] = NULL;
1153     run_program(script, argv, 0);
1154 }
1155
1156 /*
1157  * ipcp_printpkt - print the contents of an IPCP packet.
1158  */
1159 char *ipcp_codenames[] = {
1160     "ConfReq", "ConfAck", "ConfNak", "ConfRej",
1161     "TermReq", "TermAck", "CodeRej"
1162 };
1163
1164 int
1165 ipcp_printpkt(p, plen, printer, arg)
1166     u_char *p;
1167     int plen;
1168     void (*printer)();
1169     void *arg;
1170 {
1171     int code, id, len, olen;
1172     u_char *pstart, *optend;
1173     u_short cishort;
1174     u_int32_t cilong;
1175
1176     if (plen < HEADERLEN)
1177         return 0;
1178     pstart = p;
1179     GETCHAR(code, p);
1180     GETCHAR(id, p);
1181     GETSHORT(len, p);
1182     if (len < HEADERLEN || len > plen)
1183         return 0;
1184
1185     if (code >= 1 && code <= sizeof(ipcp_codenames) / sizeof(char *))
1186         printer(arg, " %s", ipcp_codenames[code-1]);
1187     else
1188         printer(arg, " code=0x%x", code);
1189     printer(arg, " id=0x%x", id);
1190     len -= HEADERLEN;
1191     switch (code) {
1192     case CONFREQ:
1193     case CONFACK:
1194     case CONFNAK:
1195     case CONFREJ:
1196         /* print option list */
1197         while (len >= 2) {
1198             GETCHAR(code, p);
1199             GETCHAR(olen, p);
1200             p -= 2;
1201             if (olen < 2 || olen > len) {
1202                 break;
1203             }
1204             printer(arg, " <");
1205             len -= olen;
1206             optend = p + olen;
1207             switch (code) {
1208             case CI_ADDRS:
1209                 if (olen == CILEN_ADDRS) {
1210                     p += 2;
1211                     GETLONG(cilong, p);
1212                     printer(arg, "addrs %s", ip_ntoa(htonl(cilong)));
1213                     GETLONG(cilong, p);
1214                     printer(arg, " %s", ip_ntoa(htonl(cilong)));
1215                 }
1216                 break;
1217             case CI_COMPRESSTYPE:
1218                 if (olen >= CILEN_COMPRESS) {
1219                     p += 2;
1220                     GETSHORT(cishort, p);
1221                     printer(arg, "compress ");
1222                     switch (cishort) {
1223                     case IPCP_VJ_COMP:
1224                         printer(arg, "VJ");
1225                         break;
1226                     case IPCP_VJ_COMP_OLD:
1227                         printer(arg, "old-VJ");
1228                         break;
1229                     default:
1230                         printer(arg, "0x%x", cishort);
1231                     }
1232                 }
1233                 break;
1234             case CI_ADDR:
1235                 if (olen == CILEN_ADDR) {
1236                     p += 2;
1237                     GETLONG(cilong, p);
1238                     printer(arg, "addr %s", ip_ntoa(htonl(cilong)));
1239                 }
1240                 break;
1241             }
1242             while (p < optend) {
1243                 GETCHAR(code, p);
1244                 printer(arg, " %.2x", code);
1245             }
1246             printer(arg, ">");
1247         }
1248         break;
1249     }
1250
1251     /* print the rest of the bytes in the packet */
1252     for (; len > 0; --len) {
1253         GETCHAR(code, p);
1254         printer(arg, " %.2x", code);
1255     }
1256
1257     return p - pstart;
1258 }