home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
HAM Radio 1
/
HamRadio.cdr
/
misc
/
src0131
/
pppcmd.c
< prev
next >
Wrap
C/C++ Source or Header
|
1990-12-09
|
22KB
|
840 lines
/*
* PPPCMD.C -- PPP related user commands
*
* 12-89 -- Katie Stevens (dkstevens@ucdavis.edu)
* UC Davis, Computing Services
* PPP.07 04-90 [ks] new storage for peer addr for IPCP
* PPP.08 05-90 [ks] improve PPP trace reporting
* PPP.09 05-90 [ks] add commands to set PPP Auth protocol
* (UPAP server) and UPAP peerID (UPAP client)
* PPP.10 6-90 [ks] improve keybd input of UPAP password
* make ppp open/close/reset work properly
* add peer IP lookup pool
* PPP.13 8-90 [ks] report PPP open timestamp with stats
* PPP.14 8-90 [ks] change UPAP to PAP for consistency with RFC1172
* add RLSD physical link up/down handling
* add autobaud handling to set link speed
* make LCP/IPCP timeout configurable
* PPP.15 09-90 [ks] update to KA9Q NOS v900828
*/
#include <stdio.h>
#include <time.h>
#include "global.h"
#include "mbuf.h"
#include "iface.h"
#include "timer.h"
#include "pktdrvr.h"
#include "asy.h"
#include "slcompre.h"
#include "ppp.h"
#include "slip.h"
#include "commands.h"
#include "netuser.h"
/*#include "internet.h"*/
#include "cmdparse.h"
#include "config.h"
extern char Badhost[];
int16 Ppptrace = 0;
int16 Npool = 0; /* Number of pools for PPP interfaces */
#ifdef notdef /*MUXASY*/
struct ipcppool PPPpool[ASY_MAX*PORTS_PER_MUX]; /* For pooling peer IP addrs */
#else
struct ipcppool PPPpool[ASY_MAX]; /* For pooling peer IP addrs */
#endif
static int dopppaccomp __ARGS((int argc, char *argv[], void *p));
static int dopppactive __ARGS((int argc, char *argv[], void *p));
static int dopppauth __ARGS((int argc, char *argv[], void *p));
static int dopppclose __ARGS((int argc, char *argv[], void *p));
static int dopppctlmap __ARGS((int argc, char *argv[], void *p));
static int dopppmru __ARGS((int argc, char *argv[], void *p));
static int dopppipcomp __ARGS((int argc, char *argv[], void *p));
static int doppppassive __ARGS((int argc, char *argv[], void *p));
static int doppppeer __ARGS((int argc, char *argv[], void *p));
static int doppppool __ARGS((int argc, char *argv[], void *p));
static int dopppprotcomp __ARGS((int argc, char *argv[], void *p));
static int dopppreset __ARGS((int argc, char *argv[], void *p));
static int dopppstat __ARGS((int argc, char *argv[], void *p));
static int doppptrace __ARGS((int argc, char *argv[], void *p));
static int doppptimeout __ARGS((int argc, char *argv[], void *p));
static int dopapuser __ARGS((int argc, char *argv[], void *p));
static void genstat __ARGS((struct slip *sp));
static void pppstat __ARGS((struct slip *sp));
static void lcpstat __ARGS((struct lcpctl *lcpiop));
static void ipcpstat __ARGS((struct ipcpctl *ipcpiop));
static struct iface *ppplookup __ARGS((char *ifname));
static void dumppool __ARGS((void));
static char *uptime __ARGS((long first, long second));
/* "ppp" subcommands */
static struct cmds Pppcmds[] = {
"accompr", dopppaccomp, 0, 2,
"ppp accompr <iface> <int>",
"activeopen", dopppactive, 0, 2,
"ppp activeopen <iface>",
"authprot", dopppauth, 0, 2,
"ppp authprot <authtype>",
"close", dopppclose, 512, 2,
"ppp close <iface>",
"ctlmap", dopppctlmap, 0, 2,
"ppp ctlmap <iface> <int>",
"ipcompr", dopppipcomp, 0, 2,
"ppp ipcompr <iface> <comprtype>",
"mru", dopppmru, 0, 2,
"ppp mru <iface> <int>",
"passiveopen", doppppassive, 0, 2,
"ppp passiveopen <iface>",
"peeraddr", doppppeer, 0, 2,
"ppp peeraddr <iface> <addr>",
"peerid", dopapuser, 0, 2,
"ppp peerid <iface> <peer ID code>",
"pooladdr", doppppool, 0, 1,
"ppp pooladdr <addr>:<# addr in pool> [ <iface> ... ]",
"protcompr", dopppprotcomp, 0, 2,
"ppp protcompr <iface> <int>",
"reset", dopppreset, 0, 2,
"ppp reset <iface>",
"status", dopppstat, 0, 0, NULLCHAR,
"timeout", doppptimeout, 0, 2,
"ppp timeout <iface> <#sec>",
"trace", doppptrace, 0, 0, NULLCHAR,
NULLCHAR,
};
static char *PPPStatus[] = {
"physical layer down",
"waiting for link speed assignment message",
"Closed",
"waiting for LCP negotiation",
"waiting for PAP verfication",
"waiting for IPCP negotiation",
"Open"
};
static char *LCPStatus[] = {
"Closed",
"Listen; waiting for remote host to attempt open",
"Req Sent: Attempting to start configuration exchange",
"Ack Rcvd: Remote host accepted our request; waiting for remote request",
"Ack Sent: Waiting for reply to our request; accepted remote request",
"Open; configuration negotiation complete",
"Terminate request sent to remote host"
};
/****************************************************************************/
int
dopppcontrol(argc,argv,p)
int argc;
char *argv[];
void *p;
{
return subcmd(Pppcmds,argc,argv,p);
}
/****************************************************************************/
/* Initiate active open on a PPP interface */
static int
dopppactive(argc,argv,p)
int argc;
char *argv[];
void *p;
{
struct iface *ifp;
struct pppctl *pppiop;
struct lcpctl *lcpiop;
/* Look for the PPP interface */
if ((ifp = ppplookup(argv[1])) == NULLIF)
return -1;
/* Start LCP configuration negotiation on interface */
pppiop = Slip[ifp->xdev].pppio;
lcpiop = &(pppiop->lcpio);
lcpiop->active = 1;
if ((pppiop->state == PPP_PL_DOWN) || (pppiop->state == PPP_AUTOBAUD))
return 0;
else
return(lcp_start(&Slip[ifp->xdev]));
}
/* Close connection on PPP interface */
static int
dopppclose(argc,argv,p)
int argc;
char *argv[];
void *p;
{
struct iface *ifp;
/* Look for the PPP interface */
if ((ifp = ppplookup(argv[1])) == NULLIF)
return -1;
/* Close PPP connection */
return(ppp_close(&Slip[ifp->xdev],1));
}
/* Set PPP interface to passive open; will revert to LISTEN on next close */
static int
doppppassive(argc,argv,p)
int argc;
char *argv[];
void *p;
{
struct iface *ifp;
struct pppctl *pppiop;
struct lcpctl *lcpiop;
/* Look for the PPP interface */
if ((ifp = ppplookup(argv[1])) == NULLIF)
return -1;
/* Start LCP configuration negotiation on interface */
pppiop = Slip[ifp->xdev].pppio;
lcpiop = &(pppiop->lcpio);
lcpiop->active = 0;
return 0;
}
/* Close and reopen connection on PPP interface */
static int
dopppreset(argc,argv,p)
int argc;
char *argv[];
void *p;
{
struct iface *ifp;
struct slip *sp;
struct pppctl *pp;
struct slcompress *slp;
/* Look for the PPP interface */
if ((ifp = ppplookup(argv[1])) == NULLIF)
return -1;
sp = &Slip[ifp->xdev];
pp = sp->pppio;
/* Close PPP connection */
ppp_close(&Slip[ifp->xdev],0);
#ifndef PPP_NO_STATS
/* Zero PPP packet counters */
pp->sndpkt = 0L; /* # packets sent on PPP interface */
pp->snderr = 0; /* # pkts with PPP error on send */
pp->rcvpkt = 0L; /* # packets rcvd on PPP interface */
pp->rcverr = 0; /* # pkts with error */
pp->csumerr = 0; /* # rcv pkts with bad PPP checksum */
pp->sndlcp = 0; /* # LCP packets sent */
pp->sndpap = 0; /* # PAP packets sent */
pp->sndipcp = 0; /* # IPCP packets sent */
pp->sndip = 0L; /* # IP packets sent */
pp->rcvlcp = 0; /* # LCP packets received */
pp->rcvpap = 0; /* # PAP packets received */
pp->rcvipcp = 0; /* # IPCP packets received */
pp->rcvip = 0L; /* # IP packets received */
pp->rcvunk = 0; /* # unknown packets received */
#endif
#ifndef SL_NO_STATS
slp = sp->slcomp;
slp->sls_nontcp = 0L; /* outbound non-TCP packets */
slp->sls_asistcp = 0L; /* outbound TCP packets */
slp->sls_compressed = 0L; /* outbound compressed packets */
slp->sls_uncompressed = 0L; /* outbound uncompressed packets */
slp->sls_searches = 0L; /* searches for connection state */
slp->sls_misses = 0L; /* times couldn't find conn. state */
slp->sls_nontcpin = 0L; /* inbound non-TCP packets */
slp->sls_tcpin = 0L; /* inbound TCP packets */
slp->sls_uncompressedin = 0L; /* inbound uncompressed packets */
slp->sls_compressedin = 0L; /* inbound compressed packets */
slp->sls_errorin = 0L; /* inbound unknown type packets */
slp->sls_tossed = 0L; /* inbound tossed because of error */
#endif
/* Always restart as active open when PPP reset */
pp->lcpio.active = 1;
tprintf("Attempting to reopen PPP interface %s\n",ifp->name);
return(lcp_start(&Slip[ifp->xdev]));
}
/*******************************************/
/* Set Address/Control Compression for a PPP interface */
static int
dopppaccomp(argc,argv,p)
int argc;
char *argv[];
void *p;
{
struct iface *ifp;
struct pppctl *pppiop;
struct lcpctl *lcpiop;
struct lcpparm *localp;
if ((ifp = ppplookup(argv[1])) == NULLIF)
return -1;
--argc;++argv;
pppiop = Slip[ifp->xdev].pppio;
lcpiop = &(pppiop->lcpio);
localp = &(lcpiop->initparm);
localp->neg_ac_compress = 1;
return setbool(&(localp->ac_compress),
"Addr/Ctl Field Compression",argc,argv);
}
/* Set authentication type for PPP interface */
static int
dopppauth(argc,argv,p)
int argc;
char *argv[];
void *p;
{
struct iface *ifp;
struct pppctl *pppiop;
struct lcpctl *lcpiop;
struct lcpparm *localp;
if ((ifp = ppplookup(argv[1])) == NULLIF)
return -1;
pppiop = Slip[ifp->xdev].pppio;
lcpiop = &(pppiop->lcpio);
localp = &(lcpiop->initparm);
if (argc < 3) {
tprintf("%s\n",((localp->auth_type == PAP_AUTH_TYPE) ? "PAP" : "None"));
} else if ((strnicmp("pap",argv[2],2) == 0)
|| ((int16)strtol(argv[2],NULLCHARP,0)==PAP_AUTH_TYPE)) {
localp->neg_auth_type = 1;
localp->auth_type = PAP_AUTH_TYPE;
} else if ((stricmp("none",argv[2]) == 0)
|| ((int16)strtol(argv[2],NULLCHARP,0) == 0)) {
localp->neg_auth_type = 0;
localp->auth_type = DEF_AUTH_TYPE;
} else {
tprintf("unknown Authentication Protocol type; command ignored\n");
return 1;
}
return 0;
}
/* Set Async Control Map for a PPP interface */
static int
dopppctlmap(argc,argv,p)
int argc;
char *argv[];
void *p;
{
long lx;
struct iface *ifp;
struct pppctl *pppiop;
struct lcpctl *lcpiop;
struct lcpparm *localp;
if ((ifp = ppplookup(argv[1])) == NULLIF)
return -1;
pppiop = Slip[ifp->xdev].pppio;
lcpiop = &(pppiop->lcpio);
localp = &(lcpiop->initparm);
if (argc < 3) {
tprintf("0x%08lx\n",localp->ctl_map);
} else {
lx = strtol(argv[2], NULLCHARP, 0);
localp->neg_ctl_map = 1;
localp->ctl_map = lx;
}
return 0;
}
/* Set preferred Maximum Receive Unit for a PPP interface */
static int
dopppmru(argc,argv,p)
int argc;
char *argv[];
void *p;
{
int x;
struct iface *ifp;
struct pppctl *pppiop;
struct lcpctl *lcpiop;
struct lcpparm *localp;
if ((ifp = ppplookup(argv[1])) == NULLIF)
return -1;
pppiop = Slip[ifp->xdev].pppio;
lcpiop = &(pppiop->lcpio);
localp = &(lcpiop->initparm);
if (argc < 3) {
tprintf("%d\n",localp->mru);
} else {
x = atoi(argv[2]);
if ((x < MIN_MRU)||(x > DEF_MRU)) {
tprintf("Command rejected; MRU out of range: Min MRU: %d Max MRU: %d\n",
MIN_MRU,DEF_MRU);
return -1;
} else {
localp->neg_mru = 1;
localp->mru = x;
}
}
return 0;
}
/* Set Protocol Compression for a PPP interface */
static int
dopppprotcomp(argc,argv,p)
int argc;
char *argv[];
void *p;
{
struct iface *ifp;
struct pppctl *pppiop;
struct lcpctl *lcpiop;
struct lcpparm *localp;
if ((ifp = ppplookup(argv[1])) == NULLIF)
return -1;
--argc;++argv;
pppiop = Slip[ifp->xdev].pppio;
lcpiop = &(pppiop->lcpio);
localp = &(lcpiop->initparm);
localp->neg_prot_compress = 1;
return setbool(&(localp->prot_compress),
"Protocol Field Compression",argc,argv);
}
/* Set timeout interval when waiting for response from remote peer */
static int
doppptimeout(argc,argv,p)
int argc;
char *argv[];
void *p;
{
int x;
struct iface *ifp;
struct pppctl *pppiop;
struct lcpctl *lcpiop;
struct ipcpctl *ipcpiop;
struct timer *t;
if ((ifp = ppplookup(argv[1])) == NULLIF)
return -1;
pppiop = Slip[ifp->xdev].pppio;
lcpiop = &(pppiop->lcpio);
t = &(lcpiop->lcp_tm);
if (argc < 3) {
tprintf("%d\n",(dur_timer(t)/1000L));
} else {
x = atoi(argv[2]);
if (x <= 0) {
tprintf("Command rejected; timeout value must be > 0\n");
return -1;
} else {
set_timer(t,x*1000L);
ipcpiop = &(pppiop->ipcpio);
t = &(ipcpiop->ipcp_tm);
set_timer(t,x*1000L);
}
}
return 0;
}
/* Set peer ID string to send with PAP AUTH_REQ */
static int
dopapuser(argc,argv,p)
int argc;
char *argv[];
void *p;
{
struct iface *ifp;
struct pppctl *pppiop;
struct lcpctl *lcpiop;
if ((ifp = ppplookup(argv[1])) == NULLIF)
return -1;
pppiop = Slip[ifp->xdev].pppio;
lcpiop = &(pppiop->lcpio);
if (argc < 3) {
tprintf("%s\n",((lcpiop->pap_user==NULLCHAR)?"None":lcpiop->pap_user));
} else if (strnicmp("none",argv[2],2) == 0) {
if (lcpiop->pap_user != NULLCHAR)
free(lcpiop->pap_user);
} else {
if (lcpiop->pap_user != NULLCHAR)
free(lcpiop->pap_user);
if (lcpiop->pap_pass != NULLCHAR)
free(lcpiop->pap_pass);
lcpiop->pap_user = mallocw(strlen(argv[2])+1);
strcpy(lcpiop->pap_user,argv[2]);
pap_getpass(&Slip[ifp->xdev],0);
}
return 0;
}
/*******************************************/
/* Set IP compression type for PPP interface */
static int
dopppipcomp(argc,argv,p)
int argc;
char *argv[];
void *p;
{
struct iface *ifp;
struct pppctl *pppiop;
struct ipcpctl *ipcpiop;
if ((ifp = ppplookup(argv[1])) == NULLIF)
return -1;
pppiop = Slip[ifp->xdev].pppio;
ipcpiop = &(pppiop->ipcpio);
if (argc < 3) {
if (ipcpiop->ip_compr_type == IPCP_VJCOMPR)
tprintf("Van Jacobson TCP header compression enabled\n");
else
tprintf("IP compression disabled\n");
} else if ((strnicmp("vj",argv[2],2) == 0)
|| ((int16)strtol(argv[2],NULLCHARP,0) == IPCP_VJCOMPR)) {
ipcpiop->neg_ip_compr = 1;
ipcpiop->ip_compr_type = IPCP_VJCOMPR;
} else if ((int16)strtol(argv[2],NULLCHARP,0) == 0) {
ipcpiop->neg_ip_compr = 1;
ipcpiop->ip_compr_type = 0;
} else {
tprintf("unknown IP compression type; command ignored\n");
return 1;
}
return 0;
}
/* Set peer address for PPP interface */
static int
doppppeer(argc,argv,p)
int argc;
char *argv[];
void *p;
{
int32 x32;
struct iface *ifp;
struct pppctl *pppiop;
struct ipcpctl *ipcpiop;
if ((ifp = ppplookup(argv[1])) == NULLIF)
return -1;
pppiop = Slip[ifp->xdev].pppio;
ipcpiop = &(pppiop->ipcpio);
if (argc < 3) {
tprintf("%s\n",inet_ntoa(ipcpiop->peer_addr));
} else if ((x32 = resolve(argv[2])) == 0L) {
tprintf(Badhost,argv[2]);
return 1;
} else {
ipcpiop->peer_addr = x32;
}
return 0;
}
/* Set a pool of peer addresses for PPP interface */
static int
doppppool(argc,argv,p)
int argc;
char *argv[];
void *p;
{
int pool;
int pool_cnt;
char *bitp;
int32 pool_addr;
struct ipcppool *poolp;
struct iface *ifp;
struct pppctl *pppiop;
if (argc < 2) {
dumppool();
return 0;
}
if (Npool > ASY_MAX) {
tprintf("Too many PPP address pools -- command rejected\n");
return -1;
}
/* Need at least one IP address for the pool */
if((pool_addr = resolve(argv[1])) == 0){
tprintf("Must specify an IP address pool\n");
return -1;
}
/* May specify a consecutive range of addresses; otherwise assume 1 */
if((bitp = strchr(argv[1],':')) != NULLCHAR){
bitp++;
pool_cnt = atoi(bitp);
} else
pool_cnt = 1;
if (pool_cnt < 0) {
tprintf("Unreasonable address range -- command rejected\n");
return -1;
}
if (argc < 3) {
printf("Must specify a PPP interface\n");
return -1;
}
pool = Npool++;
poolp = &(PPPpool[pool]);
poolp->peer_min = pool_addr;
poolp->peer_max = pool_addr + pool_cnt - 1;
poolp->peer_next = pool_addr;
argc -= 2;argv++;
while (argc--) {
argv++;
if ((ifp = ppplookup(*argv)) == NULLIF)
continue;
pppiop = Slip[ifp->xdev].pppio;
pppiop->ipcpio.peer_pool = &(PPPpool[pool]);
}
return 0;
}
/****************************************************************************/
static int
doppptrace(argc,argv,p)
int argc;
char *argv[];
void *p;
{
return setshort(&Ppptrace,"PPP tracing",argc,argv);
}
/****************************************************************************/
static int
dopppstat(argc,argv,p)
int argc;
char *argv[];
void *p;
{
register struct slip *sp;
struct iface *ifp;
if (argc < 2) {
for (sp = Slip;sp < &Slip[ASY_MAX];sp++) {
if (sp->type != CL_PPP)
continue;
genstat(sp);
}
} else {
if ((ifp = ppplookup(argv[1])) == NULLIF)
return -1;
sp = &Slip[ifp->xdev];
genstat(sp);
pppstat(sp);
lcpstat(&(sp->pppio->lcpio));
ipcpstat(&(sp->pppio->ipcpio));
}
return 0;
}
static void
genstat(sp)
struct slip *sp;
{
register struct pppctl *pp;
pp = sp->pppio;
tprintf("%s:\t",sp->iface->name);
tprintf("SndPkt: %ld SndErr: %d RcvPkt: %ld RcvErr: %d ChksumErr: %d\n",
pp->sndpkt,pp->snderr,pp->rcvpkt,pp->rcverr,pp->csumerr);
return;
}
static void
pppstat(sp)
struct slip *sp;
{
register struct pppctl *pp;
register struct slcompress *scp;
pp = sp->pppio;
scp = sp->slcomp;
tprintf("\tOverall PPP state: %s",
PPPStatus[pp->state]);
if (pp->state == PPP_OPEN) {
tprintf(" (open for %s)\n",uptime(pp->upsince,time(0L)));
} else {
tprintf("\n");
}
tprintf("\t SndIP: %ld SndLCP: %d SndPAP: %d SndIPCP: %d\n",
pp->sndip,pp->sndlcp,pp->sndpap,pp->sndipcp);
if (sp->escaped & PPP_XMT_VJCOMPR) {
tprintf("\t (IP) NotTCP: %ld AsIsTCP: %ld CmpTCP: %ld UncmpTCP: %ld\n",
scp->sls_nontcp,scp->sls_asistcp,scp->sls_compressed,scp->sls_uncompressed);
}
tprintf("\t RcvIP: %ld RcvLCP: %d RcvPAP: %d RcvIPCP: %d RcvUnknown: %d\n",
pp->rcvip,pp->rcvlcp,pp->rcvpap,pp->rcvipcp,pp->rcvunk);
if (sp->escaped & PPP_RCV_VJCOMPR) {
tprintf("\t (IP) NotTCP: %ld AsIsTCP: %ld CmpTCP: %ld UncmpTCP: %ld\n",
scp->sls_nontcpin,scp->sls_tcpin,scp->sls_compressedin,scp->sls_uncompressedin);
tprintf("\t Unknown: %ld CmpError: %ld\n",
scp->sls_errorin,scp->sls_tossed);
}
return;
}
static void
lcpstat(lcpiop)
struct lcpctl *lcpiop;
{
struct lcpparm *localp, *remotep;
localp = &(lcpiop->lclparm);
remotep = &(lcpiop->remparm);
tprintf("\tLCP state: %s\n",LCPStatus[lcpiop->lcp_state]);
tprintf("\t\t\t\tLocal options\tRemote options\n");
tprintf("\t MRU:\t\t%d\t\t%d\n",
localp->mru,remotep->mru);
tprintf("\t Ctl Map:\t\t0x%08lx\t0x%08lx\n",
localp->ctl_map,remotep->ctl_map);
tprintf("\t Auth Prot:\t\t%s\t\t%s\n",
((localp->auth_type == PAP_AUTH_TYPE) ? "PAP" : "None"),
((remotep->auth_type == PAP_AUTH_TYPE) ? "PAP" : "None"));
tprintf("\t Protocol Compr:\t%s\t\t%s\n",
(localp->prot_compress ? "ON" : "OFF"),
(remotep->prot_compress ? "ON" : "OFF"));
tprintf("\t Addr/Ctl Compr:\t%s\t\t%s\n",
(localp->ac_compress ? "ON" : "OFF"),
(remotep->ac_compress ? "ON" : "OFF"));
}
static void
ipcpstat(ipcpiop)
struct ipcpctl *ipcpiop;
{
tprintf("\tIPCP state: %s\n",LCPStatus[ipcpiop->ipcp_state]);
tprintf("\t IPCP local IP address:\t%s\n",
inet_ntoa(ipcpiop->attempt_src));
tprintf("\t IPCP remote IP address:\t%s\n",
inet_ntoa(ipcpiop->attempt_dest));
if (ipcpiop->lcl_ip_compr == IPCP_VJCOMPR)
tprintf("\t Rcv: Van Jacobson TCP header compression enabled\n");
else
tprintf("\t Rcv: IP compression disabled\n");
if (ipcpiop->rem_ip_compr == IPCP_VJCOMPR)
tprintf("\t Snd: Van Jacobson TCP header compression enabled\n");
else
tprintf("\t Snd: IP compression disabled\n");
return;
}
/****************************************************************************/
static void
dumppool()
{
struct iface *ifp;
struct pppctl *pppiop;
struct ipcppool *poolp;
tprintf("Interface Pool Base/Count\tNext Address\n");
for (ifp=Ifaces; ifp != NULLIF; ifp = ifp->next) {
if ((Slip[ifp->xdev].iface == ifp) &&
(Slip[ifp->xdev].type == CL_PPP)) {
pppiop = Slip[ifp->xdev].pppio;
poolp = pppiop->ipcpio.peer_pool;
if (poolp == NULLPOOL)
continue;
tprintf("%-11s%19s/%-2d",
ifp->name,inet_ntoa(poolp->peer_min),
(poolp->peer_max - poolp->peer_min + 1));
tprintf("\t%s\n",inet_ntoa(poolp->peer_next));
}
}
return;
}
static struct iface *
ppplookup(ifname)
char *ifname;
{
struct iface *ifp;
for (ifp=Ifaces;ifp != NULLIF;ifp = ifp->next) {
if (!strcmp(ifname,ifp->name))
break;
}
if (ifp == NULLIF) {
tprintf("Interface %s unknown\n",ifname);
return(NULLIF);
} else if (ifp->type != CL_PPP) {
tprintf("Interface %s not a PPP interface\n",ifp->name);
return(NULLIF);
} else {
return(ifp);
}
}
/* Break a time differential, measured in seconds, into weeks, days */
/* hours, minutes, and seconds. Store ASCII description in static buffer */
#define SECS_MIN 60L
#define SECS_HR 3600L
#define SECS_DAY 86400L
#define SECS_WEEK 604800L
static char utbuf[128];
static char *
uptime(first, second)
long first;
long second;
{
int found = 0;
long diff;
long part;
utbuf[0] = '\0';
diff = second - first;
if ((diff > SECS_DAY)||(found)) {
part = diff / SECS_DAY;
sprintf(&(utbuf[strlen(utbuf)]),
"%ld day%s ",part,((part==1)?",":"s,"));
diff -= (part * SECS_DAY);
found = 100;
}
if ((diff > SECS_HR)||(found)) {
part = diff / SECS_HR;
sprintf(&(utbuf[strlen(utbuf)]),
"%ld hr%s ",part,((part==1)?",":"s,"));
diff -= (part * SECS_HR);
++found;
}
if ((diff > SECS_MIN)||(found)) {
part = diff / SECS_MIN;
sprintf(&(utbuf[strlen(utbuf)]),"%ld mi%s",part,
((found < 100)?"n, ":"n"));
diff -= (part * SECS_MIN);
}
if (found < 100)
sprintf(&(utbuf[strlen(utbuf)]),"%ld sec",diff);
return(utbuf);
}