pppd/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 #define RCSID   "$Id: fsm.c,v 1.23 2004/11/13 02:28:15 paulus Exp $"
  44
  45 /*
  46  * TODO:
  47  * Randomize fsm id on link/init.
  48  * Deal with variable outgoing MTU.
  49  */
  50
  51 #include <stdio.h>
  52 #include <string.h>
  53 #include <sys/types.h>
  54
  55 #include "pppd.h"
  56 #include "fsm.h"
  57
  58
  59 static void fsm_timeout __P((void *));
  60 static void fsm_rconfreq __P((fsm *, int, u_char *, int));
  61 static void fsm_rconfack __P((fsm *, int, u_char *, int));
  62 static void fsm_rconfnakrej __P((fsm *, int, int, u_char *, int));
  63 static void fsm_rtermreq __P((fsm *, int, u_char *, int));
  64 static void fsm_rtermack __P((fsm *));
  65 static void fsm_rcoderej __P((fsm *, u_char *, int));
  66 static void fsm_sconfreq __P((fsm *, int));
  67
  68 #define PROTO_NAME(f)   ((f)->callbacks->proto_name)
  69
  70 int peer_mru[NUM_PPP];
  71
  72
  73 /*
  74  * fsm_init - Initialize fsm.
  75  *
  76  * Initialize fsm state.
  77  */
  78 void
  79 fsm_init(f)
  80     fsm *f;
  81 {
  82     f->state = INITIAL;
  83     f->flags = 0;
  84     f->id = 0;                          /* XXX Start with random id? */
  85     f->timeouttime = DEFTIMEOUT;
  86     f->maxconfreqtransmits = DEFMAXCONFREQS;
  87     f->maxtermtransmits = DEFMAXTERMREQS;
  88     f->maxnakloops = DEFMAXNAKLOOPS;
  89     f->term_reason_len = 0;
  90 }
  91
  92
  93 /*
  94  * fsm_lowerup - The lower layer is up.
  95  */
  96 void
  97 fsm_lowerup(f)
  98     fsm *f;
  99 {
 100     switch( f->state ){
 101     case INITIAL:
 102         f->state = CLOSED;
 103         break;
 104
 105     case STARTING:
 106         if( f->flags & OPT_SILENT )
 107             f->state = STOPPED;
 108         else {
 109             /* Send an initial configure-request */
 110             fsm_sconfreq(f, 0);
 111             f->state = REQSENT;
 112         }
 113         break;
 114
 115     default:
 116         FSMDEBUG(("%s: Up event in state %d!", PROTO_NAME(f), f->state));
 117     }
 118 }
 119
 120
 121 /*
 122  * fsm_lowerdown - The lower layer is down.
 123  *
 124  * Cancel all timeouts and inform upper layers.
 125  */
 126 void
 127 fsm_lowerdown(f)
 128     fsm *f;
 129 {
 130     switch( f->state ){
 131     case CLOSED:
 132         f->state = INITIAL;
 133         break;
 134
 135     case STOPPED:
 136         f->state = STARTING;
 137         if( f->callbacks->starting )
 138             (*f->callbacks->starting)(f);
 139         break;
 140
 141     case CLOSING:
 142         f->state = INITIAL;
 143         UNTIMEOUT(fsm_timeout, f);      /* Cancel timeout */
 144         break;
 145
 146     case STOPPING:
 147     case REQSENT:
 148     case ACKRCVD:
 149     case ACKSENT:
 150         f->state = STARTING;
 151         UNTIMEOUT(fsm_timeout, f);      /* Cancel timeout */
 152         break;
 153
 154     case OPENED:
 155         if( f->callbacks->down )
 156             (*f->callbacks->down)(f);
 157         f->state = STARTING;
 158         break;
 159
 160     default:
 161         FSMDEBUG(("%s: Down event in state %d!", PROTO_NAME(f), f->state));
 162     }
 163 }
 164
 165
 166 /*
 167  * fsm_open - Link is allowed to come up.
 168  */
 169 void
 170 fsm_open(f)
 171     fsm *f;
 172 {
 173     switch( f->state ){
 174     case INITIAL:
 175         f->state = STARTING;
 176         if( f->callbacks->starting )
 177             (*f->callbacks->starting)(f);
 178         break;
 179
 180     case CLOSED:
 181         if( f->flags & OPT_SILENT )
 182             f->state = STOPPED;
 183         else {
 184             /* Send an initial configure-request */
 185             fsm_sconfreq(f, 0);
 186             f->state = REQSENT;
 187         }
 188         break;
 189
 190     case CLOSING:
 191         f->state = STOPPING;
 192         /* fall through */
 193     case STOPPED:
 194     case OPENED:
 195         if( f->flags & OPT_RESTART ){
 196             fsm_lowerdown(f);
 197             fsm_lowerup(f);
 198         }
 199         break;
 200     }
 201 }
 202
 203 /*
 204  * terminate_layer - Start process of shutting down the FSM
 205  *
 206  * Cancel any timeout running, notify upper layers we're done, and
 207  * send a terminate-request message as configured.
 208  */
 209 static void
 210 terminate_layer(f, nextstate)
 211     fsm *f;
 212     int nextstate;
 213 {
 214     if( f->state != OPENED )
 215         UNTIMEOUT(fsm_timeout, f);      /* Cancel timeout */
 216     else if( f->callbacks->down )
 217         (*f->callbacks->down)(f);       /* Inform upper layers we're down */
 218
 219     /* Init restart counter and send Terminate-Request */
 220     f->retransmits = f->maxtermtransmits;
 221     fsm_sdata(f, TERMREQ, f->reqid = ++f->id,
 222               (u_char *) f->term_reason, f->term_reason_len);
 223
 224     if (f->retransmits == 0) {
 225         /*
 226          * User asked for no terminate requests at all; just close it.
 227          * We've already fired off one Terminate-Request just to be nice
 228          * to the peer, but we're not going to wait for a reply.
 229          */
 230         f->state = nextstate == CLOSING ? CLOSED : STOPPED;
 231         if( f->callbacks->finished )
 232             (*f->callbacks->finished)(f);
 233         return;
 234     }
 235
 236     TIMEOUT(fsm_timeout, f, f->timeouttime);
 237     --f->retransmits;
 238
 239     f->state = nextstate;
 240 }
 241
 242 /*
 243  * fsm_close - Start closing connection.
 244  *
 245  * Cancel timeouts and either initiate close or possibly go directly to
 246  * the CLOSED state.
 247  */
 248 void
 249 fsm_close(f, reason)
 250     fsm *f;
 251     char *reason;
 252 {
 253     f->term_reason = reason;
 254     f->term_reason_len = (reason == NULL? 0: strlen(reason));
 255     switch( f->state ){
 256     case STARTING:
 257         f->state = INITIAL;
 258         break;
 259     case STOPPED:
 260         f->state = CLOSED;
 261         break;
 262     case STOPPING:
 263         f->state = CLOSING;
 264         break;
 265
 266     case REQSENT:
 267     case ACKRCVD:
 268     case ACKSENT:
 269     case OPENED:
 270         terminate_layer(f, CLOSING);
 271         break;
 272     }
 273 }
 274
 275
 276 /*
 277  * fsm_timeout - Timeout expired.
 278  */
 279 static void
 280 fsm_timeout(arg)
 281     void *arg;
 282 {
 283     fsm *f = (fsm *) arg;
 284
 285     switch (f->state) {
 286     case CLOSING:
 287     case STOPPING:
 288         if( f->retransmits <= 0 ){
 289             /*
 290              * We've waited for an ack long enough.  Peer probably heard us.
 291              */
 292             f->state = (f->state == CLOSING)? CLOSED: STOPPED;
 293             if( f->callbacks->finished )
 294                 (*f->callbacks->finished)(f);
 295         } else {
 296             /* Send Terminate-Request */
 297             fsm_sdata(f, TERMREQ, f->reqid = ++f->id,
 298                       (u_char *) f->term_reason, f->term_reason_len);
 299             TIMEOUT(fsm_timeout, f, f->timeouttime);
 300             --f->retransmits;
 301         }
 302         break;
 303
 304     case REQSENT:
 305     case ACKRCVD:
 306     case ACKSENT:
 307         if (f->retransmits <= 0) {
 308             warn("%s: timeout sending Config-Requests\n", PROTO_NAME(f));
 309             f->state = STOPPED;
 310             if( (f->flags & OPT_PASSIVE) == 0 && f->callbacks->finished )
 311                 (*f->callbacks->finished)(f);
 312
 313         } else {
 314             /* Retransmit the configure-request */
 315             if (f->callbacks->retransmit)
 316                 (*f->callbacks->retransmit)(f);
 317             fsm_sconfreq(f, 1);         /* Re-send Configure-Request */
 318             if( f->state == ACKRCVD )
 319                 f->state = REQSENT;
 320         }
 321         break;
 322
 323     default:
 324         FSMDEBUG(("%s: Timeout event in state %d!", PROTO_NAME(f), f->state));
 325     }
 326 }
 327
 328
 329 /*
 330  * fsm_input - Input packet.
 331  */
 332 void
 333 fsm_input(f, inpacket, l)
 334     fsm *f;
 335     u_char *inpacket;
 336     int l;
 337 {
 338     u_char *inp;
 339     u_char code, id;
 340     int len;
 341
 342     /*
 343      * Parse header (code, id and length).
 344      * If packet too short, drop it.
 345      */
 346     inp = inpacket;
 347     if (l < HEADERLEN) {
 348         FSMDEBUG(("fsm_input(%x): Rcvd short header.", f->protocol));
 349         return;
 350     }
 351     GETCHAR(code, inp);
 352     GETCHAR(id, inp);
 353     GETSHORT(len, inp);
 354     if (len < HEADERLEN) {
 355         FSMDEBUG(("fsm_input(%x): Rcvd illegal length.", f->protocol));
 356         return;
 357     }
 358     if (len > l) {
 359         FSMDEBUG(("fsm_input(%x): Rcvd short packet.", f->protocol));
 360         return;
 361     }
 362     len -= HEADERLEN;           /* subtract header length */
 363
 364     if( f->state == INITIAL || f->state == STARTING ){
 365         FSMDEBUG(("fsm_input(%x): Rcvd packet in state %d.",
 366                   f->protocol, f->state));
 367         return;
 368     }
 369
 370     /*
 371      * Action depends on code.
 372      */
 373     switch (code) {
 374     case CONFREQ:
 375         fsm_rconfreq(f, id, inp, len);
 376         break;
 377
 378     case CONFACK:
 379         fsm_rconfack(f, id, inp, len);
 380         break;
 381
 382     case CONFNAK:
 383     case CONFREJ:
 384         fsm_rconfnakrej(f, code, id, inp, len);
 385         break;
 386
 387     case TERMREQ:
 388         fsm_rtermreq(f, id, inp, len);
 389         break;
 390
 391     case TERMACK:
 392         fsm_rtermack(f);
 393         break;
 394
 395     case CODEREJ:
 396         fsm_rcoderej(f, inp, len);
 397         break;
 398
 399     default:
 400         if( !f->callbacks->extcode
 401            || !(*f->callbacks->extcode)(f, code, id, inp, len) )
 402             fsm_sdata(f, CODEREJ, ++f->id, inpacket, len + HEADERLEN);
 403         break;
 404     }
 405 }
 406
 407
 408 /*
 409  * fsm_rconfreq - Receive Configure-Request.
 410  */
 411 static void
 412 fsm_rconfreq(f, id, inp, len)
 413     fsm *f;
 414     u_char id;
 415     u_char *inp;
 416     int len;
 417 {
 418     int code, reject_if_disagree;
 419
 420     switch( f->state ){
 421     case CLOSED:
 422         /* Go away, we're closed */
 423         fsm_sdata(f, TERMACK, id, NULL, 0);
 424         return;
 425     case CLOSING:
 426     case STOPPING:
 427         return;
 428
 429     case OPENED:
 430         /* Go down and restart negotiation */
 431         if( f->callbacks->down )
 432             (*f->callbacks->down)(f);   /* Inform upper layers */
 433         fsm_sconfreq(f, 0);             /* Send initial Configure-Request */
 434         f->state = REQSENT;
 435         break;
 436
 437     case STOPPED:
 438         /* Negotiation started by our peer */
 439         fsm_sconfreq(f, 0);             /* Send initial Configure-Request */
 440         f->state = REQSENT;
 441         break;
 442     }
 443
 444     /*
 445      * Pass the requested configuration options
 446      * to protocol-specific code for checking.
 447      */
 448     if (f->callbacks->reqci){           /* Check CI */
 449         reject_if_disagree = (f->nakloops >= f->maxnakloops);
 450         code = (*f->callbacks->reqci)(f, inp, &len, reject_if_disagree);
 451     } else if (len)
 452         code = CONFREJ;                 /* Reject all CI */
 453     else
 454         code = CONFACK;
 455
 456     /* send the Ack, Nak or Rej to the peer */
 457     fsm_sdata(f, code, id, inp, len);
 458
 459     if (code == CONFACK) {
 460         if (f->state == ACKRCVD) {
 461             UNTIMEOUT(fsm_timeout, f);  /* Cancel timeout */
 462             f->state = OPENED;
 463             if (f->callbacks->up)
 464                 (*f->callbacks->up)(f); /* Inform upper layers */
 465         } else
 466             f->state = ACKSENT;
 467         f->nakloops = 0;
 468
 469     } else {
 470         /* we sent CONFNAK or CONFREJ */
 471         if (f->state != ACKRCVD)
 472             f->state = REQSENT;
 473         if( code == CONFNAK )
 474             ++f->nakloops;
 475     }
 476 }
 477
 478
 479 /*
 480  * fsm_rconfack - Receive Configure-Ack.
 481  */
 482 static void
 483 fsm_rconfack(f, id, inp, len)
 484     fsm *f;
 485     int id;
 486     u_char *inp;
 487     int len;
 488 {
 489     if (id != f->reqid || f->seen_ack)          /* Expected id? */
 490         return;                                 /* Nope, toss... */
 491     if( !(f->callbacks->ackci? (*f->callbacks->ackci)(f, inp, len):
 492           (len == 0)) ){
 493         /* Ack is bad - ignore it */
 494         error("Received bad configure-ack: %P", inp, len);
 495         return;
 496     }
 497     f->seen_ack = 1;
 498     f->rnakloops = 0;
 499
 500     switch (f->state) {
 501     case CLOSED:
 502     case STOPPED:
 503         fsm_sdata(f, TERMACK, id, NULL, 0);
 504         break;
 505
 506     case REQSENT:
 507         f->state = ACKRCVD;
 508         f->retransmits = f->maxconfreqtransmits;
 509         break;
 510
 511     case ACKRCVD:
 512         /* Huh? an extra valid Ack? oh well... */
 513         UNTIMEOUT(fsm_timeout, f);      /* Cancel timeout */
 514         fsm_sconfreq(f, 0);
 515         f->state = REQSENT;
 516         break;
 517
 518     case ACKSENT:
 519         UNTIMEOUT(fsm_timeout, f);      /* Cancel timeout */
 520         f->state = OPENED;
 521         f->retransmits = f->maxconfreqtransmits;
 522         if (f->callbacks->up)
 523             (*f->callbacks->up)(f);     /* Inform upper layers */
 524         break;
 525
 526     case OPENED:
 527         /* Go down and restart negotiation */
 528         if (f->callbacks->down)
 529             (*f->callbacks->down)(f);   /* Inform upper layers */
 530         fsm_sconfreq(f, 0);             /* Send initial Configure-Request */
 531         f->state = REQSENT;
 532         break;
 533     }
 534 }
 535
 536
 537 /*
 538  * fsm_rconfnakrej - Receive Configure-Nak or Configure-Reject.
 539  */
 540 static void
 541 fsm_rconfnakrej(f, code, id, inp, len)
 542     fsm *f;
 543     int code, id;
 544     u_char *inp;
 545     int len;
 546 {
 547     int ret;
 548     int treat_as_reject;
 549
 550     if (id != f->reqid || f->seen_ack)  /* Expected id? */
 551         return;                         /* Nope, toss... */
 552
 553     if (code == CONFNAK) {
 554         ++f->rnakloops;
 555         treat_as_reject = (f->rnakloops >= f->maxnakloops);
 556         if (f->callbacks->nakci == NULL
 557             || !(ret = f->callbacks->nakci(f, inp, len, treat_as_reject))) {
 558             error("Received bad configure-nak: %P", inp, len);
 559             return;
 560         }
 561     } else {
 562         f->rnakloops = 0;
 563         if (f->callbacks->rejci == NULL
 564             || !(ret = f->callbacks->rejci(f, inp, len))) {
 565             error("Received bad configure-rej: %P", inp, len);
 566             return;
 567         }
 568     }
 569
 570     f->seen_ack = 1;
 571
 572     switch (f->state) {
 573     case CLOSED:
 574     case STOPPED:
 575         fsm_sdata(f, TERMACK, id, NULL, 0);
 576         break;
 577
 578     case REQSENT:
 579     case ACKSENT:
 580         /* They didn't agree to what we wanted - try another request */
 581         UNTIMEOUT(fsm_timeout, f);      /* Cancel timeout */
 582         if (ret < 0)
 583             f->state = STOPPED;         /* kludge for stopping CCP */
 584         else
 585             fsm_sconfreq(f, 0);         /* Send Configure-Request */
 586         break;
 587
 588     case ACKRCVD:
 589         /* Got a Nak/reject when we had already had an Ack?? oh well... */
 590         UNTIMEOUT(fsm_timeout, f);      /* Cancel timeout */
 591         fsm_sconfreq(f, 0);
 592         f->state = REQSENT;
 593         break;
 594
 595     case OPENED:
 596         /* Go down and restart negotiation */
 597         if (f->callbacks->down)
 598             (*f->callbacks->down)(f);   /* Inform upper layers */
 599         fsm_sconfreq(f, 0);             /* Send initial Configure-Request */
 600         f->state = REQSENT;
 601         break;
 602     }
 603 }
 604
 605
 606 /*
 607  * fsm_rtermreq - Receive Terminate-Req.
 608  */
 609 static void
 610 fsm_rtermreq(f, id, p, len)
 611     fsm *f;
 612     int id;
 613     u_char *p;
 614     int len;
 615 {
 616     switch (f->state) {
 617     case ACKRCVD:
 618     case ACKSENT:
 619         f->state = REQSENT;             /* Start over but keep trying */
 620         break;
 621
 622     case OPENED:
 623         if (len > 0) {
 624             info("%s terminated by peer (%0.*v)", PROTO_NAME(f), len, p);
 625         } else
 626             info("%s terminated by peer", PROTO_NAME(f));
 627         f->retransmits = 0;
 628         f->state = STOPPING;
 629         if (f->callbacks->down)
 630             (*f->callbacks->down)(f);   /* Inform upper layers */
 631         TIMEOUT(fsm_timeout, f, f->timeouttime);
 632         break;
 633     }
 634
 635     fsm_sdata(f, TERMACK, id, NULL, 0);
 636 }
 637
 638
 639 /*
 640  * fsm_rtermack - Receive Terminate-Ack.
 641  */
 642 static void
 643 fsm_rtermack(f)
 644     fsm *f;
 645 {
 646     switch (f->state) {
 647     case CLOSING:
 648         UNTIMEOUT(fsm_timeout, f);
 649         f->state = CLOSED;
 650         if( f->callbacks->finished )
 651             (*f->callbacks->finished)(f);
 652         break;
 653     case STOPPING:
 654         UNTIMEOUT(fsm_timeout, f);
 655         f->state = STOPPED;
 656         if( f->callbacks->finished )
 657             (*f->callbacks->finished)(f);
 658         break;
 659
 660     case ACKRCVD:
 661         f->state = REQSENT;
 662         break;
 663
 664     case OPENED:
 665         if (f->callbacks->down)
 666             (*f->callbacks->down)(f);   /* Inform upper layers */
 667         fsm_sconfreq(f, 0);
 668         f->state = REQSENT;
 669         break;
 670     }
 671 }
 672
 673
 674 /*
 675  * fsm_rcoderej - Receive an Code-Reject.
 676  */
 677 static void
 678 fsm_rcoderej(f, inp, len)
 679     fsm *f;
 680     u_char *inp;
 681     int len;
 682 {
 683     u_char code, id;
 684
 685     if (len < HEADERLEN) {
 686         FSMDEBUG(("fsm_rcoderej: Rcvd short Code-Reject packet!"));
 687         return;
 688     }
 689     GETCHAR(code, inp);
 690     GETCHAR(id, inp);
 691     warn("%s: Rcvd Code-Reject for code %d, id %d", PROTO_NAME(f), code, id);
 692
 693     if( f->state == ACKRCVD )
 694         f->state = REQSENT;
 695 }
 696
 697
 698 /*
 699  * fsm_protreject - Peer doesn't speak this protocol.
 700  *
 701  * Treat this as a catastrophic error (RXJ-).
 702  */
 703 void
 704 fsm_protreject(f)
 705     fsm *f;
 706 {
 707     switch( f->state ){
 708     case CLOSING:
 709         UNTIMEOUT(fsm_timeout, f);      /* Cancel timeout */
 710         /* fall through */
 711     case CLOSED:
 712         f->state = CLOSED;
 713         if( f->callbacks->finished )
 714             (*f->callbacks->finished)(f);
 715         break;
 716
 717     case STOPPING:
 718     case REQSENT:
 719     case ACKRCVD:
 720     case ACKSENT:
 721         UNTIMEOUT(fsm_timeout, f);      /* Cancel timeout */
 722         /* fall through */
 723     case STOPPED:
 724         f->state = STOPPED;
 725         if( f->callbacks->finished )
 726             (*f->callbacks->finished)(f);
 727         break;
 728
 729     case OPENED:
 730         terminate_layer(f, STOPPING);
 731         break;
 732
 733     default:
 734         FSMDEBUG(("%s: Protocol-reject event in state %d!",
 735                   PROTO_NAME(f), f->state));
 736     }
 737 }
 738
 739
 740 /*
 741  * fsm_sconfreq - Send a Configure-Request.
 742  */
 743 static void
 744 fsm_sconfreq(f, retransmit)
 745     fsm *f;
 746     int retransmit;
 747 {
 748     u_char *outp;
 749     int cilen;
 750
 751     if( f->state != REQSENT && f->state != ACKRCVD && f->state != ACKSENT ){
 752         /* Not currently negotiating - reset options */
 753         if( f->callbacks->resetci )
 754             (*f->callbacks->resetci)(f);
 755         f->nakloops = 0;
 756         f->rnakloops = 0;
 757     }
 758
 759     if( !retransmit ){
 760         /* New request - reset retransmission counter, use new ID */
 761         f->retransmits = f->maxconfreqtransmits;
 762         f->reqid = ++f->id;
 763     }
 764
 765     f->seen_ack = 0;
 766
 767     /*
 768      * Make up the request packet
 769      */
 770     outp = outpacket_buf + PPP_HDRLEN + HEADERLEN;
 771     if( f->callbacks->cilen && f->callbacks->addci ){
 772         cilen = (*f->callbacks->cilen)(f);
 773         if( cilen > peer_mru[f->unit] - HEADERLEN )
 774             cilen = peer_mru[f->unit] - HEADERLEN;
 775         if (f->callbacks->addci)
 776             (*f->callbacks->addci)(f, outp, &cilen);
 777     } else
 778         cilen = 0;
 779
 780     /* send the request to our peer */
 781     fsm_sdata(f, CONFREQ, f->reqid, outp, cilen);
 782
 783     /* start the retransmit timer */
 784     --f->retransmits;
 785     TIMEOUT(fsm_timeout, f, f->timeouttime);
 786 }
 787
 788
 789 /*
 790  * fsm_sdata - Send some data.
 791  *
 792  * Used for all packets sent to our peer by this module.
 793  */
 794 void
 795 fsm_sdata(f, code, id, data, datalen)
 796     fsm *f;
 797     u_char code, id;
 798     u_char *data;
 799     int datalen;
 800 {
 801     u_char *outp;
 802     int outlen;
 803
 804     /* Adjust length to be smaller than MTU */
 805     outp = outpacket_buf;
 806     if (datalen > peer_mru[f->unit] - HEADERLEN)
 807         datalen = peer_mru[f->unit] - HEADERLEN;
 808     if (datalen && data != outp + PPP_HDRLEN + HEADERLEN)
 809         BCOPY(data, outp + PPP_HDRLEN + HEADERLEN, datalen);
 810     outlen = datalen + HEADERLEN;
 811     MAKEHEADER(outp, f->protocol);
 812     PUTCHAR(code, outp);
 813     PUTCHAR(id, outp);
 814     PUTSHORT(outlen, outp);
 815     output(f->unit, outpacket_buf, outlen + PPP_HDRLEN);
 816 }