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 #define RCSID   "$Id: ipcp.c,v 1.60 2002/01/22 16:02:58 dfs Exp $"
  21
  22 /*
  23  * TODO:
  24  */
  25
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <stdlib.h>
  29 #include <netdb.h>
  30 #include <sys/param.h>
  31 #include <sys/types.h>
  32 #include <sys/socket.h>
  33 #include <netinet/in.h>
  34 #include <arpa/inet.h>
  35
  36 #include "pppd.h"
  37 #include "fsm.h"
  38 #include "ipcp.h"
  39 #include "pathnames.h"
  40
  41 static const char rcsid[] = RCSID;
  42
  43 /* global vars */
  44 ipcp_options ipcp_wantoptions[NUM_PPP]; /* Options that we want to request */
  45 ipcp_options ipcp_gotoptions[NUM_PPP];  /* Options that peer ack'd */
  46 ipcp_options ipcp_allowoptions[NUM_PPP]; /* Options we allow peer to request */
  47 ipcp_options ipcp_hisoptions[NUM_PPP];  /* Options that we ack'd */
  48
  49 u_int32_t netmask = 0;          /* IP netmask to set on interface */
  50
  51 bool    disable_defaultip = 0;  /* Don't use hostname for default IP adrs */
  52
  53 /* Hook for a plugin to know when IP protocol has come up */
  54 void (*ip_up_hook) __P((void)) = NULL;
  55
  56 /* Hook for a plugin to know when IP protocol has come down */
  57 void (*ip_down_hook) __P((void)) = NULL;
  58
  59 /* Hook for a plugin to choose the remote IP address */
  60 void (*ip_choose_hook) __P((u_int32_t *)) = NULL;
  61
  62 /* Notifiers for when IPCP goes up and down */
  63 struct notifier *ip_up_notifier = NULL;
  64 struct notifier *ip_down_notifier = NULL;
  65
  66 /* local vars */
  67 static int default_route_set[NUM_PPP];  /* Have set up a default route */
  68 static int proxy_arp_set[NUM_PPP];      /* Have created proxy arp entry */
  69 static bool usepeerdns;                 /* Ask peer for DNS addrs */
  70 static int ipcp_is_up;                  /* have called np_up() */
  71 static bool ask_for_local;              /* request our address from peer */
  72 static char vj_value[8];                /* string form of vj option value */
  73 static char netmask_str[20];            /* string form of netmask value */
  74
  75 /*
  76  * Callbacks for fsm code.  (CI = Configuration Information)
  77  */
  78 static void ipcp_resetci __P((fsm *));  /* Reset our CI */
  79 static int  ipcp_cilen __P((fsm *));            /* Return length of our CI */
  80 static void ipcp_addci __P((fsm *, u_char *, int *)); /* Add our CI */
  81 static int  ipcp_ackci __P((fsm *, u_char *, int));     /* Peer ack'd our CI */
  82 static int  ipcp_nakci __P((fsm *, u_char *, int));     /* Peer nak'd our CI */
  83 static int  ipcp_rejci __P((fsm *, u_char *, int));     /* Peer rej'd our CI */
  84 static int  ipcp_reqci __P((fsm *, u_char *, int *, int)); /* Rcv CI */
  85 static void ipcp_up __P((fsm *));               /* We're UP */
  86 static void ipcp_down __P((fsm *));             /* We're DOWN */
  87 static void ipcp_finished __P((fsm *)); /* Don't need lower layer */
  88
  89 fsm ipcp_fsm[NUM_PPP];          /* IPCP fsm structure */
  90
  91 static fsm_callbacks ipcp_callbacks = { /* IPCP callback routines */
  92     ipcp_resetci,               /* Reset our Configuration Information */
  93     ipcp_cilen,                 /* Length of our Configuration Information */
  94     ipcp_addci,                 /* Add our Configuration Information */
  95     ipcp_ackci,                 /* ACK our Configuration Information */
  96     ipcp_nakci,                 /* NAK our Configuration Information */
  97     ipcp_rejci,                 /* Reject our Configuration Information */
  98     ipcp_reqci,                 /* Request peer's Configuration Information */
  99     ipcp_up,                    /* Called when fsm reaches OPENED state */
 100     ipcp_down,                  /* Called when fsm leaves OPENED state */
 101     NULL,                       /* Called when we want the lower layer up */
 102     ipcp_finished,              /* Called when we want the lower layer down */
 103     NULL,                       /* Called when Protocol-Reject received */
 104     NULL,                       /* Retransmission is necessary */
 105     NULL,                       /* Called to handle protocol-specific codes */
 106     "IPCP"                      /* String name of protocol */
 107 };
 108
 109 /*
 110  * Command-line options.
 111  */
 112 static int setvjslots __P((char **));
 113 static int setdnsaddr __P((char **));
 114 static int setwinsaddr __P((char **));
 115 static int setnetmask __P((char **));
 116 int setipaddr __P((char *, char **, int));
 117 static void printipaddr __P((option_t *, void (*)(void *, char *,...),void *));
 118
 119 static option_t ipcp_option_list[] = {
 120     { "noip", o_bool, &ipcp_protent.enabled_flag,
 121       "Disable IP and IPCP" },
 122     { "-ip", o_bool, &ipcp_protent.enabled_flag,
 123       "Disable IP and IPCP", OPT_ALIAS },
 124
 125     { "novj", o_bool, &ipcp_wantoptions[0].neg_vj,
 126       "Disable VJ compression", OPT_A2CLR, &ipcp_allowoptions[0].neg_vj },
 127     { "-vj", o_bool, &ipcp_wantoptions[0].neg_vj,
 128       "Disable VJ compression", OPT_ALIAS | OPT_A2CLR,
 129       &ipcp_allowoptions[0].neg_vj },
 130
 131     { "novjccomp", o_bool, &ipcp_wantoptions[0].cflag,
 132       "Disable VJ connection-ID compression", OPT_A2CLR,
 133       &ipcp_allowoptions[0].cflag },
 134     { "-vjccomp", o_bool, &ipcp_wantoptions[0].cflag,
 135       "Disable VJ connection-ID compression", OPT_ALIAS | OPT_A2CLR,
 136       &ipcp_allowoptions[0].cflag },
 137
 138     { "vj-max-slots", o_special, (void *)setvjslots,
 139       "Set maximum VJ header slots",
 140       OPT_PRIO | OPT_A2STRVAL | OPT_STATIC, vj_value },
 141
 142     { "ipcp-accept-local", o_bool, &ipcp_wantoptions[0].accept_local,
 143       "Accept peer's address for us", 1 },
 144     { "ipcp-accept-remote", o_bool, &ipcp_wantoptions[0].accept_remote,
 145       "Accept peer's address for it", 1 },
 146
 147     { "ipparam", o_string, &ipparam,
 148       "Set ip script parameter", OPT_PRIO },
 149
 150     { "noipdefault", o_bool, &disable_defaultip,
 151       "Don't use name for default IP adrs", 1 },
 152
 153     { "ms-dns", 1, (void *)setdnsaddr,
 154       "DNS address for the peer's use" },
 155     { "ms-wins", 1, (void *)setwinsaddr,
 156       "Nameserver for SMB over TCP/IP for peer" },
 157
 158     { "ipcp-restart", o_int, &ipcp_fsm[0].timeouttime,
 159       "Set timeout for IPCP", OPT_PRIO },
 160     { "ipcp-max-terminate", o_int, &ipcp_fsm[0].maxtermtransmits,
 161       "Set max #xmits for term-reqs", OPT_PRIO },
 162     { "ipcp-max-configure", o_int, &ipcp_fsm[0].maxconfreqtransmits,
 163       "Set max #xmits for conf-reqs", OPT_PRIO },
 164     { "ipcp-max-failure", o_int, &ipcp_fsm[0].maxnakloops,
 165       "Set max #conf-naks for IPCP", OPT_PRIO },
 166
 167     { "defaultroute", o_bool, &ipcp_wantoptions[0].default_route,
 168       "Add default route", OPT_ENABLE|1, &ipcp_allowoptions[0].default_route },
 169     { "nodefaultroute", o_bool, &ipcp_allowoptions[0].default_route,
 170       "disable defaultroute option", OPT_A2CLR,
 171       &ipcp_wantoptions[0].default_route },
 172     { "-defaultroute", o_bool, &ipcp_allowoptions[0].default_route,
 173       "disable defaultroute option", OPT_ALIAS | OPT_A2CLR,
 174       &ipcp_wantoptions[0].default_route },
 175
 176     { "proxyarp", o_bool, &ipcp_wantoptions[0].proxy_arp,
 177       "Add proxy ARP entry", OPT_ENABLE|1, &ipcp_allowoptions[0].proxy_arp },
 178     { "noproxyarp", o_bool, &ipcp_allowoptions[0].proxy_arp,
 179       "disable proxyarp option", OPT_A2CLR,
 180       &ipcp_wantoptions[0].proxy_arp },
 181     { "-proxyarp", o_bool, &ipcp_allowoptions[0].proxy_arp,
 182       "disable proxyarp option", OPT_ALIAS | OPT_A2CLR,
 183       &ipcp_wantoptions[0].proxy_arp },
 184
 185     { "usepeerdns", o_bool, &usepeerdns,
 186       "Ask peer for DNS address(es)", 1 },
 187
 188     { "netmask", o_special, (void *)setnetmask,
 189       "set netmask", OPT_PRIO | OPT_A2STRVAL | OPT_STATIC, netmask_str },
 190
 191     { "IP addresses", o_wild, (void *) &setipaddr,
 192       "set local and remote IP addresses",
 193       OPT_NOARG | OPT_A2PRINTER, (void *) &printipaddr },
 194
 195     { NULL }
 196 };
 197
 198 /*
 199  * Protocol entry points from main code.
 200  */
 201 static void ipcp_init __P((int));
 202 static void ipcp_open __P((int));
 203 static void ipcp_close __P((int, char *));
 204 static void ipcp_lowerup __P((int));
 205 static void ipcp_lowerdown __P((int));
 206 static void ipcp_input __P((int, u_char *, int));
 207 static void ipcp_protrej __P((int));
 208 static int  ipcp_printpkt __P((u_char *, int,
 209                                void (*) __P((void *, char *, ...)), void *));
 210 static void ip_check_options __P((void));
 211 static int  ip_demand_conf __P((int));
 212 static int  ip_active_pkt __P((u_char *, int));
 213 static void create_resolv __P((u_int32_t, u_int32_t));
 214
 215 struct protent ipcp_protent = {
 216     PPP_IPCP,
 217     ipcp_init,
 218     ipcp_input,
 219     ipcp_protrej,
 220     ipcp_lowerup,
 221     ipcp_lowerdown,
 222     ipcp_open,
 223     ipcp_close,
 224     ipcp_printpkt,
 225     NULL,
 226     1,
 227     "IPCP",
 228     "IP",
 229     ipcp_option_list,
 230     ip_check_options,
 231     ip_demand_conf,
 232     ip_active_pkt
 233 };
 234
 235 static void ipcp_clear_addrs __P((int, u_int32_t, u_int32_t));
 236 static void ipcp_script __P((char *));          /* Run an up/down script */
 237 static void ipcp_script_done __P((void *));
 238
 239 /*
 240  * Lengths of configuration options.
 241  */
 242 #define CILEN_VOID      2
 243 #define CILEN_COMPRESS  4       /* min length for compression protocol opt. */
 244 #define CILEN_VJ        6       /* length for RFC1332 Van-Jacobson opt. */
 245 #define CILEN_ADDR      6       /* new-style single address option */
 246 #define CILEN_ADDRS     10      /* old-style dual address option */
 247
 248
 249 #define CODENAME(x)     ((x) == CONFACK ? "ACK" : \
 250                          (x) == CONFNAK ? "NAK" : "REJ")
 251
 252 /*
 253  * This state variable is used to ensure that we don't
 254  * run an ipcp-up/down script while one is already running.
 255  */
 256 static enum script_state {
 257     s_down,
 258     s_up,
 259 } ipcp_script_state;
 260 static pid_t ipcp_script_pid;
 261
 262 /*
 263  * Make a string representation of a network IP address.
 264  */
 265 char *
 266 ip_ntoa(ipaddr)
 267 u_int32_t ipaddr;
 268 {
 269     static char b[64];
 270
 271     slprintf(b, sizeof(b), "%I", ipaddr);
 272     return b;
 273 }
 274
 275 /*
 276  * Option parsing.
 277  */
 278
 279 /*
 280  * setvjslots - set maximum number of connection slots for VJ compression
 281  */
 282 static int
 283 setvjslots(argv)
 284     char **argv;
 285 {
 286     int value;
 287
 288     if (!int_option(*argv, &value))
 289         return 0;
 290     if (value < 2 || value > 16) {
 291         option_error("vj-max-slots value must be between 2 and 16");
 292         return 0;
 293     }
 294     ipcp_wantoptions [0].maxslotindex =
 295         ipcp_allowoptions[0].maxslotindex = value - 1;
 296     slprintf(vj_value, sizeof(vj_value), "%d", value);
 297     return 1;
 298 }
 299
 300 /*
 301  * setdnsaddr - set the dns address(es)
 302  */
 303 static int
 304 setdnsaddr(argv)
 305     char **argv;
 306 {
 307     u_int32_t dns;
 308     struct hostent *hp;
 309
 310     dns = inet_addr(*argv);
 311     if (dns == (u_int32_t) -1) {
 312         if ((hp = gethostbyname(*argv)) == NULL) {
 313             option_error("invalid address parameter '%s' for ms-dns option",
 314                          *argv);
 315             return 0;
 316         }
 317         dns = *(u_int32_t *)hp->h_addr;
 318     }
 319
 320     /* We take the last 2 values given, the 2nd-last as the primary
 321        and the last as the secondary.  If only one is given it
 322        becomes both primary and secondary. */
 323     if (ipcp_allowoptions[0].dnsaddr[1] == 0)
 324         ipcp_allowoptions[0].dnsaddr[0] = dns;
 325     else
 326         ipcp_allowoptions[0].dnsaddr[0] = ipcp_allowoptions[0].dnsaddr[1];
 327
 328     /* always set the secondary address value. */
 329     ipcp_allowoptions[0].dnsaddr[1] = dns;
 330
 331     return (1);
 332 }
 333
 334 /*
 335  * setwinsaddr - set the wins address(es)
 336  * This is primrarly used with the Samba package under UNIX or for pointing
 337  * the caller to the existing WINS server on a Windows NT platform.
 338  */
 339 static int
 340 setwinsaddr(argv)
 341     char **argv;
 342 {
 343     u_int32_t wins;
 344     struct hostent *hp;
 345
 346     wins = inet_addr(*argv);
 347     if (wins == (u_int32_t) -1) {
 348         if ((hp = gethostbyname(*argv)) == NULL) {
 349             option_error("invalid address parameter '%s' for ms-wins option",
 350                          *argv);
 351             return 0;
 352         }
 353         wins = *(u_int32_t *)hp->h_addr;
 354     }
 355
 356     /* We take the last 2 values given, the 2nd-last as the primary
 357        and the last as the secondary.  If only one is given it
 358        becomes both primary and secondary. */
 359     if (ipcp_allowoptions[0].winsaddr[1] == 0)
 360         ipcp_allowoptions[0].winsaddr[0] = wins;
 361     else
 362         ipcp_allowoptions[0].winsaddr[0] = ipcp_allowoptions[0].winsaddr[1];
 363
 364     /* always set the secondary address value. */
 365     ipcp_allowoptions[0].winsaddr[1] = wins;
 366
 367     return (1);
 368 }
 369
 370 /*
 371  * setipaddr - Set the IP address
 372  * If doit is 0, the call is to check whether this option is
 373  * potentially an IP address specification.
 374  * Not static so that plugins can call it to set the addresses
 375  */
 376 int
 377 setipaddr(arg, argv, doit)
 378     char *arg;
 379     char **argv;
 380     int doit;
 381 {
 382     struct hostent *hp;
 383     char *colon;
 384     u_int32_t local, remote;
 385     ipcp_options *wo = &ipcp_wantoptions[0];
 386     static int prio_local = 0, prio_remote = 0;
 387
 388     /*
 389      * IP address pair separated by ":".
 390      */
 391     if ((colon = strchr(arg, ':')) == NULL)
 392         return 0;
 393     if (!doit)
 394         return 1;
 395
 396     /*
 397      * If colon first character, then no local addr.
 398      */
 399     if (colon != arg && option_priority >= prio_local) {
 400         *colon = '\0';
 401         if ((local = inet_addr(arg)) == (u_int32_t) -1) {
 402             if ((hp = gethostbyname(arg)) == NULL) {
 403                 option_error("unknown host: %s", arg);
 404                 return 0;
 405             }
 406             local = *(u_int32_t *)hp->h_addr;
 407         }
 408         if (bad_ip_adrs(local)) {
 409             option_error("bad local IP address %s", ip_ntoa(local));
 410             return 0;
 411         }
 412         if (local != 0)
 413             wo->ouraddr = local;
 414         *colon = ':';
 415         prio_local = option_priority;
 416     }
 417
 418     /*
 419      * If colon last character, then no remote addr.
 420      */
 421     if (*++colon != '\0' && option_priority >= prio_remote) {
 422         if ((remote = inet_addr(colon)) == (u_int32_t) -1) {
 423             if ((hp = gethostbyname(colon)) == NULL) {
 424                 option_error("unknown host: %s", colon);
 425                 return 0;
 426             }
 427             remote = *(u_int32_t *)hp->h_addr;
 428             if (remote_name[0] == 0)
 429                 strlcpy(remote_name, colon, sizeof(remote_name));
 430         }
 431         if (bad_ip_adrs(remote)) {
 432             option_error("bad remote IP address %s", ip_ntoa(remote));
 433             return 0;
 434         }
 435         if (remote != 0)
 436             wo->hisaddr = remote;
 437         prio_remote = option_priority;
 438     }
 439
 440     return 1;
 441 }
 442
 443 static void
 444 printipaddr(opt, printer, arg)
 445     option_t *opt;
 446     void (*printer) __P((void *, char *, ...));
 447     void *arg;
 448 {
 449         ipcp_options *wo = &ipcp_wantoptions[0];
 450
 451         if (wo->ouraddr != 0)
 452                 printer(arg, "%I", wo->ouraddr);
 453         printer(arg, ":");
 454         if (wo->hisaddr != 0)
 455                 printer(arg, "%I", wo->hisaddr);
 456 }
 457
 458 /*
 459  * setnetmask - set the netmask to be used on the interface.
 460  */
 461 static int
 462 setnetmask(argv)
 463     char **argv;
 464 {
 465     u_int32_t mask;
 466     int n;
 467     char *p;
 468
 469     /*
 470      * Unfortunately, if we use inet_addr, we can't tell whether
 471      * a result of all 1s is an error or a valid 255.255.255.255.
 472      */
 473     p = *argv;
 474     n = parse_dotted_ip(p, &mask);
 475
 476     mask = htonl(mask);
 477
 478     if (n == 0 || p[n] != 0 || (netmask & ~mask) != 0) {
 479         option_error("invalid netmask value '%s'", *argv);
 480         return 0;
 481     }
 482
 483     netmask = mask;
 484     slprintf(netmask_str, sizeof(netmask_str), "%I", mask);
 485
 486     return (1);
 487 }
 488
 489 int
 490 parse_dotted_ip(p, vp)
 491     char *p;
 492     u_int32_t *vp;
 493 {
 494     int n;
 495     u_int32_t v, b;
 496     char *endp, *p0 = p;
 497
 498     v = 0;
 499     for (n = 3;; --n) {
 500         b = strtoul(p, &endp, 0);
 501         if (endp == p)
 502             return 0;
 503         if (b > 255) {
 504             if (n < 3)
 505                 return 0;
 506             /* accept e.g. 0xffffff00 */
 507             *vp = b;
 508             return endp - p0;
 509         }
 510         v |= b << (n * 8);
 511         p = endp;
 512         if (n == 0)
 513             break;
 514         if (*p != '.')
 515             return 0;
 516         ++p;
 517     }
 518     *vp = v;
 519     return p - p0;
 520 }
 521
 522
 523 /*
 524  * ipcp_init - Initialize IPCP.
 525  */
 526 static void
 527 ipcp_init(unit)
 528     int unit;
 529 {
 530     fsm *f = &ipcp_fsm[unit];
 531     ipcp_options *wo = &ipcp_wantoptions[unit];
 532     ipcp_options *ao = &ipcp_allowoptions[unit];
 533
 534     f->unit = unit;
 535     f->protocol = PPP_IPCP;
 536     f->callbacks = &ipcp_callbacks;
 537     fsm_init(&ipcp_fsm[unit]);
 538
 539     memset(wo, 0, sizeof(*wo));
 540     memset(ao, 0, sizeof(*ao));
 541
 542     wo->neg_addr = 1;
 543     wo->neg_vj = 1;
 544     wo->vj_protocol = IPCP_VJ_COMP;
 545     wo->maxslotindex = MAX_STATES - 1; /* really max index */
 546     wo->cflag = 1;
 547
 548
 549     /* max slots and slot-id compression are currently hardwired in */
 550     /* ppp_if.c to 16 and 1, this needs to be changed (among other */
 551     /* things) gmc */
 552
 553     ao->neg_addr = 1;
 554     ao->neg_vj = 1;
 555     ao->maxslotindex = MAX_STATES - 1;
 556     ao->cflag = 1;
 557
 558     /*
 559      * XXX These control whether the user may use the proxyarp
 560      * and defaultroute options.
 561      */
 562     ao->proxy_arp = 1;
 563     ao->default_route = 1;
 564 }
 565
 566
 567 /*
 568  * ipcp_open - IPCP is allowed to come up.
 569  */
 570 static void
 571 ipcp_open(unit)
 572     int unit;
 573 {
 574     fsm_open(&ipcp_fsm[unit]);
 575 }
 576
 577
 578 /*
 579  * ipcp_close - Take IPCP down.
 580  */
 581 static void
 582 ipcp_close(unit, reason)
 583     int unit;
 584     char *reason;
 585 {
 586     fsm_close(&ipcp_fsm[unit], reason);
 587 }
 588
 589
 590 /*
 591  * ipcp_lowerup - The lower layer is up.
 592  */
 593 static void
 594 ipcp_lowerup(unit)
 595     int unit;
 596 {
 597     fsm_lowerup(&ipcp_fsm[unit]);
 598 }
 599
 600
 601 /*
 602  * ipcp_lowerdown - The lower layer is down.
 603  */
 604 static void
 605 ipcp_lowerdown(unit)
 606     int unit;
 607 {
 608     fsm_lowerdown(&ipcp_fsm[unit]);
 609 }
 610
 611
 612 /*
 613  * ipcp_input - Input IPCP packet.
 614  */
 615 static void
 616 ipcp_input(unit, p, len)
 617     int unit;
 618     u_char *p;
 619     int len;
 620 {
 621     fsm_input(&ipcp_fsm[unit], p, len);
 622 }
 623
 624
 625 /*
 626  * ipcp_protrej - A Protocol-Reject was received for IPCP.
 627  *
 628  * Pretend the lower layer went down, so we shut up.
 629  */
 630 static void
 631 ipcp_protrej(unit)
 632     int unit;
 633 {
 634     fsm_lowerdown(&ipcp_fsm[unit]);
 635 }
 636
 637
 638 /*
 639  * ipcp_resetci - Reset our CI.
 640  * Called by fsm_sconfreq, Send Configure Request.
 641  */
 642 static void
 643 ipcp_resetci(f)
 644     fsm *f;
 645 {
 646     ipcp_options *wo = &ipcp_wantoptions[f->unit];
 647     ipcp_options *go = &ipcp_gotoptions[f->unit];
 648
 649     wo->req_addr = wo->neg_addr && ipcp_allowoptions[f->unit].neg_addr;
 650     if (wo->ouraddr == 0)
 651         wo->accept_local = 1;
 652     if (wo->hisaddr == 0)
 653         wo->accept_remote = 1;
 654     wo->req_dns1 = usepeerdns;  /* Request DNS addresses from the peer */
 655     wo->req_dns2 = usepeerdns;
 656     *go = *wo;
 657     if (!ask_for_local)
 658         go->ouraddr = 0;
 659     if (ip_choose_hook) {
 660         ip_choose_hook(&wo->hisaddr);
 661         if (wo->hisaddr) {
 662             wo->accept_remote = 0;
 663         }
 664     }
 665 }
 666
 667
 668 /*
 669  * ipcp_cilen - Return length of our CI.
 670  * Called by fsm_sconfreq, Send Configure Request.
 671  */
 672 static int
 673 ipcp_cilen(f)
 674     fsm *f;
 675 {
 676     ipcp_options *go = &ipcp_gotoptions[f->unit];
 677     ipcp_options *wo = &ipcp_wantoptions[f->unit];
 678     ipcp_options *ho = &ipcp_hisoptions[f->unit];
 679
 680 #define LENCIVJ(neg, old)       (neg ? (old? CILEN_COMPRESS : CILEN_VJ) : 0)
 681 #define LENCIADDR(neg, old)     (neg ? (old? CILEN_ADDRS : CILEN_ADDR) : 0)
 682 #define LENCIDNS(neg)           (neg ? (CILEN_ADDR) : 0)
 683
 684     /*
 685      * First see if we want to change our options to the old
 686      * forms because we have received old forms from the peer.
 687      */
 688     if (wo->neg_addr && !go->neg_addr && !go->old_addrs) {
 689         /* use the old style of address negotiation */
 690         go->neg_addr = 1;
 691         go->old_addrs = 1;
 692     }
 693     if (wo->neg_vj && !go->neg_vj && !go->old_vj) {
 694         /* try an older style of VJ negotiation */
 695         /* use the old style only if the peer did */
 696         if (ho->neg_vj && ho->old_vj) {
 697             go->neg_vj = 1;
 698             go->old_vj = 1;
 699             go->vj_protocol = ho->vj_protocol;
 700         }
 701     }
 702
 703     return (LENCIADDR(go->neg_addr, go->old_addrs) +
 704             LENCIVJ(go->neg_vj, go->old_vj) +
 705             LENCIDNS(go->req_dns1) +
 706             LENCIDNS(go->req_dns2)) ;
 707 }
 708
 709
 710 /*
 711  * ipcp_addci - Add our desired CIs to a packet.
 712  * Called by fsm_sconfreq, Send Configure Request.
 713  */
 714 static void
 715 ipcp_addci(f, ucp, lenp)
 716     fsm *f;
 717     u_char *ucp;
 718     int *lenp;
 719 {
 720     ipcp_options *go = &ipcp_gotoptions[f->unit];
 721     int len = *lenp;
 722
 723 #define ADDCIVJ(opt, neg, val, old, maxslotindex, cflag) \
 724     if (neg) { \
 725         int vjlen = old? CILEN_COMPRESS : CILEN_VJ; \
 726         if (len >= vjlen) { \
 727             PUTCHAR(opt, ucp); \
 728             PUTCHAR(vjlen, ucp); \
 729             PUTSHORT(val, ucp); \
 730             if (!old) { \
 731                 PUTCHAR(maxslotindex, ucp); \
 732                 PUTCHAR(cflag, ucp); \
 733             } \
 734             len -= vjlen; \
 735         } else \
 736             neg = 0; \
 737     }
 738
 739 #define ADDCIADDR(opt, neg, old, val1, val2) \
 740     if (neg) { \
 741         int addrlen = (old? CILEN_ADDRS: CILEN_ADDR); \
 742         if (len >= addrlen) { \
 743             u_int32_t l; \
 744             PUTCHAR(opt, ucp); \
 745             PUTCHAR(addrlen, ucp); \
 746             l = ntohl(val1); \
 747             PUTLONG(l, ucp); \
 748             if (old) { \
 749                 l = ntohl(val2); \
 750                 PUTLONG(l, ucp); \
 751             } \
 752             len -= addrlen; \
 753         } else \
 754             neg = 0; \
 755     }
 756
 757 #define ADDCIDNS(opt, neg, addr) \
 758     if (neg) { \
 759         if (len >= CILEN_ADDR) { \
 760             u_int32_t l; \
 761             PUTCHAR(opt, ucp); \
 762             PUTCHAR(CILEN_ADDR, ucp); \
 763             l = ntohl(addr); \
 764             PUTLONG(l, ucp); \
 765             len -= CILEN_ADDR; \
 766         } else \
 767             neg = 0; \
 768     }
 769
 770     ADDCIADDR((go->old_addrs? CI_ADDRS: CI_ADDR), go->neg_addr,
 771               go->old_addrs, go->ouraddr, go->hisaddr);
 772
 773     ADDCIVJ(CI_COMPRESSTYPE, go->neg_vj, go->vj_protocol, go->old_vj,
 774             go->maxslotindex, go->cflag);
 775
 776     ADDCIDNS(CI_MS_DNS1, go->req_dns1, go->dnsaddr[0]);
 777
 778     ADDCIDNS(CI_MS_DNS2, go->req_dns2, go->dnsaddr[1]);
 779
 780     *lenp -= len;
 781 }
 782
 783
 784 /*
 785  * ipcp_ackci - Ack our CIs.
 786  * Called by fsm_rconfack, Receive Configure ACK.
 787  *
 788  * Returns:
 789  *      0 - Ack was bad.
 790  *      1 - Ack was good.
 791  */
 792 static int
 793 ipcp_ackci(f, p, len)
 794     fsm *f;
 795     u_char *p;
 796     int len;
 797 {
 798     ipcp_options *go = &ipcp_gotoptions[f->unit];
 799     u_short cilen, citype, cishort;
 800     u_int32_t cilong;
 801     u_char cimaxslotindex, cicflag;
 802
 803     /*
 804      * CIs must be in exactly the same order that we sent...
 805      * Check packet length and CI length at each step.
 806      * If we find any deviations, then this packet is bad.
 807      */
 808
 809 #define ACKCIVJ(opt, neg, val, old, maxslotindex, cflag) \
 810     if (neg) { \
 811         int vjlen = old? CILEN_COMPRESS : CILEN_VJ; \
 812         if ((len -= vjlen) < 0) \
 813             goto bad; \
 814         GETCHAR(citype, p); \
 815         GETCHAR(cilen, p); \
 816         if (cilen != vjlen || \
 817             citype != opt)  \
 818             goto bad; \
 819         GETSHORT(cishort, p); \
 820         if (cishort != val) \
 821             goto bad; \
 822         if (!old) { \
 823             GETCHAR(cimaxslotindex, p); \
 824             if (cimaxslotindex != maxslotindex) \
 825                 goto bad; \
 826             GETCHAR(cicflag, p); \
 827             if (cicflag != cflag) \
 828                 goto bad; \
 829         } \
 830     }
 831
 832 #define ACKCIADDR(opt, neg, old, val1, val2) \
 833     if (neg) { \
 834         int addrlen = (old? CILEN_ADDRS: CILEN_ADDR); \
 835         u_int32_t l; \
 836         if ((len -= addrlen) < 0) \
 837             goto bad; \
 838         GETCHAR(citype, p); \
 839         GETCHAR(cilen, p); \
 840         if (cilen != addrlen || \
 841             citype != opt) \
 842             goto bad; \
 843         GETLONG(l, p); \
 844         cilong = htonl(l); \
 845         if (val1 != cilong) \
 846             goto bad; \
 847         if (old) { \
 848             GETLONG(l, p); \
 849             cilong = htonl(l); \
 850             if (val2 != cilong) \
 851                 goto bad; \
 852         } \
 853     }
 854
 855 #define ACKCIDNS(opt, neg, addr) \
 856     if (neg) { \
 857         u_int32_t l; \
 858         if ((len -= CILEN_ADDR) < 0) \
 859             goto bad; \
 860         GETCHAR(citype, p); \
 861         GETCHAR(cilen, p); \
 862         if (cilen != CILEN_ADDR || citype != opt) \
 863             goto bad; \
 864         GETLONG(l, p); \
 865         cilong = htonl(l); \
 866         if (addr != cilong) \
 867             goto bad; \
 868     }
 869
 870     ACKCIADDR((go->old_addrs? CI_ADDRS: CI_ADDR), go->neg_addr,
 871               go->old_addrs, go->ouraddr, go->hisaddr);
 872
 873     ACKCIVJ(CI_COMPRESSTYPE, go->neg_vj, go->vj_protocol, go->old_vj,
 874             go->maxslotindex, go->cflag);
 875
 876     ACKCIDNS(CI_MS_DNS1, go->req_dns1, go->dnsaddr[0]);
 877
 878     ACKCIDNS(CI_MS_DNS2, go->req_dns2, go->dnsaddr[1]);
 879
 880     /*
 881      * If there are any remaining CIs, then this packet is bad.
 882      */
 883     if (len != 0)
 884         goto bad;
 885     return (1);
 886
 887 bad:
 888     IPCPDEBUG(("ipcp_ackci: received bad Ack!"));
 889     return (0);
 890 }
 891
 892 /*
 893  * ipcp_nakci - Peer has sent a NAK for some of our CIs.
 894  * This should not modify any state if the Nak is bad
 895  * or if IPCP is in the OPENED state.
 896  * Calback from fsm_rconfnakrej - Receive Configure-Nak or Configure-Reject.
 897  *
 898  * Returns:
 899  *      0 - Nak was bad.
 900  *      1 - Nak was good.
 901  */
 902 static int
 903 ipcp_nakci(f, p, len)
 904     fsm *f;
 905     u_char *p;
 906     int len;
 907 {
 908     ipcp_options *go = &ipcp_gotoptions[f->unit];
 909     u_char cimaxslotindex, cicflag;
 910     u_char citype, cilen, *next;
 911     u_short cishort;
 912     u_int32_t ciaddr1, ciaddr2, l, cidnsaddr;
 913     ipcp_options no;            /* options we've seen Naks for */
 914     ipcp_options try;           /* options to request next time */
 915
 916     BZERO(&no, sizeof(no));
 917     try = *go;
 918
 919     /*
 920      * Any Nak'd CIs must be in exactly the same order that we sent.
 921      * Check packet length and CI length at each step.
 922      * If we find any deviations, then this packet is bad.
 923      */
 924 #define NAKCIADDR(opt, neg, old, code) \
 925     if (go->neg && \
 926         len >= (cilen = (old? CILEN_ADDRS: CILEN_ADDR)) && \
 927         p[1] == cilen && \
 928         p[0] == opt) { \
 929         len -= cilen; \
 930         INCPTR(2, p); \
 931         GETLONG(l, p); \
 932         ciaddr1 = htonl(l); \
 933         if (old) { \
 934             GETLONG(l, p); \
 935             ciaddr2 = htonl(l); \
 936             no.old_addrs = 1; \
 937         } else \
 938             ciaddr2 = 0; \
 939         no.neg = 1; \
 940         code \
 941     }
 942
 943 #define NAKCIVJ(opt, neg, code) \
 944     if (go->neg && \
 945         ((cilen = p[1]) == CILEN_COMPRESS || cilen == CILEN_VJ) && \
 946         len >= cilen && \
 947         p[0] == opt) { \
 948         len -= cilen; \
 949         INCPTR(2, p); \
 950         GETSHORT(cishort, p); \
 951         no.neg = 1; \
 952         code \
 953     }
 954
 955 #define NAKCIDNS(opt, neg, code) \
 956     if (go->neg && \
 957         ((cilen = p[1]) == CILEN_ADDR) && \
 958         len >= cilen && \
 959         p[0] == opt) { \
 960         len -= cilen; \
 961         INCPTR(2, p); \
 962         GETLONG(l, p); \
 963         cidnsaddr = htonl(l); \
 964         no.neg = 1; \
 965         code \
 966     }
 967
 968     /*
 969      * Accept the peer's idea of {our,his} address, if different
 970      * from our idea, only if the accept_{local,remote} flag is set.
 971      */
 972     NAKCIADDR((go->old_addrs? CI_ADDRS: CI_ADDR), neg_addr, go->old_addrs,
 973               if (go->accept_local && ciaddr1) { /* Do we know our address? */
 974                   try.ouraddr = ciaddr1;
 975               }
 976               if (go->accept_remote && ciaddr2) { /* Does he know his? */
 977                   try.hisaddr = ciaddr2;
 978               }
 979               );
 980
 981     /*
 982      * Accept the peer's value of maxslotindex provided that it
 983      * is less than what we asked for.  Turn off slot-ID compression
 984      * if the peer wants.  Send old-style compress-type option if
 985      * the peer wants.
 986      */
 987     NAKCIVJ(CI_COMPRESSTYPE, neg_vj,
 988             if (cilen == CILEN_VJ) {
 989                 GETCHAR(cimaxslotindex, p);
 990                 GETCHAR(cicflag, p);
 991                 if (cishort == IPCP_VJ_COMP) {
 992                     try.old_vj = 0;
 993                     if (cimaxslotindex < go->maxslotindex)
 994                         try.maxslotindex = cimaxslotindex;
 995                     if (!cicflag)
 996                         try.cflag = 0;
 997                 } else {
 998                     try.neg_vj = 0;
 999                 }
1000             } else {
1001                 if (cishort == IPCP_VJ_COMP || cishort == IPCP_VJ_COMP_OLD) {
1002                     try.old_vj = 1;
1003                     try.vj_protocol = cishort;
1004                 } else {
1005                     try.neg_vj = 0;
1006                 }
1007             }
1008             );
1009
1010     NAKCIDNS(CI_MS_DNS1, req_dns1,
1011             try.dnsaddr[0] = cidnsaddr;
1012             );
1013
1014     NAKCIDNS(CI_MS_DNS2, req_dns2,
1015             try.dnsaddr[1] = cidnsaddr;
1016             );
1017
1018     /*
1019      * There may be remaining CIs, if the peer is requesting negotiation
1020      * on an option that we didn't include in our request packet.
1021      * If they want to negotiate about IP addresses, we comply.
1022      * If they want us to ask for compression, we refuse.
1023      */
1024     while (len > CILEN_VOID) {
1025         GETCHAR(citype, p);
1026         GETCHAR(cilen, p);
1027         if( (len -= cilen) < 0 )
1028             goto bad;
1029         next = p + cilen - 2;
1030
1031         switch (citype) {
1032         case CI_COMPRESSTYPE:
1033             if (go->neg_vj || no.neg_vj ||
1034                 (cilen != CILEN_VJ && cilen != CILEN_COMPRESS))
1035                 goto bad;
1036             no.neg_vj = 1;
1037             break;
1038         case CI_ADDRS:
1039             if ((go->neg_addr && go->old_addrs) || no.old_addrs
1040                 || cilen != CILEN_ADDRS)
1041                 goto bad;
1042             try.neg_addr = 1;
1043             try.old_addrs = 1;
1044             GETLONG(l, p);
1045             ciaddr1 = htonl(l);
1046             if (ciaddr1 && go->accept_local)
1047                 try.ouraddr = ciaddr1;
1048             GETLONG(l, p);
1049             ciaddr2 = htonl(l);
1050             if (ciaddr2 && go->accept_remote)
1051                 try.hisaddr = ciaddr2;
1052             no.old_addrs = 1;
1053             break;
1054         case CI_ADDR:
1055             if (go->neg_addr || no.neg_addr || cilen != CILEN_ADDR)
1056                 goto bad;
1057             try.old_addrs = 0;
1058             GETLONG(l, p);
1059             ciaddr1 = htonl(l);
1060             if (ciaddr1 && go->accept_local)
1061                 try.ouraddr = ciaddr1;
1062             if (try.ouraddr != 0)
1063                 try.neg_addr = 1;
1064             no.neg_addr = 1;
1065             break;
1066         }
1067         p = next;
1068     }
1069
1070     /*
1071      * OK, the Nak is good.  Now we can update state.
1072      * If there are any remaining options, we ignore them.
1073      */
1074     if (f->state != OPENED)
1075         *go = try;
1076
1077     return 1;
1078
1079 bad:
1080     IPCPDEBUG(("ipcp_nakci: received bad Nak!"));
1081     return 0;
1082 }
1083
1084
1085 /*
1086  * ipcp_rejci - Reject some of our CIs.
1087  * Callback from fsm_rconfnakrej.
1088  */
1089 static int
1090 ipcp_rejci(f, p, len)
1091     fsm *f;
1092     u_char *p;
1093     int len;
1094 {
1095     ipcp_options *go = &ipcp_gotoptions[f->unit];
1096     u_char cimaxslotindex, ciflag, cilen;
1097     u_short cishort;
1098     u_int32_t cilong;
1099     ipcp_options try;           /* options to request next time */
1100
1101     try = *go;
1102     /*
1103      * Any Rejected CIs must be in exactly the same order that we sent.
1104      * Check packet length and CI length at each step.
1105      * If we find any deviations, then this packet is bad.
1106      */
1107 #define REJCIADDR(opt, neg, old, val1, val2) \
1108     if (go->neg && \
1109         len >= (cilen = old? CILEN_ADDRS: CILEN_ADDR) && \
1110         p[1] == cilen && \
1111         p[0] == opt) { \
1112         u_int32_t l; \
1113         len -= cilen; \
1114         INCPTR(2, p); \
1115         GETLONG(l, p); \
1116         cilong = htonl(l); \
1117         /* Check rejected value. */ \
1118         if (cilong != val1) \
1119             goto bad; \
1120         if (old) { \
1121             GETLONG(l, p); \
1122             cilong = htonl(l); \
1123             /* Check rejected value. */ \
1124             if (cilong != val2) \
1125                 goto bad; \
1126         } \
1127         try.neg = 0; \
1128     }
1129
1130 #define REJCIVJ(opt, neg, val, old, maxslot, cflag) \
1131     if (go->neg && \
1132         p[1] == (old? CILEN_COMPRESS : CILEN_VJ) && \
1133         len >= p[1] && \
1134         p[0] == opt) { \
1135         len -= p[1]; \
1136         INCPTR(2, p); \
1137         GETSHORT(cishort, p); \
1138         /* Check rejected value. */  \
1139         if (cishort != val) \
1140             goto bad; \
1141         if (!old) { \
1142            GETCHAR(cimaxslotindex, p); \
1143            if (cimaxslotindex != maxslot) \
1144              goto bad; \
1145            GETCHAR(ciflag, p); \
1146            if (ciflag != cflag) \
1147              goto bad; \
1148         } \
1149         try.neg = 0; \
1150      }
1151
1152 #define REJCIDNS(opt, neg, dnsaddr) \
1153     if (go->neg && \
1154         ((cilen = p[1]) == CILEN_ADDR) && \
1155         len >= cilen && \
1156         p[0] == opt) { \
1157         u_int32_t l; \
1158         len -= cilen; \
1159         INCPTR(2, p); \
1160         GETLONG(l, p); \
1161         cilong = htonl(l); \
1162         /* Check rejected value. */ \
1163         if (cilong != dnsaddr) \
1164             goto bad; \
1165         try.neg = 0; \
1166     }
1167
1168
1169     REJCIADDR((go->old_addrs? CI_ADDRS: CI_ADDR), neg_addr,
1170               go->old_addrs, go->ouraddr, go->hisaddr);
1171
1172     REJCIVJ(CI_COMPRESSTYPE, neg_vj, go->vj_protocol, go->old_vj,
1173             go->maxslotindex, go->cflag);
1174
1175     REJCIDNS(CI_MS_DNS1, req_dns1, go->dnsaddr[0]);
1176
1177     REJCIDNS(CI_MS_DNS2, req_dns2, go->dnsaddr[1]);
1178
1179     /*
1180      * If there are any remaining CIs, then this packet is bad.
1181      */
1182     if (len != 0)
1183         goto bad;
1184     /*
1185      * Now we can update state.
1186      */
1187     if (f->state != OPENED)
1188         *go = try;
1189     return 1;
1190
1191 bad:
1192     IPCPDEBUG(("ipcp_rejci: received bad Reject!"));
1193     return 0;
1194 }
1195
1196
1197 /*
1198  * ipcp_reqci - Check the peer's requested CIs and send appropriate response.
1199  * Callback from fsm_rconfreq, Receive Configure Request
1200  *
1201  * Returns: CONFACK, CONFNAK or CONFREJ and input packet modified
1202  * appropriately.  If reject_if_disagree is non-zero, doesn't return
1203  * CONFNAK; returns CONFREJ if it can't return CONFACK.
1204  */
1205 static int
1206 ipcp_reqci(f, inp, len, reject_if_disagree)
1207     fsm *f;
1208     u_char *inp;                /* Requested CIs */
1209     int *len;                   /* Length of requested CIs */
1210     int reject_if_disagree;
1211 {
1212     ipcp_options *wo = &ipcp_wantoptions[f->unit];
1213     ipcp_options *ho = &ipcp_hisoptions[f->unit];
1214     ipcp_options *ao = &ipcp_allowoptions[f->unit];
1215     ipcp_options *go = &ipcp_gotoptions[f->unit];
1216     u_char *cip, *next;         /* Pointer to current and next CIs */
1217     u_short cilen, citype;      /* Parsed len, type */
1218     u_short cishort;            /* Parsed short value */
1219     u_int32_t tl, ciaddr1, ciaddr2;/* Parsed address values */
1220     int rc = CONFACK;           /* Final packet return code */
1221     int orc;                    /* Individual option return code */
1222     u_char *p;                  /* Pointer to next char to parse */
1223     u_char *ucp = inp;          /* Pointer to current output char */
1224     int l = *len;               /* Length left */
1225     u_char maxslotindex, cflag;
1226     int d;
1227
1228     /*
1229      * Reset all his options.
1230      */
1231     BZERO(ho, sizeof(*ho));
1232
1233     /*
1234      * Process all his options.
1235      */
1236     next = inp;
1237     while (l) {
1238         orc = CONFACK;                  /* Assume success */
1239         cip = p = next;                 /* Remember begining of CI */
1240         if (l < 2 ||                    /* Not enough data for CI header or */
1241             p[1] < 2 ||                 /*  CI length too small or */
1242             p[1] > l) {                 /*  CI length too big? */
1243             IPCPDEBUG(("ipcp_reqci: bad CI length!"));
1244             orc = CONFREJ;              /* Reject bad CI */
1245             cilen = l;                  /* Reject till end of packet */
1246             l = 0;                      /* Don't loop again */
1247             goto endswitch;
1248         }
1249         GETCHAR(citype, p);             /* Parse CI type */
1250         GETCHAR(cilen, p);              /* Parse CI length */
1251         l -= cilen;                     /* Adjust remaining length */
1252         next += cilen;                  /* Step to next CI */
1253
1254         switch (citype) {               /* Check CI type */
1255         case CI_ADDRS:
1256             if (!ao->neg_addr ||
1257                 cilen != CILEN_ADDRS) { /* Check CI length */
1258                 orc = CONFREJ;          /* Reject CI */
1259                 break;
1260             }
1261
1262             /*
1263              * If he has no address, or if we both have his address but
1264              * disagree about it, then NAK it with our idea.
1265              * In particular, if we don't know his address, but he does,
1266              * then accept it.
1267              */
1268             GETLONG(tl, p);             /* Parse source address (his) */
1269             ciaddr1 = htonl(tl);
1270             if (ciaddr1 != wo->hisaddr
1271                 && (ciaddr1 == 0 || !wo->accept_remote)) {
1272                 orc = CONFNAK;
1273                 if (!reject_if_disagree) {
1274                     DECPTR(sizeof(u_int32_t), p);
1275                     tl = ntohl(wo->hisaddr);
1276                     PUTLONG(tl, p);
1277                 }
1278             } else if (ciaddr1 == 0 && wo->hisaddr == 0) {
1279                 /*
1280                  * If neither we nor he knows his address, reject the option.
1281                  */
1282                 orc = CONFREJ;
1283                 wo->req_addr = 0;       /* don't NAK with 0.0.0.0 later */
1284                 break;
1285             }
1286
1287             /*
1288              * If he doesn't know our address, or if we both have our address
1289              * but disagree about it, then NAK it with our idea.
1290              */
1291             GETLONG(tl, p);             /* Parse desination address (ours) */
1292             ciaddr2 = htonl(tl);
1293             if (ciaddr2 != wo->ouraddr) {
1294                 if (ciaddr2 == 0 || !wo->accept_local) {
1295                     orc = CONFNAK;
1296                     if (!reject_if_disagree) {
1297                         DECPTR(sizeof(u_int32_t), p);
1298                         tl = ntohl(wo->ouraddr);
1299                         PUTLONG(tl, p);
1300                     }
1301                 } else {
1302                     go->ouraddr = ciaddr2;      /* accept peer's idea */
1303                 }
1304             }
1305
1306             ho->neg_addr = 1;
1307             ho->old_addrs = 1;
1308             ho->hisaddr = ciaddr1;
1309             ho->ouraddr = ciaddr2;
1310             break;
1311
1312         case CI_ADDR:
1313             if (!ao->neg_addr ||
1314                 cilen != CILEN_ADDR) {  /* Check CI length */
1315                 orc = CONFREJ;          /* Reject CI */
1316                 break;
1317             }
1318
1319             /*
1320              * If he has no address, or if we both have his address but
1321              * disagree about it, then NAK it with our idea.
1322              * In particular, if we don't know his address, but he does,
1323              * then accept it.
1324              */
1325             GETLONG(tl, p);     /* Parse source address (his) */
1326             ciaddr1 = htonl(tl);
1327             if (ciaddr1 != wo->hisaddr
1328                 && (ciaddr1 == 0 || !wo->accept_remote)) {
1329                 orc = CONFNAK;
1330                 if (!reject_if_disagree) {
1331                     DECPTR(sizeof(u_int32_t), p);
1332                     tl = ntohl(wo->hisaddr);
1333                     PUTLONG(tl, p);
1334                 }
1335             } else if (ciaddr1 == 0 && wo->hisaddr == 0) {
1336                 /*
1337                  * Don't ACK an address of 0.0.0.0 - reject it instead.
1338                  */
1339                 orc = CONFREJ;
1340                 wo->req_addr = 0;       /* don't NAK with 0.0.0.0 later */
1341                 break;
1342             }
1343
1344             ho->neg_addr = 1;
1345             ho->hisaddr = ciaddr1;
1346             break;
1347
1348         case CI_MS_DNS1:
1349         case CI_MS_DNS2:
1350             /* Microsoft primary or secondary DNS request */
1351             d = citype == CI_MS_DNS2;
1352
1353             /* If we do not have a DNS address then we cannot send it */
1354             if (ao->dnsaddr[d] == 0 ||
1355                 cilen != CILEN_ADDR) {  /* Check CI length */
1356                 orc = CONFREJ;          /* Reject CI */
1357                 break;
1358             }
1359             GETLONG(tl, p);
1360             if (htonl(tl) != ao->dnsaddr[d]) {
1361                 DECPTR(sizeof(u_int32_t), p);
1362                 tl = ntohl(ao->dnsaddr[d]);
1363                 PUTLONG(tl, p);
1364                 orc = CONFNAK;
1365             }
1366             break;
1367
1368         case CI_MS_WINS1:
1369         case CI_MS_WINS2:
1370             /* Microsoft primary or secondary WINS request */
1371             d = citype == CI_MS_WINS2;
1372
1373             /* If we do not have a DNS address then we cannot send it */
1374             if (ao->winsaddr[d] == 0 ||
1375                 cilen != CILEN_ADDR) {  /* Check CI length */
1376                 orc = CONFREJ;          /* Reject CI */
1377                 break;
1378             }
1379             GETLONG(tl, p);
1380             if (htonl(tl) != ao->winsaddr[d]) {
1381                 DECPTR(sizeof(u_int32_t), p);
1382                 tl = ntohl(ao->winsaddr[d]);
1383                 PUTLONG(tl, p);
1384                 orc = CONFNAK;
1385             }
1386             break;
1387
1388         case CI_COMPRESSTYPE:
1389             if (!ao->neg_vj ||
1390                 (cilen != CILEN_VJ && cilen != CILEN_COMPRESS)) {
1391                 orc = CONFREJ;
1392                 break;
1393             }
1394             GETSHORT(cishort, p);
1395
1396             if (!(cishort == IPCP_VJ_COMP ||
1397                   (cishort == IPCP_VJ_COMP_OLD && cilen == CILEN_COMPRESS))) {
1398                 orc = CONFREJ;
1399                 break;
1400             }
1401
1402             ho->neg_vj = 1;
1403             ho->vj_protocol = cishort;
1404             if (cilen == CILEN_VJ) {
1405                 GETCHAR(maxslotindex, p);
1406                 if (maxslotindex > ao->maxslotindex) {
1407                     orc = CONFNAK;
1408                     if (!reject_if_disagree){
1409                         DECPTR(1, p);
1410                         PUTCHAR(ao->maxslotindex, p);
1411                     }
1412                 }
1413                 GETCHAR(cflag, p);
1414                 if (cflag && !ao->cflag) {
1415                     orc = CONFNAK;
1416                     if (!reject_if_disagree){
1417                         DECPTR(1, p);
1418                         PUTCHAR(wo->cflag, p);
1419                     }
1420                 }
1421                 ho->maxslotindex = maxslotindex;
1422                 ho->cflag = cflag;
1423             } else {
1424                 ho->old_vj = 1;
1425                 ho->maxslotindex = MAX_STATES - 1;
1426                 ho->cflag = 1;
1427             }
1428             break;
1429
1430         default:
1431             orc = CONFREJ;
1432             break;
1433         }
1434 endswitch:
1435         if (orc == CONFACK &&           /* Good CI */
1436             rc != CONFACK)              /*  but prior CI wasnt? */
1437             continue;                   /* Don't send this one */
1438
1439         if (orc == CONFNAK) {           /* Nak this CI? */
1440             if (reject_if_disagree)     /* Getting fed up with sending NAKs? */
1441                 orc = CONFREJ;          /* Get tough if so */
1442             else {
1443                 if (rc == CONFREJ)      /* Rejecting prior CI? */
1444                     continue;           /* Don't send this one */
1445                 if (rc == CONFACK) {    /* Ack'd all prior CIs? */
1446                     rc = CONFNAK;       /* Not anymore... */
1447                     ucp = inp;          /* Backup */
1448                 }
1449             }
1450         }
1451
1452         if (orc == CONFREJ &&           /* Reject this CI */
1453             rc != CONFREJ) {            /*  but no prior ones? */
1454             rc = CONFREJ;
1455             ucp = inp;                  /* Backup */
1456         }
1457
1458         /* Need to move CI? */
1459         if (ucp != cip)
1460             BCOPY(cip, ucp, cilen);     /* Move it */
1461
1462         /* Update output pointer */
1463         INCPTR(cilen, ucp);
1464     }
1465
1466     /*
1467      * If we aren't rejecting this packet, and we want to negotiate
1468      * their address, and they didn't send their address, then we
1469      * send a NAK with a CI_ADDR option appended.  We assume the
1470      * input buffer is long enough that we can append the extra
1471      * option safely.
1472      */
1473     if (rc != CONFREJ && !ho->neg_addr &&
1474         wo->req_addr && !reject_if_disagree) {
1475         if (rc == CONFACK) {
1476             rc = CONFNAK;
1477             ucp = inp;                  /* reset pointer */
1478             wo->req_addr = 0;           /* don't ask again */
1479         }
1480         PUTCHAR(CI_ADDR, ucp);
1481         PUTCHAR(CILEN_ADDR, ucp);
1482         tl = ntohl(wo->hisaddr);
1483         PUTLONG(tl, ucp);
1484     }
1485
1486     *len = ucp - inp;                   /* Compute output length */
1487     IPCPDEBUG(("ipcp: returning Configure-%s", CODENAME(rc)));
1488     return (rc);                        /* Return final code */
1489 }
1490
1491
1492 /*
1493  * ip_check_options - check that any IP-related options are OK,
1494  * and assign appropriate defaults.
1495  */
1496 static void
1497 ip_check_options()
1498 {
1499     struct hostent *hp;
1500     u_int32_t local;
1501     ipcp_options *wo = &ipcp_wantoptions[0];
1502
1503     /*
1504      * Default our local IP address based on our hostname.
1505      * If local IP address already given, don't bother.
1506      */
1507     if (wo->ouraddr == 0 && !disable_defaultip) {
1508         /*
1509          * Look up our hostname (possibly with domain name appended)
1510          * and take the first IP address as our local IP address.
1511          * If there isn't an IP address for our hostname, too bad.
1512          */
1513         wo->accept_local = 1;   /* don't insist on this default value */
1514         if ((hp = gethostbyname(hostname)) != NULL) {
1515             local = *(u_int32_t *)hp->h_addr;
1516             if (local != 0 && !bad_ip_adrs(local))
1517                 wo->ouraddr = local;
1518         }
1519     }
1520     ask_for_local = wo->ouraddr != 0 || !disable_defaultip;
1521 }
1522
1523
1524 /*
1525  * ip_demand_conf - configure the interface as though
1526  * IPCP were up, for use with dial-on-demand.
1527  */
1528 static int
1529 ip_demand_conf(u)
1530     int u;
1531 {
1532     ipcp_options *wo = &ipcp_wantoptions[u];
1533
1534     if (wo->hisaddr == 0) {
1535         /* make up an arbitrary address for the peer */
1536         wo->hisaddr = htonl(0x0a707070 + ifunit);
1537         wo->accept_remote = 1;
1538     }
1539     if (wo->ouraddr == 0) {
1540         /* make up an arbitrary address for us */
1541         wo->ouraddr = htonl(0x0a404040 + ifunit);
1542         wo->accept_local = 1;
1543         ask_for_local = 0;      /* don't tell the peer this address */
1544     }
1545     if (!sifaddr(u, wo->ouraddr, wo->hisaddr, GetMask(wo->ouraddr)))
1546         return 0;
1547     if (!sifup(u))
1548         return 0;
1549     if (!sifnpmode(u, PPP_IP, NPMODE_QUEUE))
1550         return 0;
1551     if (wo->default_route)
1552         if (sifdefaultroute(u, wo->ouraddr, wo->hisaddr))
1553             default_route_set[u] = 1;
1554     if (wo->proxy_arp)
1555         if (sifproxyarp(u, wo->hisaddr))
1556             proxy_arp_set[u] = 1;
1557
1558     notice("local  IP address %I", wo->ouraddr);
1559     notice("remote IP address %I", wo->hisaddr);
1560
1561     return 1;
1562 }
1563
1564
1565 /*
1566  * ipcp_up - IPCP has come UP.
1567  *
1568  * Configure the IP network interface appropriately and bring it up.
1569  */
1570 static void
1571 ipcp_up(f)
1572     fsm *f;
1573 {
1574     u_int32_t mask;
1575     ipcp_options *ho = &ipcp_hisoptions[f->unit];
1576     ipcp_options *go = &ipcp_gotoptions[f->unit];
1577     ipcp_options *wo = &ipcp_wantoptions[f->unit];
1578
1579     IPCPDEBUG(("ipcp: up"));
1580
1581     /*
1582      * We must have a non-zero IP address for both ends of the link.
1583      */
1584     if (!ho->neg_addr)
1585         ho->hisaddr = wo->hisaddr;
1586
1587     if (go->ouraddr == 0) {
1588         error("Could not determine local IP address");
1589         ipcp_close(f->unit, "Could not determine local IP address");
1590         return;
1591     }
1592     if (ho->hisaddr == 0) {
1593         ho->hisaddr = htonl(0x0a404040 + ifunit);
1594         warn("Could not determine remote IP address: defaulting to %I",
1595              ho->hisaddr);
1596     }
1597     script_setenv("IPLOCAL", ip_ntoa(go->ouraddr), 0);
1598     script_setenv("IPREMOTE", ip_ntoa(ho->hisaddr), 1);
1599
1600     if (usepeerdns && (go->dnsaddr[0] || go->dnsaddr[1])) {
1601         script_setenv("USEPEERDNS", "1", 0);
1602         if (go->dnsaddr[0])
1603             script_setenv("DNS1", ip_ntoa(go->dnsaddr[0]), 0);
1604         if (go->dnsaddr[1])
1605             script_setenv("DNS2", ip_ntoa(go->dnsaddr[1]), 0);
1606         create_resolv(go->dnsaddr[0], go->dnsaddr[1]);
1607     }
1608
1609     /*
1610      * Check that the peer is allowed to use the IP address it wants.
1611      */
1612     if (!auth_ip_addr(f->unit, ho->hisaddr)) {
1613         error("Peer is not authorized to use remote address %I", ho->hisaddr);
1614         ipcp_close(f->unit, "Unauthorized remote IP address");
1615         return;
1616     }
1617
1618     /* set tcp compression */
1619     sifvjcomp(f->unit, ho->neg_vj, ho->cflag, ho->maxslotindex);
1620
1621     /*
1622      * If we are doing dial-on-demand, the interface is already
1623      * configured, so we put out any saved-up packets, then set the
1624      * interface to pass IP packets.
1625      */
1626     if (demand) {
1627         if (go->ouraddr != wo->ouraddr || ho->hisaddr != wo->hisaddr) {
1628             ipcp_clear_addrs(f->unit, wo->ouraddr, wo->hisaddr);
1629             if (go->ouraddr != wo->ouraddr) {
1630                 warn("Local IP address changed to %I", go->ouraddr);
1631                 script_setenv("OLDIPLOCAL", ip_ntoa(wo->ouraddr), 0);
1632                 wo->ouraddr = go->ouraddr;
1633             } else
1634                 script_unsetenv("OLDIPLOCAL");
1635             if (ho->hisaddr != wo->hisaddr) {
1636                 warn("Remote IP address changed to %I", ho->hisaddr);
1637                 script_setenv("OLDIPREMOTE", ip_ntoa(wo->hisaddr), 0);
1638                 wo->hisaddr = ho->hisaddr;
1639             } else
1640                 script_unsetenv("OLDIPREMOTE");
1641
1642             /* Set the interface to the new addresses */
1643             mask = GetMask(go->ouraddr);
1644             if (!sifaddr(f->unit, go->ouraddr, ho->hisaddr, mask)) {
1645                 if (debug)
1646                     warn("Interface configuration failed");
1647                 ipcp_close(f->unit, "Interface configuration failed");
1648                 return;
1649             }
1650
1651             /* assign a default route through the interface if required */
1652             if (ipcp_wantoptions[f->unit].default_route)
1653                 if (sifdefaultroute(f->unit, go->ouraddr, ho->hisaddr))
1654                     default_route_set[f->unit] = 1;
1655
1656             /* Make a proxy ARP entry if requested. */
1657             if (ipcp_wantoptions[f->unit].proxy_arp)
1658                 if (sifproxyarp(f->unit, ho->hisaddr))
1659                     proxy_arp_set[f->unit] = 1;
1660
1661         }
1662         demand_rexmit(PPP_IP);
1663         sifnpmode(f->unit, PPP_IP, NPMODE_PASS);
1664
1665     } else {
1666         /*
1667          * Set IP addresses and (if specified) netmask.
1668          */
1669         mask = GetMask(go->ouraddr);
1670
1671 #if !(defined(SVR4) && (defined(SNI) || defined(__USLC__)))
1672         if (!sifaddr(f->unit, go->ouraddr, ho->hisaddr, mask)) {
1673             if (debug)
1674                 warn("Interface configuration failed");
1675             ipcp_close(f->unit, "Interface configuration failed");
1676             return;
1677         }
1678 #endif
1679
1680         /* bring the interface up for IP */
1681         if (!sifup(f->unit)) {
1682             if (debug)
1683                 warn("Interface failed to come up");
1684             ipcp_close(f->unit, "Interface configuration failed");
1685             return;
1686         }
1687
1688 #if (defined(SVR4) && (defined(SNI) || defined(__USLC__)))
1689         if (!sifaddr(f->unit, go->ouraddr, ho->hisaddr, mask)) {
1690             if (debug)
1691                 warn("Interface configuration failed");
1692             ipcp_close(f->unit, "Interface configuration failed");
1693             return;
1694         }
1695 #endif
1696         sifnpmode(f->unit, PPP_IP, NPMODE_PASS);
1697
1698         /* assign a default route through the interface if required */
1699         if (ipcp_wantoptions[f->unit].default_route)
1700             if (sifdefaultroute(f->unit, go->ouraddr, ho->hisaddr))
1701                 default_route_set[f->unit] = 1;
1702
1703         /* Make a proxy ARP entry if requested. */
1704         if (ipcp_wantoptions[f->unit].proxy_arp)
1705             if (sifproxyarp(f->unit, ho->hisaddr))
1706                 proxy_arp_set[f->unit] = 1;
1707
1708         ipcp_wantoptions[0].ouraddr = go->ouraddr;
1709
1710         notice("local  IP address %I", go->ouraddr);
1711         notice("remote IP address %I", ho->hisaddr);
1712         if (go->dnsaddr[0])
1713             notice("primary   DNS address %I", go->dnsaddr[0]);
1714         if (go->dnsaddr[1])
1715             notice("secondary DNS address %I", go->dnsaddr[1]);
1716     }
1717
1718     np_up(f->unit, PPP_IP);
1719     ipcp_is_up = 1;
1720
1721     notify(ip_up_notifier, 0);
1722     if (ip_up_hook)
1723         ip_up_hook();
1724
1725     /*
1726      * Execute the ip-up script, like this:
1727      *  /etc/ppp/ip-up interface tty speed local-IP remote-IP
1728      */
1729     if (ipcp_script_state == s_down && ipcp_script_pid == 0) {
1730         ipcp_script_state = s_up;
1731         ipcp_script(_PATH_IPUP);
1732     }
1733 }
1734
1735
1736 /*
1737  * ipcp_down - IPCP has gone DOWN.
1738  *
1739  * Take the IP network interface down, clear its addresses
1740  * and delete routes through it.
1741  */
1742 static void
1743 ipcp_down(f)
1744     fsm *f;
1745 {
1746     IPCPDEBUG(("ipcp: down"));
1747     /* XXX a bit IPv4-centric here, we only need to get the stats
1748      * before the interface is marked down. */
1749     update_link_stats(f->unit);
1750     notify(ip_down_notifier, 0);
1751     if (ip_down_hook)
1752         ip_down_hook();
1753     if (ipcp_is_up) {
1754         ipcp_is_up = 0;
1755         np_down(f->unit, PPP_IP);
1756     }
1757     sifvjcomp(f->unit, 0, 0, 0);
1758
1759     /*
1760      * If we are doing dial-on-demand, set the interface
1761      * to queue up outgoing packets (for now).
1762      */
1763     if (demand) {
1764         sifnpmode(f->unit, PPP_IP, NPMODE_QUEUE);
1765     } else {
1766         sifnpmode(f->unit, PPP_IP, NPMODE_DROP);
1767         sifdown(f->unit);
1768         ipcp_clear_addrs(f->unit, ipcp_gotoptions[f->unit].ouraddr,
1769                          ipcp_hisoptions[f->unit].hisaddr);
1770     }
1771
1772     /* Execute the ip-down script */
1773     if (ipcp_script_state == s_up && ipcp_script_pid == 0) {
1774         ipcp_script_state = s_down;
1775         ipcp_script(_PATH_IPDOWN);
1776     }
1777 }
1778
1779
1780 /*
1781  * ipcp_clear_addrs() - clear the interface addresses, routes,
1782  * proxy arp entries, etc.
1783  */
1784 static void
1785 ipcp_clear_addrs(unit, ouraddr, hisaddr)
1786     int unit;
1787     u_int32_t ouraddr;  /* local address */
1788     u_int32_t hisaddr;  /* remote address */
1789 {
1790     if (proxy_arp_set[unit]) {
1791         cifproxyarp(unit, hisaddr);
1792         proxy_arp_set[unit] = 0;
1793     }
1794     if (default_route_set[unit]) {
1795         cifdefaultroute(unit, ouraddr, hisaddr);
1796         default_route_set[unit] = 0;
1797     }
1798     cifaddr(unit, ouraddr, hisaddr);
1799 }
1800
1801
1802 /*
1803  * ipcp_finished - possibly shut down the lower layers.
1804  */
1805 static void
1806 ipcp_finished(f)
1807     fsm *f;
1808 {
1809     np_finished(f->unit, PPP_IP);
1810 }
1811
1812
1813 /*
1814  * ipcp_script_done - called when the ip-up or ip-down script
1815  * has finished.
1816  */
1817 static void
1818 ipcp_script_done(arg)
1819     void *arg;
1820 {
1821     ipcp_script_pid = 0;
1822     switch (ipcp_script_state) {
1823     case s_up:
1824         if (ipcp_fsm[0].state != OPENED) {
1825             ipcp_script_state = s_down;
1826             ipcp_script(_PATH_IPDOWN);
1827         }
1828         break;
1829     case s_down:
1830         if (ipcp_fsm[0].state == OPENED) {
1831             ipcp_script_state = s_up;
1832             ipcp_script(_PATH_IPUP);
1833         }
1834         break;
1835     }
1836 }
1837
1838
1839 /*
1840  * ipcp_script - Execute a script with arguments
1841  * interface-name tty-name speed local-IP remote-IP.
1842  */
1843 static void
1844 ipcp_script(script)
1845     char *script;
1846 {
1847     char strspeed[32], strlocal[32], strremote[32];
1848     char *argv[8];
1849
1850     slprintf(strspeed, sizeof(strspeed), "%d", baud_rate);
1851     slprintf(strlocal, sizeof(strlocal), "%I", ipcp_gotoptions[0].ouraddr);
1852     slprintf(strremote, sizeof(strremote), "%I", ipcp_hisoptions[0].hisaddr);
1853
1854     argv[0] = script;
1855     argv[1] = ifname;
1856     argv[2] = devnam;
1857     argv[3] = strspeed;
1858     argv[4] = strlocal;
1859     argv[5] = strremote;
1860     argv[6] = ipparam;
1861     argv[7] = NULL;
1862     ipcp_script_pid = run_program(script, argv, 0, ipcp_script_done, NULL);
1863 }
1864
1865 /*
1866  * create_resolv - create the replacement resolv.conf file
1867  */
1868 static void
1869 create_resolv(peerdns1, peerdns2)
1870     u_int32_t peerdns1, peerdns2;
1871 {
1872     FILE *f;
1873
1874     f = fopen(_PATH_RESOLV, "w");
1875     if (f == NULL) {
1876         error("Failed to create %s: %m", _PATH_RESOLV);
1877         return;
1878     }
1879
1880     if (peerdns1)
1881         fprintf(f, "nameserver %s\n", ip_ntoa(peerdns1));
1882
1883     if (peerdns2)
1884         fprintf(f, "nameserver %s\n", ip_ntoa(peerdns2));
1885
1886     if (ferror(f))
1887         error("Write failed to %s: %m", _PATH_RESOLV);
1888
1889     fclose(f);
1890 }
1891
1892 /*
1893  * ipcp_printpkt - print the contents of an IPCP packet.
1894  */
1895 static char *ipcp_codenames[] = {
1896     "ConfReq", "ConfAck", "ConfNak", "ConfRej",
1897     "TermReq", "TermAck", "CodeRej"
1898 };
1899
1900 static int
1901 ipcp_printpkt(p, plen, printer, arg)
1902     u_char *p;
1903     int plen;
1904     void (*printer) __P((void *, char *, ...));
1905     void *arg;
1906 {
1907     int code, id, len, olen;
1908     u_char *pstart, *optend;
1909     u_short cishort;
1910     u_int32_t cilong;
1911
1912     if (plen < HEADERLEN)
1913         return 0;
1914     pstart = p;
1915     GETCHAR(code, p);
1916     GETCHAR(id, p);
1917     GETSHORT(len, p);
1918     if (len < HEADERLEN || len > plen)
1919         return 0;
1920
1921     if (code >= 1 && code <= sizeof(ipcp_codenames) / sizeof(char *))
1922         printer(arg, " %s", ipcp_codenames[code-1]);
1923     else
1924         printer(arg, " code=0x%x", code);
1925     printer(arg, " id=0x%x", id);
1926     len -= HEADERLEN;
1927     switch (code) {
1928     case CONFREQ:
1929     case CONFACK:
1930     case CONFNAK:
1931     case CONFREJ:
1932         /* print option list */
1933         while (len >= 2) {
1934             GETCHAR(code, p);
1935             GETCHAR(olen, p);
1936             p -= 2;
1937             if (olen < 2 || olen > len) {
1938                 break;
1939             }
1940             printer(arg, " <");
1941             len -= olen;
1942             optend = p + olen;
1943             switch (code) {
1944             case CI_ADDRS:
1945                 if (olen == CILEN_ADDRS) {
1946                     p += 2;
1947                     GETLONG(cilong, p);
1948                     printer(arg, "addrs %I", htonl(cilong));
1949                     GETLONG(cilong, p);
1950                     printer(arg, " %I", htonl(cilong));
1951                 }
1952                 break;
1953             case CI_COMPRESSTYPE:
1954                 if (olen >= CILEN_COMPRESS) {
1955                     p += 2;
1956                     GETSHORT(cishort, p);
1957                     printer(arg, "compress ");
1958                     switch (cishort) {
1959                     case IPCP_VJ_COMP:
1960                         printer(arg, "VJ");
1961                         break;
1962                     case IPCP_VJ_COMP_OLD:
1963                         printer(arg, "old-VJ");
1964                         break;
1965                     default:
1966                         printer(arg, "0x%x", cishort);
1967                     }
1968                 }
1969                 break;
1970             case CI_ADDR:
1971                 if (olen == CILEN_ADDR) {
1972                     p += 2;
1973                     GETLONG(cilong, p);
1974                     printer(arg, "addr %I", htonl(cilong));
1975                 }
1976                 break;
1977             case CI_MS_DNS1:
1978             case CI_MS_DNS2:
1979                 p += 2;
1980                 GETLONG(cilong, p);
1981                 printer(arg, "ms-dns%d %I", code - CI_MS_DNS1 + 1,
1982                         htonl(cilong));
1983                 break;
1984             case CI_MS_WINS1:
1985             case CI_MS_WINS2:
1986                 p += 2;
1987                 GETLONG(cilong, p);
1988                 printer(arg, "ms-wins %I", htonl(cilong));
1989                 break;
1990             }
1991             while (p < optend) {
1992                 GETCHAR(code, p);
1993                 printer(arg, " %.2x", code);
1994             }
1995             printer(arg, ">");
1996         }
1997         break;
1998
1999     case TERMACK:
2000     case TERMREQ:
2001         if (len > 0 && *p >= ' ' && *p < 0x7f) {
2002             printer(arg, " ");
2003             print_string((char *)p, len, printer, arg);
2004             p += len;
2005             len = 0;
2006         }
2007         break;
2008     }
2009
2010     /* print the rest of the bytes in the packet */
2011     for (; len > 0; --len) {
2012         GETCHAR(code, p);
2013         printer(arg, " %.2x", code);
2014     }
2015
2016     return p - pstart;
2017 }
2018
2019 /*
2020  * ip_active_pkt - see if this IP packet is worth bringing the link up for.
2021  * We don't bring the link up for IP fragments or for TCP FIN packets
2022  * with no data.
2023  */
2024 #define IP_HDRLEN       20      /* bytes */
2025 #define IP_OFFMASK      0x1fff
2026 #ifndef IPPROTO_TCP
2027 #define IPPROTO_TCP     6
2028 #endif
2029 #define TCP_HDRLEN      20
2030 #define TH_FIN          0x01
2031
2032 /*
2033  * We use these macros because the IP header may be at an odd address,
2034  * and some compilers might use word loads to get th_off or ip_hl.
2035  */
2036
2037 #define net_short(x)    (((x)[0] << 8) + (x)[1])
2038 #define get_iphl(x)     (((unsigned char *)(x))[0] & 0xF)
2039 #define get_ipoff(x)    net_short((unsigned char *)(x) + 6)
2040 #define get_ipproto(x)  (((unsigned char *)(x))[9])
2041 #define get_tcpoff(x)   (((unsigned char *)(x))[12] >> 4)
2042 #define get_tcpflags(x) (((unsigned char *)(x))[13])
2043
2044 static int
2045 ip_active_pkt(pkt, len)
2046     u_char *pkt;
2047     int len;
2048 {
2049     u_char *tcp;
2050     int hlen;
2051
2052     len -= PPP_HDRLEN;
2053     pkt += PPP_HDRLEN;
2054     if (len < IP_HDRLEN)
2055         return 0;
2056     if ((get_ipoff(pkt) & IP_OFFMASK) != 0)
2057         return 0;
2058     if (get_ipproto(pkt) != IPPROTO_TCP)
2059         return 1;
2060     hlen = get_iphl(pkt) * 4;
2061     if (len < hlen + TCP_HDRLEN)
2062         return 0;
2063     tcp = pkt + hlen;
2064     if ((get_tcpflags(tcp) & TH_FIN) != 0 && len == hlen + get_tcpoff(tcp) * 4)
2065         return 0;
2066     return 1;
2067 }