geekos/src/lwip/netif/ppp/lcp.c

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