d/freebsd-dev
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

o Move struct lcp and struct ccp into struct link.

Browse Source 
o Remove bundle2lcp(), bundle2ccp() and bundle2link().
  They're too resource-hungry and we have `owner pointers'
  to do their job.
o Make our FSM understand LCPs that are always ST_OPENED
  (with a minimum code that != 1).
o Send FSM code rejects for invalid codes.
o Make our bundle fsm_parent deal with multiple links.
o Make timer diagnostics pretty and allow access via ~t
  in `term' mode (not just when logging debug) and
  `show timers'.  Only show timers every second in debug
  mode, otherwise we get too many diagnostics to be useful
  (we probably still do).  Also, don't restrict ~m in term
  mode to depend on debug logging.
o Rationalise our bundles' phases.
o Create struct mp (multilink protocol).  This is both an
  NCP and a type of struct link.  It feeds off other NCPs
  for output, passing fragmented packets into the queues
  of available datalinks.  It also gets PROTO_MP input,
  reassembles the fragments into ppp frames, and passes
  them back to the HDLC layer that the fragments were passed
  from.
  ** It's not yet possible to enter multilink mode :-( **
o Add `set weight' (requires context) for deciding on a links
  weighting in multilink mode.  Weighting is simplistic (and
  probably badly implemented) for now.
o Remove the function pointers in struct link.  They ended up
  only applying to physical links.
o Configure our tun device with an MTU equal to the MRU from
  struct mp's LCP and a speed equal to the sum of our link
  speeds.
o `show {lcp,ccp,proto}' and `set deflate' now have optional
  context and use ChooseLink() to decide on which `struct link'
  to use.  This allows behaviour as before when in non-multilink
  mode, and allows access to the MP logical link in multilink
  mode.
o Ignore reconnect and redial values when in -direct mode and
  when cleaning up.  Always redial when in -ddial or -dedicated
  mode (unless cleaning up).
o Tell our links to `staydown' when we close them due to a signal.
o Remove remaining `#ifdef SIGALRM's (ppp doesn't function without
  alarms).
o Don't bother strdup()ing our physical link name.
o Various other cosmetic changes.
This commit is contained in:
Brian Somers 1998-04-03 19:21:56 +00:00
parent 5cf4388bdf
commit 3b0f8d2ed6
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/cvs2svn/branches/MP/; revision=35009
50 changed files with 1194 additions and 521 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
usr.sbin/ppp/Makefile
View File

@ -1,11 +1,11 @@
# $Id: Makefile,v 1.36.2.6 1998/02/10 03:23:04 brian Exp $
# $Id: Makefile,v 1.36.2.7 1998/02/15 23:59:34 brian Exp $
PROG= ppp
SRCS= arp.c async.c auth.c bundle.c ccp.c chap.c chat.c command.c deflate.c \
datalink.c defs.c filter.c fsm.c hdlc.c id.c ip.c ipcp.c iplist.c \
lcp.c link.c log.c lqr.c main.c mbuf.c modem.c pap.c physical.c pred.c \
prompt.c route.c server.c sig.c slcompress.c systems.c throughput.c \
timer.c tun.c vars.c vjcomp.c
SRCS= arp.c async.c auth.c bundle.c ccp.c chap.c chat.c command.c \
deflate.c datalink.c defs.c filter.c fsm.c hdlc.c id.c ip.c \
ipcp.c iplist.c lcp.c link.c log.c lqr.c main.c mbuf.c modem.c \
mp.c pap.c physical.c pred.c prompt.c route.c server.c sig.c \
slcompress.c systems.c throughput.c timer.c tun.c vars.c vjcomp.c
CFLAGS+=-Wall -Wpointer-arith
LDADD+= -lmd -lcrypt -lutil -lz
DPADD+= ${LIBMD} ${LIBCRYPT} ${LIBUTIL} ${LIBZ}

8
usr.sbin/ppp/arp.c
View File

@ -17,7 +17,7 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: arp.c,v 1.27.2.8 1998/03/16 22:53:25 brian Exp $
* $Id: arp.c,v 1.27.2.9 1998/03/20 19:47:38 brian Exp $
*
*/
@ -62,6 +62,12 @@
#include "ipcp.h"
#include "filter.h"
#include "descriptor.h"
#include "lqr.h"
#include "hdlc.h"
#include "lcp.h"
#include "ccp.h"
#include "link.h"
#include "mp.h"
#include "bundle.h"
#include "arp.h"

3
usr.sbin/ppp/async.c
View File

@ -17,7 +17,7 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: async.c,v 1.15.2.7 1998/02/18 19:35:07 brian Exp $
* $Id: async.c,v 1.15.2.8 1998/03/13 00:43:50 brian Exp $
*
*/
#include <sys/param.h>
@ -42,6 +42,7 @@
#include "vars.h"
#include "async.h"
#include "throughput.h"
#include "ccp.h"
#include "link.h"
#include "descriptor.h"
#include "physical.h"

5
usr.sbin/ppp/auth.c
View File

@ -17,7 +17,7 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: auth.c,v 1.27.2.14 1998/03/16 22:51:43 brian Exp $
* $Id: auth.c,v 1.27.2.15 1998/03/16 22:53:28 brian Exp $
*
* TODO:
* o Implement check against with registered IP addresses.
@ -51,12 +51,14 @@
#include "lqr.h"
#include "hdlc.h"
#include "async.h"
#include "ccp.h"
#include "link.h"
#include "descriptor.h"
#include "physical.h"
#include "chat.h"
#include "lcpproto.h"
#include "filter.h"
#include "mp.h"
#include "bundle.h"
const char *
@ -262,6 +264,7 @@ StartAuthChallenge(struct authinfo *authp, struct physical *physical,
authp->physical = physical;
StopTimer(&authp->authtimer);
authp->authtimer.func = AuthTimeout;
authp->authtimer.name = "auth";
authp->authtimer.load = VarRetryTimeout * SECTICKS;
authp->authtimer.state = TIMER_STOPPED;
authp->authtimer.arg = (void *) authp;

249
usr.sbin/ppp/bundle.c
View File

@ -23,7 +23,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: bundle.c,v 1.1.2.32 1998/03/25 00:59:28 brian Exp $
* $Id: bundle.c,v 1.1.2.33 1998/03/25 18:38:38 brian Exp $
*/
#include <sys/param.h>
@ -58,10 +58,8 @@
#include "throughput.h"
#include "slcompress.h"
#include "ipcp.h"
#include "link.h"
#include "filter.h"
#include "descriptor.h"
#include "bundle.h"
#include "loadalias.h"
#include "vars.h"
#include "arp.h"
@ -69,6 +67,9 @@
#include "route.h"
#include "lcp.h"
#include "ccp.h"
#include "link.h"
#include "mp.h"
#include "bundle.h"
#include "async.h"
#include "physical.h"
#include "modem.h"
@ -176,10 +177,6 @@ static void
bundle_LayerStart(void *v, struct fsm *fp)
{
/* The given FSM is about to start up ! */
struct bundle *bundle = (struct bundle *)v;
if (fp->proto == PROTO_LCP && bundle_Phase(bundle) == PHASE_DEAD)
bundle_NewPhase(bundle, PHASE_ESTABLISH);
}
@ -195,27 +192,37 @@ bundle_Notify(struct bundle *bundle, char c)
bundle->notify.fd = -1;
}
}
static void
bundle_LayerUp(void *v, struct fsm *fp)
bundle_vLayerUp(void *v, struct fsm *fp)
{
bundle_LayerUp((struct bundle *)v, fp);
}
void
bundle_LayerUp(struct bundle *bundle, struct fsm *fp)
{
/*
* The given fsm is now up
* If it's a datalink, adjust our mtu enter network phase
* If it's the first NCP, start the idle timer.
* If it's an LCP (including MP initialisation), set our mtu
* (This routine is also called from mp_Init() with it's LCP)
* If it's an NCP, tell our background mode parent to go away.
* If it's the first NCP, start the idle timer.
*/
struct bundle *bundle = (struct bundle *)v;
if (fp->proto == PROTO_LCP) {
struct lcp *lcp = fsm2lcp(fp);
if (bundle->ncp.mp.active) {
int speed;
struct datalink *dl;
/* XXX Should figure out what the optimum mru and speed are */
tun_configure(bundle, lcp->his_mru, modem_Speed(link2physical(fp->link)));
bundle_NewPhase(bundle, PHASE_NETWORK);
}
if (fp->proto == PROTO_IPCP) {
for (dl = bundle->links, speed = 0; dl; dl = dl->next)
speed += modem_Speed(dl->physical);
if (speed)
tun_configure(bundle, bundle->ncp.mp.link.lcp.his_mru, speed);
} else
tun_configure(bundle, fsm2lcp(fp)->his_mru,
modem_Speed(link2physical(fp->link)));
} else if (fp->proto == PROTO_IPCP) {
bundle_StartIdleTimer(bundle);
bundle_Notify(bundle, EX_NORMAL);
}
@ -227,12 +234,32 @@ bundle_LayerDown(void *v, struct fsm *fp)
/*
* The given FSM has been told to come down.
* If it's our last NCP, stop the idle timer.
* If it's our last NCP *OR* LCP, enter TERMINATE phase.
* If it's an LCP and we're in multilink mode, adjust our tun speed.
*/
struct bundle *bundle = (struct bundle *)v;
if (fp->proto == PROTO_IPCP)
if (fp->proto == PROTO_IPCP) {
bundle_StopIdleTimer(bundle);
bundle_NewPhase(bundle, PHASE_TERMINATE);
} else if (fp->proto == PROTO_LCP) {
int speed, others_active;
struct datalink *dl;
others_active = 0;
for (dl = bundle->links, speed = 0; dl; dl = dl->next)
if (fp != &dl->physical->link.lcp.fsm &&
dl->state != DATALINK_CLOSED && dl->state != DATALINK_HANGUP) {
speed += modem_Speed(dl->physical);
others_active++;
}
if (bundle->ncp.mp.active && speed)
tun_configure(bundle, bundle->ncp.mp.link.lcp.his_mru, speed);
if (!others_active)
bundle_NewPhase(bundle, PHASE_TERMINATE);
}
}
static void
@ -241,23 +268,31 @@ bundle_LayerFinish(void *v, struct fsm *fp)
/* The given fsm is now down (fp cannot be NULL)
*
* If it's the last LCP, FsmDown all NCPs
* If it's the last NCP, FsmClose all LCPs and enter TERMINATE phase.
* If it's the last NCP, FsmClose all LCPs
*/
struct bundle *bundle = (struct bundle *)v;
struct datalink *dl;
if (fp->proto == PROTO_IPCP) {
struct datalink *dl;
bundle_NewPhase(bundle, PHASE_TERMINATE);
for (dl = bundle->links; dl; dl = dl->next)
datalink_Close(dl, 1);
}
datalink_Close(dl, 0);
FsmDown(fp);
FsmClose(fp);
} else if (fp->proto == PROTO_LCP) {
int others_active;
/* when either the LCP or IPCP is down, drop IPCP */
FsmDown(&bundle->ncp.ipcp.fsm);
FsmClose(&bundle->ncp.ipcp.fsm); /* ST_INITIAL please */
others_active = 0;
for (dl = bundle->links; dl; dl = dl->next)
if (fp != &dl->physical->link.lcp.fsm &&
dl->state != DATALINK_CLOSED && dl->state != DATALINK_HANGUP)
others_active++;
if (!others_active) {
FsmDown(&bundle->ncp.ipcp.fsm);
FsmClose(&bundle->ncp.ipcp.fsm); /* ST_INITIAL please */
}
}
}
int
@ -271,33 +306,52 @@ bundle_Close(struct bundle *bundle, const char *name, int staydown)
{
/*
* Please close the given datalink.
*
* If name == NULL or name is the last datalink, enter TERMINATE phase.
*
* If name == NULL, FsmClose all NCPs.
*
* If name is the last datalink, FsmClose all NCPs.
*
* If isn't the last datalink, just Close that datalink.
* If name == NULL or name is the last datalink, enter TERMINATE phase
* and FsmClose all NCPs (except our MP)
* If it isn't the last datalink, just Close that datalink.
*/
struct datalink *dl;
struct datalink *dl, *this_dl;
int others_active;
if (bundle->ncp.ipcp.fsm.state > ST_CLOSED ||
bundle->ncp.ipcp.fsm.state == ST_STARTING) {
bundle_NewPhase(bundle, PHASE_TERMINATE);
FsmClose(&bundle->ncp.ipcp.fsm);
if (staydown)
for (dl = bundle->links; dl; dl = dl->next)
if (bundle->phase == PHASE_TERMINATE || bundle->phase == PHASE_DEAD)
return;
others_active = 0;
this_dl = NULL;
for (dl = bundle->links; dl; dl = dl->next) {
if (name && !strcasecmp(name, dl->name))
this_dl = dl;
if (name == NULL || this_dl == dl) {
if (staydown)
datalink_StayDown(dl);
} else {
if (bundle->ncp.ipcp.fsm.state > ST_INITIAL) {
FsmClose(&bundle->ncp.ipcp.fsm);
FsmDown(&bundle->ncp.ipcp.fsm);
}
for (dl = bundle->links; dl; dl = dl->next)
datalink_Close(dl, staydown);
} else if (dl->state != DATALINK_CLOSED && dl->state != DATALINK_HANGUP)
others_active++;
}
if (name && this_dl == NULL) {
LogPrintf(LogWARN, "%s: Invalid datalink name\n", name);
return;
}
if (!others_active) {
if (bundle->ncp.ipcp.fsm.state > ST_CLOSED ||
bundle->ncp.ipcp.fsm.state == ST_STARTING)
FsmClose(&bundle->ncp.ipcp.fsm);
else {
/* This shouldn't happen ! */
LogPrintf(LogWARN, "Tidying up hung FSMs\n");
if (bundle->ncp.ipcp.fsm.state > ST_INITIAL) {
FsmClose(&bundle->ncp.ipcp.fsm);
FsmDown(&bundle->ncp.ipcp.fsm);
}
for (dl = bundle->links; dl; dl = dl->next)
datalink_Close(dl, staydown);
}
} else if (this_dl && this_dl->state != DATALINK_CLOSED &&
this_dl->state != DATALINK_HANGUP)
datalink_Close(this_dl, staydown);
}
static int
@ -353,7 +407,7 @@ bundle_DescriptorWrite(struct descriptor *d, struct bundle *bundle,
#define MAX_TUN 256
/*
* MAX_TUN is set at 256 because that is the largest minor number
* we can use (certainly with mknod(1) anyway. The search for a
* we can use (certainly with mknod(1) anyway). The search for a
* device aborts when it reaches the first `Device not configured'
* (ENXIO) or the third `No such file or directory' (ENOENT) error.
*/
@ -448,7 +502,7 @@ bundle_Create(const char *prefix)
bundle.CleaningUp = 0;
bundle.fsm.LayerStart = bundle_LayerStart;
bundle.fsm.LayerUp = bundle_LayerUp;
bundle.fsm.LayerUp = bundle_vLayerUp;
bundle.fsm.LayerDown = bundle_LayerDown;
bundle.fsm.LayerFinish = bundle_LayerFinish;
bundle.fsm.object = &bundle;
@ -539,7 +593,6 @@ bundle_Destroy(struct bundle *bundle)
dl = datalink_Destroy(dl);
bundle_Notify(bundle, EX_ERRDEAD);
bundle->ifname = NULL;
}
@ -684,23 +737,30 @@ bundle_LinkClosed(struct bundle *bundle, struct datalink *dl)
/*
* Our datalink has closed.
* If it's DIRECT or BACKGROUND, delete it.
* If it's the last data link,
* If it's the last data link, enter phase DEAD.
*/
if (mode & (MODE_BACKGROUND|MODE_DIRECT))
bundle->CleaningUp = 1;
struct datalink *odl;
int other_links;
if (!(mode & MODE_AUTO))
bundle_DownInterface(bundle);
if (mode & (MODE_DIRECT|MODE_BACKGROUND)) {
struct datalink **dlp;
for (dlp = &bundle->links; *dlp; dlp = &(*dlp)->next)
if (*dlp == dl)
*dlp = datalink_Destroy(*dlp);
}
if (mode & MODE_DDIAL)
datalink_Up(dl, 1, 1);
else
other_links = 0;
for (odl = bundle->links; odl; odl = odl->next)
if (odl != dl && odl->state != DATALINK_CLOSED)
other_links++;
if (!other_links) {
if (!(mode & MODE_AUTO))
bundle_DownInterface(bundle);
bundle_NewPhase(bundle, PHASE_DEAD);
if (mode & MODE_INTER)
prompt_Display(&prompt, bundle);
}
}
void
@ -719,8 +779,6 @@ bundle_Open(struct bundle *bundle, const char *name)
if (name != NULL)
break;
}
if (bundle_Phase(bundle) == PHASE_DEAD)
bundle_NewPhase(bundle, PHASE_ESTABLISH);
}
struct datalink *
@ -745,24 +803,6 @@ bundle2physical(struct bundle *bundle, const char *name)
return dl ? dl->physical : NULL;
}
struct ccp *
bundle2ccp(struct bundle *bundle, const char *name)
{
struct datalink *dl = bundle2datalink(bundle, name);
if (dl)
return &dl->ccp;
return NULL;
}
struct lcp *
bundle2lcp(struct bundle *bundle, const char *name)
{
struct datalink *dl = bundle2datalink(bundle, name);
if (dl)
return &dl->lcp;
return NULL;
}
struct authinfo *
bundle2pap(struct bundle *bundle, const char *name)
{
@ -781,31 +821,23 @@ bundle2chap(struct bundle *bundle, const char *name)
return NULL;
}
struct link *
bundle2link(struct bundle *bundle, const char *name)
{
struct physical *physical = bundle2physical(bundle, name);
return physical ? &physical->link : NULL;
}
int
bundle_FillQueues(struct bundle *bundle)
{
struct datalink *dl;
int packets, total;
int total;
total = 0;
for (dl = bundle->links; dl; dl = dl->next) {
packets = link_QueueLen(&dl->physical->link);
if (packets == 0) {
IpStartOutput(&dl->physical->link, bundle);
packets = link_QueueLen(&dl->physical->link);
}
total += packets;
if (bundle->ncp.mp.active) {
total = mp_FillQueues(bundle);
} else {
struct datalink *dl;
dl = bundle2datalink(bundle, NULL);
total = link_QueueLen(&dl->physical->link);
if (total == 0 && dl->physical->out == NULL)
total = IpFlushPacket(&dl->physical->link, bundle);
}
total += ip_QueueLen();
return total;
return total + ip_QueueLen();
}
int
@ -843,6 +875,7 @@ bundle_StartIdleTimer(struct bundle *bundle)
if (!(mode & (MODE_DEDICATED | MODE_DDIAL)) && bundle->cfg.idle_timeout) {
StopTimer(&bundle->idle.timer);
bundle->idle.timer.func = bundle_IdleTimeout;
bundle->idle.timer.name = "idle";
bundle->idle.timer.load = bundle->cfg.idle_timeout * SECTICKS;
bundle->idle.timer.state = TIMER_STOPPED;
bundle->idle.timer.arg = bundle;
@ -872,3 +905,9 @@ bundle_RemainingIdleTime(struct bundle *bundle)
return bundle->idle.done - time(NULL);
return -1;
}
int
bundle_IsDead(struct bundle *bundle)
{
return !bundle->links || (bundle->phase == PHASE_DEAD && bundle->CleaningUp);
}

8
usr.sbin/ppp/bundle.h
View File

@ -23,7 +23,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: bundle.h,v 1.1.2.20 1998/03/20 19:47:42 brian Exp $
* $Id: bundle.h,v 1.1.2.21 1998/03/25 18:38:40 brian Exp $
*/
#define PHASE_DEAD 0 /* Link is dead */
@ -58,6 +58,7 @@ struct bundle {
struct {
struct ipcp ipcp; /* Our IPCP FSM */
struct mp mp; /* Our MP */
} ncp;
struct {
@ -99,11 +100,10 @@ extern void bundle_StartIdleTimer(struct bundle *);
extern void bundle_SetIdleTimer(struct bundle *, int);
extern void bundle_StopIdleTimer(struct bundle *);
extern int bundle_RemainingIdleTime(struct bundle *);
extern void bundle_LayerUp(struct bundle *, struct fsm *);
extern int bundle_IsDead(struct bundle *);
extern struct link *bundle2link(struct bundle *, const char *);
extern struct physical *bundle2physical(struct bundle *, const char *);
extern struct datalink *bundle2datalink(struct bundle *, const char *);
extern struct authinfo *bundle2pap(struct bundle *, const char *);
extern struct chap *bundle2chap(struct bundle *, const char *);
extern struct ccp *bundle2ccp(struct bundle *, const char *);
extern struct lcp *bundle2lcp(struct bundle *, const char *);

20
usr.sbin/ppp/ccp.c
View File

@ -17,7 +17,7 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: ccp.c,v 1.30.2.27 1998/03/20 19:47:44 brian Exp $
* $Id: ccp.c,v 1.30.2.28 1998/03/24 18:46:37 brian Exp $
*
* TODO:
* o Support other compression protocols
@ -51,14 +51,17 @@
#include "ipcp.h"
#include "filter.h"
#include "descriptor.h"
#include "bundle.h"
#include "prompt.h"
#include "lqr.h"
#include "hdlc.h"
#include "link.h"
#include "mp.h"
#include "bundle.h"
#include "chat.h"
#include "auth.h"
#include "chap.h"
#include "async.h"
#include "physical.h"
#include "datalink.h"
static void CcpSendConfigReq(struct fsm *);
@ -132,7 +135,7 @@ static const struct ccp_algorithm *algorithm[] = {
int
ccp_ReportStatus(struct cmdargs const *arg)
{
struct ccp *ccp = arg->cx ? &arg->cx->ccp : bundle2ccp(arg->bundle, NULL);
struct ccp *ccp = &ChooseLink(arg)->ccp;
prompt_Printf(&prompt, "%s [%s]\n", ccp->fsm.name,
State2Nam(ccp->fsm.state));
@ -149,8 +152,11 @@ ccp_Init(struct ccp *ccp, struct bundle *bundle, struct link *l,
const struct fsm_parent *parent)
{
/* Initialise ourselves */
fsm_Init(&ccp->fsm, "CCP", PROTO_CCP, CCP_MAXCODE, 10, LogCCP,
bundle, l, parent, &ccp_Callbacks);
static const char *timer_names[] =
{"CCP restart", "CCP openmode", "CCP stopped"};
fsm_Init(&ccp->fsm, "CCP", PROTO_CCP, 1, CCP_MAXCODE, 10, LogCCP,
bundle, l, parent, &ccp_Callbacks, timer_names);
ccp->cfg.deflate.in.winsize = 0;
ccp->cfg.deflate.out.winsize = 15;
ccp_Setup(ccp);
@ -483,8 +489,8 @@ CcpRecvResetAck(struct fsm *fp, u_char id)
}
int
ccp_Output(struct ccp *ccp, struct link *l, int pri, u_short proto,
struct mbuf *m)
ccp_Compress(struct ccp *ccp, struct link *l, int pri, u_short proto,
struct mbuf *m)
{
/* Compress outgoing Network Layer data */
if ((proto & 0xfff1) == 0x21 && ccp->fsm.state == ST_OPENED &&

4
usr.sbin/ppp/ccp.h
View File

@ -15,7 +15,7 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: ccp.h,v 1.14.2.12 1998/02/27 01:22:19 brian Exp $
* $Id: ccp.h,v 1.14.2.13 1998/03/17 22:29:03 brian Exp $
*
* TODO:
*/
@ -111,5 +111,5 @@ extern void ccp_Setup(struct ccp *);
extern void CcpSendResetReq(struct fsm *);
extern void CcpInput(struct ccp *, struct bundle *, struct mbuf *);
extern int ccp_ReportStatus(struct cmdargs const *);
extern int ccp_Output(struct ccp *, struct link *, int, u_short, struct mbuf *);
extern int ccp_Compress(struct ccp *, struct link *, int, u_short, struct mbuf *);
extern struct mbuf *ccp_Decompress(struct ccp *, u_short *, struct mbuf *);

17
usr.sbin/ppp/chap.c
View File

@ -17,7 +17,7 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: chap.c,v 1.28.2.17 1998/03/16 22:51:52 brian Exp $
* $Id: chap.c,v 1.28.2.18 1998/03/16 22:53:34 brian Exp $
*
* TODO:
*/
@ -60,15 +60,16 @@
#include "chap.h"
#include "async.h"
#include "throughput.h"
#include "link.h"
#include "descriptor.h"
#include "physical.h"
#include "iplist.h"
#include "slcompress.h"
#include "ipcp.h"
#include "filter.h"
#include "bundle.h"
#include "ccp.h"
#include "link.h"
#include "physical.h"
#include "mp.h"
#include "bundle.h"
#include "chat.h"
#include "datalink.h"
@ -242,7 +243,7 @@ RecvChapTalk(struct bundle *bundle, struct fsmheader *chp, struct mbuf *bp,
ChapOutput(physical, CHAP_SUCCESS, chp->id, "Welcome!!", 10);
Physical_Login(physical, name);
if (dl->lcp.auth_iwait == 0)
if (dl->physical->link.lcp.auth_iwait == 0)
/*
* Either I didn't need to authenticate, or I've already been
* told that I got the answer right.
@ -272,9 +273,9 @@ RecvChapResult(struct bundle *bundle, struct fsmheader *chp, struct mbuf *bp,
len = ntohs(chp->length);
LogPrintf(LogDEBUG, "RecvChapResult: length: %d\n", len);
if (chp->code == CHAP_SUCCESS) {
if (dl->lcp.auth_iwait == PROTO_CHAP) {
dl->lcp.auth_iwait = 0;
if (dl->lcp.auth_ineed == 0)
if (dl->physical->link.lcp.auth_iwait == PROTO_CHAP) {
dl->physical->link.lcp.auth_iwait = 0;
if (dl->physical->link.lcp.auth_ineed == 0)
/*
* We've succeeded in our ``login''
* If we're not expecting the peer to authenticate (or he already

5
usr.sbin/ppp/chat.c
View File

@ -23,7 +23,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: chat.c,v 1.44.2.16 1998/03/13 21:07:59 brian Exp $
* $Id: chat.c,v 1.44.2.17 1998/03/20 19:47:47 brian Exp $
*/
#include <sys/param.h>
@ -55,6 +55,7 @@
#include "throughput.h"
#include "fsm.h"
#include "lcp.h"
#include "ccp.h"
#include "link.h"
#include "async.h"
#include "descriptor.h"
@ -84,6 +85,7 @@ chat_Pause(struct chat *c, u_long load)
c->pause.state = TIMER_STOPPED;
c->pause.load += load;
c->pause.func = chat_PauseTimer;
c->pause.name = "chat pause";
c->pause.arg = c;
StartTimer(&c->pause);
}
@ -104,6 +106,7 @@ chat_SetTimeout(struct chat *c)
if (c->TimeoutSec > 0) {
c->timeout.load = SECTICKS * c->TimeoutSec;
c->timeout.func = chat_TimeoutTimer;
c->timeout.name = "chat timeout";
c->timeout.arg = c;
StartTimer(&c->timeout);
}

92
usr.sbin/ppp/command.c
View File

@ -17,7 +17,7 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: command.c,v 1.131.2.42 1998/03/20 19:47:51 brian Exp $
* $Id: command.c,v 1.131.2.43 1998/03/24 18:46:43 brian Exp $
*
*/
#include <sys/param.h>
@ -67,7 +67,6 @@
#include "systems.h"
#include "filter.h"
#include "descriptor.h"
#include "bundle.h"
#include "main.h"
#include "route.h"
#include "ccp.h"
@ -76,6 +75,8 @@
#include "async.h"
#include "link.h"
#include "physical.h"
#include "mp.h"
#include "bundle.h"
#include "server.h"
#include "prompt.h"
#include "chat.h"
@ -88,7 +89,6 @@ static int ShowCommand(struct cmdargs const *);
static int TerminalCommand(struct cmdargs const *);
static int QuitCommand(struct cmdargs const *);
static int CloseCommand(struct cmdargs const *);
static int DialCommand(struct cmdargs const *);
static int DownCommand(struct cmdargs const *);
static int AllowCommand(struct cmdargs const *);
static int SetCommand(struct cmdargs const *);
@ -447,22 +447,29 @@ ShowTimeout(struct cmdargs const *arg)
return 0;
}
static int
ShowTimerList(struct cmdargs const *arg)
{
ShowTimers(0);
return 0;
}
static int
ShowStopped(struct cmdargs const *arg)
{
prompt_Printf(&prompt, " Stopped Timer: LCP: ");
if (!arg->cx->lcp.fsm.StoppedTimer.load)
if (!arg->cx->physical->link.lcp.fsm.StoppedTimer.load)
prompt_Printf(&prompt, "Disabled");
else
prompt_Printf(&prompt, "%ld secs",
arg->cx->lcp.fsm.StoppedTimer.load / SECTICKS);
arg->cx->physical->link.lcp.fsm.StoppedTimer.load / SECTICKS);
prompt_Printf(&prompt, ", CCP: ");
if (!arg->cx->ccp.fsm.StoppedTimer.load)
if (!arg->cx->physical->link.ccp.fsm.StoppedTimer.load)
prompt_Printf(&prompt, "Disabled");
else
prompt_Printf(&prompt, "%ld secs",
arg->cx->ccp.fsm.StoppedTimer.load / SECTICKS);
arg->cx->physical->link.ccp.fsm.StoppedTimer.load / SECTICKS);
prompt_Printf(&prompt, "\n");
@ -504,6 +511,14 @@ ShowPreferredMTU(struct cmdargs const *arg)
return 0;
}
int
ShowProtocolStats(struct cmdargs const *arg)
{
link_ReportProtocolStatus(ChooseLink(arg));
return 0;
}
static int
ShowReconnect(struct cmdargs const *arg)
{
@ -572,7 +587,7 @@ static struct cmdtab const ShowCommands[] = {
"Show packet filters", "show filter [in|out|dial|alive]"},
{"ipcp", NULL, ReportIpcpStatus, LOCAL_AUTH,
"Show IPCP status", "show ipcp"},
{"lcp", NULL, lcp_ReportStatus, LOCAL_AUTH | LOCAL_CX,
{"lcp", NULL, lcp_ReportStatus, LOCAL_AUTH | LOCAL_CX_OPT,
"Show LCP status", "show lcp"},
{"links", "link", bundle_ShowLinks, LOCAL_AUTH,
"Show available link names", "show links"},
@ -592,7 +607,7 @@ static struct cmdtab const ShowCommands[] = {
#endif
{"mtu", NULL, ShowPreferredMTU, LOCAL_AUTH,
"Show Preferred MTU", "show mtu"},
{"proto", NULL, Physical_ReportProtocolStatus, LOCAL_AUTH,
{"proto", NULL, ShowProtocolStats, LOCAL_AUTH | LOCAL_CX_OPT,
"Show protocol summary", "show proto"},
{"reconnect", NULL, ShowReconnect, LOCAL_AUTH | LOCAL_CX,
"Show reconnect timer", "show reconnect"},
@ -602,6 +617,8 @@ static struct cmdtab const ShowCommands[] = {
"Show routing table", "show route"},
{"timeout", NULL, ShowTimeout, LOCAL_AUTH,
"Show Idle timeout", "show timeout"},
{"timers", NULL, ShowTimerList, LOCAL_AUTH,
"Show alarm timers", "show timers"},
{"stopped", NULL, ShowStopped, LOCAL_AUTH | LOCAL_CX,
"Show STOPPED timeout", "show stopped"},
{"version", NULL, ShowVersion, LOCAL_NO_AUTH | LOCAL_AUTH,
@ -781,9 +798,9 @@ ShowCommand(struct cmdargs const *arg)
static int
TerminalCommand(struct cmdargs const *arg)
{
if (arg->cx->lcp.fsm.state > ST_CLOSED) {
if (arg->cx->physical->link.lcp.fsm.state > ST_CLOSED) {
prompt_Printf(&prompt, "LCP state is [%s]\n",
State2Nam(arg->cx->lcp.fsm.state));
State2Nam(arg->cx->physical->link.lcp.fsm.state));
return 1;
}
@ -821,7 +838,7 @@ CloseCommand(struct cmdargs const *arg)
static int
DownCommand(struct cmdargs const *arg)
{
link_Close(&arg->cx->physical->link, arg->bundle, 0, 1);
datalink_Down(arg->cx, 1);
return 0;
}
@ -925,13 +942,15 @@ SetRedialTimeout(struct cmdargs const *arg)
static int
SetStoppedTimeout(struct cmdargs const *arg)
{
arg->cx->lcp.fsm.StoppedTimer.load = 0;
arg->cx->ccp.fsm.StoppedTimer.load = 0;
struct link *l = &arg->cx->physical->link;
l->lcp.fsm.StoppedTimer.load = 0;
l->ccp.fsm.StoppedTimer.load = 0;
if (arg->argc <= 2) {
if (arg->argc > 0) {
arg->cx->lcp.fsm.StoppedTimer.load = atoi(arg->argv[0]) * SECTICKS;
l->lcp.fsm.StoppedTimer.load = atoi(arg->argv[0]) * SECTICKS;
if (arg->argc > 1)
arg->cx->ccp.fsm.StoppedTimer.load = atoi(arg->argv[1]) * SECTICKS;
l->ccp.fsm.StoppedTimer.load = atoi(arg->argv[1]) * SECTICKS;
}
return 0;
}
@ -1316,23 +1335,25 @@ SetVariable(struct cmdargs const *arg)
break;
case VAR_WINSIZE:
if (arg->argc > 0) {
cx->ccp.cfg.deflate.out.winsize = atoi(arg->argv[0]);
if (cx->ccp.cfg.deflate.out.winsize < 8 ||
cx->ccp.cfg.deflate.out.winsize > 15) {
struct link *l = ChooseLink(arg);
l->ccp.cfg.deflate.out.winsize = atoi(arg->argv[0]);
if (l->ccp.cfg.deflate.out.winsize < 8 ||
l->ccp.cfg.deflate.out.winsize > 15) {
LogPrintf(LogWARN, "%d: Invalid outgoing window size\n",
cx->ccp.cfg.deflate.out.winsize);
cx->ccp.cfg.deflate.out.winsize = 15;
l->ccp.cfg.deflate.out.winsize);
l->ccp.cfg.deflate.out.winsize = 15;
}
if (arg->argc > 1) {
cx->ccp.cfg.deflate.in.winsize = atoi(arg->argv[1]);
if (cx->ccp.cfg.deflate.in.winsize < 8 ||
cx->ccp.cfg.deflate.in.winsize > 15) {
l->ccp.cfg.deflate.in.winsize = atoi(arg->argv[1]);
if (l->ccp.cfg.deflate.in.winsize < 8 ||
l->ccp.cfg.deflate.in.winsize > 15) {
LogPrintf(LogWARN, "%d: Invalid incoming window size\n",
cx->ccp.cfg.deflate.in.winsize);
cx->ccp.cfg.deflate.in.winsize = 15;
l->ccp.cfg.deflate.in.winsize);
l->ccp.cfg.deflate.in.winsize = 15;
}
} else
cx->ccp.cfg.deflate.in.winsize = 0;
l->ccp.cfg.deflate.in.winsize = 0;
}
break;
case VAR_DEVICE:
@ -1406,7 +1427,7 @@ static struct cmdtab const SetCommands[] = {
"Set authentication name", "set authname name", (const void *) VAR_AUTHNAME},
{"ctsrts", NULL, SetCtsRts, LOCAL_AUTH | LOCAL_CX,
"Use CTS/RTS modem signalling", "set ctsrts [on|off]"},
{"deflate", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX,
{"deflate", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX_OPT,
"Set deflate window sizes", "set deflate out-winsize in-winsize",
(const void *) VAR_WINSIZE},
{"device", "line", SetVariable, LOCAL_AUTH | LOCAL_CX,
@ -1462,6 +1483,8 @@ static struct cmdtab const SetCommands[] = {
"Set Idle timeout", "set timeout idle LQR FSM-resend"},
{"vj", NULL, SetInitVJ, LOCAL_AUTH,
"Set vj values", "set vj slots|slotcomp"},
{"weight", NULL, mp_SetDatalinkWeight, LOCAL_AUTH | LOCAL_CX,
"Set datalink weighting", "set weight n"},
{"help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH,
"Display this message", "set help|? [command]", SetCommands},
{NULL, NULL, NULL},
@ -1679,3 +1702,16 @@ LinkCommand(struct cmdargs const *arg)
return 0;
}
struct link *
ChooseLink(struct cmdargs const *arg)
{
if (arg->cx)
return &arg->cx->physical->link;
else if (arg->bundle->ncp.mp.active)
return &arg->bundle->ncp.mp.link;
else {
struct physical *p = bundle2physical(arg->bundle, NULL);
return p ? &p->link : NULL;
}
}

3
usr.sbin/ppp/command.h
View File

@ -15,7 +15,7 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: command.h,v 1.12.2.4 1998/02/17 19:27:54 brian Exp $
* $Id: command.h,v 1.12.2.5 1998/03/17 22:29:07 brian Exp $
*
* TODO:
*/
@ -61,3 +61,4 @@ extern int IsInteractive(int);
extern void InterpretCommand(char *, int, int *, char ***);
extern void RunCommand(struct bundle *, int, char const *const *, const char *);
extern void DecodeCommand(struct bundle *, char *, int, const char *);
extern struct link *ChooseLink(struct cmdargs const *);

111
usr.sbin/ppp/datalink.c
View File

@ -23,7 +23,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: datalink.c,v 1.1.2.27 1998/03/20 19:47:54 brian Exp $
* $Id: datalink.c,v 1.1.2.28 1998/03/25 00:59:33 brian Exp $
*/
#include <sys/param.h>
@ -51,15 +51,16 @@
#include "hdlc.h"
#include "async.h"
#include "throughput.h"
#include "ccp.h"
#include "link.h"
#include "physical.h"
#include "iplist.h"
#include "slcompress.h"
#include "ipcp.h"
#include "filter.h"
#include "mp.h"
#include "bundle.h"
#include "chat.h"
#include "ccp.h"
#include "auth.h"
#include "main.h"
#include "modem.h"
@ -93,6 +94,7 @@ datalink_StartDialTimer(struct datalink *dl, int Timeout)
else
dl->dial_timer.load = (random() % DIAL_TIMEOUT) * SECTICKS;
dl->dial_timer.func = datalink_OpenTimeout;
dl->dial_timer.name = "dial";
dl->dial_timer.arg = dl;
StartTimer(&dl->dial_timer);
if (dl->state == DATALINK_OPENING)
@ -107,13 +109,17 @@ datalink_HangupDone(struct datalink *dl)
modem_Close(dl->physical);
dl->phone.chosen = "[N/A]";
if (!dl->dial_tries || (dl->dial_tries < 0 && !dl->reconnect_tries)) {
if (dl->bundle->CleaningUp ||
(mode & MODE_DIRECT) ||
((!dl->dial_tries || (dl->dial_tries < 0 && !dl->reconnect_tries)) &&
!(mode & (MODE_DDIAL|MODE_DEDICATED)))) {
LogPrintf(LogPHASE, "%s: Entering CLOSED state\n", dl->name);
dl->state = DATALINK_CLOSED;
dl->dial_tries = -1;
dl->reconnect_tries = 0;
bundle_LinkClosed(dl->bundle, dl);
datalink_StartDialTimer(dl, dl->cfg.dial_timeout);
if (!dl->bundle->CleaningUp)
datalink_StartDialTimer(dl, dl->cfg.dial_timeout);
} else {
LogPrintf(LogPHASE, "%s: Re-entering OPENING state\n", dl->name);
dl->state = DATALINK_OPENING;
@ -170,13 +176,17 @@ datalink_LoginDone(struct datalink *dl)
} else {
dl->dial_tries = -1;
lcp_Setup(&dl->lcp, dl->state == DATALINK_READY ? 0 : VarOpenMode);
ccp_Setup(&dl->ccp);
hdlc_Init(&dl->physical->hdlc);
async_Init(&dl->physical->async);
lcp_Setup(&dl->physical->link.lcp,
dl->state == DATALINK_READY ? 0 : VarOpenMode);
ccp_Setup(&dl->physical->link.ccp);
LogPrintf(LogPHASE, "%s: Entering LCP state\n", dl->name);
dl->state = DATALINK_LCP;
FsmUp(&dl->lcp.fsm);
FsmOpen(&dl->lcp.fsm);
FsmUp(&dl->physical->link.lcp.fsm);
FsmOpen(&dl->physical->link.lcp.fsm);
}
}
@ -215,14 +225,17 @@ datalink_UpdateSet(struct descriptor *d, fd_set *r, fd_set *w, fd_set *e,
else
LogPrintf(LogCHAT, "Failed to open modem\n");
if (!(mode & MODE_DDIAL) && dl->cfg.max_dial && dl->dial_tries == 0) {
if (dl->bundle->CleaningUp ||
(!(mode & (MODE_DDIAL|MODE_DEDICATED)) &&
dl->cfg.max_dial && dl->dial_tries == 0)) {
LogPrintf(LogPHASE, "%s: Entering CLOSED state\n", dl->name);
dl->state = DATALINK_CLOSED;
dl->reconnect_tries = 0;
dl->dial_tries = -1;
bundle_LinkClosed(dl->bundle, dl);
}
datalink_StartDialTimer(dl, dl->cfg.dial_timeout);
if (!dl->bundle->CleaningUp)
datalink_StartDialTimer(dl, dl->cfg.dial_timeout);
}
}
break;
@ -387,17 +400,17 @@ datalink_LayerUp(void *v, struct fsm *fp)
struct datalink *dl = (struct datalink *)v;
if (fp->proto == PROTO_LCP) {
dl->lcp.auth_ineed = dl->lcp.want_auth;
dl->lcp.auth_iwait = dl->lcp.his_auth;
if (dl->lcp.his_auth || dl->lcp.want_auth) {
if (bundle_Phase(dl->bundle) == PHASE_DEAD ||
bundle_Phase(dl->bundle) == PHASE_ESTABLISH)
dl->physical->link.lcp.auth_ineed = dl->physical->link.lcp.want_auth;
dl->physical->link.lcp.auth_iwait = dl->physical->link.lcp.his_auth;
if (dl->physical->link.lcp.his_auth || dl->physical->link.lcp.want_auth) {
if (bundle_Phase(dl->bundle) == PHASE_ESTABLISH)
bundle_NewPhase(dl->bundle, PHASE_AUTHENTICATE);
LogPrintf(LogPHASE, "%s: his = %s, mine = %s\n", dl->name,
Auth2Nam(dl->lcp.his_auth), Auth2Nam(dl->lcp.want_auth));
if (dl->lcp.his_auth == PROTO_PAP)
Auth2Nam(dl->physical->link.lcp.his_auth),
Auth2Nam(dl->physical->link.lcp.want_auth));
if (dl->physical->link.lcp.his_auth == PROTO_PAP)
StartAuthChallenge(&dl->pap, dl->physical, SendPapChallenge);
if (dl->lcp.want_auth == PROTO_CHAP)
if (dl->physical->link.lcp.want_auth == PROTO_CHAP)
StartAuthChallenge(&dl->chap.auth, dl->physical, SendChapChallenge);
} else
datalink_AuthOk(dl);
@ -407,17 +420,20 @@ datalink_LayerUp(void *v, struct fsm *fp)
void
datalink_AuthOk(struct datalink *dl)
{
FsmUp(&dl->ccp.fsm);
FsmOpen(&dl->ccp.fsm);
/* XXX: Connect to another ppp instance HERE */
FsmUp(&dl->physical->link.ccp.fsm);
FsmOpen(&dl->physical->link.ccp.fsm);
dl->state = DATALINK_OPEN;
(*dl->parent->LayerUp)(dl->parent->object, &dl->lcp.fsm);
bundle_NewPhase(dl->bundle, PHASE_NETWORK);
(*dl->parent->LayerUp)(dl->parent->object, &dl->physical->link.lcp.fsm);
}
void
datalink_AuthNotOk(struct datalink *dl)
{
dl->state = DATALINK_LCP;
FsmClose(&dl->lcp.fsm);
FsmClose(&dl->physical->link.lcp.fsm);
}
static void
@ -429,8 +445,8 @@ datalink_LayerDown(void *v, struct fsm *fp)
if (fp->proto == PROTO_LCP) {
switch (dl->state) {
case DATALINK_OPEN:
FsmDown(&dl->ccp.fsm);
FsmClose(&dl->ccp.fsm);
FsmDown(&dl->physical->link.ccp.fsm);
FsmClose(&dl->physical->link.ccp.fsm);
(*dl->parent->LayerDown)(dl->parent->object, fp);
/* fall through */
@ -484,6 +500,7 @@ datalink_Create(const char *name, struct bundle *bundle,
dl->phone.chosen = "N/A";
dl->script.run = 1;
dl->script.packetmode = 1;
mp_linkInit(&dl->mp);
dl->bundle = bundle;
dl->next = NULL;
@ -500,26 +517,23 @@ datalink_Create(const char *name, struct bundle *bundle,
dl->cfg.reconnect_timeout = RECONNECT_TIMEOUT;
dl->name = strdup(name);
if ((dl->physical = modem_Create(dl->name, dl)) == NULL) {
dl->parent = parent;
dl->fsmp.LayerStart = datalink_LayerStart;
dl->fsmp.LayerUp = datalink_LayerUp;
dl->fsmp.LayerDown = datalink_LayerDown;
dl->fsmp.LayerFinish = datalink_LayerFinish;
dl->fsmp.object = dl;
authinfo_Init(&dl->pap);
authinfo_Init(&dl->chap.auth);
if ((dl->physical = modem_Create(dl)) == NULL) {
free(dl->name);
free(dl);
return NULL;
}
chat_Init(&dl->chat, dl->physical, NULL, 1, NULL);
dl->parent = parent;
dl->fsm.LayerStart = datalink_LayerStart;
dl->fsm.LayerUp = datalink_LayerUp;
dl->fsm.LayerDown = datalink_LayerDown;
dl->fsm.LayerFinish = datalink_LayerFinish;
dl->fsm.object = dl;
lcp_Init(&dl->lcp, dl->bundle, dl->physical, &dl->fsm);
ccp_Init(&dl->ccp, dl->bundle, &dl->physical->link, &dl->fsm);
authinfo_Init(&dl->pap);
authinfo_Init(&dl->chap.auth);
LogPrintf(LogPHASE, "%s: Created in CLOSED state\n", dl->name);
return dl;
@ -536,7 +550,7 @@ datalink_Destroy(struct datalink *dl)
result = dl->next;
chat_Destroy(&dl->chat);
link_Destroy(&dl->physical->link);
modem_Destroy(dl->physical);
free(dl->name);
free(dl);
@ -549,6 +563,9 @@ datalink_Up(struct datalink *dl, int runscripts, int packetmode)
switch (dl->state) {
case DATALINK_CLOSED:
LogPrintf(LogPHASE, "%s: Entering OPENING state\n", dl->name);
if (bundle_Phase(dl->bundle) == PHASE_DEAD ||
bundle_Phase(dl->bundle) == PHASE_TERMINATE)
bundle_NewPhase(dl->bundle, PHASE_ESTABLISH);
dl->state = DATALINK_OPENING;
dl->reconnect_tries = dl->cfg.max_reconnect;
dl->dial_tries = dl->cfg.max_dial;
@ -579,13 +596,13 @@ datalink_Close(struct datalink *dl, int stay)
/* Please close */
switch (dl->state) {
case DATALINK_OPEN:
FsmDown(&dl->ccp.fsm);
FsmClose(&dl->ccp.fsm);
FsmDown(&dl->physical->link.ccp.fsm);
FsmClose(&dl->physical->link.ccp.fsm);
/* fall through */
case DATALINK_AUTH:
case DATALINK_LCP:
FsmClose(&dl->lcp.fsm);
FsmClose(&dl->physical->link.lcp.fsm);
if (stay) {
dl->dial_tries = -1;
dl->reconnect_tries = 0;
@ -603,17 +620,17 @@ datalink_Down(struct datalink *dl, int stay)
/* Carrier is lost */
switch (dl->state) {
case DATALINK_OPEN:
FsmDown(&dl->ccp.fsm);
FsmClose(&dl->ccp.fsm);
FsmDown(&dl->physical->link.ccp.fsm);
FsmClose(&dl->physical->link.ccp.fsm);
/* fall through */
case DATALINK_AUTH:
case DATALINK_LCP:
FsmDown(&dl->lcp.fsm);
FsmDown(&dl->physical->link.lcp.fsm);
if (stay)
FsmClose(&dl->lcp.fsm);
FsmClose(&dl->physical->link.lcp.fsm);
else
FsmOpen(&dl->ccp.fsm);
FsmOpen(&dl->physical->link.ccp.fsm);
/* fall through */
default:

8
usr.sbin/ppp/datalink.h
View File

@ -23,7 +23,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: datalink.h,v 1.1.2.11 1998/03/09 19:24:56 brian Exp $
* $Id: datalink.h,v 1.1.2.12 1998/03/13 21:07:03 brian Exp $
*/
#define DATALINK_CLOSED (0)
@ -78,14 +78,14 @@ struct datalink {
char *name; /* Our name */
struct fsm_parent fsm; /* Our callback functions */
struct fsm_parent fsmp; /* Our callback functions */
const struct fsm_parent *parent; /* Our parent */
struct lcp lcp; /* Our line control FSM */
struct ccp ccp; /* Our compression FSM */
struct authinfo pap; /* Authentication using pap */
struct chap chap; /* Authentication using chap */
struct mp_link mp; /* multilink data */
struct bundle *bundle; /* for the moment */
struct datalink *next; /* Next in the list */
};

4
usr.sbin/ppp/defs.h
View File

@ -15,7 +15,7 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: defs.h,v 1.29.2.6 1998/03/09 19:26:37 brian Exp $
* $Id: defs.h,v 1.29.2.7 1998/03/25 18:38:49 brian Exp $
*
* TODO:
*/
@ -42,6 +42,8 @@
#define MAXARGS 40 /* How many args per config line */
#define NCP_IDLE_TIMEOUT 180 /* Drop all links */
#define LINK_MINWEIGHT 20
#define CONFFILE "ppp.conf"
#define LINKUPFILE "ppp.linkup"
#define LINKDOWNFILE "ppp.linkdown"

7
usr.sbin/ppp/filter.c
View File

@ -17,7 +17,7 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: filter.c,v 1.22.2.8 1998/03/16 22:52:04 brian Exp $
* $Id: filter.c,v 1.22.2.9 1998/03/16 22:53:42 brian Exp $
*
* TODO: Shoud send ICMP error message when we discard packets.
*/
@ -45,13 +45,16 @@
#include "throughput.h"
#include "lqr.h"
#include "hdlc.h"
#include "link.h"
#include "fsm.h"
#include "lcp.h"
#include "ccp.h"
#include "link.h"
#include "slcompress.h"
#include "ipcp.h"
#include "filter.h"
#include "descriptor.h"
#include "prompt.h"
#include "mp.h"
#include "bundle.h"
static const u_long netmasks[33] = {

35
usr.sbin/ppp/fsm.c
View File

@ -17,7 +17,7 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: fsm.c,v 1.27.2.23 1998/03/20 19:46:43 brian Exp $
* $Id: fsm.c,v 1.27.2.24 1998/03/24 18:46:55 brian Exp $
*
* TODO:
* o Refer loglevel for log output
@ -55,6 +55,7 @@
#include "slcompress.h"
#include "ipcp.h"
#include "filter.h"
#include "mp.h"
#include "bundle.h"
#include "auth.h"
#include "chat.h"
@ -128,19 +129,24 @@ StoppedTimeout(void *v)
fp->name);
StopTimer(&fp->OpenTimer);
}
if (link_IsActive(fp->link))
link_Close(fp->link, fp->bundle, 0, 1);
if (fp->state == ST_STOPPED) {
/* Force ourselves back to initial */
FsmDown(fp);
FsmClose(fp);
}
}
void
fsm_Init(struct fsm *fp, const char *name, u_short proto, int maxcode,
int maxcfg, int LogLevel, struct bundle *bundle, struct link *l,
const struct fsm_parent *parent, struct fsm_callbacks *fn)
fsm_Init(struct fsm *fp, const char *name, u_short proto, int mincode,
int maxcode, int maxcfg, int LogLevel, struct bundle *bundle,
struct link *l, const struct fsm_parent *parent,
struct fsm_callbacks *fn, const char *timer_names[3])
{
fp->name = name;
fp->proto = proto;
fp->min_code = mincode;
fp->max_code = maxcode;
fp->state = ST_INITIAL;
fp->state = fp->min_code > CODE_TERMACK ? ST_OPENED : ST_INITIAL;
fp->reqid = 1;
fp->restart = 1;
fp->maxconfig = maxcfg;
@ -152,6 +158,9 @@ fsm_Init(struct fsm *fp, const char *name, u_short proto, int maxcode,
fp->bundle = bundle;
fp->parent = parent;
fp->fn = fn;
fp->FsmTimer.name = timer_names[0];
fp->OpenTimer.name = timer_names[1];
fp->StoppedTimer.name = timer_names[2];
}
static void
@ -763,7 +772,7 @@ FsmRecvProtoRej(struct fsm *fp, struct fsmheader *lhp, struct mbuf *bp)
break;
case PROTO_CCP:
if (fp->proto == PROTO_LCP) {
fp = &lcp2ccp(fsm2lcp(fp))->fsm;
fp = &fp->link->ccp.fsm;
(*fp->fn->LayerFinish)(fp);
switch (fp->state) {
case ST_CLOSED:
@ -879,9 +888,15 @@ FsmInput(struct fsm *fp, struct mbuf *bp)
return;
}
lhp = (struct fsmheader *) MBUF_CTOP(bp);
if (lhp->code == 0 || lhp->code > fp->max_code ||
if (lhp->code < fp->min_code || lhp->code > fp->max_code ||
lhp->code > sizeof FsmCodes / sizeof *FsmCodes) {
pfree(bp); /* XXX: Should send code reject */
/*
* Use a private id. This is really a response-type packet, but we
* MUST send a unique id for each REQ....
*/
static u_char id;
FsmOutput(fp, CODE_CODEREJ, id++, MBUF_CTOP(bp), bp->cnt);
pfree(bp);
return;
}
bp->offset += sizeof(struct fsmheader);

9
usr.sbin/ppp/fsm.h
View File

@ -15,7 +15,7 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: fsm.h,v 1.16.2.11 1998/03/20 19:46:46 brian Exp $
* $Id: fsm.h,v 1.16.2.12 1998/03/24 18:46:59 brian Exp $
*
* TODO:
*/
@ -79,12 +79,13 @@ struct fsm_parent {
struct fsm {
const char *name; /* Name of protocol */
u_short proto; /* Protocol number */
u_short min_code;
u_short max_code;
int open_mode; /* Delay before config REQ (-1 forever) */
int state; /* State of the machine */
u_char reqid; /* Next request id */
int restart; /* Restart counter value */
int maxconfig; /* Max config REQ (overridden in Init funcs) */
int maxconfig; /* Max config REQ before a close() */
struct pppTimer FsmTimer; /* Restart Timer */
struct pppTimer OpenTimer; /* Delay before opening */
@ -139,9 +140,9 @@ struct fsmconfig {
u_char length;
};
extern void fsm_Init(struct fsm *, const char *, u_short, int, int, int,
extern void fsm_Init(struct fsm *, const char *, u_short, int, int, int, int,
struct bundle *, struct link *, const struct fsm_parent *,
struct fsm_callbacks *);
struct fsm_callbacks *, const char *[3]);
extern void FsmOutput(struct fsm *, u_int, u_int, u_char *, int);
extern void FsmOpen(struct fsm *);
extern void FsmUp(struct fsm *);

53
usr.sbin/ppp/hdlc.c
View File

@ -17,7 +17,7 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: hdlc.c,v 1.28.2.20 1998/03/16 22:52:15 brian Exp $
* $Id: hdlc.c,v 1.28.2.21 1998/03/16 22:53:50 brian Exp $
*
* TODO:
*/
@ -59,6 +59,7 @@
#include "physical.h"
#include "prompt.h"
#include "chat.h"
#include "mp.h"
#include "datalink.h"
#include "filter.h"
#include "bundle.h"
@ -164,7 +165,7 @@ HdlcOutput(struct link *l, int pri, u_short proto, struct mbuf *bp)
mhp = mballoc(4, MB_HDLCOUT);
mhp->cnt = 0;
cp = MBUF_CTOP(mhp);
if (proto == PROTO_LCP || p->dl->lcp.his_acfcomp == 0) {
if (proto == PROTO_LCP || p->link.lcp.his_acfcomp == 0) {
*cp++ = HDLC_ADDR;
*cp++ = HDLC_UI;
mhp->cnt += 2;
@ -173,7 +174,7 @@ HdlcOutput(struct link *l, int pri, u_short proto, struct mbuf *bp)
/*
* If possible, compress protocol field.
*/
if (p->dl->lcp.his_protocomp && (proto & 0xff00) == 0) {
if (p->link.lcp.his_protocomp && (proto & 0xff00) == 0) {
*cp++ = proto;
mhp->cnt++;
} else {
@ -196,7 +197,7 @@ HdlcOutput(struct link *l, int pri, u_short proto, struct mbuf *bp)
/* Overwrite the entire packet */
struct lqrdata lqr;
lqr.MagicNumber = p->dl->lcp.want_magic;
lqr.MagicNumber = p->link.lcp.want_magic;
lqr.LastOutLQRs = p->hdlc.lqm.lqr.peer.PeerOutLQRs;
lqr.LastOutPackets = p->hdlc.lqm.lqr.peer.PeerOutPackets;
lqr.LastOutOctets = p->hdlc.lqm.lqr.peer.PeerOutOctets;
@ -368,23 +369,22 @@ hdlc_Protocol2Nam(u_short proto)
return "unrecognised protocol";
}
static void
DecodePacket(struct bundle *bundle, u_short proto, struct mbuf * bp,
struct link *l)
void
hdlc_DecodePacket(struct bundle *bundle, u_short proto, struct mbuf * bp,
struct link *l)
{
struct physical *p = link2physical(l);
struct datalink *dl = bundle2datalink(bundle, l->name);
u_char *cp;
LogPrintf(LogDEBUG, "DecodePacket: proto = 0x%04x\n", proto);
/* decompress everything. CCP needs uncompressed data too */
if ((bp = ccp_Decompress(&dl->ccp, &proto, bp)) == NULL)
if ((bp = ccp_Decompress(&l->ccp, &proto, bp)) == NULL)
return;
switch (proto) {
case PROTO_LCP:
LcpInput(&dl->lcp, bp);
LcpInput(&l->lcp, bp);
break;
case PROTO_PAP:
if (p)
@ -424,19 +424,31 @@ DecodePacket(struct bundle *bundle, u_short proto, struct mbuf * bp,
IpcpInput(&bundle->ncp.ipcp, bp);
break;
case PROTO_CCP:
CcpInput(&dl->ccp, bundle, bp);
CcpInput(&l->ccp, bundle, bp);
break;
case PROTO_MP:
if (bundle->ncp.mp.active) {
if (p)
mp_Input(&bundle->ncp.mp, bp, p);
else {
LogPrintf(LogERROR, "DecodePacket: MP inside MP ?!\n");
pfree(bp);
}
break;
}
/* Fall through */
default:
LogPrintf(LogPHASE, "Unknown protocol 0x%04x (%s)\n",
LogPrintf(LogPHASE, "%s protocol 0x%04x (%s)\n",
proto == PROTO_MP ? "Unexpected" : "Unknown",
proto, hdlc_Protocol2Nam(proto));
bp->offset -= 2;
bp->cnt += 2;
cp = MBUF_CTOP(bp);
if (p)
lcp_SendProtoRej(&dl->lcp, cp, bp->cnt);
/* XXX: Eeek - how to we proto-reject something at the bundle level ? */
p->hdlc.lqm.SaveInDiscards++;
p->hdlc.stats.unknownproto++;
lcp_SendProtoRej(&l->lcp, cp, bp->cnt);
if (p) {
p->hdlc.lqm.SaveInDiscards++;
p->hdlc.stats.unknownproto++;
}
pfree(bp);
break;
}
@ -473,7 +485,7 @@ HdlcInput(struct bundle *bundle, struct mbuf * bp, struct physical *physical)
}
cp = MBUF_CTOP(bp);
if (!physical->dl->lcp.want_acfcomp) {
if (!physical->link.lcp.want_acfcomp) {
/*
* We expect that packet is not compressed.
*/
@ -505,7 +517,7 @@ HdlcInput(struct bundle *bundle, struct mbuf * bp, struct physical *physical)
bp->offset += 2;
bp->cnt -= 2;
}
if (physical->dl->lcp.want_protocomp) {
if (physical->link.lcp.want_protocomp) {
proto = 0;
cp--;
do {
@ -525,7 +537,7 @@ HdlcInput(struct bundle *bundle, struct mbuf * bp, struct physical *physical)
link_ProtocolRecord(physical2link(physical), proto, PROTO_IN);
physical->hdlc.lqm.SaveInPackets++;
DecodePacket(bundle, proto, bp, physical2link(physical));
hdlc_DecodePacket(bundle, proto, bp, physical2link(physical));
}
/*
@ -604,6 +616,7 @@ hdlc_StartTimer(struct hdlc *hdlc)
hdlc->ReportTimer.load = 60 * SECTICKS;
hdlc->ReportTimer.arg = hdlc;
hdlc->ReportTimer.func = hdlc_ReportTime;
hdlc->ReportTimer.name = "hdlc";
StartTimer(&hdlc->ReportTimer);
}

4
usr.sbin/ppp/hdlc.h
View File

@ -15,7 +15,7 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: hdlc.h,v 1.14.2.6 1998/02/18 19:35:45 brian Exp $
* $Id: hdlc.h,v 1.14.2.7 1998/03/13 00:44:04 brian Exp $
*
* TODO:
*/
@ -109,3 +109,5 @@ extern void HdlcOutput(struct link *, int, u_short, struct mbuf *bp);
extern u_short HdlcFcs(u_short, u_char *, int);
extern int ReportProtStatus(struct cmdargs const *);
extern u_char *HdlcDetect(struct physical *, u_char *, int);
extern void hdlc_DecodePacket(struct bundle *, u_short, struct mbuf *,
struct link *);

16
usr.sbin/ppp/ip.c
View File

@ -17,7 +17,7 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: ip.c,v 1.38.2.15 1998/03/20 19:48:02 brian Exp $
* $Id: ip.c,v 1.38.2.16 1998/03/24 18:47:04 brian Exp $
*
* TODO:
* o Return ICMP message for filterd packet
@ -63,9 +63,12 @@
#include "ipcp.h"
#include "filter.h"
#include "descriptor.h"
#include "lcp.h"
#include "ccp.h"
#include "link.h"
#include "mp.h"
#include "bundle.h"
#include "vjcomp.h"
#include "lcp.h"
#include "modem.h"
#include "tun.h"
#include "ip.h"
@ -451,15 +454,15 @@ ip_QueueLen()
return result;
}
void
IpStartOutput(struct link *l, struct bundle *bundle)
int
IpFlushPacket(struct link *l, struct bundle *bundle)
{
struct mqueue *queue;
struct mbuf *bp;
int cnt;
if (bundle->ncp.ipcp.fsm.state != ST_OPENED)
return;
return 0;
for (queue = &IpOutputQueues[PRI_FAST]; queue >= IpOutputQueues; queue--)
if (queue->top) {
@ -472,8 +475,9 @@ IpStartOutput(struct link *l, struct bundle *bundle)
if (!(FilterCheck(pip, &bundle->filter.alive) & A_DENY))
bundle_StartIdleTimer(bundle);
ipcp_AddOutOctets(&bundle->ncp.ipcp, cnt);
break;
return 1;
}
}
return 0;
}

4
usr.sbin/ppp/ip.h
View File

@ -17,13 +17,13 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: ip.h,v 1.8.2.5 1998/03/09 19:26:38 brian Exp $
* $Id: ip.h,v 1.8.2.6 1998/03/16 22:52:18 brian Exp $
*
*/
struct filter;
extern void IpStartOutput(struct link *, struct bundle *);
extern int IpFlushPacket(struct link *, struct bundle *);
extern int PacketCheck(struct bundle *, char *, int, struct filter *);
extern void IpEnqueue(int, char *, int);
extern void IpInput(struct bundle *, struct mbuf *);

14
usr.sbin/ppp/ipcp.c
View File

@ -17,7 +17,7 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: ipcp.c,v 1.50.2.26 1998/03/20 19:48:04 brian Exp $
* $Id: ipcp.c,v 1.50.2.27 1998/03/24 18:47:10 brian Exp $
*
* TODO:
* o More RFC1772 backwoard compatibility
@ -54,7 +54,6 @@
#include "ipcp.h"
#include "filter.h"
#include "descriptor.h"
#include "bundle.h"
#include "loadalias.h"
#include "vars.h"
#include "vjcomp.h"
@ -63,8 +62,11 @@
#include "lqr.h"
#include "hdlc.h"
#include "async.h"
#include "ccp.h"
#include "link.h"
#include "physical.h"
#include "mp.h"
#include "bundle.h"
#include "id.h"
#include "arp.h"
#include "systems.h"
@ -209,9 +211,11 @@ ipcp_Init(struct ipcp *ipcp, struct bundle *bundle, struct link *l,
{
struct hostent *hp;
char name[MAXHOSTNAMELEN];
static const char *timer_names[] =
{"IPCP restart", "IPCP openmode", "IPCP stopped"};
fsm_Init(&ipcp->fsm, "IPCP", PROTO_IPCP, IPCP_MAXCODE, 10, LogIPCP,
bundle, l, parent, &ipcp_Callbacks);
fsm_Init(&ipcp->fsm, "IPCP", PROTO_IPCP, 1, IPCP_MAXCODE, 10, LogIPCP,
bundle, l, parent, &ipcp_Callbacks, timer_names);
ipcp->cfg.VJInitSlots = DEF_VJ_STATES;
ipcp->cfg.VJInitComp = 1;
@ -561,7 +565,7 @@ IpcpLayerUp(struct fsm *fp)
} else
SelectSystem(fp->bundle, "MYADDR", LINKUPFILE);
throughput_start(&ipcp->throughput);
throughput_start(&ipcp->throughput, "IPCP throughput");
prompt_Display(&prompt, fp->bundle);
}

49
usr.sbin/ppp/lcp.c
View File

@ -17,7 +17,7 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: lcp.c,v 1.55.2.32 1998/03/20 19:48:06 brian Exp $
* $Id: lcp.c,v 1.55.2.33 1998/03/24 18:47:17 brian Exp $
*
* TODO:
* o Limit data field length by MRU
@ -56,7 +56,6 @@
#include "lcpproto.h"
#include "filter.h"
#include "descriptor.h"
#include "bundle.h"
#include "lqr.h"
#include "hdlc.h"
#include "ccp.h"
@ -72,6 +71,8 @@
#include "tun.h"
#include "link.h"
#include "physical.h"
#include "mp.h"
#include "bundle.h"
#include "prompt.h"
#include "chat.h"
#include "datalink.h"
@ -142,20 +143,22 @@ static const char *cftypes[] = {
int
lcp_ReportStatus(struct cmdargs const *arg)
{
prompt_Printf(&prompt, "%s [%s]\n", arg->cx->lcp.fsm.name,
State2Nam(arg->cx->lcp.fsm.state));
struct lcp *lcp = &ChooseLink(arg)->lcp;
prompt_Printf(&prompt, "%s [%s]\n", lcp->fsm.name,
State2Nam(lcp->fsm.state));
prompt_Printf(&prompt,
" his side: MRU %d, ACCMAP %08lx, PROTOCOMP %d, ACFCOMP %d,\n"
" MAGIC %08lx, REJECT %04x\n",
arg->cx->lcp.his_mru, (u_long)arg->cx->lcp.his_accmap,
arg->cx->lcp.his_protocomp, arg->cx->lcp.his_acfcomp,
(u_long)arg->cx->lcp.his_magic, arg->cx->lcp.his_reject);
lcp->his_mru, (u_long)lcp->his_accmap,
lcp->his_protocomp, lcp->his_acfcomp,
(u_long)lcp->his_magic, lcp->his_reject);
prompt_Printf(&prompt,
" my side: MRU %d, ACCMAP %08lx, PROTOCOMP %d, ACFCOMP %d,\n"
" MAGIC %08lx, REJECT %04x\n",
arg->cx->lcp.want_mru, (u_long)arg->cx->lcp.want_accmap,
arg->cx->lcp.want_protocomp, arg->cx->lcp.want_acfcomp,
(u_long)arg->cx->lcp.want_magic, arg->cx->lcp.my_reject);
lcp->want_mru, (u_long)lcp->want_accmap,
lcp->want_protocomp, lcp->want_acfcomp,
(u_long)lcp->want_magic, lcp->my_reject);
prompt_Printf(&prompt, "\nDefaults: MRU = %d, ACCMAP = %08lx\t",
VarMRU, (u_long)VarAccmap);
prompt_Printf(&prompt, "Open Mode: %s",
@ -175,26 +178,25 @@ GenerateMagic(void)
}
void
lcp_Init(struct lcp *lcp, struct bundle *bundle, struct physical *physical,
lcp_Init(struct lcp *lcp, struct bundle *bundle, struct link *l,
const struct fsm_parent *parent)
{
/* Initialise ourselves */
fsm_Init(&lcp->fsm, "LCP", PROTO_LCP, LCP_MAXCODE, 10, LogLCP, bundle,
&physical->link, parent, &lcp_Callbacks);
int mincode = parent ? 1 : LCP_MINMPCODE;
static const char *timer_names[] =
{"LCP restart", "LCP openmode", "LCP stopped"};
fsm_Init(&lcp->fsm, "LCP", PROTO_LCP, mincode, LCP_MAXCODE, 10, LogLCP,
bundle, l, parent, &lcp_Callbacks, timer_names);
lcp_Setup(lcp, 1);
}
void
lcp_Setup(struct lcp *lcp, int openmode)
{
struct physical *p = link2physical(lcp->fsm.link);
lcp->fsm.open_mode = openmode;
lcp->fsm.maxconfig = 10;
hdlc_Init(&p->hdlc);
async_Init(&p->async);
lcp->his_mru = DEF_MRU;
lcp->his_accmap = 0xffffffff;
lcp->his_magic = 0;
@ -214,6 +216,7 @@ lcp_Setup(struct lcp *lcp, int openmode)
lcp->his_reject = lcp->my_reject = 0;
lcp->auth_iwait = lcp->auth_ineed = 0;
lcp->LcpFailedMagic = 0;
}
static void
@ -333,13 +336,9 @@ LcpLayerUp(struct fsm *fp)
struct lcp *lcp = fsm2lcp(fp);
LogPrintf(LogLCP, "LcpLayerUp\n");
if (p) {
async_SetLinkParams(&p->async, lcp);
StartLqm(lcp);
hdlc_StartTimer(&p->hdlc);
} else
LogPrintf(LogERROR, "LcpLayerUp: Not a physical link !\n");
async_SetLinkParams(&p->async, lcp);
StartLqm(lcp);
hdlc_StartTimer(&p->hdlc);
}
static void

6
usr.sbin/ppp/lcp.h
View File

@ -15,7 +15,7 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: lcp.h,v 1.16.2.14 1998/03/13 21:07:07 brian Exp $
* $Id: lcp.h,v 1.16.2.15 1998/03/20 19:46:58 brian Exp $
*
* TODO:
*/
@ -50,6 +50,7 @@ struct lcp {
};
#define LCP_MAXCODE CODE_DISCREQ
#define LCP_MINMPCODE CODE_CODEREJ
#define TY_MRU 1 /* Maximum-Receive-Unit */
#define TY_ACCMAP 2 /* Async-Control-Character-Map */
@ -79,9 +80,8 @@ struct lcp_opt {
struct physical;
#define fsm2lcp(fp) (fp->proto == PROTO_LCP ? (struct lcp *)fp : NULL)
#define lcp2ccp(lcp) (&link2physical((lcp)->fsm.link)->dl->ccp)
extern void lcp_Init(struct lcp *, struct bundle *, struct physical *,
extern void lcp_Init(struct lcp *, struct bundle *, struct link *,
const struct fsm_parent *);
extern void lcp_Setup(struct lcp *, int);

3
usr.sbin/ppp/lcpproto.h
View File

@ -15,7 +15,7 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: lcpproto.h,v 1.9 1997/10/26 01:02:59 brian Exp $
* $Id: lcpproto.h,v 1.10 1997/10/26 12:42:12 brian Exp $
*
* TODO:
*/
@ -26,6 +26,7 @@
#define PROTO_IP 0x0021 /* IP */
#define PROTO_VJUNCOMP 0x002f /* VJ Uncompressed */
#define PROTO_VJCOMP 0x002d /* VJ Compressed */
#define PROTO_MP 0x003d /* Multilink fragment */
#define PROTO_ICOMPD 0x00fb /* Individual link compressed */
#define PROTO_COMPD 0x00fd /* Compressed datagram */

55
usr.sbin/ppp/link.c
View File

@ -23,7 +23,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: link.c,v 1.1.2.13 1998/03/16 22:54:05 brian Exp $
* $Id: link.c,v 1.1.2.14 1998/03/20 19:48:08 brian Exp $
*
*/
@ -46,13 +46,17 @@
#include "lcpproto.h"
#include "loadalias.h"
#include "vars.h"
#include "link.h"
#include "fsm.h"
#include "iplist.h"
#include "slcompress.h"
#include "ipcp.h"
#include "filter.h"
#include "descriptor.h"
#include "async.h"
#include "lcp.h"
#include "ccp.h"
#include "link.h"
#include "mp.h"
#include "bundle.h"
#include "prompt.h"
@ -87,6 +91,25 @@ link_QueueLen(struct link *l)
return len;
}
int
link_QueueBytes(struct link *l)
{
int i, len, bytes;
struct mbuf *m;
bytes = 0;
for (i = 0, len = 0; i < LINK_QUEUES; i++) {
len = l->Queue[i].qlen;
m = l->Queue[i].top;
while (len--) {
bytes += plength(m);
m = m->pnext;
}
}
return bytes;
}
struct mbuf *
link_Dequeue(struct link *l)
{
@ -122,12 +145,6 @@ link_Write(struct link *l, int pri, const char *ptr, int count)
Enqueue(l->Queue + pri, bp);
}
void
link_StartOutput(struct link *l, struct bundle *bundle)
{
(*l->StartOutput)(l, bundle);
}
void
link_Output(struct link *l, int pri, struct mbuf *bp)
{
@ -143,25 +160,6 @@ link_Output(struct link *l, int pri, struct mbuf *bp)
Enqueue(l->Queue + pri, wp);
}
int
link_IsActive(struct link *l)
{
return (*l->IsActive)(l);
}
void
link_Close(struct link *l, struct bundle *bundle, int dedicated_force, int stay)
{
(*l->Close)(l, dedicated_force);
bundle_LinkLost(bundle, l, stay);
}
void
link_Destroy(struct link *l)
{
(*l->Destroy)(l);
}
static struct protostatheader {
u_short number;
const char *name;
@ -176,6 +174,7 @@ static struct protostatheader {
{ PROTO_PAP, "PAP" },
{ PROTO_LQR, "LQR" },
{ PROTO_CHAP, "CHAP" },
{ PROTO_MP, "MULTILINK" },
{ 0, "Others" }
};
@ -207,6 +206,6 @@ link_ReportProtocolStatus(struct link *l)
if ((i % 2) == 0)
prompt_Printf(&prompt, "\n");
}
if (i % 2)
if (!(i % 2))
prompt_Printf(&prompt, "\n");
}

16
usr.sbin/ppp/link.h
View File

@ -23,7 +23,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: link.h,v 1.1.2.5 1998/02/21 01:45:18 brian Exp $
* $Id: link.h,v 1.1.2.6 1998/02/23 00:38:34 brian Exp $
*
*/
@ -32,7 +32,7 @@
#define MP_LINK 2
#define LINK_QUEUES (PRI_MAX + 1)
#define NPROTOSTAT 11
#define NPROTOSTAT 12
struct bundle;
@ -47,11 +47,8 @@ struct link {
u_long proto_in[NPROTOSTAT]; /* outgoing protocol stats */
u_long proto_out[NPROTOSTAT]; /* incoming protocol stats */
/* Implementation routines for use by link_ routines */
void (*StartOutput)(struct link *, struct bundle *); /* send queued data */
int (*IsActive)(struct link *); /* Are we active ? */
void (*Close)(struct link *, int); /* Close the link */
void (*Destroy)(struct link *); /* Destructor */
struct lcp lcp; /* Our line control FSM */
struct ccp ccp; /* Our compression FSM */
};
extern void link_AddInOctets(struct link *, int);
@ -59,6 +56,7 @@ extern void link_AddOutOctets(struct link *, int);
extern void link_SequenceQueue(struct link *);
extern int link_QueueLen(struct link *);
extern int link_QueueBytes(struct link *);
extern struct mbuf *link_Dequeue(struct link *);
extern void link_Write(struct link *, int, const char *, int);
extern void link_StartOutput(struct link *, struct bundle *);
@ -68,7 +66,3 @@ extern void link_Output(struct link *, int, struct mbuf *);
#define PROTO_OUT 2
extern void link_ProtocolRecord(struct link *, u_short, int);
extern void link_ReportProtocolStatus(struct link *);
extern int link_IsActive(struct link *);
extern void link_Close(struct link *, struct bundle *, int, int);
extern void link_Destroy(struct link *);

5
usr.sbin/ppp/lqr.c
View File

@ -17,7 +17,7 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: lqr.c,v 1.22.2.16 1998/03/20 19:47:30 brian Exp $
* $Id: lqr.c,v 1.22.2.17 1998/03/25 18:37:51 brian Exp $
*
* o LQR based on RFC1333
*
@ -47,6 +47,7 @@
#include "hdlc.h"
#include "async.h"
#include "throughput.h"
#include "ccp.h"
#include "link.h"
#include "descriptor.h"
#include "physical.h"
@ -54,6 +55,7 @@
#include "slcompress.h"
#include "ipcp.h"
#include "filter.h"
#include "mp.h"
#include "bundle.h"
#include "loadalias.h"
#include "vars.h"
@ -235,6 +237,7 @@ StartLqm(struct lcp *lcp)
physical->hdlc.lqm.timer.state = TIMER_STOPPED;
physical->hdlc.lqm.timer.load = lcp->want_lqrperiod * SECTICKS / 100;
physical->hdlc.lqm.timer.func = SendLqrReport;
physical->hdlc.lqm.timer.name = "lqm";
physical->hdlc.lqm.timer.arg = lcp;
SendLqrReport(lcp);
} else {

24
usr.sbin/ppp/main.c
View File

@ -17,7 +17,7 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: main.c,v 1.121.2.38 1998/03/25 18:38:24 brian Exp $
* $Id: main.c,v 1.121.2.39 1998/03/25 18:38:59 brian Exp $
*
* TODO:
* o Add commands for traffic summary, version display, etc.
@ -64,6 +64,8 @@
#include "ipcp.h"
#include "filter.h"
#include "descriptor.h"
#include "link.h"
#include "mp.h"
#include "bundle.h"
#include "loadalias.h"
#include "vars.h"
@ -77,7 +79,6 @@
#include "pathnames.h"
#include "tun.h"
#include "route.h"
#include "link.h"
#include "physical.h"
#include "server.h"
#include "prompt.h"
@ -104,7 +105,7 @@ Cleanup(int excode)
{
SignalBundle->CleaningUp = 1;
if (bundle_Phase(SignalBundle) != PHASE_DEAD)
bundle_Close(SignalBundle, NULL, 0);
bundle_Close(SignalBundle, NULL, 1);
}
void
@ -125,10 +126,12 @@ static void
CloseConnection(int signo)
{
/* NOTE, these are manual, we've done a setsid() */
struct datalink *dl;
pending_signal(SIGINT, SIG_IGN);
LogPrintf(LogPHASE, "Caught signal %d, abort connection\n", signo);
/* XXX close 'em all ! */
link_Close(bundle2link(SignalBundle, NULL), SignalBundle, 0, 1);
LogPrintf(LogPHASE, "Caught signal %d, abort connection(s)\n", signo);
for (dl = SignalBundle->links; dl; dl = dl->next)
datalink_Down(dl, 1);
pending_signal(SIGINT, CloseConnection);
}
@ -366,11 +369,9 @@ main(int argc, char **argv)
pending_signal(SIGTERM, CloseSession);
pending_signal(SIGINT, CloseConnection);
pending_signal(SIGQUIT, CloseSession);
pending_signal(SIGALRM, SIG_IGN);
#ifdef SIGPIPE
signal(SIGPIPE, SIG_IGN);
#endif
#ifdef SIGALRM
pending_signal(SIGALRM, SIG_IGN);
#endif
if (mode & MODE_INTER) {
#ifdef SIGTSTP
@ -514,7 +515,7 @@ DoLoop(struct bundle *bundle)
if (mode & (MODE_DIRECT|MODE_DEDICATED|MODE_BACKGROUND))
bundle_Open(bundle, NULL);
while (!bundle->CleaningUp || bundle_Phase(SignalBundle) != PHASE_DEAD) {
while (!bundle_IsDead(bundle)) {
nfds = 0;
FD_ZERO(&rfds);
FD_ZERO(&wfds);
@ -536,7 +537,7 @@ DoLoop(struct bundle *bundle)
descriptor_UpdateSet(&prompt.desc, &rfds, &wfds, &efds, &nfds);
if (bundle->CleaningUp && bundle_Phase(bundle) == PHASE_DEAD)
if (bundle_IsDead(bundle))
/* Don't select - we'll be here forever */
break;
@ -630,5 +631,6 @@ DoLoop(struct bundle *bundle)
}
}
}
prompt_Printf(&prompt, "\n");
LogPrintf(LogDEBUG, "Job (DoLoop) done.\n");
}

3
usr.sbin/ppp/mbuf.c
View File

@ -17,7 +17,7 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: mbuf.c,v 1.13.2.4 1998/02/10 03:23:33 brian Exp $
* $Id: mbuf.c,v 1.13.2.5 1998/02/16 00:00:42 brian Exp $
*
*/
#include <sys/param.h>
@ -154,6 +154,7 @@ mbwrite(struct mbuf * bp, u_char * ptr, int cnt)
int
ShowMemMap(struct cmdargs const *arg)
{
/* Watch it - ~m calls us with arg == NULL */
int i;
for (i = 0; i <= MB_MAX; i += 2)

5
usr.sbin/ppp/mbuf.h
View File

@ -15,7 +15,7 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: mbuf.h,v 1.11 1998/01/21 02:15:21 brian Exp $
* $Id: mbuf.h,v 1.11.2.1 1998/01/30 19:45:55 brian Exp $
*
* TODO:
*/
@ -48,7 +48,8 @@ struct mqueue {
#define MB_VJCOMP 8
#define MB_LOG 9
#define MB_IPQ 10
#define MB_MAX MB_IPQ
#define MB_MP 11
#define MB_MAX MB_MP
extern int plength(struct mbuf *);
extern struct mbuf *mballoc(int, int);

107
usr.sbin/ppp/modem.c
View File

@ -17,7 +17,7 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: modem.c,v 1.77.2.40 1998/03/20 19:48:14 brian Exp $
* $Id: modem.c,v 1.77.2.41 1998/03/21 22:58:43 brian Exp $
*
* TODO:
*/
@ -66,12 +66,13 @@
#include "ipcp.h"
#include "filter.h"
#include "descriptor.h"
#include "bundle.h"
#include "ccp.h"
#include "link.h"
#include "physical.h"
#include "mp.h"
#include "bundle.h"
#include "prompt.h"
#include "chat.h"
#include "ccp.h"
#include "auth.h"
#include "chap.h"
#include "datalink.h"
@ -83,17 +84,16 @@
#endif
#endif
static void modem_StartOutput(struct link *, struct bundle *);
static int modem_IsActive(struct link *);
static void modem_Hangup(struct link *, int);
static void modem_Destroy(struct link *);
static void modem_Hangup(struct physical *, int);
static void modem_DescriptorWrite(struct descriptor *, struct bundle *,
const fd_set *);
static void modem_DescriptorRead(struct descriptor *, struct bundle *,
const fd_set *);
static int modem_UpdateSet(struct descriptor *, fd_set *, fd_set *, fd_set *,
int *);
struct physical *
modem_Create(const char *name, struct datalink *dl)
modem_Create(struct datalink *dl)
{
struct physical *p;
@ -102,23 +102,19 @@ modem_Create(const char *name, struct datalink *dl)
return NULL;
p->link.type = PHYSICAL_LINK;
p->link.name = strdup(name);
p->link.name = dl->name;
p->link.len = sizeof *p;
memset(&p->link.throughput, '\0', sizeof p->link.throughput);
throughput_init(&p->link.throughput);
memset(&p->link.Timer, '\0', sizeof p->link.Timer);
memset(p->link.Queue, '\0', sizeof p->link.Queue);
memset(p->link.proto_in, '\0', sizeof p->link.proto_in);
memset(p->link.proto_out, '\0', sizeof p->link.proto_out);
p->link.StartOutput = modem_StartOutput;
p->link.IsActive = modem_IsActive;
p->link.Close = modem_Hangup;
p->link.Destroy = modem_Destroy;
p->desc.type = PHYSICAL_DESCRIPTOR;
p->desc.UpdateSet = modem_UpdateSet;
p->desc.IsSet = Physical_IsSet;
p->desc.Read = modem_DescriptorRead;
p->desc.Write = Physical_DescriptorWrite;
p->desc.Write = modem_DescriptorWrite;
hdlc_Init(&p->hdlc);
async_Init(&p->async);
@ -143,6 +139,12 @@ modem_Create(const char *name, struct datalink *dl)
strncpy(p->cfg.devlist, MODEM_LIST, sizeof p->cfg.devlist - 1);
p->cfg.devlist[sizeof p->cfg.devlist - 1] = '\0';
hdlc_Init(&p->hdlc);
async_Init(&p->async);
lcp_Init(&p->link.lcp, dl->bundle, &p->link, &dl->fsmp);
ccp_Init(&p->link.ccp, dl->bundle, &p->link, &dl->fsmp);
return p;
}
@ -291,7 +293,8 @@ modem_Timeout(void *data)
if (to->modem->fd >= 0) {
if (ioctl(to->modem->fd, TIOCMGET, &to->modem->mbits) < 0) {
LogPrintf(LogPHASE, "ioctl error (%s)!\n", strerror(errno));
link_Close(&to->modem->link, to->bundle, 0, 0);
modem_Hangup(to->modem, 0);
bundle_LinkLost(to->bundle, &to->modem->link, 0);
return;
}
} else
@ -306,7 +309,8 @@ modem_Timeout(void *data)
*/
} else {
LogPrintf(LogDEBUG, "modem_Timeout: online -> offline\n");
link_Close(&to->modem->link, to->bundle, 0, 0);
modem_Hangup(to->modem, 0);
bundle_LinkLost(to->bundle, &to->modem->link, 0);
}
}
else
@ -332,6 +336,7 @@ modem_StartTimer(struct bundle *bundle, struct physical *modem)
ModemTimer->state = TIMER_STOPPED;
ModemTimer->load = SECTICKS;
ModemTimer->func = modem_Timeout;
ModemTimer->name = "modem CD";
ModemTimer->arg = &to;
LogPrintf(LogDEBUG, "ModemTimer using modem_Timeout() - %p\n", modem_Timeout);
StartTimer(ModemTimer);
@ -492,7 +497,7 @@ modem_Unlock(struct physical *modem)
static void
modem_Found(struct physical *modem)
{
throughput_start(&modem->link.throughput);
throughput_start(&modem->link.throughput, "modem throughput");
modem->connect_count++;
LogPrintf(LogPHASE, "Connected!\n");
}
@ -764,10 +769,9 @@ modem_PhysicalClose(struct physical *modem)
static int force_hack;
static void
modem_Hangup(struct link *l, int dedicated_force)
modem_Hangup(struct physical *modem, int dedicated_force)
{
/* We're about to close (pre hangup script) */
struct physical *modem = (struct physical *)l;
force_hack = dedicated_force;
if (modem->fd >= 0) {
@ -801,14 +805,13 @@ modem_Offline(struct physical *modem)
void
modem_Close(struct physical *modem)
{
LogPrintf(LogDEBUG, "Close modem (%s)\n",
modem->fd >= 0 ? "open" : "closed");
if (modem->fd < 0)
return;
LogPrintf(LogDEBUG, "Close modem\n");
if (modem->link.Timer.load)
modem_Hangup(&modem->link, force_hack);
modem_Hangup(modem, force_hack);
if (!isatty(modem->fd)) {
modem_PhysicalClose(modem);
@ -837,16 +840,11 @@ modem_Close(struct physical *modem)
}
}
static void
modem_Destroy(struct link *l)
void
modem_Destroy(struct physical *modem)
{
struct physical *p;
p = link2physical(l);
if (p->fd != -1)
modem_Close(p);
free(l->name);
free(p);
modem_Close(modem);
free(modem);
}
static void
@ -861,48 +859,36 @@ modem_LogicalClose(struct physical *modem)
}
static void
modem_StartOutput(struct link *l, struct bundle *bundle)
modem_DescriptorWrite(struct descriptor *d, struct bundle *bundle,
const fd_set *fdset)
{
struct physical *modem = (struct physical *)l;
struct physical *modem = descriptor2physical(d);
int nb, nw;
if (modem->out == NULL) {
if (link_QueueLen(l) == 0)
IpStartOutput(l, bundle);
modem->out = link_Dequeue(l);
}
if (modem->out == NULL)
modem->out = link_Dequeue(&modem->link);
if (modem->out) {
nb = modem->out->cnt;
nw = write(modem->fd, MBUF_CTOP(modem->out), nb);
LogPrintf(LogDEBUG, "modem_StartOutput: wrote: %d(%d) to %d\n",
LogPrintf(LogDEBUG, "modem_DescriptorWrite: wrote: %d(%d) to %d\n",
nw, nb, modem->fd);
if (nw > 0) {
LogDumpBuff(LogDEBUG, "modem_StartOutput: modem write",
MBUF_CTOP(modem->out), nw);
modem->out->cnt -= nw;
modem->out->offset += nw;
if (modem->out->cnt == 0) {
if (modem->out->cnt == 0)
modem->out = mbfree(modem->out);
LogPrintf(LogDEBUG, "modem_StartOutput: mbfree\n");
}
} else if (nw < 0) {
if (errno != EAGAIN) {
LogPrintf(LogERROR, "modem write (%d): %s\n", modem->fd,
strerror(errno));
link_Close(&modem->link, bundle, 0, 0);
modem_Hangup(modem, 0);
bundle_LinkLost(bundle, &modem->link, 0);
}
}
}
}
static int
modem_IsActive(struct link *l)
{
return ((struct physical *)l)->fd >= 0;
}
int
modem_ShowStatus(struct cmdargs const *arg)
{
@ -990,19 +976,18 @@ modem_DescriptorRead(struct descriptor *d, struct bundle *bundle,
u_char rbuff[MAX_MRU], *cp;
int n;
LogPrintf(LogDEBUG, "descriptor2physical; %p -> %p\n", d, p);
/* something to read from modem */
if (p->dl->lcp.fsm.state <= ST_CLOSED)
if (p->link.lcp.fsm.state <= ST_CLOSED)
nointr_usleep(10000);
n = Physical_Read(p, rbuff, sizeof rbuff);
if ((mode & MODE_DIRECT) && n <= 0)
link_Close(&p->link, bundle, 0, 1);
else
if ((mode & MODE_DIRECT) && n <= 0) {
modem_Hangup(p, 0);
bundle_LinkLost(bundle, &p->link, 1);
} else
LogDumpBuff(LogASYNC, "ReadFromModem", rbuff, n);
if (p->dl->lcp.fsm.state <= ST_CLOSED) {
if (p->link.lcp.fsm.state <= ST_CLOSED) {
/* In dedicated mode, we just discard input until LCP is started */
if (!(mode & MODE_DEDICATED)) {
cp = HdlcDetect(p, rbuff, n);

5
usr.sbin/ppp/modem.h
View File

@ -15,7 +15,7 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: modem.h,v 1.16.2.11 1998/03/06 00:34:44 brian Exp $
* $Id: modem.h,v 1.16.2.12 1998/03/13 00:44:49 brian Exp $
*
* TODO:
*/
@ -25,7 +25,7 @@ struct physical;
struct ccp;
extern int modem_Raw(struct physical *, struct bundle *);
extern struct physical *modem_Create(const char *, struct datalink *);
extern struct physical *modem_Create(struct datalink *);
extern int modem_Open(struct physical *, struct bundle *);
extern int modem_Speed(struct physical *);
extern speed_t IntToSpeed(int);
@ -33,3 +33,4 @@ extern int modem_SetParity(struct physical *, const char *);
extern int modem_ShowStatus(struct cmdargs const *);
extern void modem_Close(struct physical *);
extern void modem_Offline(struct physical *);
extern void modem_Destroy(struct physical *);

457
usr.sbin/ppp/mp.c Normal file
View File

@ -0,0 +1,457 @@
/*-
* Copyright (c) 1998 Brian Somers <brian@Awfulhak.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id$
*/
#include <sys/types.h>
#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <netinet/ip.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <termios.h>
#include "command.h"
#include "mbuf.h"
#include "log.h"
#include "defs.h"
#include "timer.h"
#include "fsm.h"
#include "iplist.h"
#include "throughput.h"
#include "slcompress.h"
#include "ipcp.h"
/* #include "loadalias.h" */
/* #include "vars.h" */
#include "auth.h"
/* #include "systems.h" */
#include "lcp.h"
#include "lqr.h"
#include "hdlc.h"
#include "async.h"
#include "ccp.h"
#include "link.h"
#include "descriptor.h"
#include "physical.h"
#include "chat.h"
#include "lcpproto.h"
#include "filter.h"
#include "mp.h"
#include "pap.h"
#include "chap.h"
#include "datalink.h"
#include "bundle.h"
#include "ip.h"
static u_int32_t
inc_seq(struct mp *mp, u_int32_t seq)
{
seq++;
if (mp->is12bit) {
if (seq & 0xfffff000)
seq = 0;
} else if (seq & 0xff000000)
seq = 0;
return seq;
}
static int
mp_ReadHeader(struct mp *mp, struct mbuf *m, struct mp_header *header)
{
if (mp->is12bit) {
header->seq = *(u_int16_t *)MBUF_CTOP(m);
if (header->seq & 0x3000) {
LogPrintf(LogWARN, "Oops - MP header without required zero bits\n");
return 0;
}
header->begin = header->seq & 0x8000;
header->end = header->seq & 0x4000;
header->seq &= 0x0fff;
return 2;
} else {
header->seq = *(u_int32_t *)MBUF_CTOP(m);
if (header->seq & 0x3f000000) {
LogPrintf(LogWARN, "Oops - MP header without required zero bits\n");
return 0;
}
header->begin = header->seq & 0x80000000;
header->end = header->seq & 0x40000000;
header->seq &= 0x00ffffff;
return 4;
}
}
static void
mp_LayerStart(void *v, struct fsm *fp)
{
/* The given FSM is about to start up ! */
}
static void
mp_LayerUp(void *v, struct fsm *fp)
{
/* The given fsm is now up */
}
static void
mp_LayerDown(void *v, struct fsm *fp)
{
/* The given FSM has been told to come down */
}
static void
mp_LayerFinish(void *v, struct fsm *fp)
{
/* The given fsm is now down */
}
void
mp_Init(struct mp *mp, struct bundle *bundle)
{
mp->is12bit = 0;
mp->seq.out = 0;
mp->seq.min_in = 0;
mp->seq.next_in = 0;
mp->inbufs = NULL;
mp->bundle = bundle;
mp->link.type = MP_LINK;
mp->link.name = "mp";
mp->link.len = sizeof *mp;
throughput_init(&mp->link.throughput);
memset(&mp->link.Timer, '\0', sizeof mp->link.Timer);
memset(mp->link.Queue, '\0', sizeof mp->link.Queue);
memset(mp->link.proto_in, '\0', sizeof mp->link.proto_in);
memset(mp->link.proto_out, '\0', sizeof mp->link.proto_out);
mp->fsmp.LayerStart = mp_LayerStart;
mp->fsmp.LayerUp = mp_LayerUp;
mp->fsmp.LayerDown = mp_LayerDown;
mp->fsmp.LayerFinish = mp_LayerFinish;
mp->fsmp.object = mp;
lcp_Init(&mp->link.lcp, mp->bundle, &mp->link, NULL);
ccp_Init(&mp->link.ccp, mp->bundle, &mp->link, &mp->fsmp);
/* Our lcp's already up 'cos of the NULL parent */
FsmUp(&mp->link.ccp.fsm);
FsmOpen(&mp->link.ccp.fsm);
mp->active = 1;
bundle_LayerUp(mp->bundle, &mp->link.lcp.fsm);
}
void
mp_linkInit(struct mp_link *mplink)
{
mplink->seq = 0;
mplink->weight = 1500;
}
void
mp_Input(struct mp *mp, struct mbuf *m, struct physical *p)
{
struct mp_header mh, h;
struct mbuf *q, *last;
int32_t seq;
int len;
if ((len = mp_ReadHeader(mp, m, &mh)) == 0) {
pfree(m);
return;
}
seq = p->dl->mp.seq;
p->dl->mp.seq = mh.seq;
if (mp->seq.min_in == seq) {
/*
* We've received new data on the link that has our min (oldest) seq.
* Figure out which link now has the smallest (oldest) seq.
*/
struct datalink *dl;
mp->seq.min_in = p->dl->mp.seq;
for (dl = mp->bundle->links; dl; dl = dl->next)
if (mp->seq.min_in > dl->mp.seq)
mp->seq.min_in = dl->mp.seq;
}
/*
* Now process as many of our fragments as we can, adding our new
* fragment in as we go, and ordering with the oldest at the top of
* the queue.
*/
if (!mp->inbufs) {
mp->inbufs = m;
m = NULL;
}
last = NULL;
seq = mp->seq.next_in;
q = mp->inbufs;
while (q) {
mp_ReadHeader(mp, q, &h);
if (m && h.seq > mh.seq) {
/* Our received fragment fits in before this one, so link it in */
if (last)
last->pnext = m;
else
mp->inbufs = m;
m->pnext = q;
q = m;
h = mh;
m = NULL;
}
if (h.seq != seq) {
/* we're missing something :-( */
if (mp->seq.min_in > seq) {
/* we're never gonna get it */
struct mbuf *next;
/* Zap all older fragments */
while (mp->inbufs != q) {
next = mp->inbufs->pnext;
pfree(mp->inbufs);
mp->inbufs = next;
}
/*
* Zap everything until the next `end' fragment OR just before
* the next `begin' fragment OR 'till seq.min_in - whichever
* comes first.
*/
do {
mp_ReadHeader(mp, mp->inbufs, &h);
if (h.begin) {
h.seq--; /* We're gonna look for fragment with h.seq+1 */
break;
}
next = mp->inbufs->pnext;
pfree(mp->inbufs);
mp->inbufs = next;
} while (h.seq >= mp->seq.min_in || h.end);
/*
* Continue processing things from here.
* This deals with the possibility that we received a fragment
* on the slowest link that invalidates some of our data (because
* of the hole at `q'), but where there are subsequent `whole'
* packets that have already been received.
*/
mp->seq.next_in = seq = h.seq + 1;
last = NULL;
q = mp->inbufs;
} else
/* we may still receive the missing fragment */
break;
} else if (h.end) {
/* We've got something, reassemble */
struct mbuf **frag = &q;
int len;
u_short proto = 0;
u_char ch;
do {
*frag = mp->inbufs;
mp->inbufs = mp->inbufs->pnext;
len = mp_ReadHeader(mp, *frag, &h);
(*frag)->offset += len;
(*frag)->cnt -= len;
(*frag)->pnext = NULL;
if (frag == &q && !h.begin) {
LogPrintf(LogWARN, "Oops - MP frag %lu should have a begin flag\n",
(u_long)h.seq);
pfree(q);
q = NULL;
} else if (frag != &q && h.begin) {
LogPrintf(LogWARN, "Oops - MP frag %lu should have an end flag\n",
(u_long)h.seq - 1);
/*
* Stuff our fragment back at the front of the queue and zap
* our half-assembed packet.
*/
(*frag)->pnext = mp->inbufs;
mp->inbufs = *frag;
*frag = NULL;
pfree(q);
q = NULL;
frag = &q;
h.end = 0; /* just in case it's a whole packet */
} else
do
frag = &(*frag)->next;
while ((*frag)->next != NULL);
} while (!h.end);
if (q) {
do {
q = mbread(q, &ch, 1);
proto = proto << 8;
proto += ch;
} while (!(proto & 1));
hdlc_DecodePacket(mp->bundle, proto, q, &mp->link);
}
mp->seq.next_in = seq = h.seq + 1;
last = NULL;
q = mp->inbufs;
} else {
/* Look for the next fragment */
seq++;
last = q;
q = q->pnext;
}
}
if (m) {
/* We still have to find a home for our new fragment */
last = NULL;
for (q = mp->inbufs; q; last = q, q = q->pnext) {
mp_ReadHeader(mp, q, &h);
if (h.seq > mh.seq) {
/* Our received fragment fits in before this one, so link it in */
if (last)
last->pnext = m;
else
mp->inbufs = m;
m->pnext = q;
break;
}
}
}
}
static void
mp_Output(struct mp *mp, struct link *l, struct mbuf *m, int begin, int end)
{
struct mbuf *mo;
u_char *cp;
u_int32_t *seq32;
u_int16_t *seq16;
mo = mballoc(4, MB_MP);
mo->next = m;
cp = MBUF_CTOP(mo);
seq32 = (u_int32_t *)cp;
seq16 = (u_int16_t *)cp;
*seq32 = 0;
*cp = (begin << 7) | (end << 6);
if (mp->is12bit) {
*seq16 |= (u_int16_t)mp->seq.out;
mo->cnt = 2;
} else {
*seq32 |= (u_int32_t)mp->seq.out;
mo->cnt = 4;
}
mp->seq.out = inc_seq(mp, mp->seq.out);
HdlcOutput(l, PRI_NORMAL, PROTO_MP, mo);
}
int
mp_FillQueues(struct bundle *bundle)
{
struct mp *mp = &bundle->ncp.mp;
struct datalink *dl;
int total, add, len, begin, end, looped;
struct mbuf *m, *mo;
/*
* XXX: This routine is fairly simplistic. It should re-order the
* links based on the amount of data less than the links weight
* that was queued. That way we'd ``prefer'' the least used
* links the next time 'round.
*/
total = 0;
for (dl = bundle->links; dl; dl = dl->next) {
if (dl->physical->out)
/* this link has suffered a short write. Let it continue */
continue;
add = link_QueueLen(&dl->physical->link);
total += add;
if (add)
/* this link has got stuff already queued. Let it continue */
continue;
if (!link_QueueLen(&mp->link) && !IpFlushPacket(&mp->link, bundle))
/* Nothing else to send */
break;
m = link_Dequeue(&mp->link);
len = plength(m);
add += len;
begin = 1;
end = 0;
looped = 0;
for (; !end; dl = dl->next) {
if (dl == NULL) {
/* Keep going 'till we get rid of the whole of `m' */
looped = 1;
dl = bundle->links;
}
if (len <= dl->mp.weight + LINK_MINWEIGHT) {
mo = m;
end = 1;
} else {
mo = mballoc(dl->mp.weight, MB_MP);
mo->cnt = dl->mp.weight;
len -= mo->cnt;
m = mbread(m, MBUF_CTOP(mo), mo->cnt);
}
mp_Output(mp, &dl->physical->link, mo, begin, end);
begin = 0;
}
if (looped)
break;
}
return total;
}
int
mp_SetDatalinkWeight(struct cmdargs const *arg)
{
int val;
if (arg->argc != 1)
return -1;
val = atoi(arg->argv[0]);
if (val < LINK_MINWEIGHT) {
LogPrintf(LogWARN, "Link weights must not be less than %d\n",
LINK_MINWEIGHT);
return 1;
}
arg->cx->mp.weight = val;
return 0;
}

62
usr.sbin/ppp/mp.h Normal file
View File

@ -0,0 +1,62 @@
/*-
* Copyright (c) 1998 Brian Somers <brian@Awfulhak.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id$
*/
struct mp {
struct link link;
unsigned active : 1;
unsigned is12bit : 1; /* 12 / 24bit seq nos */
struct {
u_int32_t out; /* next outgoing seq */
u_int32_t min_in; /* minimum received incoming seq */
u_int32_t next_in; /* next incoming seq to process */
} seq;
struct mbuf *inbufs; /* Received fragments */
struct fsm_parent fsmp; /* Our callback functions */
struct bundle *bundle;
};
struct mp_link {
u_int32_t seq; /* 12 or 24 bit incoming seq */
int weight; /* bytes to send with each write */
};
struct mp_header {
unsigned begin : 1;
unsigned end : 1;
u_int32_t seq;
};
extern void mp_Init(struct mp *, struct bundle *);
extern void mp_linkInit(struct mp_link *);
extern void mp_Input(struct mp *, struct mbuf *, struct physical *);
extern int mp_FillQueues(struct bundle *);
extern int mp_SetDatalinkWeight(struct cmdargs const *);

15
usr.sbin/ppp/pap.c
View File

@ -18,7 +18,7 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: pap.c,v 1.20.2.18 1998/03/16 22:52:35 brian Exp $
* $Id: pap.c,v 1.20.2.19 1998/03/16 22:54:16 brian Exp $
*
* TODO:
*/
@ -55,6 +55,7 @@
#include "lcpproto.h"
#include "async.h"
#include "throughput.h"
#include "ccp.h"
#include "link.h"
#include "descriptor.h"
#include "physical.h"
@ -62,9 +63,9 @@
#include "slcompress.h"
#include "ipcp.h"
#include "filter.h"
#include "mp.h"
#include "bundle.h"
#include "chat.h"
#include "ccp.h"
#include "chap.h"
#include "datalink.h"
@ -163,10 +164,10 @@ PapInput(struct bundle *bundle, struct mbuf *bp, struct physical *physical)
cp = (u_char *) (php + 1);
if (PapValidate(bundle, cp, cp + *cp + 1, physical)) {
SendPapCode(php->id, PAP_ACK, "Greetings!!", physical);
dl->lcp.auth_ineed = 0;
dl->physical->link.lcp.auth_ineed = 0;
Physical_Login(physical, cp + 1);
if (dl->lcp.auth_iwait == 0)
if (dl->physical->link.lcp.auth_iwait == 0)
/*
* Either I didn't need to authenticate, or I've already been
* told that I got the answer right.
@ -184,9 +185,9 @@ PapInput(struct bundle *bundle, struct mbuf *bp, struct physical *physical)
len = *cp++;
cp[len] = 0;
LogPrintf(LogPHASE, "Received PAP_ACK (%s)\n", cp);
if (dl->lcp.auth_iwait == PROTO_PAP) {
dl->lcp.auth_iwait = 0;
if (dl->lcp.auth_ineed == 0)
if (dl->physical->link.lcp.auth_iwait == PROTO_PAP) {
dl->physical->link.lcp.auth_iwait = 0;
if (dl->physical->link.lcp.auth_ineed == 0)
/*
* We've succeeded in our ``login''
* If we're not expecting the peer to authenticate (or he already

30
usr.sbin/ppp/physical.c
View File

@ -16,7 +16,7 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: physical.c,v 1.1.2.18 1998/03/16 22:54:18 brian Exp $
* $Id: physical.c,v 1.1.2.19 1998/03/20 19:48:16 brian Exp $
*
*/
@ -55,6 +55,7 @@
#include "fsm.h"
#include "lcp.h"
#include "async.h"
#include "ccp.h"
#include "link.h"
#include "descriptor.h"
@ -65,6 +66,12 @@
#include "slcompress.h"
#include "ipcp.h"
#include "filter.h"
#include "mp.h"
#include "auth.h"
#include "chap.h"
#include "pap.h"
#include "chat.h"
#include "datalink.h"
#include "bundle.h"
#include "log.h"
#include "id.h"
@ -183,13 +190,6 @@ Physical_Write(struct physical *phys, const void *buf, size_t nbytes) {
return write(phys->fd, buf, nbytes);
}
int
Physical_ReportProtocolStatus(struct cmdargs const *arg)
{
link_ReportProtocolStatus(bundle2link(arg->bundle, NULL));
return 0;
}
int
Physical_UpdateSet(struct descriptor *d, fd_set *r, fd_set *w, fd_set *e,
int *n, int force)
@ -197,8 +197,6 @@ Physical_UpdateSet(struct descriptor *d, fd_set *r, fd_set *w, fd_set *e,
struct physical *p = descriptor2physical(d);
int sets;
LogPrintf(LogDEBUG, "descriptor2physical; %p -> %p\n", d, p);
sets = 0;
if (p->fd >= 0) {
if (r) {
@ -224,21 +222,9 @@ int
Physical_IsSet(struct descriptor *d, const fd_set *fdset)
{
struct physical *p = descriptor2physical(d);
LogPrintf(LogDEBUG, "descriptor2physical; %p -> %p\n", d, p);
return p->fd >= 0 && FD_ISSET(p->fd, fdset);
}
void
Physical_DescriptorWrite(struct descriptor *d, struct bundle *bundle,
const fd_set *fdset)
{
struct physical *p = descriptor2physical(d);
LogPrintf(LogDEBUG, "descriptor2physical; %p -> %p\n", d, p);
link_StartOutput(&p->link, bundle);
}
void
Physical_Login(struct physical *phys, const char *name)
{

3
usr.sbin/ppp/physical.h
View File

@ -16,7 +16,7 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: physical.h,v 1.1.2.16 1998/03/20 19:47:22 brian Exp $
* $Id: physical.h,v 1.1.2.17 1998/03/20 19:48:18 brian Exp $
*
*/
@ -98,7 +98,6 @@ int Physical_FD_ISSET(struct physical *, fd_set *);
void Physical_DupAndClose(struct physical *);
ssize_t Physical_Read(struct physical *phys, void *buf, size_t nbytes);
ssize_t Physical_Write(struct physical *phys, const void *buf, size_t nbytes);
int Physical_ReportProtocolStatus(struct cmdargs const *);
int Physical_UpdateSet(struct descriptor *, fd_set *, fd_set *, fd_set *,
int *, int);
int Physical_IsSet(struct descriptor *, const fd_set *);

31
usr.sbin/ppp/prompt.c
View File

@ -23,7 +23,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: prompt.c,v 1.1.2.15 1998/03/16 22:54:22 brian Exp $
* $Id: prompt.c,v 1.1.2.16 1998/03/20 19:48:19 brian Exp $
*/
#include <sys/param.h>
@ -55,15 +55,16 @@
#include "slcompress.h"
#include "ipcp.h"
#include "filter.h"
#include "bundle.h"
#include "lqr.h"
#include "hdlc.h"
#include "async.h"
#include "mbuf.h"
#include "ccp.h"
#include "link.h"
#include "physical.h"
#include "mp.h"
#include "bundle.h"
#include "chat.h"
#include "ccp.h"
#include "chap.h"
#include "datalink.h"
@ -75,8 +76,6 @@ prompt_UpdateSet(struct descriptor *d, fd_set *r, fd_set *w, fd_set *e, int *n)
struct prompt *p = descriptor2prompt(d);
int sets;
LogPrintf(LogDEBUG, "descriptor2prompt; %p -> %p\n", d, p);
sets = 0;
if (p->fd_in >= 0) {
if (r) {
@ -98,7 +97,6 @@ static int
prompt_IsSet(struct descriptor *d, const fd_set *fdset)
{
struct prompt *p = descriptor2prompt(d);
LogPrintf(LogDEBUG, "descriptor2prompt; %p -> %p\n", d, p);
return p->fd_in >= 0 && FD_ISSET(p->fd_in, fdset);
}
@ -110,8 +108,8 @@ prompt_ShowHelp(struct prompt *p)
prompt_Printf(p, " ~p\tEnter Packet mode\r\n");
prompt_Printf(p, " ~-\tDecrease log level\r\n");
prompt_Printf(p, " ~+\tIncrease log level\r\n");
prompt_Printf(p, " ~t\tShow timers (only in \"log debug\" mode)\r\n");
prompt_Printf(p, " ~m\tShow memory map (only in \"log debug\" mode)\r\n");
prompt_Printf(p, " ~t\tShow timers\r\n");
prompt_Printf(p, " ~m\tShow memory map\r\n");
prompt_Printf(p, " ~.\tTerminate program\r\n");
prompt_Printf(p, " ~?\tThis help\r\n");
}
@ -125,7 +123,6 @@ prompt_Read(struct descriptor *d, struct bundle *bundle, const fd_set *fdset)
static int ttystate;
char linebuff[LINE_LEN];
LogPrintf(LogDEBUG, "descriptor2prompt; %p -> %p\n", d, p);
LogPrintf(LogDEBUG, "termode = %p, p->fd_in = %d, mode = %d\n",
p->TermMode, p->fd_in, mode);
@ -136,9 +133,9 @@ prompt_Read(struct descriptor *d, struct bundle *bundle, const fd_set *fdset)
linebuff[--n] = '\0';
else
linebuff[n] = '\0';
prompt_nonewline = 1; /* In case DecodeCommand does a prompt */
if (n)
DecodeCommand(bundle, linebuff, n, IsInteractive(0) ? NULL : "Client");
prompt_nonewline = 1;
prompt_Display(&prompt, bundle);
} else if (n <= 0) {
LogPrintf(LogPHASE, "Client connection closed.\n");
@ -201,15 +198,11 @@ prompt_Read(struct descriptor *d, struct bundle *bundle, const fd_set *fdset)
prompt_Display(&prompt, bundle);
break;
case 't':
if (LogIsKept(LogDEBUG)) {
ShowTimers();
break;
}
ShowTimers(0);
break;
case 'm':
if (LogIsKept(LogDEBUG)) {
ShowMemMap(NULL);
break;
}
ShowMemMap(NULL);
break;
default:
if (Physical_Write(bundle2physical(bundle, NULL), &ch, n) < 0)
LogPrintf(LogERROR, "error writing to modem.\n");
@ -270,7 +263,7 @@ prompt_Display(struct prompt *p, struct bundle *bundle)
{
const char *pconnect, *pauth;
if (!p->Term || p->TermMode != NULL || bundle->CleaningUp)
if (!p->Term || p->TermMode != NULL)
return;
if (prompt_nonewline)

8
usr.sbin/ppp/route.c
View File

@ -17,7 +17,7 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: route.c,v 1.42.2.12 1998/03/16 22:54:23 brian Exp $
* $Id: route.c,v 1.42.2.13 1998/03/20 19:48:21 brian Exp $
*
*/
@ -55,12 +55,16 @@
#include "throughput.h"
#include "lqr.h"
#include "hdlc.h"
#include "link.h"
#include "async.h"
#include "fsm.h"
#include "lcp.h"
#include "ccp.h"
#include "link.h"
#include "slcompress.h"
#include "ipcp.h"
#include "filter.h"
#include "descriptor.h"
#include "mp.h"
#include "bundle.h"
#include "route.h"
#include "prompt.h"

7
usr.sbin/ppp/server.c
View File

@ -23,7 +23,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: server.c,v 1.16.2.8 1998/02/23 00:38:42 brian Exp $
* $Id: server.c,v 1.16.2.9 1998/03/20 19:48:23 brian Exp $
*/
#include <sys/param.h>
@ -58,7 +58,6 @@ server_UpdateSet(struct descriptor *d, fd_set *r, fd_set *w, fd_set *e, int *n)
{
struct server *s = descriptor2server(d);
LogPrintf(LogDEBUG, "descriptor2server; %p -> %p\n", d, s);
if (r && s->fd >= 0) {
if (*n < s->fd + 1)
*n = s->fd + 1;
@ -72,8 +71,6 @@ static int
server_IsSet(struct descriptor *d, const fd_set *fdset)
{
struct server *s = descriptor2server(d);
LogPrintf(LogDEBUG, "descriptor2server; %p -> %p\n", d, s);
return s->fd >= 0 && FD_ISSET(s->fd, fdset);
}
@ -90,8 +87,6 @@ server_Read(struct descriptor *d, struct bundle *bundle, const fd_set *fdset)
struct sockaddr_in *sin = (struct sockaddr_in *)hisaddr;
int ssize = ADDRSZ, wfd;
LogPrintf(LogDEBUG, "descriptor2server; %p -> %p\n", d, s);
wfd = accept(s->fd, sa, &ssize);
if (wfd < 0) {
LogPrintf(LogERROR, "server_Read: accept(): %s\n", strerror(errno));

8
usr.sbin/ppp/slcompress.c
View File

@ -17,7 +17,7 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: slcompress.c,v 1.15.2.2 1998/02/10 03:23:42 brian Exp $
* $Id: slcompress.c,v 1.15.2.3 1998/03/16 22:54:25 brian Exp $
*
* Van Jacobson (van@helios.ee.lbl.gov), Dec 31, 1989:
* - Initial distribution.
@ -48,6 +48,12 @@
#include "iplist.h"
#include "ipcp.h"
#include "filter.h"
#include "lqr.h"
#include "hdlc.h"
#include "lcp.h"
#include "ccp.h"
#include "link.h"
#include "mp.h"
#include "bundle.h"
void

6
usr.sbin/ppp/throughput.c
View File

@ -23,7 +23,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: throughput.c,v 1.4 1997/12/21 12:11:09 brian Exp $
* $Id: throughput.c,v 1.4.4.1 1998/02/10 03:23:43 brian Exp $
*/
#include <sys/param.h>
@ -53,6 +53,7 @@ throughput_init(struct pppThroughput *t)
for (f = 0; f < SAMPLE_PERIOD; f++)
t->SampleOctets[f] = 0;
t->OctetsPerSecond = t->BestOctetsPerSecond = t->nSample = 0;
t->Timer.name = "throughput";
throughput_stop(t);
}
@ -124,7 +125,7 @@ throughput_sampler(void *v)
}
void
throughput_start(struct pppThroughput *t)
throughput_start(struct pppThroughput *t, const char *name)
{
throughput_init(t);
time(&t->uptime);
@ -132,6 +133,7 @@ throughput_start(struct pppThroughput *t)
t->Timer.state = TIMER_STOPPED;
t->Timer.load = SECTICKS;
t->Timer.func = throughput_sampler;
t->Timer.name = name;
t->Timer.arg = t;
StartTimer(&t->Timer);
}

4
usr.sbin/ppp/throughput.h
View File

@ -23,7 +23,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: throughput.h,v 1.2 1997/12/21 12:11:09 brian Exp $
* $Id: throughput.h,v 1.2.4.1 1998/02/10 03:23:48 brian Exp $
*/
#define SAMPLE_PERIOD 5
@ -42,7 +42,7 @@ struct pppThroughput {
extern void throughput_init(struct pppThroughput *);
extern void throughput_disp(struct pppThroughput *);
extern void throughput_log(struct pppThroughput *, int, const char *);
extern void throughput_start(struct pppThroughput *);
extern void throughput_start(struct pppThroughput *, const char *);
extern void throughput_stop(struct pppThroughput *);
extern void throughput_addin(struct pppThroughput *, int);
extern void throughput_addout(struct pppThroughput *, int);

89
usr.sbin/ppp/timer.c
View File

@ -17,16 +17,16 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: timer.c,v 1.26 1997/12/29 22:23:52 brian Exp $
* $Id: timer.c,v 1.27 1998/01/21 02:15:29 brian Exp $
*
* TODO:
*/
#include <signal.h>
#ifdef SIGALRM
#include <errno.h>
#endif
#include <signal.h>
#include <stdio.h>
#include <sys/time.h>
#include <termios.h>
#include <unistd.h>
#include "command.h"
@ -34,24 +34,32 @@
#include "log.h"
#include "sig.h"
#include "timer.h"
#include "descriptor.h"
#include "prompt.h"
static struct pppTimer *TimerList = NULL;
static void StopTimerNoBlock(struct pppTimer *);
static void InitTimerService(void);
static const char *
tState2Nam(u_int state)
{
static const char *StateNames[] = { "stopped", "running", "expired" };
if (state >= sizeof StateNames / sizeof StateNames[0])
return "unknown";
return StateNames[state];
}
void
StopTimer(struct pppTimer * tp)
{
#ifdef SIGALRM
int omask;
omask = sigblock(sigmask(SIGALRM));
#endif
StopTimerNoBlock(tp);
#ifdef SIGALRM
sigsetmask(omask);
#endif
}
void
@ -59,25 +67,20 @@ StartTimer(struct pppTimer * tp)
{
struct pppTimer *t, *pt;
u_long ticks = 0;
#ifdef SIGALRM
int omask;
omask = sigblock(sigmask(SIGALRM));
#endif
if (tp->state != TIMER_STOPPED) {
StopTimerNoBlock(tp);
}
if (tp->load == 0) {
LogPrintf(LogDEBUG, "timer %x has 0 load!\n", tp);
LogPrintf(LogDEBUG, "%s timer[%p] has 0 load!\n", tp->name, tp);
sigsetmask(omask);
return;
}
pt = NULL;
for (t = TimerList; t; t = t->next) {
LogPrintf(LogDEBUG, "StartTimer: %x(%d): ticks: %d, rest: %d\n",
t, t->state, ticks, t->rest);
if (ticks + t->rest >= tp->load)
break;
ticks += t->rest;
@ -86,8 +89,13 @@ StartTimer(struct pppTimer * tp)
tp->state = TIMER_RUNNING;
tp->rest = tp->load - ticks;
LogPrintf(LogDEBUG, "StartTimer: Inserting %x before %x, rest = %d\n",
tp, t, tp->rest);
if (t)
LogPrintf(LogDEBUG, "StartTimer: Inserting %s timer[%p] before %s "
"timer[%p], delta = %d\n", tp->name, tp, t->name, t, tp->rest);
else
LogPrintf(LogDEBUG, "StartTimer: Inserting %s timer[%p]\n", tp->name, tp);
/* Insert given *tp just before *t */
tp->next = t;
if (pt) {
@ -99,9 +107,7 @@ StartTimer(struct pppTimer * tp)
if (t)
t->rest -= tp->rest;
#ifdef SIGALRM
sigsetmask(omask);
#endif
}
static void
@ -114,8 +120,6 @@ StopTimerNoBlock(struct pppTimer * tp)
* already removing TimerList. So just marked as TIMER_STOPPED. Do not
* change tp->enext!! (Might be Called by expired proc)
*/
LogPrintf(LogDEBUG, "StopTimer: %x, next = %x state=%x\n",
tp, tp->next, tp->state);
if (tp->state != TIMER_RUNNING) {
tp->next = NULL;
tp->state = TIMER_STOPPED;
@ -146,8 +150,14 @@ TimerService()
{
struct pppTimer *tp, *exp, *wt;
if (LogIsKept(LogDEBUG))
ShowTimers();
if (LogIsKept(LogDEBUG)) {
static time_t t;
time_t n = time(NULL); /* Only show timers every second */
if (n > t)
ShowTimers(LogDEBUG);
t = n;
}
tp = TimerList;
if (tp) {
tp->rest--;
@ -162,15 +172,12 @@ TimerService()
wt = tp->next;
tp->enext = exp;
exp = tp;
LogPrintf(LogDEBUG, "TimerService: Add %x to exp\n", tp);
tp = wt;
} while (tp && (tp->rest == 0));
TimerList = tp;
if (TimerList == NULL) /* No timers ? */
TermTimerService(); /* Terminate Timer Service */
LogPrintf(LogDEBUG, "TimerService: next is %x(%d)\n",
TimerList, TimerList ? TimerList->rest : 0);
/*
* Process all expired timers.
@ -193,19 +200,33 @@ TimerService()
}
void
ShowTimers()
ShowTimers(int LogLevel)
{
struct pppTimer *pt;
int rest = 0;
LogPrintf(LogDEBUG, "---- Begin of Timer Service List---\n");
for (pt = TimerList; pt; pt = pt->next)
LogPrintf(LogDEBUG, "%x: load = %d, rest = %d, state =%x\n",
pt, pt->load, pt->rest, pt->state);
LogPrintf(LogDEBUG, "---- End of Timer Service List ---\n");
#define SECS(val) ((val) / SECTICKS)
#define HSECS(val) (((val) % SECTICKS) * 100 / SECTICKS)
#define DISP \
"%s timer[%p]: freq = %d.%02ds, next = %d.%02ds, state = %s\n", \
pt->name, pt, SECS(pt->load), HSECS(pt->load), SECS(rest), \
HSECS(rest), tState2Nam(pt->state)
if (LogIsKept(LogLevel))
LogPrintf(LogLevel, "---- Begin of Timer Service List---\n");
for (pt = TimerList; pt; pt = pt->next) {
rest += pt->rest;
if (LogIsKept(LogLevel))
LogPrintf(LogLevel, DISP);
else if (LogLevel < LogMIN)
prompt_Printf(&prompt, DISP);
}
if (LogIsKept(LogLevel))
LogPrintf(LogLevel, "---- End of Timer Service List ---\n");
}
#ifdef SIGALRM
static void
nointr_dosleep(u_int sec, u_int usec)
{
@ -285,5 +306,3 @@ TermTimerService(void)
LogPrintf(LogERROR, "Unable to set itimer.\n");
pending_signal(SIGALRM, SIG_IGN);
}
#endif

9
usr.sbin/ppp/timer.h
View File

@ -15,16 +15,17 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: timer.h,v 1.4 1997/12/28 21:55:05 brian Exp $
* $Id: timer.h,v 1.5 1998/01/21 02:15:30 brian Exp $
*
* TODO:
*/
#define TICKUNIT 100000 /* Unit in usec */
#define SECTICKS (1000000/TICKUNIT)
#define TICKUNIT 100000 /* usec's per Unit */
#define SECTICKS (1000000/TICKUNIT) /* Units per second */
struct pppTimer {
int state;
const char *name;
u_long rest; /* Ticks to expire */
u_long load; /* Initial load value */
void (*func)(void *); /* Function called when timer is expired */
@ -40,7 +41,7 @@ struct pppTimer {
extern void StartTimer(struct pppTimer *);
extern void StopTimer(struct pppTimer *);
extern void TermTimerService(void);
extern void ShowTimers(void);
extern void ShowTimers(int LogLevel);
#ifdef SIGALRM
extern void nointr_sleep(u_int);

6
usr.sbin/ppp/tun.c
View File

@ -23,7 +23,7 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: tun.c,v 1.6.4.8 1998/03/16 22:54:28 brian Exp $
* $Id: tun.c,v 1.6.4.9 1998/03/20 19:48:25 brian Exp $
*/
#include <sys/param.h>
@ -57,6 +57,10 @@
#include "ipcp.h"
#include "filter.h"
#include "descriptor.h"
#include "lcp.h"
#include "ccp.h"
#include "link.h"
#include "mp.h"
#include "bundle.h"
#include "tun.h"

5
usr.sbin/ppp/vars.c
View File

@ -17,7 +17,7 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: vars.c,v 1.45.2.16 1998/03/20 19:47:07 brian Exp $
* $Id: vars.c,v 1.45.2.17 1998/03/24 18:47:27 brian Exp $
*
*/
#include <sys/param.h>
@ -41,13 +41,14 @@
#include "lcp.h"
#include "async.h"
#include "throughput.h"
#include "ccp.h"
#include "link.h"
#include "descriptor.h"
#include "physical.h"
#include "prompt.h"
char VarVersion[] = "PPP Version 2.0-beta";
char VarLocalVersion[] = "$Date: 1998/03/20 19:47:07 $";
char VarLocalVersion[] = "$Date: 1998/03/24 18:47:27 $";
/*
* Order of conf option is important. See vars.h.

6
usr.sbin/ppp/vjcomp.c
View File

@ -17,7 +17,7 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Id: vjcomp.c,v 1.16.2.9 1998/03/16 22:54:32 brian Exp $
* $Id: vjcomp.c,v 1.16.2.10 1998/03/20 19:48:28 brian Exp $
*
* TODO:
*/
@ -47,6 +47,7 @@
#include "link.h"
#include "filter.h"
#include "descriptor.h"
#include "mp.h"
#include "bundle.h"
#include "vjcomp.h"
@ -58,7 +59,6 @@ SendPppFrame(struct link *l, struct mbuf * bp, struct bundle *bundle)
int type;
u_short proto;
u_short cproto = bundle->ncp.ipcp.peer_compproto >> 16;
struct ccp *ccp = bundle2ccp(bundle, l->name);
LogPrintf(LogDEBUG, "SendPppFrame: proto = %x\n",
bundle->ncp.ipcp.peer_compproto);
@ -87,7 +87,7 @@ SendPppFrame(struct link *l, struct mbuf * bp, struct bundle *bundle)
} else
proto = PROTO_IP;
if (!ccp_Output(ccp, l, PRI_NORMAL, proto, bp))
if (!ccp_Compress(&l->ccp, l, PRI_NORMAL, proto, bp))
HdlcOutput(l, PRI_NORMAL, proto, bp);
}