*/
#ifndef lint
-static char rcsid[] = "$Id: lcp.c,v 1.10 1994/08/09 06:24:59 paulus Exp $";
+static char rcsid[] = "$Id: lcp.c,v 1.15 1994/10/24 04:31:11 paulus Exp $";
#endif
/*
#include <netinet/in.h>
#include "pppd.h"
-#include "ppp.h"
#include "fsm.h"
#include "lcp.h"
#include "magic.h"
#endif
/* global vars */
-fsm lcp_fsm[NPPP]; /* LCP fsm structure (global)*/
-lcp_options lcp_wantoptions[NPPP]; /* Options that we want to request */
-lcp_options lcp_gotoptions[NPPP]; /* Options that peer ack'd */
-lcp_options lcp_allowoptions[NPPP]; /* Options we allow peer to request */
-lcp_options lcp_hisoptions[NPPP]; /* Options that we ack'd */
-u_long xmit_accm[NPPP][8]; /* extended transmit ACCM */
+fsm lcp_fsm[NUM_PPP]; /* LCP fsm structure (global)*/
+lcp_options lcp_wantoptions[NUM_PPP]; /* Options that we want to request */
+lcp_options lcp_gotoptions[NUM_PPP]; /* Options that peer ack'd */
+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_long lcp_echos_pending = 0; /* Number of outstanding echo msgs */
-static u_long lcp_echo_number = 0; /* ID number of next echo frame */
-static u_long lcp_echo_timer_running = 0; /* TRUE if a timer is running */
-
-u_long lcp_echo_interval = 0;
-u_long lcp_echo_fails = 0;
+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 */
/*
* Callbacks for fsm code. (CI = Configuration Information)
*/
-static void lcp_resetci __ARGS((fsm *)); /* Reset our CI */
-static int lcp_cilen __ARGS((fsm *)); /* Return length of our CI */
-static void lcp_addci __ARGS((fsm *, u_char *, int *)); /* Add our CI to pkt */
-static int lcp_ackci __ARGS((fsm *, u_char *, int)); /* Peer ack'd our CI */
-static int lcp_nakci __ARGS((fsm *, u_char *, int)); /* Peer nak'd our CI */
-static int lcp_rejci __ARGS((fsm *, u_char *, int)); /* Peer rej'd our CI */
-static int lcp_reqci __ARGS((fsm *, u_char *, int *, int)); /* Rcv peer CI */
-static void lcp_up __ARGS((fsm *)); /* We're UP */
-static void lcp_down __ARGS((fsm *)); /* We're DOWN */
-static void lcp_starting __ARGS((fsm *)); /* We need lower layer up */
-static void lcp_finished __ARGS((fsm *)); /* We need lower layer down */
-static int lcp_extcode __ARGS((fsm *, int, int, u_char *, int));
-static void lcp_rprotrej __ARGS((fsm *, u_char *, int));
+static void lcp_resetci __P((fsm *)); /* Reset our CI */
+static int lcp_cilen __P((fsm *)); /* Return length of our CI */
+static void lcp_addci __P((fsm *, u_char *, int *)); /* Add our CI to pkt */
+static int lcp_ackci __P((fsm *, u_char *, int)); /* Peer ack'd our CI */
+static int lcp_nakci __P((fsm *, u_char *, int)); /* Peer nak'd our CI */
+static int lcp_rejci __P((fsm *, u_char *, int)); /* Peer rej'd our CI */
+static int lcp_reqci __P((fsm *, u_char *, int *, int)); /* Rcv peer CI */
+static void lcp_up __P((fsm *)); /* We're UP */
+static void lcp_down __P((fsm *)); /* We're DOWN */
+static void lcp_starting __P((fsm *)); /* We need lower layer up */
+static void lcp_finished __P((fsm *)); /* We need lower layer down */
+static int lcp_extcode __P((fsm *, int, int, u_char *, int));
+static void lcp_rprotrej __P((fsm *, u_char *, int));
/*
* routines to send LCP echos to peer
*/
-static void lcp_echo_lowerup __ARGS((int));
-static void lcp_echo_lowerdown __ARGS((int));
-static void LcpEchoTimeout __ARGS((caddr_t));
-static void lcp_received_echo_reply __ARGS((fsm *, int, u_char *, int));
-static void LcpSendEchoRequest __ARGS((fsm *));
-static void LcpLinkFailure __ARGS((fsm *));
+static void lcp_echo_lowerup __P((int));
+static void lcp_echo_lowerdown __P((int));
+static void LcpEchoTimeout __P((caddr_t));
+static void lcp_received_echo_reply __P((fsm *, int, u_char *, int));
+static void LcpSendEchoRequest __P((fsm *));
+static void LcpLinkFailure __P((fsm *));
static fsm_callbacks lcp_callbacks = { /* LCP callback routines */
lcp_resetci, /* Reset our Configuration Information */
lcp_options *ao = &lcp_allowoptions[unit];
f->unit = unit;
- f->protocol = LCP;
+ f->protocol = PPP_LCP;
f->callbacks = &lcp_callbacks;
fsm_init(f);
{
sifdown(unit);
ppp_set_xaccm(unit, xmit_accm[unit]);
- ppp_send_config(unit, MTU, 0xffffffff, 0, 0);
- ppp_recv_config(unit, MTU, 0x00000000, 0, 0);
- peer_mru[unit] = MTU;
+ ppp_send_config(unit, PPP_MRU, 0xffffffff, 0, 0);
+ ppp_recv_config(unit, PPP_MRU, 0x00000000, 0, 0);
+ peer_mru[unit] = PPP_MRU;
lcp_allowoptions[unit].asyncmap = xmit_accm[unit][0];
fsm_lowerup(&lcp_fsm[unit]);
u_char *p;
int len;
{
- fsm_input(&lcp_fsm[unit], p, len);
+ int oldstate;
+ fsm *f = &lcp_fsm[unit];
+ lcp_options *go = &lcp_gotoptions[f->unit];
+
+ oldstate = f->state;
+ fsm_input(f, p, len);
+ if (oldstate == REQSENT && f->state == ACKSENT) {
+ /*
+ * The peer will probably send us an ack soon and then
+ * immediately start sending packets with the negotiated
+ * options. So as to be ready when that happens, we set
+ * our receive side to accept packets as negotiated now.
+ */
+ ppp_recv_config(f->unit, PPP_MRU,
+ go->neg_asyncmap? go->asyncmap: 0x00000000,
+ go->neg_pcompression, go->neg_accompression);
+ }
}
LCPDEBUG((LOG_INFO, "lcp: Echo-Request, Rcvd id %d", id));
magp = inp;
PUTLONG(lcp_gotoptions[f->unit].magicnumber, magp);
- if (len < CILEN_LONG)
- len = CILEN_LONG;
fsm_sdata(f, ECHOREP, id, inp, len);
break;
lcp_wantoptions[f->unit].magicnumber = magic();
lcp_wantoptions[f->unit].numloops = 0;
lcp_gotoptions[f->unit] = lcp_wantoptions[f->unit];
- peer_mru[f->unit] = MTU;
+ peer_mru[f->unit] = PPP_MRU;
}
if (neg) { \
PUTCHAR(opt, ucp); \
PUTCHAR(CILEN_LQR, ucp); \
- PUTSHORT(LQR, ucp); \
+ PUTSHORT(PPP_LQR, ucp); \
PUTLONG(val, ucp); \
}
ADDCISHORT(CI_MRU, go->neg_mru, go->mru);
ADDCILONG(CI_ASYNCMAP, go->neg_asyncmap, go->asyncmap);
- ADDCICHAP(CI_AUTHTYPE, go->neg_chap, CHAP, go->chap_mdtype);
- ADDCISHORT(CI_AUTHTYPE, !go->neg_chap && go->neg_upap, UPAP);
+ 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);
ADDCILONG(CI_MAGICNUMBER, go->neg_magicnumber, go->magicnumber);
ADDCIVOID(CI_PCOMPRESSION, go->neg_pcompression);
lcp_options *go = &lcp_gotoptions[f->unit];
u_char cilen, citype, cichar;
u_short cishort;
- u_long cilong;
+ u_int32_t cilong;
/*
* CIs must be in exactly the same order that we sent.
citype != opt) \
goto bad; \
GETSHORT(cishort, p); \
- if (cishort != LQR) \
+ if (cishort != PPP_LQR) \
goto bad; \
GETLONG(cilong, p); \
if (cilong != val) \
ACKCISHORT(CI_MRU, go->neg_mru, go->mru);
ACKCILONG(CI_ASYNCMAP, go->neg_asyncmap, go->asyncmap);
- ACKCICHAP(CI_AUTHTYPE, go->neg_chap, CHAP, go->chap_mdtype);
- ACKCISHORT(CI_AUTHTYPE, !go->neg_chap && go->neg_upap, UPAP);
+ 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);
ACKCILONG(CI_MAGICNUMBER, go->neg_magicnumber, go->magicnumber);
ACKCIVOID(CI_PCOMPRESSION, go->neg_pcompression);
lcp_options *wo = &lcp_wantoptions[f->unit];
u_char cilen, citype, cichar, *next;
u_short cishort;
- u_long cilong;
+ u_int32_t cilong;
lcp_options no; /* options we've seen Naks for */
lcp_options try; /* options to request next time */
int looped_back = 0;
* If they Nak the reporting period, take their value XXX ?
*/
NAKCILQR(CI_QUALITY, neg_lqr,
- if (cishort != LQR)
+ if (cishort != PPP_LQR)
try.neg_lqr = 0;
else
try.lqr_period = cilong;
lcp_options *go = &lcp_gotoptions[f->unit];
u_char cichar;
u_short cishort;
- u_long cilong;
+ u_int32_t cilong;
u_char *start = p;
int plen = len;
lcp_options try; /* options to request next time */
GETSHORT(cishort, p); \
GETLONG(cilong, p); \
/* Check rejected value. */ \
- if (cishort != LQR || cilong != val) \
+ if (cishort != PPP_LQR || cilong != val) \
goto bad; \
try.neg = 0; \
LCPDEBUG((LOG_INFO,"lcp_rejci rejected LQR opt %d", opt)); \
REJCISHORT(CI_MRU, neg_mru, go->mru);
REJCILONG(CI_ASYNCMAP, neg_asyncmap, go->asyncmap);
- REJCICHAP(CI_AUTHTYPE, neg_chap, CHAP, go->chap_mdtype);
+ REJCICHAP(CI_AUTHTYPE, neg_chap, PPP_CHAP, go->chap_mdtype);
if (!go->neg_chap) {
- REJCISHORT(CI_AUTHTYPE, neg_upap, UPAP);
+ REJCISHORT(CI_AUTHTYPE, neg_upap, PPP_PAP);
}
REJCILQR(CI_QUALITY, neg_lqr, go->lqr_period);
REJCILONG(CI_MAGICNUMBER, neg_magicnumber, go->magicnumber);
u_char *cip, *next; /* Pointer to current and next CIs */
u_char cilen, citype, cichar;/* Parsed len, type, char value */
u_short cishort; /* Parsed short value */
- u_long cilong; /* Parse long value */
+ u_int32_t cilong; /* Parse long value */
int rc = CONFACK; /* Final packet return code */
int orc; /* Individual option return code */
u_char *p; /* Pointer to next char to parse */
* the ordering of the CIs in the peer's Configure-Request.
*/
- if (cishort == UPAP) {
+ if (cishort == PPP_PAP) {
if (!ao->neg_upap || /* we don't want to do PAP */
ho->neg_chap || /* or we've already accepted CHAP */
cilen != CILEN_SHORT) {
ho->neg_upap = 1;
break;
}
- if (cishort == CHAP) {
+ if (cishort == PPP_CHAP) {
if (!ao->neg_chap || /* we don't want to do CHAP */
ho->neg_upap || /* or we've already accepted UPAP */
cilen != CILEN_CHAP) {
GETSHORT(cishort, p);
GETLONG(cilong, p);
LCPDEBUG((LOG_INFO, "(%x %lx)", cishort, cilong));
- if (cishort != LQR) {
+ if (cishort != PPP_LQR) {
orc = CONFREJ;
break;
}
* set our MRU to the larger of value we wanted and
* the value we got in the negotiation.
*/
- ppp_send_config(f->unit, MIN(ao->mru, (ho->neg_mru? ho->mru: MTU)),
+ 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);
/*
* 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): MTU),
+ ppp_recv_config(f->unit, (go->neg_mru? MAX(wo->mru, go->mru): PPP_MRU),
(go->neg_asyncmap? go->asyncmap: 0x00000000),
go->neg_pcompression, go->neg_accompression);
ChapLowerUp(f->unit); /* Enable CHAP */
upap_lowerup(f->unit); /* Enable UPAP */
ipcp_lowerup(f->unit); /* Enable IPCP */
+ ccp_lowerup(f->unit); /* Enable CCP */
lcp_echo_lowerup(f->unit); /* Enable echo messages */
link_established(f->unit);
fsm *f;
{
lcp_echo_lowerdown(f->unit);
+ ccp_lowerdown(f->unit);
ipcp_lowerdown(f->unit);
ChapLowerDown(f->unit);
upap_lowerdown(f->unit);
sifdown(f->unit);
- ppp_send_config(f->unit, MTU, 0xffffffff, 0, 0);
- ppp_recv_config(f->unit, MTU, 0x00000000, 0, 0);
- peer_mru[f->unit] = MTU;
+ ppp_send_config(f->unit, PPP_MRU, 0xffffffff, 0, 0);
+ ppp_recv_config(f->unit, PPP_MRU, 0x00000000, 0, 0);
+ peer_mru[f->unit] = PPP_MRU;
link_down(f->unit);
}
lcp_printpkt(p, plen, printer, arg)
u_char *p;
int plen;
- void (*printer) __ARGS((void *, char *, ...));
+ void (*printer) __P((void *, char *, ...));
void *arg;
{
int code, id, len, olen;
u_char *pstart, *optend;
u_short cishort;
- u_long cilong;
+ u_int32_t cilong;
if (plen < HEADERLEN)
return 0;
printer(arg, "auth ");
GETSHORT(cishort, p);
switch (cishort) {
- case UPAP:
+ case PPP_PAP:
printer(arg, "upap");
break;
- case CHAP:
+ case PPP_CHAP:
printer(arg, "chap");
break;
default:
printer(arg, "quality ");
GETSHORT(cishort, p);
switch (cishort) {
- case LQR:
+ case PPP_LQR:
printer(arg, "lqr");
break;
default:
LcpEchoCheck (f)
fsm *f;
{
- u_long delta;
+ u_int32_t delta;
#ifdef __linux__
- struct ppp_ddinfo ddinfo;
- u_long latest;
+ struct ppp_ddinfo ddinfo;
+ u_int32_t latest;
/*
* Read the time since the last packet was received.
*/
fsm *f;
int id; u_char *inp; int len;
{
- u_long magic;
+ u_int32_t magic;
/* Check the magic number - don't count replies from ourselves. */
- if (len < CILEN_LONG)
+ if (len < 4) {
+ syslog(LOG_DEBUG, "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)
+ && magic == lcp_gotoptions[f->unit].magicnumber) {
+ syslog(LOG_WARNING, "appear to have received our own echo-reply!");
return;
+ }
/* Reset the number of outstanding echo frames */
lcp_echos_pending = 0;
LcpSendEchoRequest (f)
fsm *f;
{
- u_long lcp_magic;
+ u_int32_t lcp_magic;
u_char pkt[4], *pktp;
/*
projects / ppp.git / blobdiff