pppd/fsm.c

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