pppd/lcp.c

   1 /*
   2  * lcp.c - PPP Link 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: lcp.c,v 1.56 2001/02/22 03:16:26 paulus Exp $"
  21
  22 /*
  23  * TODO:
  24  */
  25
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <stdlib.h>
  29
  30 #include "pppd.h"
  31 #include "fsm.h"
  32 #include "lcp.h"
  33 #include "chap.h"
  34 #include "magic.h"
  35
  36 static const char rcsid[] = RCSID;
  37
  38 /*
  39  * When the link comes up we want to be able to wait for a short while,
  40  * or until seeing some input from the peer, before starting to send
  41  * configure-requests.  We do this by delaying the fsm_lowerup call.
  42  */
  43 /* steal a bit in fsm flags word */
  44 #define DELAYED_UP      0x100
  45
  46 static void lcp_delayed_up __P((void *));
  47
  48 /*
  49  * LCP-related command-line options.
  50  */
  51 int     lcp_echo_interval = 0;  /* Interval between LCP echo-requests */
  52 int     lcp_echo_fails = 0;     /* Tolerance to unanswered echo-requests */
  53 bool    lax_recv = 0;           /* accept control chars in asyncmap */
  54 bool    noendpoint = 0;         /* don't send/accept endpoint discriminator */
  55
  56 static int noopt __P((char **));
  57 static int setescape __P((char **));
  58
  59 #ifdef HAVE_MULTILINK
  60 static int setendpoint __P((char **));
  61 #endif /* HAVE_MULTILINK */
  62
  63 static option_t lcp_option_list[] = {
  64     /* LCP options */
  65     { "-all", o_special_noarg, (void *)noopt,
  66       "Don't request/allow any LCP options" },
  67     { "noaccomp", o_bool, &lcp_wantoptions[0].neg_accompression,
  68       "Disable address/control compression",
  69       OPT_A2COPY, &lcp_allowoptions[0].neg_accompression },
  70     { "-ac", o_bool, &lcp_wantoptions[0].neg_accompression,
  71       "Disable address/control compression",
  72       OPT_A2COPY, &lcp_allowoptions[0].neg_accompression },
  73     { "default-asyncmap", o_bool, &lcp_wantoptions[0].neg_asyncmap,
  74       "Disable asyncmap negotiation",
  75       OPT_A2COPY, &lcp_allowoptions[0].neg_asyncmap },
  76     { "-am", o_bool, &lcp_wantoptions[0].neg_asyncmap,
  77       "Disable asyncmap negotiation",
  78       OPT_A2COPY, &lcp_allowoptions[0].neg_asyncmap },
  79     { "asyncmap", o_uint32, &lcp_wantoptions[0].asyncmap,
  80       "Set asyncmap (for received packets)",
  81       OPT_OR, &lcp_wantoptions[0].neg_asyncmap },
  82     { "-as", o_uint32, &lcp_wantoptions[0].asyncmap,
  83       "Set asyncmap (for received packets)",
  84       OPT_OR, &lcp_wantoptions[0].neg_asyncmap },
  85     { "nomagic", o_bool, &lcp_wantoptions[0].neg_magicnumber,
  86       "Disable magic number negotiation (looped-back line detection)",
  87       OPT_A2COPY, &lcp_allowoptions[0].neg_magicnumber },
  88     { "-mn", o_bool, &lcp_wantoptions[0].neg_magicnumber,
  89       "Disable magic number negotiation (looped-back line detection)",
  90       OPT_A2COPY, &lcp_allowoptions[0].neg_magicnumber },
  91     { "default-mru", o_bool, &lcp_wantoptions[0].neg_mru,
  92       "Disable MRU negotiation (use default 1500)",
  93       OPT_A2COPY, &lcp_allowoptions[0].neg_mru },
  94     { "-mru", o_bool, &lcp_wantoptions[0].neg_mru,
  95       "Disable MRU negotiation (use default 1500)",
  96       OPT_A2COPY, &lcp_allowoptions[0].neg_mru },
  97     { "mru", o_int, &lcp_wantoptions[0].mru,
  98       "Set MRU (maximum received packet size) for negotiation",
  99       0, &lcp_wantoptions[0].neg_mru },
 100     { "mtu", o_int, &lcp_allowoptions[0].mru,
 101       "Set our MTU", OPT_LIMITS, NULL, MAXMRU, MINMRU },
 102     { "nopcomp", o_bool, &lcp_wantoptions[0].neg_pcompression,
 103       "Disable protocol field compression",
 104       OPT_A2COPY, &lcp_allowoptions[0].neg_pcompression },
 105     { "-pc", o_bool, &lcp_wantoptions[0].neg_pcompression,
 106       "Disable protocol field compression",
 107       OPT_A2COPY, &lcp_allowoptions[0].neg_pcompression },
 108     { "-p", o_bool, &lcp_wantoptions[0].passive,
 109       "Set passive mode", 1 },
 110     { "passive", o_bool, &lcp_wantoptions[0].passive,
 111       "Set passive mode", 1 },
 112     { "silent", o_bool, &lcp_wantoptions[0].silent,
 113       "Set silent mode", 1 },
 114     { "escape", o_special, (void *)setescape,
 115       "List of character codes to escape on transmission" },
 116     { "lcp-echo-failure", o_int, &lcp_echo_fails,
 117       "Set number of consecutive echo failures to indicate link failure" },
 118     { "lcp-echo-interval", o_int, &lcp_echo_interval,
 119       "Set time in seconds between LCP echo requests" },
 120     { "lcp-restart", o_int, &lcp_fsm[0].timeouttime,
 121       "Set time in seconds between LCP retransmissions" },
 122     { "lcp-max-terminate", o_int, &lcp_fsm[0].maxtermtransmits,
 123       "Set maximum number of LCP terminate-request transmissions" },
 124     { "lcp-max-configure", o_int, &lcp_fsm[0].maxconfreqtransmits,
 125       "Set maximum number of LCP configure-request transmissions" },
 126     { "lcp-max-failure", o_int, &lcp_fsm[0].maxnakloops,
 127       "Set limit on number of LCP configure-naks" },
 128     { "receive-all", o_bool, &lax_recv,
 129       "Accept all received control characters", 1 },
 130 #ifdef HAVE_MULTILINK
 131     { "mrru", o_int, &lcp_wantoptions[0].mrru,
 132       "Maximum received packet size for multilink bundle",
 133       0, &lcp_wantoptions[0].neg_mrru },
 134     { "mpshortseq", o_bool, &lcp_wantoptions[0].neg_ssnhf,
 135       "Use short sequence numbers in multilink headers",
 136       OPT_A2COPY | 1, &lcp_allowoptions[0].neg_ssnhf },
 137     { "nompshortseq", o_bool, &lcp_wantoptions[0].neg_ssnhf,
 138       "Don't use short sequence numbers in multilink headers",
 139       OPT_A2COPY, &lcp_allowoptions[0].neg_ssnhf },
 140     { "endpoint", o_special, setendpoint,
 141       "Endpoint discriminator for multilink" },
 142 #endif /* HAVE_MULTILINK */
 143     { "noendpoint", o_bool, &noendpoint,
 144       "Don't send or accept multilink endpoint discriminator", 1 },
 145     {NULL}
 146 };
 147
 148 /* global vars */
 149 fsm lcp_fsm[NUM_PPP];                   /* LCP fsm structure (global)*/
 150 lcp_options lcp_wantoptions[NUM_PPP];   /* Options that we want to request */
 151 lcp_options lcp_gotoptions[NUM_PPP];    /* Options that peer ack'd */
 152 lcp_options lcp_allowoptions[NUM_PPP];  /* Options we allow peer to request */
 153 lcp_options lcp_hisoptions[NUM_PPP];    /* Options that we ack'd */
 154 u_int32_t xmit_accm[NUM_PPP][8];        /* extended transmit ACCM */
 155
 156 static int lcp_echos_pending = 0;       /* Number of outstanding echo msgs */
 157 static int lcp_echo_number   = 0;       /* ID number of next echo frame */
 158 static int lcp_echo_timer_running = 0;  /* set if a timer is running */
 159
 160 static u_char nak_buffer[PPP_MRU];      /* where we construct a nak packet */
 161
 162 /*
 163  * Callbacks for fsm code.  (CI = Configuration Information)
 164  */
 165 static void lcp_resetci __P((fsm *));   /* Reset our CI */
 166 static int  lcp_cilen __P((fsm *));             /* Return length of our CI */
 167 static void lcp_addci __P((fsm *, u_char *, int *)); /* Add our CI to pkt */
 168 static int  lcp_ackci __P((fsm *, u_char *, int)); /* Peer ack'd our CI */
 169 static int  lcp_nakci __P((fsm *, u_char *, int)); /* Peer nak'd our CI */
 170 static int  lcp_rejci __P((fsm *, u_char *, int)); /* Peer rej'd our CI */
 171 static int  lcp_reqci __P((fsm *, u_char *, int *, int)); /* Rcv peer CI */
 172 static void lcp_up __P((fsm *));                /* We're UP */
 173 static void lcp_down __P((fsm *));              /* We're DOWN */
 174 static void lcp_starting __P((fsm *));  /* We need lower layer up */
 175 static void lcp_finished __P((fsm *));  /* We need lower layer down */
 176 static int  lcp_extcode __P((fsm *, int, int, u_char *, int));
 177 static void lcp_rprotrej __P((fsm *, u_char *, int));
 178
 179 /*
 180  * routines to send LCP echos to peer
 181  */
 182
 183 static void lcp_echo_lowerup __P((int));
 184 static void lcp_echo_lowerdown __P((int));
 185 static void LcpEchoTimeout __P((void *));
 186 static void lcp_received_echo_reply __P((fsm *, int, u_char *, int));
 187 static void LcpSendEchoRequest __P((fsm *));
 188 static void LcpLinkFailure __P((fsm *));
 189 static void LcpEchoCheck __P((fsm *));
 190
 191 static fsm_callbacks lcp_callbacks = {  /* LCP callback routines */
 192     lcp_resetci,                /* Reset our Configuration Information */
 193     lcp_cilen,                  /* Length of our Configuration Information */
 194     lcp_addci,                  /* Add our Configuration Information */
 195     lcp_ackci,                  /* ACK our Configuration Information */
 196     lcp_nakci,                  /* NAK our Configuration Information */
 197     lcp_rejci,                  /* Reject our Configuration Information */
 198     lcp_reqci,                  /* Request peer's Configuration Information */
 199     lcp_up,                     /* Called when fsm reaches OPENED state */
 200     lcp_down,                   /* Called when fsm leaves OPENED state */
 201     lcp_starting,               /* Called when we want the lower layer up */
 202     lcp_finished,               /* Called when we want the lower layer down */
 203     NULL,                       /* Called when Protocol-Reject received */
 204     NULL,                       /* Retransmission is necessary */
 205     lcp_extcode,                /* Called to handle LCP-specific codes */
 206     "LCP"                       /* String name of protocol */
 207 };
 208
 209 /*
 210  * Protocol entry points.
 211  * Some of these are called directly.
 212  */
 213
 214 static void lcp_init __P((int));
 215 static void lcp_input __P((int, u_char *, int));
 216 static void lcp_protrej __P((int));
 217 static int  lcp_printpkt __P((u_char *, int,
 218                               void (*) __P((void *, char *, ...)), void *));
 219
 220 struct protent lcp_protent = {
 221     PPP_LCP,
 222     lcp_init,
 223     lcp_input,
 224     lcp_protrej,
 225     lcp_lowerup,
 226     lcp_lowerdown,
 227     lcp_open,
 228     lcp_close,
 229     lcp_printpkt,
 230     NULL,
 231     1,
 232     "LCP",
 233     NULL,
 234     lcp_option_list,
 235     NULL,
 236     NULL,
 237     NULL
 238 };
 239
 240 int lcp_loopbackfail = DEFLOOPBACKFAIL;
 241
 242 /*
 243  * Length of each type of configuration option (in octets)
 244  */
 245 #define CILEN_VOID      2
 246 #define CILEN_CHAR      3
 247 #define CILEN_SHORT     4       /* CILEN_VOID + 2 */
 248 #define CILEN_CHAP      5       /* CILEN_VOID + 2 + 1 */
 249 #define CILEN_LONG      6       /* CILEN_VOID + 4 */
 250 #define CILEN_LQR       8       /* CILEN_VOID + 2 + 4 */
 251 #define CILEN_CBCP      3
 252
 253 #define CODENAME(x)     ((x) == CONFACK ? "ACK" : \
 254                          (x) == CONFNAK ? "NAK" : "REJ")
 255
 256 /*
 257  * noopt - Disable all options (why?).
 258  */
 259 static int
 260 noopt(argv)
 261     char **argv;
 262 {
 263     BZERO((char *) &lcp_wantoptions[0], sizeof (struct lcp_options));
 264     BZERO((char *) &lcp_allowoptions[0], sizeof (struct lcp_options));
 265
 266     return (1);
 267 }
 268
 269 /*
 270  * setescape - add chars to the set we escape on transmission.
 271  */
 272 static int
 273 setescape(argv)
 274     char **argv;
 275 {
 276     int n, ret;
 277     char *p, *endp;
 278
 279     p = *argv;
 280     ret = 1;
 281     while (*p) {
 282         n = strtol(p, &endp, 16);
 283         if (p == endp) {
 284             option_error("escape parameter contains invalid hex number '%s'",
 285                          p);
 286             return 0;
 287         }
 288         p = endp;
 289         if (n < 0 || n == 0x5E || n > 0xFF) {
 290             option_error("can't escape character 0x%x", n);
 291             ret = 0;
 292         } else
 293             xmit_accm[0][n >> 5] |= 1 << (n & 0x1F);
 294         while (*p == ',' || *p == ' ')
 295             ++p;
 296     }
 297     return ret;
 298 }
 299
 300 #ifdef HAVE_MULTILINK
 301 static int
 302 setendpoint(argv)
 303     char **argv;
 304 {
 305     if (str_to_epdisc(&lcp_wantoptions[0].endpoint, *argv)) {
 306         lcp_wantoptions[0].neg_endpoint = 1;
 307         return 1;
 308     }
 309     option_error("Can't parse '%s' as an endpoint discriminator", *argv);
 310     return 0;
 311 }
 312 #endif /* HAVE_MULTILINK */
 313
 314 /*
 315  * lcp_init - Initialize LCP.
 316  */
 317 static void
 318 lcp_init(unit)
 319     int unit;
 320 {
 321     fsm *f = &lcp_fsm[unit];
 322     lcp_options *wo = &lcp_wantoptions[unit];
 323     lcp_options *ao = &lcp_allowoptions[unit];
 324
 325     f->unit = unit;
 326     f->protocol = PPP_LCP;
 327     f->callbacks = &lcp_callbacks;
 328
 329     fsm_init(f);
 330
 331     BZERO(wo, sizeof(*wo));
 332     wo->neg_mru = 1;
 333     wo->mru = DEFMRU;
 334     wo->neg_asyncmap = 1;
 335     wo->chap_mdtype = CHAP_DIGEST_MD5;
 336     wo->neg_magicnumber = 1;
 337     wo->neg_pcompression = 1;
 338     wo->neg_accompression = 1;
 339
 340     BZERO(ao, sizeof(*ao));
 341     ao->neg_mru = 1;
 342     ao->mru = MAXMRU;
 343     ao->neg_asyncmap = 1;
 344     ao->neg_chap = 1;
 345     ao->chap_mdtype = CHAP_DIGEST_MD5;
 346     ao->neg_upap = 1;
 347     ao->neg_magicnumber = 1;
 348     ao->neg_pcompression = 1;
 349     ao->neg_accompression = 1;
 350 #ifdef CBCP_SUPPORT
 351     ao->neg_cbcp = 1;
 352 #endif
 353     ao->neg_endpoint = 1;
 354
 355     BZERO(xmit_accm[unit], sizeof(xmit_accm[0]));
 356     xmit_accm[unit][3] = 0x60000000;
 357 }
 358
 359
 360 /*
 361  * lcp_open - LCP is allowed to come up.
 362  */
 363 void
 364 lcp_open(unit)
 365     int unit;
 366 {
 367     fsm *f = &lcp_fsm[unit];
 368     lcp_options *wo = &lcp_wantoptions[unit];
 369
 370     f->flags &= ~(OPT_PASSIVE | OPT_SILENT);
 371     if (wo->passive)
 372         f->flags |= OPT_PASSIVE;
 373     if (wo->silent)
 374         f->flags |= OPT_SILENT;
 375     fsm_open(f);
 376 }
 377
 378
 379 /*
 380  * lcp_close - Take LCP down.
 381  */
 382 void
 383 lcp_close(unit, reason)
 384     int unit;
 385     char *reason;
 386 {
 387     fsm *f = &lcp_fsm[unit];
 388
 389     if (phase != PHASE_DEAD)
 390         new_phase(PHASE_TERMINATE);
 391     if (f->state == STOPPED && f->flags & (OPT_PASSIVE|OPT_SILENT)) {
 392         /*
 393          * This action is not strictly according to the FSM in RFC1548,
 394          * but it does mean that the program terminates if you do a
 395          * lcp_close() in passive/silent mode when a connection hasn't
 396          * been established.
 397          */
 398         f->state = CLOSED;
 399         lcp_finished(f);
 400
 401     } else
 402         fsm_close(&lcp_fsm[unit], reason);
 403 }
 404
 405
 406 /*
 407  * lcp_lowerup - The lower layer is up.
 408  */
 409 void
 410 lcp_lowerup(unit)
 411     int unit;
 412 {
 413     lcp_options *wo = &lcp_wantoptions[unit];
 414     fsm *f = &lcp_fsm[unit];
 415
 416     /*
 417      * Don't use A/C or protocol compression on transmission,
 418      * but accept A/C and protocol compressed packets
 419      * if we are going to ask for A/C and protocol compression.
 420      */
 421     ppp_set_xaccm(unit, xmit_accm[unit]);
 422     ppp_send_config(unit, PPP_MRU, 0xffffffff, 0, 0);
 423     ppp_recv_config(unit, PPP_MRU, (lax_recv? 0: 0xffffffff),
 424                     wo->neg_pcompression, wo->neg_accompression);
 425     peer_mru[unit] = PPP_MRU;
 426     lcp_allowoptions[unit].asyncmap = xmit_accm[unit][0];
 427
 428     if (listen_time != 0) {
 429         f->flags |= DELAYED_UP;
 430         timeout(lcp_delayed_up, f, 0, listen_time * 1000);
 431     } else
 432         fsm_lowerup(f);
 433 }
 434
 435
 436 /*
 437  * lcp_lowerdown - The lower layer is down.
 438  */
 439 void
 440 lcp_lowerdown(unit)
 441     int unit;
 442 {
 443     fsm *f = &lcp_fsm[unit];
 444
 445     if (f->flags & DELAYED_UP)
 446         f->flags &= ~DELAYED_UP;
 447     else
 448         fsm_lowerdown(&lcp_fsm[unit]);
 449 }
 450
 451
 452 /*
 453  * lcp_delayed_up - Bring the lower layer up now.
 454  */
 455 static void
 456 lcp_delayed_up(arg)
 457     void *arg;
 458 {
 459     fsm *f = arg;
 460
 461     if (f->flags & DELAYED_UP) {
 462         f->flags &= ~DELAYED_UP;
 463         fsm_lowerup(f);
 464     }
 465 }
 466
 467
 468 /*
 469  * lcp_input - Input LCP packet.
 470  */
 471 static void
 472 lcp_input(unit, p, len)
 473     int unit;
 474     u_char *p;
 475     int len;
 476 {
 477     fsm *f = &lcp_fsm[unit];
 478
 479     if (f->flags & DELAYED_UP) {
 480         f->flags &= ~DELAYED_UP;
 481         fsm_lowerup(f);
 482     }
 483     fsm_input(f, p, len);
 484 }
 485
 486
 487 /*
 488  * lcp_extcode - Handle a LCP-specific code.
 489  */
 490 static int
 491 lcp_extcode(f, code, id, inp, len)
 492     fsm *f;
 493     int code, id;
 494     u_char *inp;
 495     int len;
 496 {
 497     u_char *magp;
 498
 499     switch( code ){
 500     case PROTREJ:
 501         lcp_rprotrej(f, inp, len);
 502         break;
 503
 504     case ECHOREQ:
 505         if (f->state != OPENED)
 506             break;
 507         magp = inp;
 508         PUTLONG(lcp_gotoptions[f->unit].magicnumber, magp);
 509         fsm_sdata(f, ECHOREP, id, inp, len);
 510         break;
 511
 512     case ECHOREP:
 513         lcp_received_echo_reply(f, id, inp, len);
 514         break;
 515
 516     case DISCREQ:
 517         break;
 518
 519     default:
 520         return 0;
 521     }
 522     return 1;
 523 }
 524
 525
 526 /*
 527  * lcp_rprotrej - Receive an Protocol-Reject.
 528  *
 529  * Figure out which protocol is rejected and inform it.
 530  */
 531 static void
 532 lcp_rprotrej(f, inp, len)
 533     fsm *f;
 534     u_char *inp;
 535     int len;
 536 {
 537     int i;
 538     struct protent *protp;
 539     u_short prot;
 540
 541     if (len < 2) {
 542         LCPDEBUG(("lcp_rprotrej: Rcvd short Protocol-Reject packet!"));
 543         return;
 544     }
 545
 546     GETSHORT(prot, inp);
 547
 548     /*
 549      * Protocol-Reject packets received in any state other than the LCP
 550      * OPENED state SHOULD be silently discarded.
 551      */
 552     if( f->state != OPENED ){
 553         LCPDEBUG(("Protocol-Reject discarded: LCP in state %d", f->state));
 554         return;
 555     }
 556
 557     /*
 558      * Upcall the proper Protocol-Reject routine.
 559      */
 560     for (i = 0; (protp = protocols[i]) != NULL; ++i)
 561         if (protp->protocol == prot && protp->enabled_flag) {
 562             (*protp->protrej)(f->unit);
 563             return;
 564         }
 565
 566     warn("Protocol-Reject for unsupported protocol 0x%x", prot);
 567 }
 568
 569
 570 /*
 571  * lcp_protrej - A Protocol-Reject was received.
 572  */
 573 /*ARGSUSED*/
 574 static void
 575 lcp_protrej(unit)
 576     int unit;
 577 {
 578     /*
 579      * Can't reject LCP!
 580      */
 581     error("Received Protocol-Reject for LCP!");
 582     fsm_protreject(&lcp_fsm[unit]);
 583 }
 584
 585
 586 /*
 587  * lcp_sprotrej - Send a Protocol-Reject for some protocol.
 588  */
 589 void
 590 lcp_sprotrej(unit, p, len)
 591     int unit;
 592     u_char *p;
 593     int len;
 594 {
 595     /*
 596      * Send back the protocol and the information field of the
 597      * rejected packet.  We only get here if LCP is in the OPENED state.
 598      */
 599     p += 2;
 600     len -= 2;
 601
 602     fsm_sdata(&lcp_fsm[unit], PROTREJ, ++lcp_fsm[unit].id,
 603               p, len);
 604 }
 605
 606
 607 /*
 608  * lcp_resetci - Reset our CI.
 609  */
 610 static void
 611 lcp_resetci(f)
 612     fsm *f;
 613 {
 614     lcp_options *wo = &lcp_wantoptions[f->unit];
 615     lcp_options *go = &lcp_gotoptions[f->unit];
 616     lcp_options *ao = &lcp_allowoptions[f->unit];
 617
 618     wo->magicnumber = magic();
 619     wo->numloops = 0;
 620     *go = *wo;
 621     if (!multilink) {
 622         go->neg_mrru = 0;
 623         go->neg_ssnhf = 0;
 624         go->neg_endpoint = 0;
 625     }
 626     if (noendpoint)
 627         ao->neg_endpoint = 0;
 628     peer_mru[f->unit] = PPP_MRU;
 629     auth_reset(f->unit);
 630 }
 631
 632
 633 /*
 634  * lcp_cilen - Return length of our CI.
 635  */
 636 static int
 637 lcp_cilen(f)
 638     fsm *f;
 639 {
 640     lcp_options *go = &lcp_gotoptions[f->unit];
 641
 642 #define LENCIVOID(neg)  ((neg) ? CILEN_VOID : 0)
 643 #define LENCICHAP(neg)  ((neg) ? CILEN_CHAP : 0)
 644 #define LENCISHORT(neg) ((neg) ? CILEN_SHORT : 0)
 645 #define LENCILONG(neg)  ((neg) ? CILEN_LONG : 0)
 646 #define LENCILQR(neg)   ((neg) ? CILEN_LQR: 0)
 647 #define LENCICBCP(neg)  ((neg) ? CILEN_CBCP: 0)
 648     /*
 649      * NB: we only ask for one of CHAP and UPAP, even if we will
 650      * accept either.
 651      */
 652     return (LENCISHORT(go->neg_mru && go->mru != DEFMRU) +
 653             LENCILONG(go->neg_asyncmap && go->asyncmap != 0xFFFFFFFF) +
 654             LENCICHAP(go->neg_chap) +
 655             LENCISHORT(!go->neg_chap && go->neg_upap) +
 656             LENCILQR(go->neg_lqr) +
 657             LENCICBCP(go->neg_cbcp) +
 658             LENCILONG(go->neg_magicnumber) +
 659             LENCIVOID(go->neg_pcompression) +
 660             LENCIVOID(go->neg_accompression) +
 661             LENCISHORT(go->neg_mrru) +
 662             LENCIVOID(go->neg_ssnhf) +
 663             (go->neg_endpoint? CILEN_CHAR + go->endpoint.length: 0));
 664 }
 665
 666
 667 /*
 668  * lcp_addci - Add our desired CIs to a packet.
 669  */
 670 static void
 671 lcp_addci(f, ucp, lenp)
 672     fsm *f;
 673     u_char *ucp;
 674     int *lenp;
 675 {
 676     lcp_options *go = &lcp_gotoptions[f->unit];
 677     u_char *start_ucp = ucp;
 678
 679 #define ADDCIVOID(opt, neg) \
 680     if (neg) { \
 681         PUTCHAR(opt, ucp); \
 682         PUTCHAR(CILEN_VOID, ucp); \
 683     }
 684 #define ADDCISHORT(opt, neg, val) \
 685     if (neg) { \
 686         PUTCHAR(opt, ucp); \
 687         PUTCHAR(CILEN_SHORT, ucp); \
 688         PUTSHORT(val, ucp); \
 689     }
 690 #define ADDCICHAP(opt, neg, val, digest) \
 691     if (neg) { \
 692         PUTCHAR(opt, ucp); \
 693         PUTCHAR(CILEN_CHAP, ucp); \
 694         PUTSHORT(val, ucp); \
 695         PUTCHAR(digest, ucp); \
 696     }
 697 #define ADDCILONG(opt, neg, val) \
 698     if (neg) { \
 699         PUTCHAR(opt, ucp); \
 700         PUTCHAR(CILEN_LONG, ucp); \
 701         PUTLONG(val, ucp); \
 702     }
 703 #define ADDCILQR(opt, neg, val) \
 704     if (neg) { \
 705         PUTCHAR(opt, ucp); \
 706         PUTCHAR(CILEN_LQR, ucp); \
 707         PUTSHORT(PPP_LQR, ucp); \
 708         PUTLONG(val, ucp); \
 709     }
 710 #define ADDCICHAR(opt, neg, val) \
 711     if (neg) { \
 712         PUTCHAR(opt, ucp); \
 713         PUTCHAR(CILEN_CHAR, ucp); \
 714         PUTCHAR(val, ucp); \
 715     }
 716 #define ADDCIENDP(opt, neg, class, val, len) \
 717     if (neg) { \
 718         int i; \
 719         PUTCHAR(opt, ucp); \
 720         PUTCHAR(CILEN_CHAR + len, ucp); \
 721         PUTCHAR(class, ucp); \
 722         for (i = 0; i < len; ++i) \
 723             PUTCHAR(val[i], ucp); \
 724     }
 725
 726     ADDCISHORT(CI_MRU, go->neg_mru && go->mru != DEFMRU, go->mru);
 727     ADDCILONG(CI_ASYNCMAP, go->neg_asyncmap && go->asyncmap != 0xFFFFFFFF,
 728               go->asyncmap);
 729     ADDCICHAP(CI_AUTHTYPE, go->neg_chap, PPP_CHAP, go->chap_mdtype);
 730     ADDCISHORT(CI_AUTHTYPE, !go->neg_chap && go->neg_upap, PPP_PAP);
 731     ADDCILQR(CI_QUALITY, go->neg_lqr, go->lqr_period);
 732     ADDCICHAR(CI_CALLBACK, go->neg_cbcp, CBCP_OPT);
 733     ADDCILONG(CI_MAGICNUMBER, go->neg_magicnumber, go->magicnumber);
 734     ADDCIVOID(CI_PCOMPRESSION, go->neg_pcompression);
 735     ADDCIVOID(CI_ACCOMPRESSION, go->neg_accompression);
 736     ADDCISHORT(CI_MRRU, go->neg_mrru, go->mrru);
 737     ADDCIVOID(CI_SSNHF, go->neg_ssnhf);
 738     ADDCIENDP(CI_EPDISC, go->neg_endpoint, go->endpoint.class,
 739               go->endpoint.value, go->endpoint.length);
 740
 741     if (ucp - start_ucp != *lenp) {
 742         /* this should never happen, because peer_mtu should be 1500 */
 743         error("Bug in lcp_addci: wrong length");
 744     }
 745 }
 746
 747
 748 /*
 749  * lcp_ackci - Ack our CIs.
 750  * This should not modify any state if the Ack is bad.
 751  *
 752  * Returns:
 753  *      0 - Ack was bad.
 754  *      1 - Ack was good.
 755  */
 756 static int
 757 lcp_ackci(f, p, len)
 758     fsm *f;
 759     u_char *p;
 760     int len;
 761 {
 762     lcp_options *go = &lcp_gotoptions[f->unit];
 763     u_char cilen, citype, cichar;
 764     u_short cishort;
 765     u_int32_t cilong;
 766
 767     /*
 768      * CIs must be in exactly the same order that we sent.
 769      * Check packet length and CI length at each step.
 770      * If we find any deviations, then this packet is bad.
 771      */
 772 #define ACKCIVOID(opt, neg) \
 773     if (neg) { \
 774         if ((len -= CILEN_VOID) < 0) \
 775             goto bad; \
 776         GETCHAR(citype, p); \
 777         GETCHAR(cilen, p); \
 778         if (cilen != CILEN_VOID || \
 779             citype != opt) \
 780             goto bad; \
 781     }
 782 #define ACKCISHORT(opt, neg, val) \
 783     if (neg) { \
 784         if ((len -= CILEN_SHORT) < 0) \
 785             goto bad; \
 786         GETCHAR(citype, p); \
 787         GETCHAR(cilen, p); \
 788         if (cilen != CILEN_SHORT || \
 789             citype != opt) \
 790             goto bad; \
 791         GETSHORT(cishort, p); \
 792         if (cishort != val) \
 793             goto bad; \
 794     }
 795 #define ACKCICHAR(opt, neg, val) \
 796     if (neg) { \
 797         if ((len -= CILEN_CHAR) < 0) \
 798             goto bad; \
 799         GETCHAR(citype, p); \
 800         GETCHAR(cilen, p); \
 801         if (cilen != CILEN_CHAR || \
 802             citype != opt) \
 803             goto bad; \
 804         GETCHAR(cichar, p); \
 805         if (cichar != val) \
 806             goto bad; \
 807     }
 808 #define ACKCICHAP(opt, neg, val, digest) \
 809     if (neg) { \
 810         if ((len -= CILEN_CHAP) < 0) \
 811             goto bad; \
 812         GETCHAR(citype, p); \
 813         GETCHAR(cilen, p); \
 814         if (cilen != CILEN_CHAP || \
 815             citype != opt) \
 816             goto bad; \
 817         GETSHORT(cishort, p); \
 818         if (cishort != val) \
 819             goto bad; \
 820         GETCHAR(cichar, p); \
 821         if (cichar != digest) \
 822           goto bad; \
 823     }
 824 #define ACKCILONG(opt, neg, val) \
 825     if (neg) { \
 826         if ((len -= CILEN_LONG) < 0) \
 827             goto bad; \
 828         GETCHAR(citype, p); \
 829         GETCHAR(cilen, p); \
 830         if (cilen != CILEN_LONG || \
 831             citype != opt) \
 832             goto bad; \
 833         GETLONG(cilong, p); \
 834         if (cilong != val) \
 835             goto bad; \
 836     }
 837 #define ACKCILQR(opt, neg, val) \
 838     if (neg) { \
 839         if ((len -= CILEN_LQR) < 0) \
 840             goto bad; \
 841         GETCHAR(citype, p); \
 842         GETCHAR(cilen, p); \
 843         if (cilen != CILEN_LQR || \
 844             citype != opt) \
 845             goto bad; \
 846         GETSHORT(cishort, p); \
 847         if (cishort != PPP_LQR) \
 848             goto bad; \
 849         GETLONG(cilong, p); \
 850         if (cilong != val) \
 851           goto bad; \
 852     }
 853 #define ACKCIENDP(opt, neg, class, val, vlen) \
 854     if (neg) { \
 855         int i; \
 856         if ((len -= CILEN_CHAR + vlen) < 0) \
 857             goto bad; \
 858         GETCHAR(citype, p); \
 859         GETCHAR(cilen, p); \
 860         if (cilen != CILEN_CHAR + vlen || \
 861             citype != opt) \
 862             goto bad; \
 863         GETCHAR(cichar, p); \
 864         if (cichar != class) \
 865             goto bad; \
 866         for (i = 0; i < vlen; ++i) { \
 867             GETCHAR(cichar, p); \
 868             if (cichar != val[i]) \
 869                 goto bad; \
 870         } \
 871     }
 872
 873     ACKCISHORT(CI_MRU, go->neg_mru && go->mru != DEFMRU, go->mru);
 874     ACKCILONG(CI_ASYNCMAP, go->neg_asyncmap && go->asyncmap != 0xFFFFFFFF,
 875               go->asyncmap);
 876     ACKCICHAP(CI_AUTHTYPE, go->neg_chap, PPP_CHAP, go->chap_mdtype);
 877     ACKCISHORT(CI_AUTHTYPE, !go->neg_chap && go->neg_upap, PPP_PAP);
 878     ACKCILQR(CI_QUALITY, go->neg_lqr, go->lqr_period);
 879     ACKCICHAR(CI_CALLBACK, go->neg_cbcp, CBCP_OPT);
 880     ACKCILONG(CI_MAGICNUMBER, go->neg_magicnumber, go->magicnumber);
 881     ACKCIVOID(CI_PCOMPRESSION, go->neg_pcompression);
 882     ACKCIVOID(CI_ACCOMPRESSION, go->neg_accompression);
 883     ACKCISHORT(CI_MRRU, go->neg_mrru, go->mrru);
 884     ACKCIVOID(CI_SSNHF, go->neg_ssnhf);
 885     ACKCIENDP(CI_EPDISC, go->neg_endpoint, go->endpoint.class,
 886               go->endpoint.value, go->endpoint.length);
 887
 888     /*
 889      * If there are any remaining CIs, then this packet is bad.
 890      */
 891     if (len != 0)
 892         goto bad;
 893     return (1);
 894 bad:
 895     LCPDEBUG(("lcp_acki: received bad Ack!"));
 896     return (0);
 897 }
 898
 899
 900 /*
 901  * lcp_nakci - Peer has sent a NAK for some of our CIs.
 902  * This should not modify any state if the Nak is bad
 903  * or if LCP is in the OPENED state.
 904  *
 905  * Returns:
 906  *      0 - Nak was bad.
 907  *      1 - Nak was good.
 908  */
 909 static int
 910 lcp_nakci(f, p, len)
 911     fsm *f;
 912     u_char *p;
 913     int len;
 914 {
 915     lcp_options *go = &lcp_gotoptions[f->unit];
 916     lcp_options *wo = &lcp_wantoptions[f->unit];
 917     u_char citype, cichar, *next;
 918     u_short cishort;
 919     u_int32_t cilong;
 920     lcp_options no;             /* options we've seen Naks for */
 921     lcp_options try;            /* options to request next time */
 922     int looped_back = 0;
 923     int cilen;
 924
 925     BZERO(&no, sizeof(no));
 926     try = *go;
 927
 928     /*
 929      * Any Nak'd CIs must be in exactly the same order that we sent.
 930      * Check packet length and CI length at each step.
 931      * If we find any deviations, then this packet is bad.
 932      */
 933 #define NAKCIVOID(opt, neg) \
 934     if (go->neg && \
 935         len >= CILEN_VOID && \
 936         p[1] == CILEN_VOID && \
 937         p[0] == opt) { \
 938         len -= CILEN_VOID; \
 939         INCPTR(CILEN_VOID, p); \
 940         no.neg = 1; \
 941         try.neg = 0; \
 942     }
 943 #define NAKCICHAP(opt, neg, code) \
 944     if (go->neg && \
 945         len >= CILEN_CHAP && \
 946         p[1] == CILEN_CHAP && \
 947         p[0] == opt) { \
 948         len -= CILEN_CHAP; \
 949         INCPTR(2, p); \
 950         GETSHORT(cishort, p); \
 951         GETCHAR(cichar, p); \
 952         no.neg = 1; \
 953         code \
 954     }
 955 #define NAKCICHAR(opt, neg, code) \
 956     if (go->neg && \
 957         len >= CILEN_CHAR && \
 958         p[1] == CILEN_CHAR && \
 959         p[0] == opt) { \
 960         len -= CILEN_CHAR; \
 961         INCPTR(2, p); \
 962         GETCHAR(cichar, p); \
 963         no.neg = 1; \
 964         code \
 965     }
 966 #define NAKCISHORT(opt, neg, code) \
 967     if (go->neg && \
 968         len >= CILEN_SHORT && \
 969         p[1] == CILEN_SHORT && \
 970         p[0] == opt) { \
 971         len -= CILEN_SHORT; \
 972         INCPTR(2, p); \
 973         GETSHORT(cishort, p); \
 974         no.neg = 1; \
 975         code \
 976     }
 977 #define NAKCILONG(opt, neg, code) \
 978     if (go->neg && \
 979         len >= CILEN_LONG && \
 980         p[1] == CILEN_LONG && \
 981         p[0] == opt) { \
 982         len -= CILEN_LONG; \
 983         INCPTR(2, p); \
 984         GETLONG(cilong, p); \
 985         no.neg = 1; \
 986         code \
 987     }
 988 #define NAKCILQR(opt, neg, code) \
 989     if (go->neg && \
 990         len >= CILEN_LQR && \
 991         p[1] == CILEN_LQR && \
 992         p[0] == opt) { \
 993         len -= CILEN_LQR; \
 994         INCPTR(2, p); \
 995         GETSHORT(cishort, p); \
 996         GETLONG(cilong, p); \
 997         no.neg = 1; \
 998         code \
 999     }
1000 #define NAKCIENDP(opt, neg) \
1001     if (go->neg && \
1002         len >= CILEN_CHAR && \
1003         p[0] == opt && \
1004         p[1] >= CILEN_CHAR && \
1005         p[1] <= len) { \
1006         len -= p[1]; \
1007         INCPTR(p[1], p); \
1008         no.neg = 1; \
1009         try.neg = 0; \
1010     }
1011
1012     /*
1013      * We don't care if they want to send us smaller packets than
1014      * we want.  Therefore, accept any MRU less than what we asked for,
1015      * but then ignore the new value when setting the MRU in the kernel.
1016      * If they send us a bigger MRU than what we asked, accept it, up to
1017      * the limit of the default MRU we'd get if we didn't negotiate.
1018      */
1019     if (go->neg_mru && go->mru != DEFMRU) {
1020         NAKCISHORT(CI_MRU, neg_mru,
1021                    if (cishort <= wo->mru || cishort <= DEFMRU)
1022                        try.mru = cishort;
1023                    );
1024     }
1025
1026     /*
1027      * Add any characters they want to our (receive-side) asyncmap.
1028      */
1029     if (go->neg_asyncmap && go->asyncmap != 0xFFFFFFFF) {
1030         NAKCILONG(CI_ASYNCMAP, neg_asyncmap,
1031                   try.asyncmap = go->asyncmap | cilong;
1032                   );
1033     }
1034
1035     /*
1036      * If they've nak'd our authentication-protocol, check whether
1037      * they are proposing a different protocol, or a different
1038      * hash algorithm for CHAP.
1039      */
1040     if ((go->neg_chap || go->neg_upap)
1041         && len >= CILEN_SHORT
1042         && p[0] == CI_AUTHTYPE && p[1] >= CILEN_SHORT && p[1] <= len) {
1043         cilen = p[1];
1044         len -= cilen;
1045         no.neg_chap = go->neg_chap;
1046         no.neg_upap = go->neg_upap;
1047         INCPTR(2, p);
1048         GETSHORT(cishort, p);
1049         if (cishort == PPP_PAP && cilen == CILEN_SHORT) {
1050             /*
1051              * If we were asking for CHAP, they obviously don't want to do it.
1052              * If we weren't asking for CHAP, then we were asking for PAP,
1053              * in which case this Nak is bad.
1054              */
1055             if (!go->neg_chap)
1056                 goto bad;
1057             try.neg_chap = 0;
1058
1059         } else if (cishort == PPP_CHAP && cilen == CILEN_CHAP) {
1060             GETCHAR(cichar, p);
1061             if (go->neg_chap) {
1062                 /*
1063                  * We were asking for CHAP/MD5; they must want a different
1064                  * algorithm.  If they can't do MD5, we can ask for M$-CHAP
1065                  * if we support it, otherwise we'll have to stop
1066                  * asking for CHAP.
1067                  */
1068                 if (cichar != go->chap_mdtype) {
1069 #ifdef CHAPMS
1070                     if (cichar == CHAP_MICROSOFT)
1071                         go->chap_mdtype = CHAP_MICROSOFT;
1072                     else
1073 #endif /* CHAPMS */
1074                         try.neg_chap = 0;
1075                 }
1076             } else {
1077                 /*
1078                  * Stop asking for PAP if we were asking for it.
1079                  */
1080                 try.neg_upap = 0;
1081             }
1082
1083         } else {
1084             /*
1085              * We don't recognize what they're suggesting.
1086              * Stop asking for what we were asking for.
1087              */
1088             if (go->neg_chap)
1089                 try.neg_chap = 0;
1090             else
1091                 try.neg_upap = 0;
1092             p += cilen - CILEN_SHORT;
1093         }
1094     }
1095
1096     /*
1097      * If they can't cope with our link quality protocol, we'll have
1098      * to stop asking for LQR.  We haven't got any other protocol.
1099      * If they Nak the reporting period, take their value XXX ?
1100      */
1101     NAKCILQR(CI_QUALITY, neg_lqr,
1102              if (cishort != PPP_LQR)
1103                  try.neg_lqr = 0;
1104              else
1105                  try.lqr_period = cilong;
1106              );
1107
1108     /*
1109      * Only implementing CBCP...not the rest of the callback options
1110      */
1111     NAKCICHAR(CI_CALLBACK, neg_cbcp,
1112               try.neg_cbcp = 0;
1113               );
1114
1115     /*
1116      * Check for a looped-back line.
1117      */
1118     NAKCILONG(CI_MAGICNUMBER, neg_magicnumber,
1119               try.magicnumber = magic();
1120               looped_back = 1;
1121               );
1122
1123     /*
1124      * Peer shouldn't send Nak for protocol compression or
1125      * address/control compression requests; they should send
1126      * a Reject instead.  If they send a Nak, treat it as a Reject.
1127      */
1128     NAKCIVOID(CI_PCOMPRESSION, neg_pcompression);
1129     NAKCIVOID(CI_ACCOMPRESSION, neg_accompression);
1130
1131     /*
1132      * Nak for MRRU option - accept their value if it is smaller
1133      * than the one we want.
1134      */
1135     if (go->neg_mrru) {
1136         NAKCISHORT(CI_MRRU, neg_mrru,
1137                    if (cishort <= wo->mrru)
1138                        try.mrru = cishort;
1139                    );
1140     }
1141
1142     /*
1143      * Nak for short sequence numbers shouldn't be sent, treat it
1144      * like a reject.
1145      */
1146     NAKCIVOID(CI_SSNHF, neg_ssnhf);
1147
1148     /*
1149      * Nak of the endpoint discriminator option is not permitted,
1150      * treat it like a reject.
1151      */
1152     NAKCIENDP(CI_EPDISC, neg_endpoint);
1153
1154     /*
1155      * There may be remaining CIs, if the peer is requesting negotiation
1156      * on an option that we didn't include in our request packet.
1157      * If we see an option that we requested, or one we've already seen
1158      * in this packet, then this packet is bad.
1159      * If we wanted to respond by starting to negotiate on the requested
1160      * option(s), we could, but we don't, because except for the
1161      * authentication type and quality protocol, if we are not negotiating
1162      * an option, it is because we were told not to.
1163      * For the authentication type, the Nak from the peer means
1164      * `let me authenticate myself with you' which is a bit pointless.
1165      * For the quality protocol, the Nak means `ask me to send you quality
1166      * reports', but if we didn't ask for them, we don't want them.
1167      * An option we don't recognize represents the peer asking to
1168      * negotiate some option we don't support, so ignore it.
1169      */
1170     while (len > CILEN_VOID) {
1171         GETCHAR(citype, p);
1172         GETCHAR(cilen, p);
1173         if (cilen < CILEN_VOID || (len -= cilen) < 0)
1174             goto bad;
1175         next = p + cilen - 2;
1176
1177         switch (citype) {
1178         case CI_MRU:
1179             if ((go->neg_mru && go->mru != DEFMRU)
1180                 || no.neg_mru || cilen != CILEN_SHORT)
1181                 goto bad;
1182             GETSHORT(cishort, p);
1183             if (cishort < DEFMRU) {
1184                 try.neg_mru = 1;
1185                 try.mru = cishort;
1186             }
1187             break;
1188         case CI_ASYNCMAP:
1189             if ((go->neg_asyncmap && go->asyncmap != 0xFFFFFFFF)
1190                 || no.neg_asyncmap || cilen != CILEN_LONG)
1191                 goto bad;
1192             break;
1193         case CI_AUTHTYPE:
1194             if (go->neg_chap || no.neg_chap || go->neg_upap || no.neg_upap)
1195                 goto bad;
1196             break;
1197         case CI_MAGICNUMBER:
1198             if (go->neg_magicnumber || no.neg_magicnumber ||
1199                 cilen != CILEN_LONG)
1200                 goto bad;
1201             break;
1202         case CI_PCOMPRESSION:
1203             if (go->neg_pcompression || no.neg_pcompression
1204                 || cilen != CILEN_VOID)
1205                 goto bad;
1206             break;
1207         case CI_ACCOMPRESSION:
1208             if (go->neg_accompression || no.neg_accompression
1209                 || cilen != CILEN_VOID)
1210                 goto bad;
1211             break;
1212         case CI_QUALITY:
1213             if (go->neg_lqr || no.neg_lqr || cilen != CILEN_LQR)
1214                 goto bad;
1215             break;
1216         case CI_MRRU:
1217             if (go->neg_mrru || no.neg_mrru || cilen != CILEN_SHORT)
1218                 goto bad;
1219             break;
1220         case CI_SSNHF:
1221             if (go->neg_ssnhf || no.neg_ssnhf || cilen != CILEN_VOID)
1222                 goto bad;
1223             try.neg_ssnhf = 1;
1224             break;
1225         case CI_EPDISC:
1226             if (go->neg_endpoint || no.neg_endpoint || cilen < CILEN_CHAR)
1227                 goto bad;
1228             break;
1229         }
1230         p = next;
1231     }
1232
1233     /*
1234      * OK, the Nak is good.  Now we can update state.
1235      * If there are any options left we ignore them.
1236      */
1237     if (f->state != OPENED) {
1238         if (looped_back) {
1239             if (++try.numloops >= lcp_loopbackfail) {
1240                 notice("Serial line is looped back.");
1241                 lcp_close(f->unit, "Loopback detected");
1242                 status = EXIT_LOOPBACK;
1243             }
1244         } else
1245             try.numloops = 0;
1246         *go = try;
1247     }
1248
1249     return 1;
1250
1251 bad:
1252     LCPDEBUG(("lcp_nakci: received bad Nak!"));
1253     return 0;
1254 }
1255
1256
1257 /*
1258  * lcp_rejci - Peer has Rejected some of our CIs.
1259  * This should not modify any state if the Reject is bad
1260  * or if LCP is in the OPENED state.
1261  *
1262  * Returns:
1263  *      0 - Reject was bad.
1264  *      1 - Reject was good.
1265  */
1266 static int
1267 lcp_rejci(f, p, len)
1268     fsm *f;
1269     u_char *p;
1270     int len;
1271 {
1272     lcp_options *go = &lcp_gotoptions[f->unit];
1273     u_char cichar;
1274     u_short cishort;
1275     u_int32_t cilong;
1276     lcp_options try;            /* options to request next time */
1277
1278     try = *go;
1279
1280     /*
1281      * Any Rejected CIs must be in exactly the same order that we sent.
1282      * Check packet length and CI length at each step.
1283      * If we find any deviations, then this packet is bad.
1284      */
1285 #define REJCIVOID(opt, neg) \
1286     if (go->neg && \
1287         len >= CILEN_VOID && \
1288         p[1] == CILEN_VOID && \
1289         p[0] == opt) { \
1290         len -= CILEN_VOID; \
1291         INCPTR(CILEN_VOID, p); \
1292         try.neg = 0; \
1293     }
1294 #define REJCISHORT(opt, neg, val) \
1295     if (go->neg && \
1296         len >= CILEN_SHORT && \
1297         p[1] == CILEN_SHORT && \
1298         p[0] == opt) { \
1299         len -= CILEN_SHORT; \
1300         INCPTR(2, p); \
1301         GETSHORT(cishort, p); \
1302         /* Check rejected value. */ \
1303         if (cishort != val) \
1304             goto bad; \
1305         try.neg = 0; \
1306     }
1307 #define REJCICHAP(opt, neg, val, digest) \
1308     if (go->neg && \
1309         len >= CILEN_CHAP && \
1310         p[1] == CILEN_CHAP && \
1311         p[0] == opt) { \
1312         len -= CILEN_CHAP; \
1313         INCPTR(2, p); \
1314         GETSHORT(cishort, p); \
1315         GETCHAR(cichar, p); \
1316         /* Check rejected value. */ \
1317         if (cishort != val || cichar != digest) \
1318             goto bad; \
1319         try.neg = 0; \
1320         try.neg_upap = 0; \
1321     }
1322 #define REJCILONG(opt, neg, val) \
1323     if (go->neg && \
1324         len >= CILEN_LONG && \
1325         p[1] == CILEN_LONG && \
1326         p[0] == opt) { \
1327         len -= CILEN_LONG; \
1328         INCPTR(2, p); \
1329         GETLONG(cilong, p); \
1330         /* Check rejected value. */ \
1331         if (cilong != val) \
1332             goto bad; \
1333         try.neg = 0; \
1334     }
1335 #define REJCILQR(opt, neg, val) \
1336     if (go->neg && \
1337         len >= CILEN_LQR && \
1338         p[1] == CILEN_LQR && \
1339         p[0] == opt) { \
1340         len -= CILEN_LQR; \
1341         INCPTR(2, p); \
1342         GETSHORT(cishort, p); \
1343         GETLONG(cilong, p); \
1344         /* Check rejected value. */ \
1345         if (cishort != PPP_LQR || cilong != val) \
1346             goto bad; \
1347         try.neg = 0; \
1348     }
1349 #define REJCICBCP(opt, neg, val) \
1350     if (go->neg && \
1351         len >= CILEN_CBCP && \
1352         p[1] == CILEN_CBCP && \
1353         p[0] == opt) { \
1354         len -= CILEN_CBCP; \
1355         INCPTR(2, p); \
1356         GETCHAR(cichar, p); \
1357         /* Check rejected value. */ \
1358         if (cichar != val) \
1359             goto bad; \
1360         try.neg = 0; \
1361     }
1362 #define REJCIENDP(opt, neg, class, val, vlen) \
1363     if (go->neg && \
1364         len >= CILEN_CHAR + vlen && \
1365         p[0] == opt && \
1366         p[1] == CILEN_CHAR + vlen) { \
1367         int i; \
1368         len -= CILEN_CHAR + vlen; \
1369         INCPTR(2, p); \
1370         GETCHAR(cichar, p); \
1371         if (cichar != class) \
1372             goto bad; \
1373         for (i = 0; i < vlen; ++i) { \
1374             GETCHAR(cichar, p); \
1375             if (cichar != val[i]) \
1376                 goto bad; \
1377         } \
1378         try.neg = 0; \
1379     }
1380
1381     REJCISHORT(CI_MRU, neg_mru, go->mru);
1382     REJCILONG(CI_ASYNCMAP, neg_asyncmap, go->asyncmap);
1383     REJCICHAP(CI_AUTHTYPE, neg_chap, PPP_CHAP, go->chap_mdtype);
1384     if (!go->neg_chap) {
1385         REJCISHORT(CI_AUTHTYPE, neg_upap, PPP_PAP);
1386     }
1387     REJCILQR(CI_QUALITY, neg_lqr, go->lqr_period);
1388     REJCICBCP(CI_CALLBACK, neg_cbcp, CBCP_OPT);
1389     REJCILONG(CI_MAGICNUMBER, neg_magicnumber, go->magicnumber);
1390     REJCIVOID(CI_PCOMPRESSION, neg_pcompression);
1391     REJCIVOID(CI_ACCOMPRESSION, neg_accompression);
1392     REJCISHORT(CI_MRRU, neg_mrru, go->mrru);
1393     REJCIVOID(CI_SSNHF, neg_ssnhf);
1394     REJCIENDP(CI_EPDISC, neg_endpoint, go->endpoint.class,
1395               go->endpoint.value, go->endpoint.length);
1396
1397     /*
1398      * If there are any remaining CIs, then this packet is bad.
1399      */
1400     if (len != 0)
1401         goto bad;
1402     /*
1403      * Now we can update state.
1404      */
1405     if (f->state != OPENED)
1406         *go = try;
1407     return 1;
1408
1409 bad:
1410     LCPDEBUG(("lcp_rejci: received bad Reject!"));
1411     return 0;
1412 }
1413
1414
1415 /*
1416  * lcp_reqci - Check the peer's requested CIs and send appropriate response.
1417  *
1418  * Returns: CONFACK, CONFNAK or CONFREJ and input packet modified
1419  * appropriately.  If reject_if_disagree is non-zero, doesn't return
1420  * CONFNAK; returns CONFREJ if it can't return CONFACK.
1421  */
1422 static int
1423 lcp_reqci(f, inp, lenp, reject_if_disagree)
1424     fsm *f;
1425     u_char *inp;                /* Requested CIs */
1426     int *lenp;                  /* Length of requested CIs */
1427     int reject_if_disagree;
1428 {
1429     lcp_options *go = &lcp_gotoptions[f->unit];
1430     lcp_options *ho = &lcp_hisoptions[f->unit];
1431     lcp_options *ao = &lcp_allowoptions[f->unit];
1432     u_char *cip, *next;         /* Pointer to current and next CIs */
1433     int cilen, citype, cichar;  /* Parsed len, type, char value */
1434     u_short cishort;            /* Parsed short value */
1435     u_int32_t cilong;           /* Parse long value */
1436     int rc = CONFACK;           /* Final packet return code */
1437     int orc;                    /* Individual option return code */
1438     u_char *p;                  /* Pointer to next char to parse */
1439     u_char *rejp;               /* Pointer to next char in reject frame */
1440     u_char *nakp;               /* Pointer to next char in Nak frame */
1441     int l = *lenp;              /* Length left */
1442
1443     /*
1444      * Reset all his options.
1445      */
1446     BZERO(ho, sizeof(*ho));
1447
1448     /*
1449      * Process all his options.
1450      */
1451     next = inp;
1452     nakp = nak_buffer;
1453     rejp = inp;
1454     while (l) {
1455         orc = CONFACK;                  /* Assume success */
1456         cip = p = next;                 /* Remember begining of CI */
1457         if (l < 2 ||                    /* Not enough data for CI header or */
1458             p[1] < 2 ||                 /*  CI length too small or */
1459             p[1] > l) {                 /*  CI length too big? */
1460             LCPDEBUG(("lcp_reqci: bad CI length!"));
1461             orc = CONFREJ;              /* Reject bad CI */
1462             cilen = l;                  /* Reject till end of packet */
1463             l = 0;                      /* Don't loop again */
1464             citype = 0;
1465             goto endswitch;
1466         }
1467         GETCHAR(citype, p);             /* Parse CI type */
1468         GETCHAR(cilen, p);              /* Parse CI length */
1469         l -= cilen;                     /* Adjust remaining length */
1470         next += cilen;                  /* Step to next CI */
1471
1472         switch (citype) {               /* Check CI type */
1473         case CI_MRU:
1474             if (!ao->neg_mru ||         /* Allow option? */
1475                 cilen != CILEN_SHORT) { /* Check CI length */
1476                 orc = CONFREJ;          /* Reject CI */
1477                 break;
1478             }
1479             GETSHORT(cishort, p);       /* Parse MRU */
1480
1481             /*
1482              * He must be able to receive at least our minimum.
1483              * No need to check a maximum.  If he sends a large number,
1484              * we'll just ignore it.
1485              */
1486             if (cishort < MINMRU) {
1487                 orc = CONFNAK;          /* Nak CI */
1488                 PUTCHAR(CI_MRU, nakp);
1489                 PUTCHAR(CILEN_SHORT, nakp);
1490                 PUTSHORT(MINMRU, nakp); /* Give him a hint */
1491                 break;
1492             }
1493             ho->neg_mru = 1;            /* Remember he sent MRU */
1494             ho->mru = cishort;          /* And remember value */
1495             break;
1496
1497         case CI_ASYNCMAP:
1498             if (!ao->neg_asyncmap ||
1499                 cilen != CILEN_LONG) {
1500                 orc = CONFREJ;
1501                 break;
1502             }
1503             GETLONG(cilong, p);
1504
1505             /*
1506              * Asyncmap must have set at least the bits
1507              * which are set in lcp_allowoptions[unit].asyncmap.
1508              */
1509             if ((ao->asyncmap & ~cilong) != 0) {
1510                 orc = CONFNAK;
1511                 PUTCHAR(CI_ASYNCMAP, nakp);
1512                 PUTCHAR(CILEN_LONG, nakp);
1513                 PUTLONG(ao->asyncmap | cilong, nakp);
1514                 break;
1515             }
1516             ho->neg_asyncmap = 1;
1517             ho->asyncmap = cilong;
1518             break;
1519
1520         case CI_AUTHTYPE:
1521             if (cilen < CILEN_SHORT ||
1522                 !(ao->neg_upap || ao->neg_chap)) {
1523                 /*
1524                  * Reject the option if we're not willing to authenticate.
1525                  */
1526                 orc = CONFREJ;
1527                 break;
1528             }
1529             GETSHORT(cishort, p);
1530
1531             /*
1532              * Authtype must be PAP or CHAP.
1533              *
1534              * Note: if both ao->neg_upap and ao->neg_chap are set,
1535              * and the peer sends a Configure-Request with two
1536              * authenticate-protocol requests, one for CHAP and one
1537              * for UPAP, then we will reject the second request.
1538              * Whether we end up doing CHAP or UPAP depends then on
1539              * the ordering of the CIs in the peer's Configure-Request.
1540              */
1541
1542             if (cishort == PPP_PAP) {
1543                 if (ho->neg_chap ||     /* we've already accepted CHAP */
1544                     cilen != CILEN_SHORT) {
1545                     LCPDEBUG(("lcp_reqci: rcvd AUTHTYPE PAP, rejecting..."));
1546                     orc = CONFREJ;
1547                     break;
1548                 }
1549                 if (!ao->neg_upap) {    /* we don't want to do PAP */
1550                     orc = CONFNAK;      /* NAK it and suggest CHAP */
1551                     PUTCHAR(CI_AUTHTYPE, nakp);
1552                     PUTCHAR(CILEN_CHAP, nakp);
1553                     PUTSHORT(PPP_CHAP, nakp);
1554                     PUTCHAR(ao->chap_mdtype, nakp);
1555                     /* XXX if we can do CHAP_MICROSOFT as well, we should
1556                        probably put in another option saying so */
1557                     break;
1558                 }
1559                 ho->neg_upap = 1;
1560                 break;
1561             }
1562             if (cishort == PPP_CHAP) {
1563                 if (ho->neg_upap ||     /* we've already accepted PAP */
1564                     cilen != CILEN_CHAP) {
1565                     LCPDEBUG(("lcp_reqci: rcvd AUTHTYPE CHAP, rejecting..."));
1566                     orc = CONFREJ;
1567                     break;
1568                 }
1569                 if (!ao->neg_chap) {    /* we don't want to do CHAP */
1570                     orc = CONFNAK;      /* NAK it and suggest PAP */
1571                     PUTCHAR(CI_AUTHTYPE, nakp);
1572                     PUTCHAR(CILEN_SHORT, nakp);
1573                     PUTSHORT(PPP_PAP, nakp);
1574                     break;
1575                 }
1576                 GETCHAR(cichar, p);     /* get digest type*/
1577                 if (cichar != CHAP_DIGEST_MD5
1578 #ifdef CHAPMS
1579                     && cichar != CHAP_MICROSOFT
1580 #endif
1581                     ) {
1582                     orc = CONFNAK;
1583                     PUTCHAR(CI_AUTHTYPE, nakp);
1584                     PUTCHAR(CILEN_CHAP, nakp);
1585                     PUTSHORT(PPP_CHAP, nakp);
1586                     PUTCHAR(ao->chap_mdtype, nakp);
1587                     break;
1588                 }
1589                 ho->chap_mdtype = cichar; /* save md type */
1590                 ho->neg_chap = 1;
1591                 break;
1592             }
1593
1594             /*
1595              * We don't recognize the protocol they're asking for.
1596              * Nak it with something we're willing to do.
1597              * (At this point we know ao->neg_upap || ao->neg_chap.)
1598              */
1599             orc = CONFNAK;
1600             PUTCHAR(CI_AUTHTYPE, nakp);
1601             if (ao->neg_chap) {
1602                 PUTCHAR(CILEN_CHAP, nakp);
1603                 PUTSHORT(PPP_CHAP, nakp);
1604                 PUTCHAR(ao->chap_mdtype, nakp);
1605             } else {
1606                 PUTCHAR(CILEN_SHORT, nakp);
1607                 PUTSHORT(PPP_PAP, nakp);
1608             }
1609             break;
1610
1611         case CI_QUALITY:
1612             if (!ao->neg_lqr ||
1613                 cilen != CILEN_LQR) {
1614                 orc = CONFREJ;
1615                 break;
1616             }
1617
1618             GETSHORT(cishort, p);
1619             GETLONG(cilong, p);
1620
1621             /*
1622              * Check the protocol and the reporting period.
1623              * XXX When should we Nak this, and what with?
1624              */
1625             if (cishort != PPP_LQR) {
1626                 orc = CONFNAK;
1627                 PUTCHAR(CI_QUALITY, nakp);
1628                 PUTCHAR(CILEN_LQR, nakp);
1629                 PUTSHORT(PPP_LQR, nakp);
1630                 PUTLONG(ao->lqr_period, nakp);
1631                 break;
1632             }
1633             break;
1634
1635         case CI_MAGICNUMBER:
1636             if (!(ao->neg_magicnumber || go->neg_magicnumber) ||
1637                 cilen != CILEN_LONG) {
1638                 orc = CONFREJ;
1639                 break;
1640             }
1641             GETLONG(cilong, p);
1642
1643             /*
1644              * He must have a different magic number.
1645              */
1646             if (go->neg_magicnumber &&
1647                 cilong == go->magicnumber) {
1648                 cilong = magic();       /* Don't put magic() inside macro! */
1649                 orc = CONFNAK;
1650                 PUTCHAR(CI_MAGICNUMBER, nakp);
1651                 PUTCHAR(CILEN_LONG, nakp);
1652                 PUTLONG(cilong, nakp);
1653                 break;
1654             }
1655             ho->neg_magicnumber = 1;
1656             ho->magicnumber = cilong;
1657             break;
1658
1659
1660         case CI_PCOMPRESSION:
1661             if (!ao->neg_pcompression ||
1662                 cilen != CILEN_VOID) {
1663                 orc = CONFREJ;
1664                 break;
1665             }
1666             ho->neg_pcompression = 1;
1667             break;
1668
1669         case CI_ACCOMPRESSION:
1670             if (!ao->neg_accompression ||
1671                 cilen != CILEN_VOID) {
1672                 orc = CONFREJ;
1673                 break;
1674             }
1675             ho->neg_accompression = 1;
1676             break;
1677
1678         case CI_MRRU:
1679             if (!ao->neg_mrru || !multilink ||
1680                 cilen != CILEN_SHORT) {
1681                 orc = CONFREJ;
1682                 break;
1683             }
1684
1685             GETSHORT(cishort, p);
1686             /* possibly should insist on a minimum/maximum MRRU here */
1687             ho->neg_mrru = 1;
1688             ho->mrru = cishort;
1689             break;
1690
1691         case CI_SSNHF:
1692             if (!ao->neg_ssnhf || !multilink ||
1693                 cilen != CILEN_VOID) {
1694                 orc = CONFREJ;
1695                 break;
1696             }
1697             ho->neg_ssnhf = 1;
1698             break;
1699
1700         case CI_EPDISC:
1701             if (!ao->neg_endpoint ||
1702                 cilen < CILEN_CHAR ||
1703                 cilen > CILEN_CHAR + MAX_ENDP_LEN) {
1704                 orc = CONFREJ;
1705                 break;
1706             }
1707             GETCHAR(cichar, p);
1708             cilen -= CILEN_CHAR;
1709             ho->neg_endpoint = 1;
1710             ho->endpoint.class = cichar;
1711             ho->endpoint.length = cilen;
1712             BCOPY(p, ho->endpoint.value, cilen);
1713             INCPTR(cilen, p);
1714             break;
1715
1716         default:
1717             LCPDEBUG(("lcp_reqci: rcvd unknown option %d", citype));
1718             orc = CONFREJ;
1719             break;
1720         }
1721
1722 endswitch:
1723         if (orc == CONFACK &&           /* Good CI */
1724             rc != CONFACK)              /*  but prior CI wasnt? */
1725             continue;                   /* Don't send this one */
1726
1727         if (orc == CONFNAK) {           /* Nak this CI? */
1728             if (reject_if_disagree      /* Getting fed up with sending NAKs? */
1729                 && citype != CI_MAGICNUMBER) {
1730                 orc = CONFREJ;          /* Get tough if so */
1731             } else {
1732                 if (rc == CONFREJ)      /* Rejecting prior CI? */
1733                     continue;           /* Don't send this one */
1734                 rc = CONFNAK;
1735             }
1736         }
1737         if (orc == CONFREJ) {           /* Reject this CI */
1738             rc = CONFREJ;
1739             if (cip != rejp)            /* Need to move rejected CI? */
1740                 BCOPY(cip, rejp, cilen); /* Move it */
1741             INCPTR(cilen, rejp);        /* Update output pointer */
1742         }
1743     }
1744
1745     /*
1746      * If we wanted to send additional NAKs (for unsent CIs), the
1747      * code would go here.  The extra NAKs would go at *nakp.
1748      * At present there are no cases where we want to ask the
1749      * peer to negotiate an option.
1750      */
1751
1752     switch (rc) {
1753     case CONFACK:
1754         *lenp = next - inp;
1755         break;
1756     case CONFNAK:
1757         /*
1758          * Copy the Nak'd options from the nak_buffer to the caller's buffer.
1759          */
1760         *lenp = nakp - nak_buffer;
1761         BCOPY(nak_buffer, inp, *lenp);
1762         break;
1763     case CONFREJ:
1764         *lenp = rejp - inp;
1765         break;
1766     }
1767
1768     LCPDEBUG(("lcp_reqci: returning CONF%s.", CODENAME(rc)));
1769     return (rc);                        /* Return final code */
1770 }
1771
1772
1773 /*
1774  * lcp_up - LCP has come UP.
1775  */
1776 static void
1777 lcp_up(f)
1778     fsm *f;
1779 {
1780     lcp_options *wo = &lcp_wantoptions[f->unit];
1781     lcp_options *ho = &lcp_hisoptions[f->unit];
1782     lcp_options *go = &lcp_gotoptions[f->unit];
1783     lcp_options *ao = &lcp_allowoptions[f->unit];
1784
1785     if (!go->neg_magicnumber)
1786         go->magicnumber = 0;
1787     if (!ho->neg_magicnumber)
1788         ho->magicnumber = 0;
1789
1790     /*
1791      * Set our MTU to the smaller of the MTU we wanted and
1792      * the MRU our peer wanted.  If we negotiated an MRU,
1793      * set our MRU to the larger of value we wanted and
1794      * the value we got in the negotiation.
1795      */
1796     ppp_send_config(f->unit, MIN(ao->mru, (ho->neg_mru? ho->mru: PPP_MRU)),
1797                     (ho->neg_asyncmap? ho->asyncmap: 0xffffffff),
1798                     ho->neg_pcompression, ho->neg_accompression);
1799     ppp_recv_config(f->unit, (go->neg_mru? MAX(wo->mru, go->mru): PPP_MRU),
1800                     (lax_recv? 0: go->neg_asyncmap? go->asyncmap: 0xffffffff),
1801                     go->neg_pcompression, go->neg_accompression);
1802
1803     if (ho->neg_mru)
1804         peer_mru[f->unit] = ho->mru;
1805
1806     lcp_echo_lowerup(f->unit);  /* Enable echo messages */
1807
1808     link_established(f->unit);
1809 }
1810
1811
1812 /*
1813  * lcp_down - LCP has gone DOWN.
1814  *
1815  * Alert other protocols.
1816  */
1817 static void
1818 lcp_down(f)
1819     fsm *f;
1820 {
1821     lcp_options *go = &lcp_gotoptions[f->unit];
1822
1823     lcp_echo_lowerdown(f->unit);
1824
1825     link_down(f->unit);
1826
1827     ppp_send_config(f->unit, PPP_MRU, 0xffffffff, 0, 0);
1828     ppp_recv_config(f->unit, PPP_MRU,
1829                     (go->neg_asyncmap? go->asyncmap: 0xffffffff),
1830                     go->neg_pcompression, go->neg_accompression);
1831     peer_mru[f->unit] = PPP_MRU;
1832 }
1833
1834
1835 /*
1836  * lcp_starting - LCP needs the lower layer up.
1837  */
1838 static void
1839 lcp_starting(f)
1840     fsm *f;
1841 {
1842     link_required(f->unit);
1843 }
1844
1845
1846 /*
1847  * lcp_finished - LCP has finished with the lower layer.
1848  */
1849 static void
1850 lcp_finished(f)
1851     fsm *f;
1852 {
1853     link_terminated(f->unit);
1854 }
1855
1856
1857 /*
1858  * lcp_printpkt - print the contents of an LCP packet.
1859  */
1860 static char *lcp_codenames[] = {
1861     "ConfReq", "ConfAck", "ConfNak", "ConfRej",
1862     "TermReq", "TermAck", "CodeRej", "ProtRej",
1863     "EchoReq", "EchoRep", "DiscReq"
1864 };
1865
1866 static int
1867 lcp_printpkt(p, plen, printer, arg)
1868     u_char *p;
1869     int plen;
1870     void (*printer) __P((void *, char *, ...));
1871     void *arg;
1872 {
1873     int code, id, len, olen, i;
1874     u_char *pstart, *optend;
1875     u_short cishort;
1876     u_int32_t cilong;
1877
1878     if (plen < HEADERLEN)
1879         return 0;
1880     pstart = p;
1881     GETCHAR(code, p);
1882     GETCHAR(id, p);
1883     GETSHORT(len, p);
1884     if (len < HEADERLEN || len > plen)
1885         return 0;
1886
1887     if (code >= 1 && code <= sizeof(lcp_codenames) / sizeof(char *))
1888         printer(arg, " %s", lcp_codenames[code-1]);
1889     else
1890         printer(arg, " code=0x%x", code);
1891     printer(arg, " id=0x%x", id);
1892     len -= HEADERLEN;
1893     switch (code) {
1894     case CONFREQ:
1895     case CONFACK:
1896     case CONFNAK:
1897     case CONFREJ:
1898         /* print option list */
1899         while (len >= 2) {
1900             GETCHAR(code, p);
1901             GETCHAR(olen, p);
1902             p -= 2;
1903             if (olen < 2 || olen > len) {
1904                 break;
1905             }
1906             printer(arg, " <");
1907             len -= olen;
1908             optend = p + olen;
1909             switch (code) {
1910             case CI_MRU:
1911                 if (olen == CILEN_SHORT) {
1912                     p += 2;
1913                     GETSHORT(cishort, p);
1914                     printer(arg, "mru %d", cishort);
1915                 }
1916                 break;
1917             case CI_ASYNCMAP:
1918                 if (olen == CILEN_LONG) {
1919                     p += 2;
1920                     GETLONG(cilong, p);
1921                     printer(arg, "asyncmap 0x%x", cilong);
1922                 }
1923                 break;
1924             case CI_AUTHTYPE:
1925                 if (olen >= CILEN_SHORT) {
1926                     p += 2;
1927                     printer(arg, "auth ");
1928                     GETSHORT(cishort, p);
1929                     switch (cishort) {
1930                     case PPP_PAP:
1931                         printer(arg, "pap");
1932                         break;
1933                     case PPP_CHAP:
1934                         printer(arg, "chap");
1935                         if (p < optend) {
1936                             switch (*p) {
1937                             case CHAP_DIGEST_MD5:
1938                                 printer(arg, " MD5");
1939                                 ++p;
1940                                 break;
1941 #ifdef CHAPMS
1942                             case CHAP_MICROSOFT:
1943                                 printer(arg, " m$oft");
1944                                 ++p;
1945                                 break;
1946 #endif
1947                             }
1948                         }
1949                         break;
1950                     default:
1951                         printer(arg, "0x%x", cishort);
1952                     }
1953                 }
1954                 break;
1955             case CI_QUALITY:
1956                 if (olen >= CILEN_SHORT) {
1957                     p += 2;
1958                     printer(arg, "quality ");
1959                     GETSHORT(cishort, p);
1960                     switch (cishort) {
1961                     case PPP_LQR:
1962                         printer(arg, "lqr");
1963                         break;
1964                     default:
1965                         printer(arg, "0x%x", cishort);
1966                     }
1967                 }
1968                 break;
1969             case CI_CALLBACK:
1970                 if (olen >= CILEN_CHAR) {
1971                     p += 2;
1972                     printer(arg, "callback ");
1973                     GETCHAR(cishort, p);
1974                     switch (cishort) {
1975                     case CBCP_OPT:
1976                         printer(arg, "CBCP");
1977                         break;
1978                     default:
1979                         printer(arg, "0x%x", cishort);
1980                     }
1981                 }
1982                 break;
1983             case CI_MAGICNUMBER:
1984                 if (olen == CILEN_LONG) {
1985                     p += 2;
1986                     GETLONG(cilong, p);
1987                     printer(arg, "magic 0x%x", cilong);
1988                 }
1989                 break;
1990             case CI_PCOMPRESSION:
1991                 if (olen == CILEN_VOID) {
1992                     p += 2;
1993                     printer(arg, "pcomp");
1994                 }
1995                 break;
1996             case CI_ACCOMPRESSION:
1997                 if (olen == CILEN_VOID) {
1998                     p += 2;
1999                     printer(arg, "accomp");
2000                 }
2001                 break;
2002             case CI_MRRU:
2003                 if (olen == CILEN_SHORT) {
2004                     p += 2;
2005                     GETSHORT(cishort, p);
2006                     printer(arg, "mrru %d", cishort);
2007                 }
2008                 break;
2009             case CI_SSNHF:
2010                 if (olen == CILEN_VOID) {
2011                     p += 2;
2012                     printer(arg, "ssnhf");
2013                 }
2014                 break;
2015             case CI_EPDISC:
2016 #ifdef HAVE_MULTILINK
2017                 if (olen >= CILEN_CHAR) {
2018                     struct epdisc epd;
2019                     p += 2;
2020                     GETCHAR(epd.class, p);
2021                     epd.length = olen - CILEN_CHAR;
2022                     if (epd.length > MAX_ENDP_LEN)
2023                         epd.length = MAX_ENDP_LEN;
2024                     if (epd.length > 0) {
2025                         BCOPY(p, epd.value, epd.length);
2026                         p += epd.length;
2027                     }
2028                     printer(arg, "endpoint [%s]", epdisc_to_str(&epd));
2029                 }
2030 #else
2031                 printer(arg, "endpoint");
2032 #endif
2033                 break;
2034             }
2035             while (p < optend) {
2036                 GETCHAR(code, p);
2037                 printer(arg, " %.2x", code);
2038             }
2039             printer(arg, ">");
2040         }
2041         break;
2042
2043     case TERMACK:
2044     case TERMREQ:
2045         if (len > 0 && *p >= ' ' && *p < 0x7f) {
2046             printer(arg, " ");
2047             print_string((char *)p, len, printer, arg);
2048             p += len;
2049             len = 0;
2050         }
2051         break;
2052
2053     case ECHOREQ:
2054     case ECHOREP:
2055     case DISCREQ:
2056         if (len >= 4) {
2057             GETLONG(cilong, p);
2058             printer(arg, " magic=0x%x", cilong);
2059             p += 4;
2060             len -= 4;
2061         }
2062         break;
2063     }
2064
2065     /* print the rest of the bytes in the packet */
2066     for (i = 0; i < len && i < 32; ++i) {
2067         GETCHAR(code, p);
2068         printer(arg, " %.2x", code);
2069     }
2070     if (i < len) {
2071         printer(arg, " ...");
2072         p += len - i;
2073     }
2074
2075     return p - pstart;
2076 }
2077
2078 /*
2079  * Time to shut down the link because there is nothing out there.
2080  */
2081
2082 static
2083 void LcpLinkFailure (f)
2084     fsm *f;
2085 {
2086     if (f->state == OPENED) {
2087         info("No response to %d echo-requests", lcp_echos_pending);
2088         notice("Serial link appears to be disconnected.");
2089         lcp_close(f->unit, "Peer not responding");
2090         status = EXIT_PEER_DEAD;
2091     }
2092 }
2093
2094 /*
2095  * Timer expired for the LCP echo requests from this process.
2096  */
2097
2098 static void
2099 LcpEchoCheck (f)
2100     fsm *f;
2101 {
2102     LcpSendEchoRequest (f);
2103     if (f->state != OPENED)
2104         return;
2105
2106     /*
2107      * Start the timer for the next interval.
2108      */
2109     if (lcp_echo_timer_running)
2110         warn("assertion lcp_echo_timer_running==0 failed");
2111     TIMEOUT (LcpEchoTimeout, f, lcp_echo_interval);
2112     lcp_echo_timer_running = 1;
2113 }
2114
2115 /*
2116  * LcpEchoTimeout - Timer expired on the LCP echo
2117  */
2118
2119 static void
2120 LcpEchoTimeout (arg)
2121     void *arg;
2122 {
2123     if (lcp_echo_timer_running != 0) {
2124         lcp_echo_timer_running = 0;
2125         LcpEchoCheck ((fsm *) arg);
2126     }
2127 }
2128
2129 /*
2130  * LcpEchoReply - LCP has received a reply to the echo
2131  */
2132
2133 static void
2134 lcp_received_echo_reply (f, id, inp, len)
2135     fsm *f;
2136     int id;
2137     u_char *inp;
2138     int len;
2139 {
2140     u_int32_t magic;
2141
2142     /* Check the magic number - don't count replies from ourselves. */
2143     if (len < 4) {
2144         dbglog("lcp: received short Echo-Reply, length %d", len);
2145         return;
2146     }
2147     GETLONG(magic, inp);
2148     if (lcp_gotoptions[f->unit].neg_magicnumber
2149         && magic == lcp_gotoptions[f->unit].magicnumber) {
2150         warn("appear to have received our own echo-reply!");
2151         return;
2152     }
2153
2154     /* Reset the number of outstanding echo frames */
2155     lcp_echos_pending = 0;
2156 }
2157
2158 /*
2159  * LcpSendEchoRequest - Send an echo request frame to the peer
2160  */
2161
2162 static void
2163 LcpSendEchoRequest (f)
2164     fsm *f;
2165 {
2166     u_int32_t lcp_magic;
2167     u_char pkt[4], *pktp;
2168
2169     /*
2170      * Detect the failure of the peer at this point.
2171      */
2172     if (lcp_echo_fails != 0) {
2173         if (lcp_echos_pending >= lcp_echo_fails) {
2174             LcpLinkFailure(f);
2175             lcp_echos_pending = 0;
2176         }
2177     }
2178
2179     /*
2180      * Make and send the echo request frame.
2181      */
2182     if (f->state == OPENED) {
2183         lcp_magic = lcp_gotoptions[f->unit].magicnumber;
2184         pktp = pkt;
2185         PUTLONG(lcp_magic, pktp);
2186         fsm_sdata(f, ECHOREQ, lcp_echo_number++ & 0xFF, pkt, pktp - pkt);
2187         ++lcp_echos_pending;
2188     }
2189 }
2190
2191 /*
2192  * lcp_echo_lowerup - Start the timer for the LCP frame
2193  */
2194
2195 static void
2196 lcp_echo_lowerup (unit)
2197     int unit;
2198 {
2199     fsm *f = &lcp_fsm[unit];
2200
2201     /* Clear the parameters for generating echo frames */
2202     lcp_echos_pending      = 0;
2203     lcp_echo_number        = 0;
2204     lcp_echo_timer_running = 0;
2205
2206     /* If a timeout interval is specified then start the timer */
2207     if (lcp_echo_interval != 0)
2208         LcpEchoCheck (f);
2209 }
2210
2211 /*
2212  * lcp_echo_lowerdown - Stop the timer for the LCP frame
2213  */
2214
2215 static void
2216 lcp_echo_lowerdown (unit)
2217     int unit;
2218 {
2219     fsm *f = &lcp_fsm[unit];
2220
2221     if (lcp_echo_timer_running != 0) {
2222         UNTIMEOUT (LcpEchoTimeout, f);
2223         lcp_echo_timer_running = 0;
2224     }
2225 }