third_party/lwip/repo/lwip/src/netif/ppp/fsm.c

   1 /*
   2  * fsm.c - {Link, IP} Control Protocol Finite State Machine.
   3  *
   4  * Copyright (c) 1984-2000 Carnegie Mellon University. All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  *
  18  * 3. The name "Carnegie Mellon University" must not be used to
  19  *    endorse or promote products derived from this software without
  20  *    prior written permission. For permission or any legal
  21  *    details, please contact
  22  *      Office of Technology Transfer
  23  *      Carnegie Mellon University
  24  *      5000 Forbes Avenue
  25  *      Pittsburgh, PA  15213-3890
  26  *      (412) 268-4387, fax: (412) 268-7395
  27  *      tech-transfer@andrew.cmu.edu
  28  *
  29  * 4. Redistributions of any form whatsoever must retain the following
  30  *    acknowledgment:
  31  *    "This product includes software developed by Computing Services
  32  *     at Carnegie Mellon University (http://www.cmu.edu/computing/)."
  33  *
  34  * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
  35  * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  36  * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE
  37  * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  38  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
  39  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
  40  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  41  */
  42
  43 #include "netif/ppp/ppp_opts.h"
  44 #if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */
  45
  46 /*
  47  * @todo:
  48  * Randomize fsm id on link/init.
  49  * Deal with variable outgoing MTU.
  50  */
  51
  52 #if 0 /* UNUSED */
  53 #include <stdio.h>
  54 #include <string.h>
  55 #include <sys/types.h>
  56 #endif /* UNUSED */
  57
  58 #include "netif/ppp/ppp_impl.h"
  59
  60 #include "netif/ppp/fsm.h"
  61
  62 static void fsm_timeout (void *);
  63 static void fsm_rconfreq(fsm *f, u_char id, u_char *inp, int len);
  64 static void fsm_rconfack(fsm *f, int id, u_char *inp, int len);
  65 static void fsm_rconfnakrej(fsm *f, int code, int id, u_char *inp, int len);
  66 static void fsm_rtermreq(fsm *f, int id, u_char *p, int len);
  67 static void fsm_rtermack(fsm *f);
  68 static void fsm_rcoderej(fsm *f, u_char *inp, int len);
  69 static void fsm_sconfreq(fsm *f, int retransmit);
  70
  71 #define PROTO_NAME(f)   ((f)->callbacks->proto_name)
  72
  73 /*
  74  * fsm_init - Initialize fsm.
  75  *
  76  * Initialize fsm state.
  77  */
  78 void fsm_init(fsm *f) {
  79     ppp_pcb *pcb = f->pcb;
  80     f->state = PPP_FSM_INITIAL;
  81     f->flags = 0;
  82     f->id = 0;                          /* XXX Start with random id? */
  83     f->maxnakloops = pcb->settings.fsm_max_nak_loops;
  84     f->term_reason_len = 0;
  85 }
  86
  87
  88 /*
  89  * fsm_lowerup - The lower layer is up.
  90  */
  91 void fsm_lowerup(fsm *f) {
  92     switch( f->state ){
  93     case PPP_FSM_INITIAL:
  94         f->state = PPP_FSM_CLOSED;
  95         break;
  96
  97     case PPP_FSM_STARTING:
  98         if( f->flags & OPT_SILENT )
  99             f->state = PPP_FSM_STOPPED;
 100         else {
 101             /* Send an initial configure-request */
 102             fsm_sconfreq(f, 0);
 103             f->state = PPP_FSM_REQSENT;
 104         }
 105         break;
 106
 107     default:
 108         FSMDEBUG(("%s: Up event in state %d!", PROTO_NAME(f), f->state));
 109         /* no break */
 110     }
 111 }
 112
 113
 114 /*
 115  * fsm_lowerdown - The lower layer is down.
 116  *
 117  * Cancel all timeouts and inform upper layers.
 118  */
 119 void fsm_lowerdown(fsm *f) {
 120     switch( f->state ){
 121     case PPP_FSM_CLOSED:
 122         f->state = PPP_FSM_INITIAL;
 123         break;
 124
 125     case PPP_FSM_STOPPED:
 126         f->state = PPP_FSM_STARTING;
 127         if( f->callbacks->starting )
 128             (*f->callbacks->starting)(f);
 129         break;
 130
 131     case PPP_FSM_CLOSING:
 132         f->state = PPP_FSM_INITIAL;
 133         UNTIMEOUT(fsm_timeout, f);      /* Cancel timeout */
 134         break;
 135
 136     case PPP_FSM_STOPPING:
 137     case PPP_FSM_REQSENT:
 138     case PPP_FSM_ACKRCVD:
 139     case PPP_FSM_ACKSENT:
 140         f->state = PPP_FSM_STARTING;
 141         UNTIMEOUT(fsm_timeout, f);      /* Cancel timeout */
 142         break;
 143
 144     case PPP_FSM_OPENED:
 145         if( f->callbacks->down )
 146             (*f->callbacks->down)(f);
 147         f->state = PPP_FSM_STARTING;
 148         break;
 149
 150     default:
 151         FSMDEBUG(("%s: Down event in state %d!", PROTO_NAME(f), f->state));
 152         /* no break */
 153     }
 154 }
 155
 156
 157 /*
 158  * fsm_open - Link is allowed to come up.
 159  */
 160 void fsm_open(fsm *f) {
 161     switch( f->state ){
 162     case PPP_FSM_INITIAL:
 163         f->state = PPP_FSM_STARTING;
 164         if( f->callbacks->starting )
 165             (*f->callbacks->starting)(f);
 166         break;
 167
 168     case PPP_FSM_CLOSED:
 169         if( f->flags & OPT_SILENT )
 170             f->state = PPP_FSM_STOPPED;
 171         else {
 172             /* Send an initial configure-request */
 173             fsm_sconfreq(f, 0);
 174             f->state = PPP_FSM_REQSENT;
 175         }
 176         break;
 177
 178     case PPP_FSM_CLOSING:
 179         f->state = PPP_FSM_STOPPING;
 180         /* fall through */
 181         /* no break */
 182     case PPP_FSM_STOPPED:
 183     case PPP_FSM_OPENED:
 184         if( f->flags & OPT_RESTART ){
 185             fsm_lowerdown(f);
 186             fsm_lowerup(f);
 187         }
 188         break;
 189     default:
 190         break;
 191     }
 192 }
 193
 194 /*
 195  * terminate_layer - Start process of shutting down the FSM
 196  *
 197  * Cancel any timeout running, notify upper layers we're done, and
 198  * send a terminate-request message as configured.
 199  */
 200 static void terminate_layer(fsm *f, int nextstate) {
 201     ppp_pcb *pcb = f->pcb;
 202
 203     if( f->state != PPP_FSM_OPENED )
 204         UNTIMEOUT(fsm_timeout, f);      /* Cancel timeout */
 205     else if( f->callbacks->down )
 206         (*f->callbacks->down)(f);       /* Inform upper layers we're down */
 207
 208     /* Init restart counter and send Terminate-Request */
 209     f->retransmits = pcb->settings.fsm_max_term_transmits;
 210     fsm_sdata(f, TERMREQ, f->reqid = ++f->id,
 211               (const u_char *) f->term_reason, f->term_reason_len);
 212
 213     if (f->retransmits == 0) {
 214         /*
 215          * User asked for no terminate requests at all; just close it.
 216          * We've already fired off one Terminate-Request just to be nice
 217          * to the peer, but we're not going to wait for a reply.
 218          */
 219         f->state = nextstate == PPP_FSM_CLOSING ? PPP_FSM_CLOSED : PPP_FSM_STOPPED;
 220         if( f->callbacks->finished )
 221             (*f->callbacks->finished)(f);
 222         return;
 223     }
 224
 225     TIMEOUT(fsm_timeout, f, pcb->settings.fsm_timeout_time);
 226     --f->retransmits;
 227
 228     f->state = nextstate;
 229 }
 230
 231 /*
 232  * fsm_close - Start closing connection.
 233  *
 234  * Cancel timeouts and either initiate close or possibly go directly to
 235  * the PPP_FSM_CLOSED state.
 236  */
 237 void fsm_close(fsm *f, const char *reason) {
 238     f->term_reason = reason;
 239     f->term_reason_len = (reason == NULL? 0: LWIP_MIN(strlen(reason), 0xFF) );
 240     switch( f->state ){
 241     case PPP_FSM_STARTING:
 242         f->state = PPP_FSM_INITIAL;
 243         break;
 244     case PPP_FSM_STOPPED:
 245         f->state = PPP_FSM_CLOSED;
 246         break;
 247     case PPP_FSM_STOPPING:
 248         f->state = PPP_FSM_CLOSING;
 249         break;
 250
 251     case PPP_FSM_REQSENT:
 252     case PPP_FSM_ACKRCVD:
 253     case PPP_FSM_ACKSENT:
 254     case PPP_FSM_OPENED:
 255         terminate_layer(f, PPP_FSM_CLOSING);
 256         break;
 257     default:
 258         break;
 259     }
 260 }
 261
 262
 263 /*
 264  * fsm_timeout - Timeout expired.
 265  */
 266 static void fsm_timeout(void *arg) {
 267     fsm *f = (fsm *) arg;
 268     ppp_pcb *pcb = f->pcb;
 269
 270     switch (f->state) {
 271     case PPP_FSM_CLOSING:
 272     case PPP_FSM_STOPPING:
 273         if( f->retransmits <= 0 ){
 274             /*
 275              * We've waited for an ack long enough.  Peer probably heard us.
 276              */
 277             f->state = (f->state == PPP_FSM_CLOSING)? PPP_FSM_CLOSED: PPP_FSM_STOPPED;
 278             if( f->callbacks->finished )
 279                 (*f->callbacks->finished)(f);
 280         } else {
 281             /* Send Terminate-Request */
 282             fsm_sdata(f, TERMREQ, f->reqid = ++f->id,
 283                       (const u_char *) f->term_reason, f->term_reason_len);
 284             TIMEOUT(fsm_timeout, f, pcb->settings.fsm_timeout_time);
 285             --f->retransmits;
 286         }
 287         break;
 288
 289     case PPP_FSM_REQSENT:
 290     case PPP_FSM_ACKRCVD:
 291     case PPP_FSM_ACKSENT:
 292         if (f->retransmits <= 0) {
 293             ppp_warn("%s: timeout sending Config-Requests", PROTO_NAME(f));
 294             f->state = PPP_FSM_STOPPED;
 295             if( (f->flags & OPT_PASSIVE) == 0 && f->callbacks->finished )
 296                 (*f->callbacks->finished)(f);
 297
 298         } else {
 299             /* Retransmit the configure-request */
 300             if (f->callbacks->retransmit)
 301                 (*f->callbacks->retransmit)(f);
 302             fsm_sconfreq(f, 1);         /* Re-send Configure-Request */
 303             if( f->state == PPP_FSM_ACKRCVD )
 304                 f->state = PPP_FSM_REQSENT;
 305         }
 306         break;
 307
 308     default:
 309         FSMDEBUG(("%s: Timeout event in state %d!", PROTO_NAME(f), f->state));
 310         /* no break */
 311     }
 312 }
 313
 314
 315 /*
 316  * fsm_input - Input packet.
 317  */
 318 void fsm_input(fsm *f, u_char *inpacket, int l) {
 319     u_char *inp;
 320     u_char code, id;
 321     int len;
 322
 323     /*
 324      * Parse header (code, id and length).
 325      * If packet too short, drop it.
 326      */
 327     inp = inpacket;
 328     if (l < HEADERLEN) {
 329         FSMDEBUG(("fsm_input(%x): Rcvd short header.", f->protocol));
 330         return;
 331     }
 332     GETCHAR(code, inp);
 333     GETCHAR(id, inp);
 334     GETSHORT(len, inp);
 335     if (len < HEADERLEN) {
 336         FSMDEBUG(("fsm_input(%x): Rcvd illegal length.", f->protocol));
 337         return;
 338     }
 339     if (len > l) {
 340         FSMDEBUG(("fsm_input(%x): Rcvd short packet.", f->protocol));
 341         return;
 342     }
 343     len -= HEADERLEN;           /* subtract header length */
 344
 345     if( f->state == PPP_FSM_INITIAL || f->state == PPP_FSM_STARTING ){
 346         FSMDEBUG(("fsm_input(%x): Rcvd packet in state %d.",
 347                   f->protocol, f->state));
 348         return;
 349     }
 350
 351     /*
 352      * Action depends on code.
 353      */
 354     switch (code) {
 355     case CONFREQ:
 356         fsm_rconfreq(f, id, inp, len);
 357         break;
 358
 359     case CONFACK:
 360         fsm_rconfack(f, id, inp, len);
 361         break;
 362
 363     case CONFNAK:
 364     case CONFREJ:
 365         fsm_rconfnakrej(f, code, id, inp, len);
 366         break;
 367
 368     case TERMREQ:
 369         fsm_rtermreq(f, id, inp, len);
 370         break;
 371
 372     case TERMACK:
 373         fsm_rtermack(f);
 374         break;
 375
 376     case CODEREJ:
 377         fsm_rcoderej(f, inp, len);
 378         break;
 379
 380     default:
 381         if( !f->callbacks->extcode
 382            || !(*f->callbacks->extcode)(f, code, id, inp, len) )
 383             fsm_sdata(f, CODEREJ, ++f->id, inpacket, len + HEADERLEN);
 384         break;
 385     }
 386 }
 387
 388
 389 /*
 390  * fsm_rconfreq - Receive Configure-Request.
 391  */
 392 static void fsm_rconfreq(fsm *f, u_char id, u_char *inp, int len) {
 393     int code, reject_if_disagree;
 394
 395     switch( f->state ){
 396     case PPP_FSM_CLOSED:
 397         /* Go away, we're closed */
 398         fsm_sdata(f, TERMACK, id, NULL, 0);
 399         return;
 400     case PPP_FSM_CLOSING:
 401     case PPP_FSM_STOPPING:
 402         return;
 403
 404     case PPP_FSM_OPENED:
 405         /* Go down and restart negotiation */
 406         if( f->callbacks->down )
 407             (*f->callbacks->down)(f);   /* Inform upper layers */
 408         fsm_sconfreq(f, 0);             /* Send initial Configure-Request */
 409         f->state = PPP_FSM_REQSENT;
 410         break;
 411
 412     case PPP_FSM_STOPPED:
 413         /* Negotiation started by our peer */
 414         fsm_sconfreq(f, 0);             /* Send initial Configure-Request */
 415         f->state = PPP_FSM_REQSENT;
 416         break;
 417     default:
 418         break;
 419     }
 420
 421     /*
 422      * Pass the requested configuration options
 423      * to protocol-specific code for checking.
 424      */
 425     if (f->callbacks->reqci){           /* Check CI */
 426         reject_if_disagree = (f->nakloops >= f->maxnakloops);
 427         code = (*f->callbacks->reqci)(f, inp, &len, reject_if_disagree);
 428     } else if (len)
 429         code = CONFREJ;                 /* Reject all CI */
 430     else
 431         code = CONFACK;
 432
 433     /* send the Ack, Nak or Rej to the peer */
 434     fsm_sdata(f, code, id, inp, len);
 435
 436     if (code == CONFACK) {
 437         if (f->state == PPP_FSM_ACKRCVD) {
 438             UNTIMEOUT(fsm_timeout, f);  /* Cancel timeout */
 439             f->state = PPP_FSM_OPENED;
 440             if (f->callbacks->up)
 441                 (*f->callbacks->up)(f); /* Inform upper layers */
 442         } else
 443             f->state = PPP_FSM_ACKSENT;
 444         f->nakloops = 0;
 445
 446     } else {
 447         /* we sent CONFACK or CONFREJ */
 448         if (f->state != PPP_FSM_ACKRCVD)
 449             f->state = PPP_FSM_REQSENT;
 450         if( code == CONFNAK )
 451             ++f->nakloops;
 452     }
 453 }
 454
 455
 456 /*
 457  * fsm_rconfack - Receive Configure-Ack.
 458  */
 459 static void fsm_rconfack(fsm *f, int id, u_char *inp, int len) {
 460     ppp_pcb *pcb = f->pcb;
 461
 462     if (id != f->reqid || f->seen_ack)          /* Expected id? */
 463         return;                                 /* Nope, toss... */
 464     if( !(f->callbacks->ackci? (*f->callbacks->ackci)(f, inp, len):
 465           (len == 0)) ){
 466         /* Ack is bad - ignore it */
 467         ppp_error("Received bad configure-ack: %P", inp, len);
 468         return;
 469     }
 470     f->seen_ack = 1;
 471     f->rnakloops = 0;
 472
 473     switch (f->state) {
 474     case PPP_FSM_CLOSED:
 475     case PPP_FSM_STOPPED:
 476         fsm_sdata(f, TERMACK, id, NULL, 0);
 477         break;
 478
 479     case PPP_FSM_REQSENT:
 480         f->state = PPP_FSM_ACKRCVD;
 481         f->retransmits = pcb->settings.fsm_max_conf_req_transmits;
 482         break;
 483
 484     case PPP_FSM_ACKRCVD:
 485         /* Huh? an extra valid Ack? oh well... */
 486         UNTIMEOUT(fsm_timeout, f);      /* Cancel timeout */
 487         fsm_sconfreq(f, 0);
 488         f->state = PPP_FSM_REQSENT;
 489         break;
 490
 491     case PPP_FSM_ACKSENT:
 492         UNTIMEOUT(fsm_timeout, f);      /* Cancel timeout */
 493         f->state = PPP_FSM_OPENED;
 494         f->retransmits = pcb->settings.fsm_max_conf_req_transmits;
 495         if (f->callbacks->up)
 496             (*f->callbacks->up)(f);     /* Inform upper layers */
 497         break;
 498
 499     case PPP_FSM_OPENED:
 500         /* Go down and restart negotiation */
 501         if (f->callbacks->down)
 502             (*f->callbacks->down)(f);   /* Inform upper layers */
 503         fsm_sconfreq(f, 0);             /* Send initial Configure-Request */
 504         f->state = PPP_FSM_REQSENT;
 505         break;
 506     default:
 507         break;
 508     }
 509 }
 510
 511
 512 /*
 513  * fsm_rconfnakrej - Receive Configure-Nak or Configure-Reject.
 514  */
 515 static void fsm_rconfnakrej(fsm *f, int code, int id, u_char *inp, int len) {
 516     int ret;
 517     int treat_as_reject;
 518
 519     if (id != f->reqid || f->seen_ack)  /* Expected id? */
 520         return;                         /* Nope, toss... */
 521
 522     if (code == CONFNAK) {
 523         ++f->rnakloops;
 524         treat_as_reject = (f->rnakloops >= f->maxnakloops);
 525         if (f->callbacks->nakci == NULL
 526             || !(ret = f->callbacks->nakci(f, inp, len, treat_as_reject))) {
 527             ppp_error("Received bad configure-nak: %P", inp, len);
 528             return;
 529         }
 530     } else {
 531         f->rnakloops = 0;
 532         if (f->callbacks->rejci == NULL
 533             || !(ret = f->callbacks->rejci(f, inp, len))) {
 534             ppp_error("Received bad configure-rej: %P", inp, len);
 535             return;
 536         }
 537     }
 538
 539     f->seen_ack = 1;
 540
 541     switch (f->state) {
 542     case PPP_FSM_CLOSED:
 543     case PPP_FSM_STOPPED:
 544         fsm_sdata(f, TERMACK, id, NULL, 0);
 545         break;
 546
 547     case PPP_FSM_REQSENT:
 548     case PPP_FSM_ACKSENT:
 549         /* They didn't agree to what we wanted - try another request */
 550         UNTIMEOUT(fsm_timeout, f);      /* Cancel timeout */
 551         if (ret < 0)
 552             f->state = PPP_FSM_STOPPED;         /* kludge for stopping CCP */
 553         else
 554             fsm_sconfreq(f, 0);         /* Send Configure-Request */
 555         break;
 556
 557     case PPP_FSM_ACKRCVD:
 558         /* Got a Nak/reject when we had already had an Ack?? oh well... */
 559         UNTIMEOUT(fsm_timeout, f);      /* Cancel timeout */
 560         fsm_sconfreq(f, 0);
 561         f->state = PPP_FSM_REQSENT;
 562         break;
 563
 564     case PPP_FSM_OPENED:
 565         /* Go down and restart negotiation */
 566         if (f->callbacks->down)
 567             (*f->callbacks->down)(f);   /* Inform upper layers */
 568         fsm_sconfreq(f, 0);             /* Send initial Configure-Request */
 569         f->state = PPP_FSM_REQSENT;
 570         break;
 571     default:
 572         break;
 573     }
 574 }
 575
 576
 577 /*
 578  * fsm_rtermreq - Receive Terminate-Req.
 579  */
 580 static void fsm_rtermreq(fsm *f, int id, u_char *p, int len) {
 581     ppp_pcb *pcb = f->pcb;
 582
 583     switch (f->state) {
 584     case PPP_FSM_ACKRCVD:
 585     case PPP_FSM_ACKSENT:
 586         f->state = PPP_FSM_REQSENT;             /* Start over but keep trying */
 587         break;
 588
 589     case PPP_FSM_OPENED:
 590         if (len > 0) {
 591             ppp_info("%s terminated by peer (%0.*v)", PROTO_NAME(f), len, p);
 592         } else
 593             ppp_info("%s terminated by peer", PROTO_NAME(f));
 594         f->retransmits = 0;
 595         f->state = PPP_FSM_STOPPING;
 596         if (f->callbacks->down)
 597             (*f->callbacks->down)(f);   /* Inform upper layers */
 598         TIMEOUT(fsm_timeout, f, pcb->settings.fsm_timeout_time);
 599         break;
 600     default:
 601         break;
 602     }
 603
 604     fsm_sdata(f, TERMACK, id, NULL, 0);
 605 }
 606
 607
 608 /*
 609  * fsm_rtermack - Receive Terminate-Ack.
 610  */
 611 static void fsm_rtermack(fsm *f) {
 612     switch (f->state) {
 613     case PPP_FSM_CLOSING:
 614         UNTIMEOUT(fsm_timeout, f);
 615         f->state = PPP_FSM_CLOSED;
 616         if( f->callbacks->finished )
 617             (*f->callbacks->finished)(f);
 618         break;
 619     case PPP_FSM_STOPPING:
 620         UNTIMEOUT(fsm_timeout, f);
 621         f->state = PPP_FSM_STOPPED;
 622         if( f->callbacks->finished )
 623             (*f->callbacks->finished)(f);
 624         break;
 625
 626     case PPP_FSM_ACKRCVD:
 627         f->state = PPP_FSM_REQSENT;
 628         break;
 629
 630     case PPP_FSM_OPENED:
 631         if (f->callbacks->down)
 632             (*f->callbacks->down)(f);   /* Inform upper layers */
 633         fsm_sconfreq(f, 0);
 634         f->state = PPP_FSM_REQSENT;
 635         break;
 636     default:
 637         break;
 638     }
 639 }
 640
 641
 642 /*
 643  * fsm_rcoderej - Receive an Code-Reject.
 644  */
 645 static void fsm_rcoderej(fsm *f, u_char *inp, int len) {
 646     u_char code, id;
 647
 648     if (len < HEADERLEN) {
 649         FSMDEBUG(("fsm_rcoderej: Rcvd short Code-Reject packet!"));
 650         return;
 651     }
 652     GETCHAR(code, inp);
 653     GETCHAR(id, inp);
 654     ppp_warn("%s: Rcvd Code-Reject for code %d, id %d", PROTO_NAME(f), code, id);
 655
 656     if( f->state == PPP_FSM_ACKRCVD )
 657         f->state = PPP_FSM_REQSENT;
 658 }
 659
 660
 661 /*
 662  * fsm_protreject - Peer doesn't speak this protocol.
 663  *
 664  * Treat this as a catastrophic error (RXJ-).
 665  */
 666 void fsm_protreject(fsm *f) {
 667     switch( f->state ){
 668     case PPP_FSM_CLOSING:
 669         UNTIMEOUT(fsm_timeout, f);      /* Cancel timeout */
 670         /* fall through */
 671         /* no break */
 672     case PPP_FSM_CLOSED:
 673         f->state = PPP_FSM_CLOSED;
 674         if( f->callbacks->finished )
 675             (*f->callbacks->finished)(f);
 676         break;
 677
 678     case PPP_FSM_STOPPING:
 679     case PPP_FSM_REQSENT:
 680     case PPP_FSM_ACKRCVD:
 681     case PPP_FSM_ACKSENT:
 682         UNTIMEOUT(fsm_timeout, f);      /* Cancel timeout */
 683         /* fall through */
 684         /* no break */
 685     case PPP_FSM_STOPPED:
 686         f->state = PPP_FSM_STOPPED;
 687         if( f->callbacks->finished )
 688             (*f->callbacks->finished)(f);
 689         break;
 690
 691     case PPP_FSM_OPENED:
 692         terminate_layer(f, PPP_FSM_STOPPING);
 693         break;
 694
 695     default:
 696         FSMDEBUG(("%s: Protocol-reject event in state %d!",
 697                   PROTO_NAME(f), f->state));
 698         /* no break */
 699     }
 700 }
 701
 702
 703 /*
 704  * fsm_sconfreq - Send a Configure-Request.
 705  */
 706 static void fsm_sconfreq(fsm *f, int retransmit) {
 707     ppp_pcb *pcb = f->pcb;
 708     struct pbuf *p;
 709     u_char *outp;
 710     int cilen;
 711
 712     if( f->state != PPP_FSM_REQSENT && f->state != PPP_FSM_ACKRCVD && f->state != PPP_FSM_ACKSENT ){
 713         /* Not currently negotiating - reset options */
 714         if( f->callbacks->resetci )
 715             (*f->callbacks->resetci)(f);
 716         f->nakloops = 0;
 717         f->rnakloops = 0;
 718     }
 719
 720     if( !retransmit ){
 721         /* New request - reset retransmission counter, use new ID */
 722         f->retransmits = pcb->settings.fsm_max_conf_req_transmits;
 723         f->reqid = ++f->id;
 724     }
 725
 726     f->seen_ack = 0;
 727
 728     /*
 729      * Make up the request packet
 730      */
 731     if( f->callbacks->cilen && f->callbacks->addci ){
 732         cilen = (*f->callbacks->cilen)(f);
 733         if( cilen > pcb->peer_mru - HEADERLEN )
 734             cilen = pcb->peer_mru - HEADERLEN;
 735     } else
 736         cilen = 0;
 737
 738     p = pbuf_alloc(PBUF_RAW, (u16_t)(cilen + HEADERLEN + PPP_HDRLEN), PPP_CTRL_PBUF_TYPE);
 739     if(NULL == p)
 740         return;
 741     if(p->tot_len != p->len) {
 742         pbuf_free(p);
 743         return;
 744     }
 745
 746     /* send the request to our peer */
 747     outp = (u_char*)p->payload;
 748     MAKEHEADER(outp, f->protocol);
 749     PUTCHAR(CONFREQ, outp);
 750     PUTCHAR(f->reqid, outp);
 751     PUTSHORT(cilen + HEADERLEN, outp);
 752     if (cilen != 0) {
 753         (*f->callbacks->addci)(f, outp, &cilen);
 754         LWIP_ASSERT("cilen == p->len - HEADERLEN - PPP_HDRLEN", cilen == p->len - HEADERLEN - PPP_HDRLEN);
 755     }
 756
 757     ppp_write(pcb, p);
 758
 759     /* start the retransmit timer */
 760     --f->retransmits;
 761     TIMEOUT(fsm_timeout, f, pcb->settings.fsm_timeout_time);
 762 }
 763
 764
 765 /*
 766  * fsm_sdata - Send some data.
 767  *
 768  * Used for all packets sent to our peer by this module.
 769  */
 770 void fsm_sdata(fsm *f, u_char code, u_char id, const u_char *data, int datalen) {
 771     ppp_pcb *pcb = f->pcb;
 772     struct pbuf *p;
 773     u_char *outp;
 774     int outlen;
 775
 776     /* Adjust length to be smaller than MTU */
 777     if (datalen > pcb->peer_mru - HEADERLEN)
 778         datalen = pcb->peer_mru - HEADERLEN;
 779     outlen = datalen + HEADERLEN;
 780
 781     p = pbuf_alloc(PBUF_RAW, (u16_t)(outlen + PPP_HDRLEN), PPP_CTRL_PBUF_TYPE);
 782     if(NULL == p)
 783         return;
 784     if(p->tot_len != p->len) {
 785         pbuf_free(p);
 786         return;
 787     }
 788
 789     outp = (u_char*)p->payload;
 790     if (datalen) /* && data != outp + PPP_HDRLEN + HEADERLEN)  -- was only for fsm_sconfreq() */
 791         MEMCPY(outp + PPP_HDRLEN + HEADERLEN, data, datalen);
 792     MAKEHEADER(outp, f->protocol);
 793     PUTCHAR(code, outp);
 794     PUTCHAR(id, outp);
 795     PUTSHORT(outlen, outp);
 796     ppp_write(pcb, p);
 797 }
 798
 799 #endif /* PPP_SUPPORT */