Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/usr.sbin/pppd/ipcp.c

969 lines
22 KiB
C
Raw Blame History

/*
* ipcp.c - PPP IP Control Protocol.
*
* Copyright (c) 1989 Carnegie Mellon University.
* All rights reserved.
*
* Redistribution and use in source and binary forms are permitted
* provided that the above copyright notice and this paragraph are
* duplicated in all such forms and that any documentation,
* advertising materials, and other materials related to such
* distribution and use acknowledge that the software was developed
* by Carnegie Mellon University. The name of the
* University may not be used to endorse or promote products derived
* from this software without specific prior written permission.
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*/
/*
* TODO:
* Fix IP address negotiation (wantoptions or hisoptions).
* Don't set zero IP addresses.
* Send NAKs for unsent CIs.
* VJ compression.
*/
#include <stdio.h>
#include <syslog.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <net/if.h>
#include <net/route.h>
#include <netinet/in.h>
#include <string.h>
#ifndef BSD
#ifndef sun
#define BSD 44
#endif
#endif /*BSD*/
#ifdef STREAMS
#include <sys/stream.h>
#include "ppp_str.h"
#endif
#include "pppd.h"
#include <net/if_ppp.h>
#include "ppp.h"
#include "fsm.h"
#include "ipcp.h"
/* global vars */
ipcp_options ipcp_wantoptions[NPPP]; /* Options that we want to request */
ipcp_options ipcp_gotoptions[NPPP]; /* Options that peer ack'd */
ipcp_options ipcp_allowoptions[NPPP]; /* Options that we allow peer to
request */
ipcp_options ipcp_hisoptions[NPPP]; /* Options that we ack'd */
/* local vars */
/*
* VJ compression protocol mode for negotiation. See ipcp.h for a
* description of each mode.
*/
static int vj_mode = IPCP_VJMODE_RFC1332;
static int vj_opt_len = 6; /* holds length in octets for valid vj */
/* compression frame depending on mode */
static int vj_opt_val = IPCP_VJ_COMP;
/* compression negotiation frames */
/* depending on vj_mode */
static void ipcp_resetci __ARGS((fsm *)); /* Reset our Configuration Information */
static int ipcp_cilen __ARGS((fsm *)); /* Return length of our CI */
static void ipcp_addci __ARGS((fsm *, u_char *)); /* Add our CIs */
static int ipcp_ackci __ARGS((fsm *, u_char *, int)); /* Ack some CIs */
static void ipcp_nakci __ARGS((fsm *, u_char *, int)); /* Nak some CIs */
static void ipcp_rejci __ARGS((fsm *, u_char *, int)); /* Reject some CIs */
static u_char ipcp_reqci __ARGS((fsm *, u_char *, int *)); /* Check the requested CIs */
static void ipcp_up __ARGS((fsm *)); /* We're UP */
static void ipcp_down __ARGS((fsm *)); /* We're DOWN */
static fsm ipcp_fsm[NPPP]; /* IPCP fsm structure */
static fsm_callbacks ipcp_callbacks = { /* IPCP callback routines */
ipcp_resetci, /* Reset our Configuration Information */
ipcp_cilen, /* Length of our Configuration Information */
ipcp_addci, /* Add our Configuration Information */
ipcp_ackci, /* ACK our Configuration Information */
ipcp_nakci, /* NAK our Configuration Information */
ipcp_rejci, /* Reject our Configuration Information */
ipcp_reqci, /* Request peer's Configuration Information */
ipcp_up, /* Called when fsm reaches OPEN state */
ipcp_down, /* Called when fsm leaves OPEN state */
NULL, /* Called when fsm reaches CLOSED state */
NULL, /* Called when Protocol-Reject received */
NULL /* Retransmission is necessary */
};
char *
ip_ntoa(ipaddr)
u_long ipaddr;
{
static char b1[64], b2[64], w = 0;
char *b = (w++&1) ? b1 : b2;
ipaddr = ntohl(ipaddr);
sprintf(b, "%d.%d.%d.%d",
(u_char)(ipaddr >> 24),
(u_char)(ipaddr >> 16),
(u_char)(ipaddr >> 8),
(u_char)(ipaddr));
return b;
}
/*
* ipcp_init - Initialize IPCP.
*/
void
ipcp_init(unit)
int unit;
{
fsm *f = &ipcp_fsm[unit];
ipcp_options *wo = &ipcp_wantoptions[unit];
ipcp_options *ao = &ipcp_allowoptions[unit];
f->unit = unit;
f->protocol = IPCP;
f->timeouttime = DEFTIMEOUT;
f->maxconfreqtransmits = DEFMAXCONFIGREQS;
f->maxtermtransmits = DEFMAXTERMTRANSMITS;
f->maxnakloops = DEFMAXNAKLOOPS;
f->callbacks = &ipcp_callbacks;
wo->neg_addrs = 1;
wo->ouraddr = 0;
wo->hisaddr = 0;
wo->neg_vj = 1;
wo->maxslotindex = MAX_STATES - 1; /* really max index */
wo->cflag = 1;
/* max slots and slot-id compression are currently hardwired in */
/* ppp_if.c to 16 and 1, this needs to be changed (among other */
/* things) gmc */
ao->neg_addrs = 1; /* accept old style dual addr */
ao->neg_addr = 1; /* accept new style single addr */
ao->neg_vj = 1;
ao->maxslotindex = MAX_STATES - 1;
ao->cflag = 1;
fsm_init(&ipcp_fsm[unit]);
}
/*
* ipcp_vj_setmode - set option length and option value for vj
* compression negotiation frames depending on mode
*/
void
ipcp_vj_setmode(mode)
int mode;
{
vj_mode = mode;
switch (vj_mode) {
case IPCP_VJMODE_OLD: /* with wrong code (0x0037) */
vj_opt_len = 4;
vj_opt_val = IPCP_VJ_COMP_OLD;
break;
case IPCP_VJMODE_RFC1172: /* as per rfc1172 */
vj_opt_len = 4;
vj_opt_val = IPCP_VJ_COMP;
break;
case IPCP_VJMODE_RFC1332: /* draft mode vj compression */
vj_opt_len = 6; /* negotiation includes values for */
/* maxslot and slot number compression */
vj_opt_val = IPCP_VJ_COMP;
break;
default:
IPCPDEBUG((LOG_WARNING, "Unknown vj compression mode %d. Please report \
this error.", vj_mode))
break;
}
}
/*
* ipcp_activeopen - Actively open IPCP.
*/
void
ipcp_activeopen(unit)
int unit;
{
fsm_activeopen(&ipcp_fsm[unit]);
}
/*
* ipcp_passiveopen - Passively open IPCP.
*/
void ipcp_passiveopen(unit)
int unit;
{
fsm_passiveopen(&ipcp_fsm[unit]);
}
/*
* ipcp_close - Close IPCP.
*/
void
ipcp_close(unit)
int unit;
{
fsm_close(&ipcp_fsm[unit]);
}
/*
* ipcp_lowerup - The lower layer is up.
*/
void
ipcp_lowerup(unit)
int unit;
{
fsm_lowerup(&ipcp_fsm[unit]);
}
/*
* ipcp_lowerdown - The lower layer is down.
*/
void
ipcp_lowerdown(unit)
int unit;
{
fsm_lowerdown(&ipcp_fsm[unit]);
}
/*
* ipcp_input - Input IPCP packet.
*/
void
ipcp_input(unit, p, len)
int unit;
u_char *p;
int len;
{
fsm_input(&ipcp_fsm[unit], p, len);
}
/*
* ipcp_protrej - A Protocol-Reject was received for IPCP.
*
* Simply pretend that LCP went down.
*/
void
ipcp_protrej(unit)
int unit;
{
fsm_lowerdown(&ipcp_fsm[unit]);
}
/*
* ipcp_resetci - Reset our CI.
*/
static void
ipcp_resetci(f)
fsm *f;
{
ipcp_gotoptions[f->unit] = ipcp_wantoptions[f->unit];
}
/*
* ipcp_cilen - Return length of our CI.
*/
static int
ipcp_cilen(f)
fsm *f;
{
ipcp_options *go = &ipcp_gotoptions[f->unit];
#define LENCISHORT(neg) (neg ? vj_opt_len : 0)
#define LENCIADDRS(neg) (neg ? 10 : 0)
#define LENCIADDR(neg) (neg ? 6 : 0)
return (LENCIADDRS(go->neg_addrs) +
LENCIADDR(go->neg_addr) +
LENCISHORT(go->neg_vj));
}
/*
* ipcp_addci - Add our desired CIs to a packet.
*/
static void
ipcp_addci(f, ucp)
fsm *f;
u_char *ucp;
{
ipcp_options *go = &ipcp_gotoptions[f->unit];
#define ADDCISHORT(opt, neg, val, maxslotindex, cflag) \
if (neg) { \
PUTCHAR(opt, ucp); \
PUTCHAR(vj_opt_len, ucp); \
PUTSHORT(val, ucp); \
if (vj_mode == IPCP_VJMODE_RFC1332) { \
PUTCHAR(maxslotindex, ucp); \
PUTCHAR(cflag, ucp); \
} \
}
#define ADDCIADDRS(opt, neg, val1, val2) \
if (neg) { \
u_long l; \
PUTCHAR(opt, ucp); \
PUTCHAR(2 + 2 * sizeof (long), ucp); \
l = ntohl(val1); \
PUTLONG(l, ucp); \
l = ntohl(val2); \
PUTLONG(l, ucp); \
}
#define ADDCIADDR(opt, neg, val) \
if (neg) { \
u_long l; \
PUTCHAR(opt, ucp); \
PUTCHAR(2 + sizeof (long), ucp); \
l = ntohl(val); \
PUTLONG(l, ucp); \
}
ADDCIADDRS(CI_ADDRS, go->neg_addrs, go->ouraddr, go->hisaddr)
ADDCIADDR(CI_ADDR, go->neg_addr, go->ouraddr)
ADDCISHORT(CI_COMPRESSTYPE, go->neg_vj, vj_opt_val,
go->maxslotindex, go->cflag)
}
/*
* ipcp_ackci - Ack our CIs.
*
* Returns:
* 0 - Ack was bad.
* 1 - Ack was good.
*/
static int
ipcp_ackci(f, p, len)
fsm *f;
u_char *p;
int len;
{
ipcp_options *go = &ipcp_gotoptions[f->unit];
u_short cilen, citype, cishort;
u_long cilong;
u_char cimaxslotindex, cicflag;
/*
* CIs must be in exactly the same order that we sent...
* Check packet length and CI length at each step.
* If we find any deviations, then this packet is bad.
*/
#define ACKCISHORT(opt, neg, val, maxslotindex, cflag) \
if (neg) { \
if ((len -= vj_opt_len) < 0) \
goto bad; \
GETCHAR(citype, p); \
GETCHAR(cilen, p); \
if (cilen != vj_opt_len || \
citype != opt) \
goto bad; \
GETSHORT(cishort, p); \
if (cishort != val) \
goto bad; \
if (vj_mode == IPCP_VJMODE_RFC1332) { \
GETCHAR(cimaxslotindex, p); \
if (cimaxslotindex > maxslotindex) \
goto bad; \
GETCHAR(cicflag, p); \
if (cicflag != cflag) \
goto bad; \
} \
}
#define ACKCIADDRS(opt, neg, val1, val2) \
if (neg) { \
u_long l; \
if ((len -= 2 + 2 * sizeof (long)) < 0) \
goto bad; \
GETCHAR(citype, p); \
GETCHAR(cilen, p); \
if (cilen != 2 + 2 * sizeof (long) || \
citype != opt) \
goto bad; \
GETLONG(l, p); \
cilong = htonl(l); \
if (val1) { \
if (val1 != cilong) \
goto bad; \
} \
else \
val1 = cilong; \
GETLONG(l, p); \
cilong = htonl(l); \
if (val2) { \
if (val2 != cilong) \
goto bad; \
} \
else \
val2 = cilong; \
}
#define ACKCIADDR(opt, neg, val) \
if (neg) { \
u_long l; \
if ((len -= 2 + sizeof (long)) < 0) \
goto bad; \
GETCHAR(citype, p); \
GETCHAR(cilen, p); \
if (cilen != 2 + sizeof (long) || \
citype != opt) \
goto bad; \
GETLONG(l, p); \
cilong = htonl(l); \
if (val) { \
if (val != cilong) \
goto bad; \
} \
else \
val = cilong; \
}
ACKCIADDRS(CI_ADDRS, go->neg_addrs, go->ouraddr, go->hisaddr)
ACKCIADDR(CI_ADDR, go->neg_addr, go->ouraddr)
ACKCISHORT(CI_COMPRESSTYPE, go->neg_vj, vj_opt_val, go->maxslotindex, go->cflag)
/*
* If there are any remaining CIs, then this packet is bad.
*/
if (len != 0)
goto bad;
return (1);
bad:
IPCPDEBUG((LOG_INFO, "ipcp_ackci: received bad Ack!"));
if (vj_mode == IPCP_VJMODE_RFC1332 )
IPCPDEBUG((LOG_INFO, "ipcp_ackci: citype %d, cilen %l",
citype, cilen));
if (citype == CI_COMPRESSTYPE) {
IPCPDEBUG((LOG_INFO, "ipcp_ackci: compress_type %d", cishort));
if (vj_mode == IPCP_VJMODE_RFC1332)
IPCPDEBUG((LOG_INFO, ", maxslotindex %d, cflag %d",
cishort, cimaxslotindex, cicflag));
}
return (0);
}
/*
* ipcp_nakci - NAK some of our CIs.
*
* Returns:
* 0 - Nak was bad.
* 1 - Nak was good.
*/
static void
ipcp_nakci(f, p, len)
fsm *f;
u_char *p;
int len;
{
ipcp_options *go = &ipcp_gotoptions[f->unit];
u_char cimaxslotindex, cicflag;
u_short cishort;
u_long ciaddr1, ciaddr2;
/*
* Any Nak'd CIs must be in exactly the same order that we sent.
* Check packet length and CI length at each step.
* If we find any deviations, then this packet is bad.
*/
#define NAKCISHORT(opt, neg, code) \
if (neg && \
len >= vj_opt_len && \
p[1] == vj_opt_len && \
p[0] == opt) { \
len -= vj_opt_len; \
INCPTR(2, p); \
GETSHORT(cishort, p); \
if (vj_mode == IPCP_VJMODE_RFC1332) { \
GETCHAR(cimaxslotindex, p); \
GETCHAR(cicflag, p); \
} \
code \
}
#define NAKCIADDRS(opt, neg, code) \
if (neg && \
len >= 2 + 2 * sizeof (long) && \
p[1] == 2 + 2 * sizeof (long) && \
p[0] == opt) { \
u_long l; \
len -= 2 + 2 * sizeof (long); \
INCPTR(2, p); \
GETLONG(l, p); \
ciaddr1 = htonl(l); \
GETLONG(l, p); \
ciaddr2 = htonl(l); \
code \
}
#define NAKCIADDR(opt, neg, code) \
if (neg && \
len >= 2 + sizeof (long) && \
p[1] == 2 + sizeof (long) && \
p[0] == opt) { \
u_long l; \
len -= 2 + sizeof (long); \
INCPTR(2, p); \
GETLONG(l, p); \
ciaddr1 = htonl(l); \
code \
}
NAKCIADDRS(CI_ADDRS, go->neg_addrs,
if (!go->ouraddr) { /* Didn't know our address? */
syslog(LOG_INFO, "local IP address %s", ip_ntoa(ciaddr1));
go->ouraddr = ciaddr1;
}
if (ciaddr2) { /* Does he know his? */
go->hisaddr = ciaddr2;
syslog(LOG_INFO, "remote IP address %s", ip_ntoa(ciaddr2));
}
)
NAKCIADDR(CI_ADDR, go->neg_addr,
logf(LOG_INFO, "acquired IP address %s", ip_ntoa(ciaddr1));
if (!go->ouraddr) { /* Didn't know our address? */
go->ouraddr = ciaddr1;
syslog(LOG_INFO, "remote IP address %s", ip_ntoa(ciaddr1));
}
)
NAKCISHORT(CI_COMPRESSTYPE, go->neg_vj,
if (cishort != vj_opt_val)
goto bad;
go->maxslotindex = cimaxslotindex; /* this is what it */
go->cflag = cicflag; /* wants */
)
/*
* If there are any remaining CIs, then this packet is bad.
*/
if (len == 0)
return;
bad:
IPCPDEBUG((LOG_INFO, "ipcp_nakci: received bad Nak!"));
}
/*
* ipcp_rejci - Reject some of our CIs.
*/
static void
ipcp_rejci(f, p, len)
fsm *f;
u_char *p;
int len;
{
ipcp_options *go = &ipcp_gotoptions[f->unit];
u_char cimaxslotindex, ciflag;
u_short cishort;
u_long cilong;
/*
* Any Rejected CIs must be in exactly the same order that we sent.
* Check packet length and CI length at each step.
* If we find any deviations, then this packet is bad.
*/
#define REJCISHORT(opt, neg, val, maxslot, cflag) \
if (neg && \
len >= vj_opt_len && \
p[1] == vj_opt_len && \
p[0] == opt) { \
len -= vj_opt_len; \
INCPTR(2, p); \
GETSHORT(cishort, p); \
/* Check rejected value. */ \
if (cishort != val) \
goto bad; \
if (vj_mode == IPCP_VJMODE_RFC1332) { \
GETCHAR(cimaxslotindex, p); \
if (cimaxslotindex != maxslot) \
goto bad; \
GETCHAR(ciflag, p); \
if (ciflag != cflag) \
goto bad; \
} \
neg = 0; \
}
#define REJCIADDRS(opt, neg, val1, val2) \
if (neg && \
len >= 2 + 2 * sizeof (long) && \
p[1] == 2 + 2 * sizeof (long) && \
p[0] == opt) { \
u_long l; \
len -= 2 + 2 * sizeof (long); \
INCPTR(2, p); \
GETLONG(l, p); \
cilong = htonl(l); \
/* Check rejected value. */ \
if (cilong != val2) \
goto bad; \
GETLONG(l, p); \
cilong = htonl(l); \
/* Check rejected value. */ \
if (cilong != val1) \
goto bad; \
neg = 0; \
}
#define REJCIADDR(opt, neg, val) \
if (neg && \
len >= 2 + sizeof (long) && \
p[1] == 2 + sizeof (long) && \
p[0] == opt) { \
u_long l; \
len -= 2 + sizeof (long); \
INCPTR(2, p); \
GETLONG(l, p); \
cilong = htonl(l); \
/* Check rejected value. */ \
if (cilong != val) \
goto bad; \
neg = 0; \
}
REJCIADDRS(CI_ADDRS, go->neg_addrs, go->ouraddr, go->hisaddr)
REJCIADDR(CI_ADDR, go->neg_addr, go->ouraddr)
REJCISHORT(CI_COMPRESSTYPE, go->neg_vj, vj_opt_val, go->maxslotindex, go->cflag)
/*
* If there are any remaining CIs, then this packet is bad.
*/
if (len == 0)
return;
bad:
IPCPDEBUG((LOG_INFO, "ipcp_rejci: received bad Reject!"));
}
/*
* ipcp_reqci - Check the peer's requested CIs and send appropriate response.
*
* Returns: CONFACK, CONFNAK or CONFREJ and input packet modified
* appropriately.
*/
static u_char
ipcp_reqci(f, inp, len)
fsm *f;
u_char *inp; /* Requested CIs */
int *len; /* Length of requested CIs */
{
ipcp_options *wo = &ipcp_wantoptions[f->unit];
ipcp_options *ho = &ipcp_hisoptions[f->unit];
ipcp_options *ao = &ipcp_allowoptions[f->unit];
ipcp_options *go = &ipcp_gotoptions[f->unit];
u_char *cip; /* Pointer to Current CI */
u_short cilen, citype; /* Parsed len, type */
u_short cishort; /* Parsed short value */
u_long tl, ciaddr1, ciaddr2; /* Parsed address values */
int rc = CONFACK; /* Final packet return code */
int orc; /* Individual option return code */
u_char *p = inp; /* Pointer to next char to parse */
u_char *ucp = inp; /* Pointer to current output char */
int l = *len; /* Length left */
u_char maxslotindex, cflag;
/*
* Reset all his options.
*/
ho->neg_addrs = 0;
ho->neg_vj = 0;
ho->maxslotindex = 0;
ho->cflag = 0;
/*
* Process all his options.
*/
while (l) {
orc = CONFACK; /* Assume success */
cip = p; /* Remember begining of CI */
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? */
IPCPDEBUG((LOG_INFO, "ipcp_reqci: bad CI length!"));
orc = CONFREJ; /* Reject bad CI */
cilen = l; /* Reject till end of packet */
l = 0; /* Don't loop again */
goto endswitch;
}
GETCHAR(citype, p); /* Parse CI type */
GETCHAR(cilen, p); /* Parse CI length */
l -= cilen; /* Adjust remaining length */
cilen -= 2; /* Adjust cilen to just data */
switch (citype) { /* Check CI type */
case CI_ADDRS:
logf(LOG_INFO, "ipcp: received ADDRS ");
if (!ao->neg_addrs ||
cilen != 2 * sizeof (long))
{ /* Check CI length */
INCPTR(cilen, p); /* Skip rest of CI */
orc = CONFREJ; /* Reject CI */
break;
}
/*
* If he has no address, or if we both have his address but
* disagree about it, then NAK it with our idea.
* In particular, if we don't know his address, but he does,
* then accept it.
*/
GETLONG(tl, p); /* Parse source address (his) */
ciaddr1 = htonl(tl);
if (!ciaddr1 ||
(wo->neg_addrs && wo->hisaddr && ciaddr1 != wo->hisaddr))
{
orc = CONFNAK;
DECPTR(sizeof (long), p);
tl = wo->neg_addrs ? ntohl(wo->hisaddr) : 0;
PUTLONG(tl, p);
}
/*
* If he doesn't know our address, or if we both have our address
* but disagree about it, then NAK it with our idea.
*/
GETLONG(tl, p); /* Parse desination address (ours) */
ciaddr2 = htonl(tl);
logf(LOG_INFO, "(%s:%s)", ip_ntoa(ciaddr1), ip_ntoa(ciaddr2));
if (!ciaddr2 ||
(wo->neg_addrs && wo->ouraddr && ciaddr2 != wo->ouraddr))
{
orc = CONFNAK;
DECPTR(sizeof (long), p);
tl = ntohl(wo->ouraddr);
PUTLONG(tl, p);
}
if (orc == CONFNAK)
break;
/* XXX ho or go? */
ho->neg_addrs = 1;
ho->hisaddr = ciaddr1;
ho->ouraddr = ciaddr2;
break;
case CI_ADDR:
logf(LOG_INFO, "ipcp: received ADDR ");
go->got_addr = 1;
go->neg_addrs = 0;
go->neg_addr = 1;
if (!ao->neg_addr ||
cilen != sizeof (long)) { /* Check CI length */
INCPTR(cilen, p); /* Skip rest of CI */
orc = CONFREJ; /* Reject CI */
break;
}
/*
* If he has no address, or if we both have his address but
* disagree about it, then NAK it with our idea.
* In particular, if we don't know his address, but he does,
* then accept it.
*/
GETLONG(tl, p); /* Parse source address (his) */
ciaddr1 = htonl(tl);
logf(LOG_INFO, "(%s)", ip_ntoa(ciaddr1));
if (!ciaddr1 ||
(wo->neg_addr && wo->hisaddr && ciaddr1 != wo->hisaddr)) {
orc = CONFNAK;
DECPTR(sizeof (long), p);
tl = wo->neg_addr ? ntohl(wo->hisaddr) : 0;
PUTLONG(tl, p);
}
if (orc == CONFNAK)
break;
/* XXX ho or go? */
ho->neg_addr = 1;
ho->hisaddr = ciaddr1;
break;
case CI_COMPRESSTYPE:
logf(LOG_INFO, "ipcp: received COMPRESSTYPE ");
if (!ao->neg_vj ||
cilen != (vj_opt_len - 2)) {
INCPTR(cilen, p);
orc = CONFREJ;
break;
}
GETSHORT(cishort, p);
logf(LOG_INFO, "(%d)", cishort);
/*
* Compresstype must be vj_opt_val.
*/
if (cishort != vj_opt_val) {
DECPTR(sizeof (short), p);
orc = CONFNAK;
PUTSHORT(vj_opt_val, p);
break;
}
ho->neg_vj = 1;
if (vj_mode == IPCP_VJMODE_RFC1332) {
GETCHAR(maxslotindex, p);
if (maxslotindex > wo->maxslotindex) {
DECPTR(1, p);
orc = CONFNAK;
PUTCHAR(wo->maxslotindex, p);
break;
}
ho->maxslotindex = maxslotindex;
GETCHAR(cflag, p);
if (cflag != wo->cflag) {
DECPTR(1, p);
orc = CONFNAK;
PUTCHAR(wo->cflag, p);
break;
}
ho->cflag = wo->cflag;
}
break;
default:
INCPTR(cilen, p);
orc = CONFREJ;
break;
}
cilen += 2; /* Adjust cilen whole CI */
endswitch:
logf(LOG_INFO, " (%s)\n",
orc == CONFACK ? "ACK" : (orc == CONFNAK ? "NAK" : "Reject"));
if (orc == CONFACK && /* Good CI */
rc != CONFACK) /* but prior CI wasnt? */
continue; /* Don't send this one */
if (orc == CONFNAK) { /* Nak this CI? */
if (rc == CONFREJ) /* Rejecting prior CI? */
continue; /* Don't send this one */
if (rc == CONFACK) { /* Ack'd all prior CIs? */
rc = CONFNAK; /* Not anymore... */
ucp = inp; /* Backup */
}
}
if (orc == CONFREJ && /* Reject this CI */
rc != CONFREJ) { /* but no prior ones? */
rc = CONFREJ;
ucp = inp; /* Backup */
}
/* Need to move CI? */
if (ucp != cip)
/* Move it */
memcpy(ucp, cip, (size_t)cilen);
/* Update output pointer */
INCPTR(cilen, ucp);
}
/*
* XXX If we wanted to send additional NAKs (for unsent CIs), the
* code would go here. This must be done with care since it might
* require a longer packet than we received.
*/
*len = ucp - inp; /* Compute output length */
syslog(LOG_INFO, "ipcp: returning Configure-%s",
rc == CONFACK ? "ACK" :
rc == CONFNAK ? "NAK" : "Reject");
return (rc); /* Return final code */
}
/*
* ipcp_up - IPCP has come UP.
*/
static void
ipcp_up(f)
fsm *f;
{
u_long mask;
syslog(LOG_INFO, "ipcp: up");
if (ipcp_hisoptions[f->unit].hisaddr == 0)
ipcp_hisoptions[f->unit].hisaddr = ipcp_wantoptions[f->unit].hisaddr;
syslog(LOG_INFO, "local IP address %s",
ip_ntoa(ipcp_gotoptions[f->unit].ouraddr));
syslog(LOG_INFO, "remote IP address %s",
ip_ntoa(ipcp_hisoptions[f->unit].hisaddr));
SIFADDR(f->unit, ipcp_gotoptions[f->unit].ouraddr,
ipcp_hisoptions[f->unit].hisaddr);
/* set new netmask if specified */
mask = GetMask(ipcp_gotoptions[f->unit].ouraddr);
if (mask)
SIFMASK(f->unit, mask);
/* set tcp compression */
SIFVJCOMP(f->unit, ipcp_hisoptions[f->unit].neg_vj);
}
/*
* ipcp_down - IPCP has gone DOWN.
*
* Alert other protocols.
*/
static void
ipcp_down(f)
fsm *f;
{
syslog(LOG_INFO, "ipcp: down");
CIFADDR(f->unit, ipcp_gotoptions[f->unit].ouraddr,
ipcp_hisoptions[f->unit].hisaddr);
}
Reference in New Issue View Git Blame Copy Permalink