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