开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
fsm.c
资源名称：vxwork_src.rar　[点击查看]
上传用户：nvosite88
上传日期：2007-01-17
资源大小：4983k
文件大小：17k
源码类别：

VxWorks

开发平台：

C/C++

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