X-Git-Url: https://git.ozlabs.org/?p=ppp.git;a=blobdiff_plain;f=pppd%2Flcp.c;h=231b7e4552861ea828cb361e9923bccf83c061d3;hp=e92639c4332cdb699fb5569f88657ba3486649a4;hb=2c872bc67b83b91ba6390f6e5e72be08e09811a1;hpb=e3a35824cd85bf337d77fda821f149a90aabb674 diff --git a/pppd/lcp.c b/pppd/lcp.c index e92639c..231b7e4 100644 --- a/pppd/lcp.c +++ b/pppd/lcp.c @@ -17,9 +17,7 @@ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. */ -#ifndef lint -static char rcsid[] = "$Id: lcp.c,v 1.23 1995/12/18 03:45:32 paulus Exp $"; -#endif +#define RCSID "$Id: lcp.c,v 1.48 2000/03/27 06:02:59 paulus Exp $"; /* * TODO: @@ -27,13 +25,7 @@ static char rcsid[] = "$Id: lcp.c,v 1.23 1995/12/18 03:45:32 paulus Exp $"; #include #include -#include -#include -#include -#include -#include -#include -#include +#include #include "pppd.h" #include "fsm.h" @@ -41,10 +33,90 @@ static char rcsid[] = "$Id: lcp.c,v 1.23 1995/12/18 03:45:32 paulus Exp $"; #include "chap.h" #include "magic.h" -#ifdef _linux_ /* Needs ppp ioctls */ -#include -#include -#endif +static const char rcsid[] = RCSID; + +/* + * LCP-related command-line options. + */ +int lcp_echo_interval = 0; /* Interval between LCP echo-requests */ +int lcp_echo_fails = 0; /* Tolerance to unanswered echo-requests */ +bool lax_recv = 0; /* accept control chars in asyncmap */ + +static int setescape __P((char **)); + +static option_t lcp_option_list[] = { + /* LCP options */ + { "noaccomp", o_bool, &lcp_wantoptions[0].neg_accompression, + "Disable address/control compression", + OPT_A2COPY, &lcp_allowoptions[0].neg_accompression }, + { "-ac", o_bool, &lcp_wantoptions[0].neg_accompression, + "Disable address/control compression", + OPT_A2COPY, &lcp_allowoptions[0].neg_accompression }, + { "default-asyncmap", o_bool, &lcp_wantoptions[0].neg_asyncmap, + "Disable asyncmap negotiation", + OPT_A2COPY, &lcp_allowoptions[0].neg_asyncmap }, + { "-am", o_bool, &lcp_wantoptions[0].neg_asyncmap, + "Disable asyncmap negotiation", + OPT_A2COPY, &lcp_allowoptions[0].neg_asyncmap }, + { "asyncmap", o_uint32, &lcp_wantoptions[0].asyncmap, + "Set asyncmap (for received packets)", + OPT_OR, &lcp_wantoptions[0].neg_asyncmap }, + { "-as", o_uint32, &lcp_wantoptions[0].asyncmap, + "Set asyncmap (for received packets)", + OPT_OR, &lcp_wantoptions[0].neg_asyncmap }, + { "nomagic", o_bool, &lcp_wantoptions[0].neg_magicnumber, + "Disable magic number negotiation (looped-back line detection)", + OPT_A2COPY, &lcp_allowoptions[0].neg_magicnumber }, + { "-mn", o_bool, &lcp_wantoptions[0].neg_magicnumber, + "Disable magic number negotiation (looped-back line detection)", + OPT_A2COPY, &lcp_allowoptions[0].neg_magicnumber }, + { "default-mru", o_bool, &lcp_wantoptions[0].neg_mru, + "Disable MRU negotiation (use default 1500)", + OPT_A2COPY, &lcp_allowoptions[0].neg_mru }, + { "-mru", o_bool, &lcp_wantoptions[0].neg_mru, + "Disable MRU negotiation (use default 1500)", + OPT_A2COPY, &lcp_allowoptions[0].neg_mru }, + { "mru", o_int, &lcp_wantoptions[0].mru, + "Set MRU (maximum received packet size) for negotiation", + 0, &lcp_wantoptions[0].neg_mru }, + { "nopcomp", o_bool, &lcp_wantoptions[0].neg_pcompression, + "Disable protocol field compression", + OPT_A2COPY, &lcp_allowoptions[0].neg_pcompression }, + { "-pc", o_bool, &lcp_wantoptions[0].neg_pcompression, + "Disable protocol field compression", + OPT_A2COPY, &lcp_allowoptions[0].neg_pcompression }, + { "-p", o_bool, &lcp_wantoptions[0].passive, + "Set passive mode", 1 }, + { "passive", o_bool, &lcp_wantoptions[0].passive, + "Set passive mode", 1 }, + { "silent", o_bool, &lcp_wantoptions[0].silent, + "Set silent mode", 1 }, + { "escape", o_special, setescape, + "List of character codes to escape on transmission" }, + { "lcp-echo-failure", o_int, &lcp_echo_fails, + "Set number of consecutive echo failures to indicate link failure" }, + { "lcp-echo-interval", o_int, &lcp_echo_interval, + "Set time in seconds between LCP echo requests" }, + { "lcp-restart", o_int, &lcp_fsm[0].timeouttime, + "Set time in seconds between LCP retransmissions" }, + { "lcp-max-terminate", o_int, &lcp_fsm[0].maxtermtransmits, + "Set maximum number of LCP terminate-request transmissions" }, + { "lcp-max-configure", o_int, &lcp_fsm[0].maxconfreqtransmits, + "Set maximum number of LCP configure-request transmissions" }, + { "lcp-max-failure", o_int, &lcp_fsm[0].maxnakloops, + "Set limit on number of LCP configure-naks" }, + { "receive-all", o_bool, &lax_recv, + "Accept all received control characters", 1 }, +#ifdef HAVE_MULTILINK + { "mpshortseq", o_bool, &lcp_wantoptions[0].neg_ssnhf, + "Use short sequence numbers in multilink headers", + OPT_A2COPY, &lcp_allowoptions[0].neg_ssnhf }, + { "nompshortseq", o_bool, &lcp_wantoptions[0].neg_ssnhf, + "Don't use short sequence numbers in multilink headers", + OPT_A2COPY, &lcp_allowoptions[0].neg_ssnhf }, +#endif /* HAVE_MULTILINK */ + {NULL} +}; /* global vars */ fsm lcp_fsm[NUM_PPP]; /* LCP fsm structure (global)*/ @@ -54,17 +126,12 @@ lcp_options lcp_allowoptions[NUM_PPP]; /* Options we allow peer to request */ lcp_options lcp_hisoptions[NUM_PPP]; /* Options that we ack'd */ u_int32_t xmit_accm[NUM_PPP][8]; /* extended transmit ACCM */ -static u_int32_t lcp_echos_pending = 0; /* Number of outstanding echo msgs */ -static u_int32_t lcp_echo_number = 0; /* ID number of next echo frame */ -static u_int32_t lcp_echo_timer_running = 0; /* TRUE if a timer is running */ +static int lcp_echos_pending = 0; /* Number of outstanding echo msgs */ +static int lcp_echo_number = 0; /* ID number of next echo frame */ +static int lcp_echo_timer_running = 0; /* set if a timer is running */ static u_char nak_buffer[PPP_MRU]; /* where we construct a nak packet */ -#ifdef _linux_ -u_int32_t idle_timer_running = 0; -extern int idle_time_limit; -#endif - /* * Callbacks for fsm code. (CI = Configuration Information) */ @@ -88,10 +155,11 @@ static void lcp_rprotrej __P((fsm *, u_char *, int)); static void lcp_echo_lowerup __P((int)); static void lcp_echo_lowerdown __P((int)); -static void LcpEchoTimeout __P((caddr_t)); +static void LcpEchoTimeout __P((void *)); static void lcp_received_echo_reply __P((fsm *, int, u_char *, int)); static void LcpSendEchoRequest __P((fsm *)); static void LcpLinkFailure __P((fsm *)); +static void LcpEchoCheck __P((fsm *)); static fsm_callbacks lcp_callbacks = { /* LCP callback routines */ lcp_resetci, /* Reset our Configuration Information */ @@ -111,10 +179,35 @@ static fsm_callbacks lcp_callbacks = { /* LCP callback routines */ "LCP" /* String name of protocol */ }; +/* + * Protocol entry points. + * Some of these are called directly. + */ + +static void lcp_init __P((int)); +static void lcp_input __P((int, u_char *, int)); +static void lcp_protrej __P((int)); +static int lcp_printpkt __P((u_char *, int, + void (*) __P((void *, char *, ...)), void *)); + struct protent lcp_protent = { - PPP_LCP, lcp_init, lcp_input, lcp_protrej, - lcp_lowerup, lcp_lowerdown, lcp_open, lcp_close, - lcp_printpkt, NULL, 1, "LCP" + PPP_LCP, + lcp_init, + lcp_input, + lcp_protrej, + lcp_lowerup, + lcp_lowerdown, + lcp_open, + lcp_close, + lcp_printpkt, + NULL, + 1, + "LCP", + NULL, + lcp_option_list, + NULL, + NULL, + NULL }; int lcp_loopbackfail = DEFLOOPBACKFAIL; @@ -123,19 +216,52 @@ int lcp_loopbackfail = DEFLOOPBACKFAIL; * Length of each type of configuration option (in octets) */ #define CILEN_VOID 2 -#define CILEN_SHORT 4 /* CILEN_VOID + sizeof(short) */ -#define CILEN_CHAP 5 /* CILEN_VOID + sizeof(short) + 1 */ -#define CILEN_LONG 6 /* CILEN_VOID + sizeof(long) */ -#define CILEN_LQR 8 /* CILEN_VOID + sizeof(short) + sizeof(long) */ +#define CILEN_CHAR 3 +#define CILEN_SHORT 4 /* CILEN_VOID + 2 */ +#define CILEN_CHAP 5 /* CILEN_VOID + 2 + 1 */ +#define CILEN_LONG 6 /* CILEN_VOID + 4 */ +#define CILEN_LQR 8 /* CILEN_VOID + 2 + 4 */ +#define CILEN_CBCP 3 #define CODENAME(x) ((x) == CONFACK ? "ACK" : \ (x) == CONFNAK ? "NAK" : "REJ") +/* + * setescape - add chars to the set we escape on transmission. + */ +static int +setescape(argv) + char **argv; +{ + int n, ret; + char *p, *endp; + + p = *argv; + ret = 1; + while (*p) { + n = strtol(p, &endp, 16); + if (p == endp) { + option_error("escape parameter contains invalid hex number '%s'", + p); + return 0; + } + p = endp; + if (n < 0 || n == 0x5E || n > 0xFF) { + option_error("can't escape character 0x%x", n); + ret = 0; + } else + xmit_accm[0][n >> 5] |= 1 << (n & 0x1F); + while (*p == ',' || *p == ' ') + ++p; + } + return ret; +} + /* * lcp_init - Initialize LCP. */ -void +static void lcp_init(unit) int unit; { @@ -155,7 +281,7 @@ lcp_init(unit) implementations */ wo->neg_mru = 1; wo->mru = DEFMRU; - wo->neg_asyncmap = 0; + wo->neg_asyncmap = 1; wo->asyncmap = 0; wo->neg_chap = 0; /* Set to 1 on server */ wo->neg_upap = 0; /* Set to 1 on server */ @@ -164,6 +290,7 @@ lcp_init(unit) wo->neg_pcompression = 1; wo->neg_accompression = 1; wo->neg_lqr = 0; /* no LQR implementation yet */ + wo->neg_cbcp = 0; ao->neg_mru = 1; ao->mru = MAXMRU; @@ -176,6 +303,11 @@ lcp_init(unit) ao->neg_pcompression = 1; ao->neg_accompression = 1; ao->neg_lqr = 0; /* no LQR implementation yet */ +#ifdef CBCP_SUPPORT + ao->neg_cbcp = 1; +#else + ao->neg_cbcp = 0; +#endif memset(xmit_accm[unit], 0, sizeof(xmit_accm[0])); xmit_accm[unit][3] = 0x60000000; @@ -211,11 +343,13 @@ lcp_close(unit, reason) { fsm *f = &lcp_fsm[unit]; + if (phase != PHASE_DEAD) + new_phase(PHASE_TERMINATE); if (f->state == STOPPED && f->flags & (OPT_PASSIVE|OPT_SILENT)) { /* * This action is not strictly according to the FSM in RFC1548, * but it does mean that the program terminates if you do a - * lcp_close(0) in passive/silent mode when a connection hasn't + * lcp_close() in passive/silent mode when a connection hasn't * been established. */ f->state = CLOSED; @@ -225,58 +359,6 @@ lcp_close(unit, reason) fsm_close(&lcp_fsm[unit], reason); } -#ifdef _linux_ -static void IdleTimeCheck __P((caddr_t)); - -/* - * Timer expired for the LCP echo requests from this process. - */ - -static void -RestartIdleTimer (f) - fsm *f; -{ - u_long delta; - struct ppp_idle ddinfo; -/* - * Read the time since the last packet was received. - */ - if (ioctl (fd, PPPIOCGIDLE, &ddinfo) < 0) { - syslog (LOG_ERR, "ioctl(PPPIOCGIDLE): %m"); - die (1); - } -/* - * Compute the time since the last packet was received. If the timer - * has expired then disconnect the line. - */ - delta = idle_time_limit - (u_long) ddinfo.recv_idle; - if (((int) delta <= 0L) && (f->state == OPENED)) { - syslog (LOG_NOTICE, "No IP frames received within idle time limit"); - lcp_close(f->unit, "Idle time limit expired"); /* Reset connection */ - phase = PHASE_TERMINATE; /* Mark it down */ - } else { - if ((int) delta <= 0L) - delta = (u_long) idle_time_limit; - assert (idle_timer_running==0); - TIMEOUT (IdleTimeCheck, (caddr_t) f, delta); - idle_timer_running = 1; - } -} - -/* - * IdleTimeCheck - Timer expired on the IDLE detection for IP frames - */ - -static void -IdleTimeCheck (arg) - caddr_t arg; -{ - if (idle_timer_running != 0) { - idle_timer_running = 0; - RestartIdleTimer ((fsm *) arg); - } -} -#endif /* * lcp_lowerup - The lower layer is up. @@ -287,7 +369,6 @@ lcp_lowerup(unit) { lcp_options *wo = &lcp_wantoptions[unit]; - sifdown(unit); /* * Don't use A/C or protocol compression on transmission, * but accept A/C and protocol compressed packets @@ -295,7 +376,7 @@ lcp_lowerup(unit) */ ppp_set_xaccm(unit, xmit_accm[unit]); ppp_send_config(unit, PPP_MRU, 0xffffffff, 0, 0); - ppp_recv_config(unit, PPP_MRU, 0x00000000, + ppp_recv_config(unit, PPP_MRU, (lax_recv? 0: 0xffffffff), wo->neg_pcompression, wo->neg_accompression); peer_mru[unit] = PPP_MRU; lcp_allowoptions[unit].asyncmap = xmit_accm[unit][0]; @@ -318,7 +399,7 @@ lcp_lowerdown(unit) /* * lcp_input - Input LCP packet. */ -void +static void lcp_input(unit, p, len) int unit; u_char *p; @@ -350,7 +431,6 @@ lcp_extcode(f, code, id, inp, len) case ECHOREQ: if (f->state != OPENED) break; - LCPDEBUG((LOG_INFO, "lcp: Echo-Request, Rcvd id %d", id)); magp = inp; PUTLONG(lcp_gotoptions[f->unit].magicnumber, magp); fsm_sdata(f, ECHOREP, id, inp, len); @@ -385,27 +465,19 @@ lcp_rprotrej(f, inp, len) struct protent *protp; u_short prot; - LCPDEBUG((LOG_INFO, "lcp_rprotrej.")); - - if (len < sizeof (u_short)) { - LCPDEBUG((LOG_INFO, - "lcp_rprotrej: Rcvd short Protocol-Reject packet!")); + if (len < 2) { + LCPDEBUG(("lcp_rprotrej: Rcvd short Protocol-Reject packet!")); return; } GETSHORT(prot, inp); - LCPDEBUG((LOG_INFO, - "lcp_rprotrej: Rcvd Protocol-Reject packet for %x!", - prot)); - /* * Protocol-Reject packets received in any state other than the LCP * OPENED state SHOULD be silently discarded. */ if( f->state != OPENED ){ - LCPDEBUG((LOG_INFO, "Protocol-Reject discarded: LCP in state %d", - f->state)); + LCPDEBUG(("Protocol-Reject discarded: LCP in state %d", f->state)); return; } @@ -418,8 +490,7 @@ lcp_rprotrej(f, inp, len) return; } - syslog(LOG_WARNING, "Protocol-Reject for unsupported protocol 0x%x", - prot); + warn("Protocol-Reject for unsupported protocol 0x%x", prot); } @@ -427,15 +498,14 @@ lcp_rprotrej(f, inp, len) * lcp_protrej - A Protocol-Reject was received. */ /*ARGSUSED*/ -void +static void lcp_protrej(unit) int unit; { /* * Can't reject LCP! */ - LCPDEBUG((LOG_WARNING, - "lcp_protrej: Received Protocol-Reject for LCP!")); + error("Received Protocol-Reject for LCP!"); fsm_protreject(&lcp_fsm[unit]); } @@ -468,10 +538,15 @@ static void lcp_resetci(f) fsm *f; { - lcp_wantoptions[f->unit].magicnumber = magic(); - lcp_wantoptions[f->unit].numloops = 0; - lcp_gotoptions[f->unit] = lcp_wantoptions[f->unit]; + lcp_options *wo = &lcp_wantoptions[f->unit]; + + wo->magicnumber = magic(); + wo->numloops = 0; + if (!wo->neg_multilink) + wo->neg_ssnhf = 0; + lcp_gotoptions[f->unit] = *wo; peer_mru[f->unit] = PPP_MRU; + auth_reset(f->unit); } @@ -489,6 +564,7 @@ lcp_cilen(f) #define LENCISHORT(neg) ((neg) ? CILEN_SHORT : 0) #define LENCILONG(neg) ((neg) ? CILEN_LONG : 0) #define LENCILQR(neg) ((neg) ? CILEN_LQR: 0) +#define LENCICBCP(neg) ((neg) ? CILEN_CBCP: 0) /* * NB: we only ask for one of CHAP and UPAP, even if we will * accept either. @@ -498,9 +574,13 @@ lcp_cilen(f) LENCICHAP(go->neg_chap) + LENCISHORT(!go->neg_chap && go->neg_upap) + LENCILQR(go->neg_lqr) + + LENCICBCP(go->neg_cbcp) + LENCILONG(go->neg_magicnumber) + LENCIVOID(go->neg_pcompression) + - LENCIVOID(go->neg_accompression)); + LENCIVOID(go->neg_accompression) + + LENCISHORT(go->neg_multilink) + + LENCIVOID(go->neg_ssnhf) + + (go->neg_endpoint? CILEN_CHAR + go->endp_len: 0)); } @@ -547,6 +627,21 @@ lcp_addci(f, ucp, lenp) PUTSHORT(PPP_LQR, ucp); \ PUTLONG(val, ucp); \ } +#define ADDCICHAR(opt, neg, val) \ + if (neg) { \ + PUTCHAR(opt, ucp); \ + PUTCHAR(CILEN_CHAR, ucp); \ + PUTCHAR(val, ucp); \ + } +#define ADDCIENDP(opt, neg, class, val, len) \ + if (neg) { \ + int i; \ + PUTCHAR(opt, ucp); \ + PUTCHAR(CILEN_CHAR + len, ucp); \ + PUTCHAR(class, ucp); \ + for (i = 0; i < len; ++i) \ + PUTCHAR(val[i], ucp); \ + } ADDCISHORT(CI_MRU, go->neg_mru && go->mru != DEFMRU, go->mru); ADDCILONG(CI_ASYNCMAP, go->neg_asyncmap && go->asyncmap != 0xFFFFFFFF, @@ -554,13 +649,18 @@ lcp_addci(f, ucp, lenp) ADDCICHAP(CI_AUTHTYPE, go->neg_chap, PPP_CHAP, go->chap_mdtype); ADDCISHORT(CI_AUTHTYPE, !go->neg_chap && go->neg_upap, PPP_PAP); ADDCILQR(CI_QUALITY, go->neg_lqr, go->lqr_period); + ADDCICHAR(CI_CALLBACK, go->neg_cbcp, CBCP_OPT); ADDCILONG(CI_MAGICNUMBER, go->neg_magicnumber, go->magicnumber); ADDCIVOID(CI_PCOMPRESSION, go->neg_pcompression); ADDCIVOID(CI_ACCOMPRESSION, go->neg_accompression); + ADDCISHORT(CI_MRRU, go->neg_multilink, go->mrru); + ADDCIVOID(CI_SSNHF, go->neg_ssnhf); + ADDCIENDP(CI_EPDISC, go->neg_endpoint, go->endp_class, go->endpoint, + go->endp_len); if (ucp - start_ucp != *lenp) { /* this should never happen, because peer_mtu should be 1500 */ - syslog(LOG_ERR, "Bug in lcp_addci: wrong length"); + error("Bug in lcp_addci: wrong length"); } } @@ -612,6 +712,19 @@ lcp_ackci(f, p, len) if (cishort != val) \ goto bad; \ } +#define ACKCICHAR(opt, neg, val) \ + if (neg) { \ + if ((len -= CILEN_CHAR) < 0) \ + goto bad; \ + GETCHAR(citype, p); \ + GETCHAR(cilen, p); \ + if (cilen != CILEN_CHAR || \ + citype != opt) \ + goto bad; \ + GETCHAR(cichar, p); \ + if (cichar != val) \ + goto bad; \ + } #define ACKCICHAP(opt, neg, val, digest) \ if (neg) { \ if ((len -= CILEN_CHAP) < 0) \ @@ -657,6 +770,25 @@ lcp_ackci(f, p, len) if (cilong != val) \ goto bad; \ } +#define ACKCIENDP(opt, neg, class, val, vlen) \ + if (neg) { \ + int i; \ + if ((len -= CILEN_CHAR + vlen) < 0) \ + goto bad; \ + GETCHAR(citype, p); \ + GETCHAR(cilen, p); \ + if (cilen != CILEN_CHAR + vlen || \ + citype != opt) \ + goto bad; \ + GETCHAR(cichar, p); \ + if (cichar != class) \ + goto bad; \ + for (i = 0; i < vlen; ++i) { \ + GETCHAR(cichar, p); \ + if (cichar != val[i]) \ + goto bad; \ + } \ + } ACKCISHORT(CI_MRU, go->neg_mru && go->mru != DEFMRU, go->mru); ACKCILONG(CI_ASYNCMAP, go->neg_asyncmap && go->asyncmap != 0xFFFFFFFF, @@ -664,9 +796,14 @@ lcp_ackci(f, p, len) ACKCICHAP(CI_AUTHTYPE, go->neg_chap, PPP_CHAP, go->chap_mdtype); ACKCISHORT(CI_AUTHTYPE, !go->neg_chap && go->neg_upap, PPP_PAP); ACKCILQR(CI_QUALITY, go->neg_lqr, go->lqr_period); + ACKCICHAR(CI_CALLBACK, go->neg_cbcp, CBCP_OPT); ACKCILONG(CI_MAGICNUMBER, go->neg_magicnumber, go->magicnumber); ACKCIVOID(CI_PCOMPRESSION, go->neg_pcompression); ACKCIVOID(CI_ACCOMPRESSION, go->neg_accompression); + ACKCISHORT(CI_MRRU, go->neg_multilink, go->mrru); + ACKCIVOID(CI_SSNHF, go->neg_ssnhf); + ACKCIENDP(CI_EPDISC, go->neg_endpoint, go->endp_class, go->endpoint, + go->endp_len); /* * If there are any remaining CIs, then this packet is bad. @@ -675,7 +812,7 @@ lcp_ackci(f, p, len) goto bad; return (1); bad: - LCPDEBUG((LOG_WARNING, "lcp_acki: received bad Ack!")); + LCPDEBUG(("lcp_acki: received bad Ack!")); return (0); } @@ -713,7 +850,7 @@ lcp_nakci(f, p, len) * Check packet length and CI length at each step. * If we find any deviations, then this packet is bad. */ -#define NAKCIVOID(opt, neg, code) \ +#define NAKCIVOID(opt, neg) \ if (go->neg && \ len >= CILEN_VOID && \ p[1] == CILEN_VOID && \ @@ -721,7 +858,7 @@ lcp_nakci(f, p, len) len -= CILEN_VOID; \ INCPTR(CILEN_VOID, p); \ no.neg = 1; \ - code \ + try.neg = 0; \ } #define NAKCICHAP(opt, neg, code) \ if (go->neg && \ @@ -735,6 +872,17 @@ lcp_nakci(f, p, len) no.neg = 1; \ code \ } +#define NAKCICHAR(opt, neg, code) \ + if (go->neg && \ + len >= CILEN_CHAR && \ + p[1] == CILEN_CHAR && \ + p[0] == opt) { \ + len -= CILEN_CHAR; \ + INCPTR(2, p); \ + GETCHAR(cichar, p); \ + no.neg = 1; \ + code \ + } #define NAKCISHORT(opt, neg, code) \ if (go->neg && \ len >= CILEN_SHORT && \ @@ -769,6 +917,17 @@ lcp_nakci(f, p, len) no.neg = 1; \ code \ } +#define NAKCIENDP(opt, neg) \ + if (go->neg && \ + len >= CILEN_CHAR && \ + p[0] == opt && \ + p[1] >= CILEN_CHAR && \ + p[1] <= len) { \ + len -= p[1]; \ + INCPTR(p[1], p); \ + no.neg = 1; \ + try.neg = 0; \ + } /* * We don't care if they want to send us smaller packets than @@ -779,7 +938,7 @@ lcp_nakci(f, p, len) */ if (go->neg_mru && go->mru != DEFMRU) { NAKCISHORT(CI_MRU, neg_mru, - if (cishort <= wo->mru || cishort < DEFMRU) + if (cishort <= wo->mru || cishort <= DEFMRU) try.mru = cishort; ); } @@ -800,35 +959,45 @@ lcp_nakci(f, p, len) */ if ((go->neg_chap || go->neg_upap) && len >= CILEN_SHORT - && p[0] == CI_AUTHTYPE && p[1] >= CILEN_SHORT) { + && p[0] == CI_AUTHTYPE && p[1] >= CILEN_SHORT && p[1] <= len) { cilen = p[1]; + len -= cilen; + no.neg_chap = go->neg_chap; + no.neg_upap = go->neg_upap; INCPTR(2, p); GETSHORT(cishort, p); if (cishort == PPP_PAP && cilen == CILEN_SHORT) { /* - * If they are asking for PAP, then they don't want to do CHAP. + * If we were asking for CHAP, they obviously don't want to do it. * If we weren't asking for CHAP, then we were asking for PAP, * in which case this Nak is bad. */ if (!go->neg_chap) goto bad; - go->neg_chap = 0; + try.neg_chap = 0; } else if (cishort == PPP_CHAP && cilen == CILEN_CHAP) { GETCHAR(cichar, p); if (go->neg_chap) { /* * We were asking for CHAP/MD5; they must want a different - * algorithm. If they can't do MD5, we'll have to stop + * algorithm. If they can't do MD5, we can ask for M$-CHAP + * if we support it, otherwise we'll have to stop * asking for CHAP. */ - if (cichar != go->chap_mdtype) - go->neg_chap = 0; + if (cichar != go->chap_mdtype) { +#ifdef CHAPMS + if (cichar == CHAP_MICROSOFT) + go->chap_mdtype = CHAP_MICROSOFT; + else +#endif /* CHAPMS */ + try.neg_chap = 0; + } } else { /* * Stop asking for PAP if we were asking for it. */ - go->neg_upap = 0; + try.neg_upap = 0; } } else { @@ -837,24 +1006,13 @@ lcp_nakci(f, p, len) * Stop asking for what we were asking for. */ if (go->neg_chap) - go->neg_chap = 0; + try.neg_chap = 0; else - go->neg_upap = 0; + try.neg_upap = 0; p += cilen - CILEN_SHORT; } } - /* - * Peer shouldn't send Nak for protocol compression or - * address/control compression requests; they should send - * a Reject instead. If they send a Nak, treat it as a Reject. - */ - if (!go->neg_chap ){ - NAKCISHORT(CI_AUTHTYPE, neg_upap, - try.neg_upap = 0; - ); - } - /* * If they can't cope with our link quality protocol, we'll have * to stop asking for LQR. We haven't got any other protocol. @@ -867,6 +1025,13 @@ lcp_nakci(f, p, len) try.lqr_period = cilong; ); + /* + * Only implementing CBCP...not the rest of the callback options + */ + NAKCICHAR(CI_CALLBACK, neg_cbcp, + try.neg_cbcp = 0; + ); + /* * Check for a looped-back line. */ @@ -875,12 +1040,36 @@ lcp_nakci(f, p, len) looped_back = 1; ); - NAKCIVOID(CI_PCOMPRESSION, neg_pcompression, - try.neg_pcompression = 0; - ); - NAKCIVOID(CI_ACCOMPRESSION, neg_accompression, - try.neg_accompression = 0; - ); + /* + * Peer shouldn't send Nak for protocol compression or + * address/control compression requests; they should send + * a Reject instead. If they send a Nak, treat it as a Reject. + */ + NAKCIVOID(CI_PCOMPRESSION, neg_pcompression); + NAKCIVOID(CI_ACCOMPRESSION, neg_accompression); + + /* + * Nak for MRRU option - accept their value if it is smaller + * than the one we want. + */ + if (go->neg_multilink) { + NAKCISHORT(CI_MRRU, neg_multilink, + if (cishort <= wo->mrru) + try.mrru = cishort; + ); + } + + /* + * Nak for short sequence numbers shouldn't be sent, treat it + * like a reject. + */ + NAKCIVOID(CI_SSNHF, neg_ssnhf); + + /* + * Nak of the endpoint discriminator option is not permitted, + * treat it like a reject. + */ + NAKCIENDP(CI_EPDISC, neg_endpoint); /* * There may be remaining CIs, if the peer is requesting negotiation @@ -901,21 +1090,23 @@ lcp_nakci(f, p, len) while (len > CILEN_VOID) { GETCHAR(citype, p); GETCHAR(cilen, p); - if ((len -= cilen) < 0) + if (cilen < CILEN_VOID || (len -= cilen) < 0) goto bad; next = p + cilen - 2; switch (citype) { case CI_MRU: - if (go->neg_mru && go->mru != DEFMRU + if ((go->neg_mru && go->mru != DEFMRU) || no.neg_mru || cilen != CILEN_SHORT) goto bad; GETSHORT(cishort, p); - if (cishort < DEFMRU) + if (cishort < DEFMRU) { + try.neg_mru = 1; try.mru = cishort; + } break; case CI_ASYNCMAP: - if (go->neg_asyncmap && go->asyncmap != 0xFFFFFFFF + if ((go->neg_asyncmap && go->asyncmap != 0xFFFFFFFF) || no.neg_asyncmap || cilen != CILEN_LONG) goto bad; break; @@ -942,22 +1133,33 @@ lcp_nakci(f, p, len) if (go->neg_lqr || no.neg_lqr || cilen != CILEN_LQR) goto bad; break; + case CI_MRRU: + if (go->neg_multilink || no.neg_multilink || cilen != CILEN_SHORT) + goto bad; + break; + case CI_SSNHF: + if (go->neg_ssnhf || no.neg_ssnhf || cilen != CILEN_VOID) + goto bad; + try.neg_ssnhf = 1; + break; + case CI_EPDISC: + if (go->neg_endpoint || no.neg_endpoint || cilen < CILEN_CHAR) + goto bad; + break; } p = next; } - /* If there is still anything left, this packet is bad. */ - if (len != 0) - goto bad; - /* * OK, the Nak is good. Now we can update state. + * If there are any options left we ignore them. */ if (f->state != OPENED) { if (looped_back) { if (++try.numloops >= lcp_loopbackfail) { - syslog(LOG_NOTICE, "Serial line is looped back."); + notice("Serial line is looped back."); lcp_close(f->unit, "Loopback detected"); + status = EXIT_LOOPBACK; } } else try.numloops = 0; @@ -967,7 +1169,7 @@ lcp_nakci(f, p, len) return 1; bad: - LCPDEBUG((LOG_WARNING, "lcp_nakci: received bad Nak!")); + LCPDEBUG(("lcp_nakci: received bad Nak!")); return 0; } @@ -991,8 +1193,6 @@ lcp_rejci(f, p, len) u_char cichar; u_short cishort; u_int32_t cilong; - u_char *start = p; - int plen = len; lcp_options try; /* options to request next time */ try = *go; @@ -1010,7 +1210,6 @@ lcp_rejci(f, p, len) len -= CILEN_VOID; \ INCPTR(CILEN_VOID, p); \ try.neg = 0; \ - LCPDEBUG((LOG_INFO, "lcp_rejci rejected void opt %d", opt)); \ } #define REJCISHORT(opt, neg, val) \ if (go->neg && \ @@ -1024,7 +1223,6 @@ lcp_rejci(f, p, len) if (cishort != val) \ goto bad; \ try.neg = 0; \ - LCPDEBUG((LOG_INFO,"lcp_rejci rejected short opt %d", opt)); \ } #define REJCICHAP(opt, neg, val, digest) \ if (go->neg && \ @@ -1040,7 +1238,6 @@ lcp_rejci(f, p, len) goto bad; \ try.neg = 0; \ try.neg_upap = 0; \ - LCPDEBUG((LOG_INFO,"lcp_rejci rejected chap opt %d", opt)); \ } #define REJCILONG(opt, neg, val) \ if (go->neg && \ @@ -1054,7 +1251,6 @@ lcp_rejci(f, p, len) if (cilong != val) \ goto bad; \ try.neg = 0; \ - LCPDEBUG((LOG_INFO,"lcp_rejci rejected long opt %d", opt)); \ } #define REJCILQR(opt, neg, val) \ if (go->neg && \ @@ -1069,7 +1265,37 @@ lcp_rejci(f, p, len) if (cishort != PPP_LQR || cilong != val) \ goto bad; \ try.neg = 0; \ - LCPDEBUG((LOG_INFO,"lcp_rejci rejected LQR opt %d", opt)); \ + } +#define REJCICBCP(opt, neg, val) \ + if (go->neg && \ + len >= CILEN_CBCP && \ + p[1] == CILEN_CBCP && \ + p[0] == opt) { \ + len -= CILEN_CBCP; \ + INCPTR(2, p); \ + GETCHAR(cichar, p); \ + /* Check rejected value. */ \ + if (cichar != val) \ + goto bad; \ + try.neg = 0; \ + } +#define REJCIENDP(opt, neg, class, val, vlen) \ + if (go->neg && \ + len >= CILEN_CHAR + vlen && \ + p[0] == opt && \ + p[1] == CILEN_CHAR + vlen) { \ + int i; \ + len -= CILEN_CHAR + vlen; \ + INCPTR(p[1], p); \ + GETCHAR(cichar, p); \ + if (cichar != class) \ + goto bad; \ + for (i = 0; i < vlen; ++i) { \ + GETCHAR(cichar, p); \ + if (cichar != val[i]) \ + goto bad; \ + } \ + try.neg = 0; \ } REJCISHORT(CI_MRU, neg_mru, go->mru); @@ -1079,9 +1305,14 @@ lcp_rejci(f, p, len) REJCISHORT(CI_AUTHTYPE, neg_upap, PPP_PAP); } REJCILQR(CI_QUALITY, neg_lqr, go->lqr_period); + REJCICBCP(CI_CALLBACK, neg_cbcp, CBCP_OPT); REJCILONG(CI_MAGICNUMBER, neg_magicnumber, go->magicnumber); REJCIVOID(CI_PCOMPRESSION, neg_pcompression); REJCIVOID(CI_ACCOMPRESSION, neg_accompression); + REJCISHORT(CI_MRRU, neg_multilink, go->mrru); + REJCIVOID(CI_SSNHF, neg_ssnhf); + REJCIENDP(CI_EPDISC, neg_endpoint, go->endp_class, go->endpoint, + go->endp_len); /* * If there are any remaining CIs, then this packet is bad. @@ -1096,9 +1327,7 @@ lcp_rejci(f, p, len) return 1; bad: - LCPDEBUG((LOG_WARNING, "lcp_rejci: received bad Reject!")); - LCPDEBUG((LOG_WARNING, "lcp_rejci: plen %d len %d off %d", - plen, len, p - start)); + LCPDEBUG(("lcp_rejci: received bad Reject!")); return 0; } @@ -1121,7 +1350,7 @@ lcp_reqci(f, inp, lenp, reject_if_disagree) lcp_options *ho = &lcp_hisoptions[f->unit]; lcp_options *ao = &lcp_allowoptions[f->unit]; u_char *cip, *next; /* Pointer to current and next CIs */ - u_char cilen, citype, cichar;/* Parsed len, type, char value */ + int cilen, citype, cichar; /* Parsed len, type, char value */ u_short cishort; /* Parsed short value */ u_int32_t cilong; /* Parse long value */ int rc = CONFACK; /* Final packet return code */ @@ -1148,10 +1377,11 @@ lcp_reqci(f, inp, lenp, reject_if_disagree) if (l < 2 || /* Not enough data for CI header or */ p[1] < 2 || /* CI length too small or */ p[1] > l) { /* CI length too big? */ - LCPDEBUG((LOG_WARNING, "lcp_reqci: bad CI length!")); + LCPDEBUG(("lcp_reqci: bad CI length!")); orc = CONFREJ; /* Reject bad CI */ cilen = l; /* Reject till end of packet */ l = 0; /* Don't loop again */ + citype = 0; goto endswitch; } GETCHAR(citype, p); /* Parse CI type */ @@ -1161,14 +1391,12 @@ lcp_reqci(f, inp, lenp, reject_if_disagree) switch (citype) { /* Check CI type */ case CI_MRU: - LCPDEBUG((LOG_INFO, "lcp_reqci: rcvd MRU")); if (!ao->neg_mru || /* Allow option? */ cilen != CILEN_SHORT) { /* Check CI length */ orc = CONFREJ; /* Reject CI */ break; } GETSHORT(cishort, p); /* Parse MRU */ - LCPDEBUG((LOG_INFO, "(%d)", cishort)); /* * He must be able to receive at least our minimum. @@ -1187,14 +1415,12 @@ lcp_reqci(f, inp, lenp, reject_if_disagree) break; case CI_ASYNCMAP: - LCPDEBUG((LOG_INFO, "lcp_reqci: rcvd ASYNCMAP")); if (!ao->neg_asyncmap || cilen != CILEN_LONG) { orc = CONFREJ; break; } GETLONG(cilong, p); - LCPDEBUG((LOG_INFO, "(%x)", (unsigned int) cilong)); /* * Asyncmap must have set at least the bits @@ -1212,7 +1438,6 @@ lcp_reqci(f, inp, lenp, reject_if_disagree) break; case CI_AUTHTYPE: - LCPDEBUG((LOG_INFO, "lcp_reqci: rcvd AUTHTYPE")); if (cilen < CILEN_SHORT || !(ao->neg_upap || ao->neg_chap)) { /* @@ -1222,10 +1447,9 @@ lcp_reqci(f, inp, lenp, reject_if_disagree) break; } GETSHORT(cishort, p); - LCPDEBUG((LOG_INFO, "(%x)", cishort)); /* - * Authtype must be UPAP or CHAP. + * Authtype must be PAP or CHAP. * * Note: if both ao->neg_upap and ao->neg_chap are set, * and the peer sends a Configure-Request with two @@ -1238,8 +1462,7 @@ lcp_reqci(f, inp, lenp, reject_if_disagree) if (cishort == PPP_PAP) { if (ho->neg_chap || /* we've already accepted CHAP */ cilen != CILEN_SHORT) { - LCPDEBUG((LOG_WARNING, - "lcp_reqci: rcvd AUTHTYPE PAP, rejecting...")); + LCPDEBUG(("lcp_reqci: rcvd AUTHTYPE PAP, rejecting...")); orc = CONFREJ; break; } @@ -1249,6 +1472,8 @@ lcp_reqci(f, inp, lenp, reject_if_disagree) PUTCHAR(CILEN_CHAP, nakp); PUTSHORT(PPP_CHAP, nakp); PUTCHAR(ao->chap_mdtype, nakp); + /* XXX if we can do CHAP_MICROSOFT as well, we should + probably put in another option saying so */ break; } ho->neg_upap = 1; @@ -1257,8 +1482,7 @@ lcp_reqci(f, inp, lenp, reject_if_disagree) if (cishort == PPP_CHAP) { if (ho->neg_upap || /* we've already accepted PAP */ cilen != CILEN_CHAP) { - LCPDEBUG((LOG_INFO, - "lcp_reqci: rcvd AUTHTYPE CHAP, rejecting...")); + LCPDEBUG(("lcp_reqci: rcvd AUTHTYPE CHAP, rejecting...")); orc = CONFREJ; break; } @@ -1270,7 +1494,11 @@ lcp_reqci(f, inp, lenp, reject_if_disagree) break; } GETCHAR(cichar, p); /* get digest type*/ - if (cichar != ao->chap_mdtype) { + if (cichar != CHAP_DIGEST_MD5 +#ifdef CHAPMS + && cichar != CHAP_MICROSOFT +#endif + ) { orc = CONFNAK; PUTCHAR(CI_AUTHTYPE, nakp); PUTCHAR(CILEN_CHAP, nakp); @@ -1301,7 +1529,6 @@ lcp_reqci(f, inp, lenp, reject_if_disagree) break; case CI_QUALITY: - LCPDEBUG((LOG_INFO, "lcp_reqci: rcvd QUALITY")); if (!ao->neg_lqr || cilen != CILEN_LQR) { orc = CONFREJ; @@ -1310,7 +1537,6 @@ lcp_reqci(f, inp, lenp, reject_if_disagree) GETSHORT(cishort, p); GETLONG(cilong, p); - LCPDEBUG((LOG_INFO, "(%x %x)", cishort, (unsigned int) cilong)); /* * Check the protocol and the reporting period. @@ -1327,14 +1553,12 @@ lcp_reqci(f, inp, lenp, reject_if_disagree) break; case CI_MAGICNUMBER: - LCPDEBUG((LOG_INFO, "lcp_reqci: rcvd MAGICNUMBER")); if (!(ao->neg_magicnumber || go->neg_magicnumber) || cilen != CILEN_LONG) { orc = CONFREJ; break; } GETLONG(cilong, p); - LCPDEBUG((LOG_INFO, "(%x)", (unsigned int) cilong)); /* * He must have a different magic number. @@ -1354,7 +1578,6 @@ lcp_reqci(f, inp, lenp, reject_if_disagree) case CI_PCOMPRESSION: - LCPDEBUG((LOG_INFO, "lcp_reqci: rcvd PCOMPRESSION")); if (!ao->neg_pcompression || cilen != CILEN_VOID) { orc = CONFREJ; @@ -1364,7 +1587,6 @@ lcp_reqci(f, inp, lenp, reject_if_disagree) break; case CI_ACCOMPRESSION: - LCPDEBUG((LOG_INFO, "lcp_reqci: rcvd ACCOMPRESSION")); if (!ao->neg_accompression || cilen != CILEN_VOID) { orc = CONFREJ; @@ -1373,15 +1595,51 @@ lcp_reqci(f, inp, lenp, reject_if_disagree) ho->neg_accompression = 1; break; + case CI_MRRU: + if (!ao->neg_multilink || + cilen != CILEN_SHORT) { + orc = CONFREJ; + break; + } + + GETSHORT(cishort, p); + /* possibly should insist on a minimum/maximum MRRU here */ + ho->neg_multilink = 1; + ho->mrru = cishort; + break; + + case CI_SSNHF: + if (!ao->neg_ssnhf || + cilen != CILEN_VOID) { + orc = CONFREJ; + break; + } + ho->neg_ssnhf = 1; + break; + + case CI_EPDISC: + if (!ao->neg_endpoint || + cilen < CILEN_CHAR || + cilen > CILEN_CHAR + MAX_ENDP_LEN) { + orc = CONFREJ; + break; + } + GETCHAR(cichar, p); + cilen -= CILEN_CHAR; + ho->neg_endpoint = 1; + ho->endp_class = cichar; + ho->endp_len = cilen; + BCOPY(p, ho->endpoint, cilen); + INCPTR(cilen, p); + break; + default: - LCPDEBUG((LOG_INFO, "lcp_reqci: rcvd unknown option %d", - citype)); + LCPDEBUG(("lcp_reqci: rcvd unknown option %d", citype)); orc = CONFREJ; break; } endswitch: - LCPDEBUG((LOG_INFO, " (%s)", CODENAME(orc))); if (orc == CONFACK && /* Good CI */ rc != CONFACK) /* but prior CI wasnt? */ continue; /* Don't send this one */ @@ -1427,7 +1685,7 @@ endswitch: break; } - LCPDEBUG((LOG_INFO, "lcp_reqci: returning CONF%s.", CODENAME(rc))); + LCPDEBUG(("lcp_reqci: returning CONF%s.", CODENAME(rc))); return (rc); /* Return final code */ } @@ -1458,13 +1716,8 @@ lcp_up(f) ppp_send_config(f->unit, MIN(ao->mru, (ho->neg_mru? ho->mru: PPP_MRU)), (ho->neg_asyncmap? ho->asyncmap: 0xffffffff), ho->neg_pcompression, ho->neg_accompression); - /* - * If the asyncmap hasn't been negotiated, we really should - * set the receive asyncmap to ffffffff, but we set it to 0 - * for backwards contemptibility. - */ ppp_recv_config(f->unit, (go->neg_mru? MAX(wo->mru, go->mru): PPP_MRU), - (go->neg_asyncmap? go->asyncmap: 0x00000000), + (lax_recv? 0: go->neg_asyncmap? go->asyncmap: 0xffffffff), go->neg_pcompression, go->neg_accompression); if (ho->neg_mru) @@ -1489,14 +1742,13 @@ lcp_down(f) lcp_echo_lowerdown(f->unit); - sifdown(f->unit); + link_down(f->unit); + ppp_send_config(f->unit, PPP_MRU, 0xffffffff, 0, 0); ppp_recv_config(f->unit, PPP_MRU, - (go->neg_asyncmap? go->asyncmap: 0x00000000), + (go->neg_asyncmap? go->asyncmap: 0xffffffff), go->neg_pcompression, go->neg_accompression); peer_mru[f->unit] = PPP_MRU; - - link_down(f->unit); } @@ -1525,21 +1777,26 @@ lcp_finished(f) /* * lcp_printpkt - print the contents of an LCP packet. */ -char *lcp_codenames[] = { +static char *lcp_codenames[] = { "ConfReq", "ConfAck", "ConfNak", "ConfRej", "TermReq", "TermAck", "CodeRej", "ProtRej", "EchoReq", "EchoRep", "DiscReq" }; -int +static char *endp_class_names[] = { + "null", "local", "IP", "MAC", "magic", "phone" +}; + +static int lcp_printpkt(p, plen, printer, arg) u_char *p; int plen; void (*printer) __P((void *, char *, ...)); void *arg; { - int code, id, len, olen; + int code, id, len, olen, i; u_char *pstart, *optend; + u_char cichar; u_short cishort; u_int32_t cilong; @@ -1600,6 +1857,20 @@ lcp_printpkt(p, plen, printer, arg) break; case PPP_CHAP: printer(arg, "chap"); + if (p < optend) { + switch (*p) { + case CHAP_DIGEST_MD5: + printer(arg, " MD5"); + ++p; + break; +#ifdef CHAPMS + case CHAP_MICROSOFT: + printer(arg, " m$oft"); + ++p; + break; +#endif + } + } break; default: printer(arg, "0x%x", cishort); @@ -1620,6 +1891,20 @@ lcp_printpkt(p, plen, printer, arg) } } break; + case CI_CALLBACK: + if (olen >= CILEN_CHAR) { + p += 2; + printer(arg, "callback "); + GETCHAR(cishort, p); + switch (cishort) { + case CBCP_OPT: + printer(arg, "CBCP"); + break; + default: + printer(arg, "0x%x", cishort); + } + } + break; case CI_MAGICNUMBER: if (olen == CILEN_LONG) { p += 2; @@ -1639,6 +1924,30 @@ lcp_printpkt(p, plen, printer, arg) printer(arg, "accomp"); } break; + case CI_MRRU: + if (olen == CILEN_SHORT) { + p += 2; + GETSHORT(cishort, p); + printer(arg, "mrru %d", cishort); + } + break; + case CI_SSNHF: + if (olen == CILEN_VOID) { + p += 2; + printer(arg, "ssnhf"); + } + break; + case CI_EPDISC: + if (olen >= CILEN_CHAR) { + p += 2; + GETCHAR(cichar, p); + if (cichar <= 5) + printer(arg, "endpoint [%s]:", + endp_class_names[cichar]); + else + printer(arg, "endpoint [%d]:"); + } + break; } while (p < optend) { GETCHAR(code, p); @@ -1647,13 +1956,38 @@ lcp_printpkt(p, plen, printer, arg) printer(arg, ">"); } break; + + case TERMACK: + case TERMREQ: + if (len > 0 && *p >= ' ' && *p < 0x7f) { + printer(arg, " "); + print_string(p, len, printer, arg); + p += len; + len = 0; + } + break; + + case ECHOREQ: + case ECHOREP: + case DISCREQ: + if (len >= 4) { + GETLONG(cilong, p); + printer(arg, " magic=0x%x", cilong); + p += 4; + len -= 4; + } + break; } /* print the rest of the bytes in the packet */ - for (; len > 0; --len) { + for (i = 0; i < len && i < 32; ++i) { GETCHAR(code, p); printer(arg, " %.2x", code); } + if (i < len) { + printer(arg, " ..."); + p += len - i; + } return p - pstart; } @@ -1667,9 +2001,10 @@ void LcpLinkFailure (f) fsm *f; { if (f->state == OPENED) { - syslog (LOG_NOTICE, "Excessive lack of response to LCP echo frames."); + info("No response to %d echo-requests", lcp_echos_pending); + notice("Serial link appears to be disconnected."); lcp_close(f->unit, "Peer not responding"); - phase = PHASE_TERMINATE; + status = EXIT_PEER_DEAD; } } @@ -1681,36 +2016,16 @@ static void LcpEchoCheck (f) fsm *f; { - long int delta; -#ifdef __linux__ - struct ppp_idle ddinfo; -/* - * Read the time since the last packet was received. - */ - if (ioctl (fd, PPPIOCGIDLE, &ddinfo) < 0) { - syslog (LOG_ERR, "ioctl(PPPIOCGIDLE): %m"); - die (1); - } -/* - * Compute the time since the last packet was received. If the timer - * has expired then send the echo request and reset the timer to maximum. - */ - delta = (long int) lcp_echo_interval - (long int) ddinfo.recv_idle; - if (delta < 0L) { - LcpSendEchoRequest (f); - delta = (int) lcp_echo_interval; - } - -#else /* Other implementations do not have ability to find delta */ LcpSendEchoRequest (f); - delta = (int) lcp_echo_interval; -#endif + if (f->state != OPENED) + return; -/* - * Start the timer for the next interval. - */ - assert (lcp_echo_timer_running==0); - TIMEOUT (LcpEchoTimeout, (caddr_t) f, (u_int32_t) delta); + /* + * Start the timer for the next interval. + */ + if (lcp_echo_timer_running) + warn("assertion lcp_echo_timer_running==0 failed"); + TIMEOUT (LcpEchoTimeout, f, lcp_echo_interval); lcp_echo_timer_running = 1; } @@ -1720,7 +2035,7 @@ LcpEchoCheck (f) static void LcpEchoTimeout (arg) - caddr_t arg; + void *arg; { if (lcp_echo_timer_running != 0) { lcp_echo_timer_running = 0; @@ -1735,19 +2050,21 @@ LcpEchoTimeout (arg) static void lcp_received_echo_reply (f, id, inp, len) fsm *f; - int id; u_char *inp; int len; + int id; + u_char *inp; + int len; { u_int32_t magic; /* Check the magic number - don't count replies from ourselves. */ if (len < 4) { - syslog(LOG_DEBUG, "lcp: received short Echo-Reply, length %d", len); + dbglog("lcp: received short Echo-Reply, length %d", len); return; } GETLONG(magic, inp); if (lcp_gotoptions[f->unit].neg_magicnumber && magic == lcp_gotoptions[f->unit].magicnumber) { - syslog(LOG_WARNING, "appear to have received our own echo-reply!"); + warn("appear to have received our own echo-reply!"); return; } @@ -1766,25 +2083,25 @@ LcpSendEchoRequest (f) u_int32_t lcp_magic; u_char pkt[4], *pktp; -/* - * Detect the failure of the peer at this point. - */ + /* + * Detect the failure of the peer at this point. + */ if (lcp_echo_fails != 0) { - if (lcp_echos_pending++ >= lcp_echo_fails) { + if (lcp_echos_pending >= lcp_echo_fails) { LcpLinkFailure(f); lcp_echos_pending = 0; } } -/* - * Make and send the echo request frame. - */ + + /* + * Make and send the echo request frame. + */ if (f->state == OPENED) { lcp_magic = lcp_gotoptions[f->unit].magicnumber; pktp = pkt; PUTLONG(lcp_magic, pktp); - - fsm_sdata(f, ECHOREQ, - lcp_echo_number++ & 0xFF, pkt, pktp - pkt); + fsm_sdata(f, ECHOREQ, lcp_echo_number++ & 0xFF, pkt, pktp - pkt); + ++lcp_echos_pending; } } @@ -1806,11 +2123,6 @@ lcp_echo_lowerup (unit) /* If a timeout interval is specified then start the timer */ if (lcp_echo_interval != 0) LcpEchoCheck (f); -#ifdef _linux_ - /* If a idle time limit is given then start it */ - if (idle_time_limit != 0) - RestartIdleTimer (f); -#endif } /* @@ -1824,14 +2136,7 @@ lcp_echo_lowerdown (unit) fsm *f = &lcp_fsm[unit]; if (lcp_echo_timer_running != 0) { - UNTIMEOUT (LcpEchoTimeout, (caddr_t) f); + UNTIMEOUT (LcpEchoTimeout, f); lcp_echo_timer_running = 0; } -#ifdef _linux_ - /* If a idle time limit is running then stop it */ - if (idle_timer_running != 0) { - UNTIMEOUT (IdleTimeCheck, (caddr_t) f); - idle_timer_running = 0; - } -#endif }