?? ppplcp.c
字號:
/*
* PPPLCP.C -- negotiate data link options
*
* This implementation of PPP is declared to be in the public domain.
* Acknowledgements and correction history may be found in PPP.C
*/
#include <stdio.h>
#include "global.h"
#include "mbuf.h"
#include "iface.h"
#include "socket.h"
#include "ppp.h"
#include "pppfsm.h"
#include "ppplcp.h"
#include "ppppap.h"
#include "cmdparse.h"
#include "devparam.h"
#include "trace.h"
/* These defaults are defined in the PPP RFCs, and must not be changed */
static struct lcp_value_s lcp_default = {
FALSE, /* no need to negotiate defaults */
LCP_MRU_DEFAULT,
LCP_ACCM_DEFAULT,
0, /* no authentication */
0, /* no encryption */
0L, /* no magic number */
0L, /* no reporting period */
};
/* for test purposes, accept anything we understand in the NAK */
static uint16 lcp_negotiate = LCP_N_MRU | LCP_N_ACCM | LCP_N_AUTHENT
| LCP_N_PFC | LCP_N_ACFC | LCP_N_MAGIC;
static byte_t option_length[] = {
0, /* unused */
4, /* MRU */
6, /* ACCM */
4, /* authentication */
4, /* encryption */
6, /* magic number */
6, /* monitor reporting period */
2, /* Protocol compression */
2 /* Address/Control compression */
};
static int dolcp_local(int argc, char *argv[], void *p);
static int dolcp_open(int argc, char *argv[], void *p);
static int dolcp_remote(int argc, char *argv[], void *p);
static int dolcp_accm(int argc, char *argv[], void *p);
static int dolcp_acfc(int argc, char *argv[], void *p);
static int dolcp_auth(int argc, char *argv[], void *p);
static int dolcp_magic(int argc, char *argv[], void *p);
static int dolcp_mru(int argc, char *argv[], void *p);
static int dolcp_pfc(int argc, char *argv[], void *p);
static int dolcp_default(int argc, char *argv[], void *p);
static void lcp_option(struct mbuf **bpp,
struct lcp_value_s *value_p,
byte_t o_type,
byte_t o_length,
struct mbuf **copy_bpp );
static void lcp_makeoptions(struct mbuf **bpp,
struct lcp_value_s *value_p,
uint16 negotiating);
static struct mbuf *lcp_makereq(struct fsm_s *fsm_p);
static int lcp_check(struct mbuf **bpp,
struct lcp_s *lcp_p,
struct lcp_side_s *side_p,
struct option_hdr *option_p,
int request);
static int lcp_request(struct fsm_s *fsm_p,
struct config_hdr *config,
struct mbuf **data);
static int lcp_ack(struct fsm_s *fsm_p,
struct config_hdr *ackcnf,
struct mbuf **data);
static int lcp_nak(struct fsm_s *fsm_p,
struct config_hdr *nakcnf,
struct mbuf **data);
static int lcp_reject(struct fsm_s *fsm_p,
struct config_hdr *rejcnf,
struct mbuf **data);
static void lcp_reset(struct fsm_s *fsm_p);
static void lcp_starting(struct fsm_s *fsm_p);
static void lcp_stopping(struct fsm_s *fsm_p);
static void lcp_closing(struct fsm_s *fsm_p);
static void lcp_opening(struct fsm_s *fsm_p);
static void lcp_free(struct fsm_s *fsm_p);
static struct fsm_constant_s lcp_constants = {
"Lcp",
PPP_LCP_PROTOCOL,
0x0FFE, /* codes 1-11 recognized */
Lcp,
LCP_REQ_TRY,
LCP_NAK_TRY,
LCP_TERM_TRY,
LCP_TIMEOUT * 1000L,
lcp_free,
lcp_reset,
lcp_starting,
lcp_opening,
lcp_closing,
lcp_stopping,
lcp_makereq,
lcp_request,
lcp_ack,
lcp_nak,
lcp_reject
};
/************************************************************************/
/* "ppp <iface> lcp" subcommands */
static struct cmds Lcpcmds[] = {
"close", doppp_close, 0, 0, NULL,
"listen", doppp_passive, 0, 0, NULL,
"local", dolcp_local, 0, 0, NULL,
"open", dolcp_open, 0, 0, NULL,
"remote", dolcp_remote, 0, 0, NULL,
"timeout", doppp_timeout, 0, 0, NULL,
"try", doppp_try, 0, 0, NULL,
NULL,
};
/* "ppp <iface> lcp [local | remote]" subcommands */
static struct cmds Lcpside_cmds[] = {
"accm", dolcp_accm, 0, 0, NULL,
"acfc", dolcp_acfc, 0, 0, NULL,
"authenticate", dolcp_auth, 0, 0, NULL,
"magic", dolcp_magic, 0, 0, NULL,
"mru", dolcp_mru, 0, 0, NULL,
"pfc", dolcp_pfc, 0, 0, NULL,
"default", dolcp_default, 0, 0, NULL,
NULL,
};
int
doppp_lcp(argc,argv,p)
int argc;
char *argv[];
void *p;
{
register struct iface *ifp = p;
register struct ppp_s *ppp_p = ifp->edv;
return subcmd(Lcpcmds, argc, argv, &(ppp_p->fsm[Lcp]));
}
static int
dolcp_local(argc,argv,p)
int argc;
char *argv[];
void *p;
{
struct fsm_s *fsm_p = p;
struct lcp_s *lcp_p = fsm_p->pdv;
return subcmd(Lcpside_cmds, argc, argv, &(lcp_p->local));
}
static int
dolcp_open(argc,argv,p)
int argc;
char *argv[];
void *p;
{
struct fsm_s *fsm_p = p;
doppp_active( argc, argv, p );
if ( fsm_p->ppp_p->phase >= pppLCP ) {
fsm_start( fsm_p );
}
return 0;
}
static int
dolcp_remote(argc,argv,p)
int argc;
char *argv[];
void *p;
{
struct fsm_s *fsm_p = p;
struct lcp_s *lcp_p = fsm_p->pdv;
return subcmd(Lcpside_cmds, argc, argv, &(lcp_p->remote));
}
/************************************************************************/
static int
dolcp_accm(argc,argv,p)
int argc;
char *argv[];
void *p;
{
struct lcp_side_s *side_p = p;
if (argc < 2) {
printf("0x%08lx\n",side_p->want.accm);
} else if (stricmp(argv[1],"allow") == 0) {
return bit16cmd(&(side_p->will_negotiate),LCP_N_ACCM,
"Allow ACCM", --argc, &argv[1] );
} else {
side_p->want.accm = strtoul(argv[1], NULL, 0);
if ( side_p->want.accm != LCP_ACCM_DEFAULT )
side_p->want.negotiate |= LCP_N_ACCM;
else
side_p->want.negotiate &= ~LCP_N_ACCM;
}
return 0;
}
static int
dolcp_acfc(argc,argv,p)
int argc;
char *argv[];
void *p;
{
struct lcp_side_s *side_p = p;
if (stricmp(argv[1],"allow") == 0) {
return bit16cmd(&(side_p->will_negotiate),LCP_N_ACFC,
"Allow Address/Control Field Compression", --argc, &argv[1] );
}
return bit16cmd( &(side_p->want.negotiate), LCP_N_ACFC,
"Address/Control Field Compression", argc, argv );
}
static int
dolcp_auth(argc,argv,p)
int argc;
char *argv[];
void *p;
{
struct lcp_side_s *side_p = p;
if (argc < 2) {
if ( side_p->want.negotiate & LCP_N_AUTHENT ) {
switch ( side_p->want.authentication ) {
case PPP_PAP_PROTOCOL:
printf("Pap\n");
break;
default:
printf("0x%04x\n", side_p->want.authentication);
break;
};
} else {
printf("None\n");
}
} else if (stricmp(argv[1],"allow") == 0) {
return bit16cmd(&(side_p->will_negotiate),LCP_N_AUTHENT,
"Allow Authentication", --argc, &argv[1] );
} else if (stricmp(argv[1],"pap") == 0) {
side_p->want.negotiate |= LCP_N_AUTHENT;
side_p->want.authentication = PPP_PAP_PROTOCOL;
} else if (stricmp(argv[1],"none") == 0) {
side_p->want.negotiate &= ~LCP_N_AUTHENT;
} else {
printf("allow pap none\n");
return 1;
}
return 0;
}
static int
dolcp_magic(argc,argv,p)
int argc;
char *argv[];
void *p;
{
struct lcp_side_s *side_p = p;
int result = 0;
if (argc < 2) {
printf("%d\n",side_p->want.magic_number);
} else if (stricmp(argv[1],"allow") == 0) {
return bit16cmd(&(side_p->will_negotiate),LCP_N_MAGIC,
"Allow Magic Number", --argc, &argv[1] );
} else {
register int32 x = strtoul(argv[1], NULL, 0);
if ( !x ) {
int test;
/* Check for keyword */
result = setbool( &test, "Magic Number", argc, argv );
if ( test ) {
/* Make a non-zero random number */
x = rdclock() << ((rdclock() & 0xf)+8);
}
}
if ( x ) {
side_p->want.negotiate |= LCP_N_MAGIC;
} else {
side_p->want.negotiate &= ~LCP_N_MAGIC;
}
side_p->want.magic_number = x;
}
return result;
}
static int
dolcp_mru(argc,argv,p)
int argc;
char *argv[];
void *p;
{
struct lcp_side_s *side_p = p;
if (argc < 2) {
printf("%d\n",side_p->want.mru);
} else if (stricmp(argv[1],"allow") == 0) {
return bit16cmd(&(side_p->will_negotiate),LCP_N_MRU,
"Allow MRU", --argc, &argv[1] );
} else {
register int x = (int)strtol( argv[1], NULL, 0 );
if (x < LCP_MRU_LO || x > LCP_MRU_HI) {
printf("MRU %s (%d) out of range %d thru %d\n",
argv[1], x, LCP_MRU_LO, LCP_MRU_HI);
return -1;
} else if ( x != LCP_MRU_DEFAULT ) {
side_p->want.negotiate |= LCP_N_MRU;
} else {
side_p->want.negotiate &= ~LCP_N_MRU;
}
side_p->want.mru = x;
}
return 0;
}
static int
dolcp_pfc(argc,argv,p)
int argc;
char *argv[];
void *p;
{
struct lcp_side_s *side_p = p;
if (stricmp(argv[1],"allow") == 0) {
return bit16cmd(&(side_p->will_negotiate),LCP_N_PFC,
"Allow Protocol Field Compression", --argc, &argv[1] );
}
return bit16cmd( &(side_p->want.negotiate), LCP_N_PFC,
"Protocol Field Compression", argc, argv );
}
static int
dolcp_default(argc,argv,p)
int argc;
char *argv[];
void *p;
{
struct lcp_side_s *side_p = p;
ASSIGN( side_p->want, lcp_default );
return 0;
}
/************************************************************************/
/* E V E N T P R O C E S S I N G */
/************************************************************************/
static void
lcp_option( bpp, value_p, o_type, o_length, copy_bpp )
struct mbuf **bpp;
struct lcp_value_s *value_p;
byte_t o_type;
byte_t o_length;
struct mbuf **copy_bpp;
{
struct mbuf *bp;
register uint8 *cp;
register int toss = o_length - OPTION_HDR_LEN;
if ((bp = alloc_mbuf(o_length)) == NULL) {
return;
}
cp = bp->data;
*cp++ = o_type;
*cp++ = o_length;
switch ( o_type ) {
case LCP_MRU:
put16(cp, value_p->mru);
toss -= 2;
#ifdef PPP_DEBUG_OPTIONS
if (PPPtrace & PPP_DEBUG_OPTIONS)
trace_log(PPPiface, " making MRU: %d", value_p->mru);
#endif
break;
case LCP_ACCM:
put32(cp, value_p->accm);
toss -= 4;
#ifdef PPP_DEBUG_OPTIONS
if (PPPtrace & PPP_DEBUG_OPTIONS)
trace_log(PPPiface, " making ACCM: 0x%08lx", value_p->accm);
#endif
break;
case LCP_AUTHENT:
put16(cp, value_p->authentication);
toss -= 2;
#ifdef PPP_DEBUG_OPTIONS
if (PPPtrace & PPP_DEBUG_OPTIONS)
trace_log(PPPiface, " making Auth Protocol: 0x%04x",
value_p->authentication);
#endif
break;
case LCP_MAGIC:
put32(cp, value_p->magic_number);
toss -= 4;
#ifdef PPP_DEBUG_OPTIONS
if (PPPtrace & PPP_DEBUG_OPTIONS)
trace_log(PPPiface, " making Magic Number: 0x%08lx",
value_p->magic_number);
#endif
break;
case LCP_PFC:
#ifdef PPP_DEBUG_OPTIONS
if (PPPtrace & PPP_DEBUG_OPTIONS)
trace_log(PPPiface, " making Protocol compression");
#endif
break;
case LCP_ACFC:
#ifdef PPP_DEBUG_OPTIONS
if (PPPtrace & PPP_DEBUG_OPTIONS)
trace_log(PPPiface, " making Addr/Ctl compression");
#endif
break;
case LCP_ENCRYPT: /* not implemented */
case LCP_QUALITY: /* not implemented */
default:
#ifdef PPP_DEBUG_OPTIONS
if (PPPtrace & PPP_DEBUG_OPTIONS)
trace_log(PPPiface, " making unimplemented type %d", o_type);
#endif
break;
};
while ( toss-- > 0 ) {
*cp++ = pullchar(copy_bpp);
}
bp->cnt += o_length;
append(bpp, &bp);
}
/************************************************************************/
/* Build a list of options */
static void
lcp_makeoptions(bpp, value_p, negotiating)
struct mbuf **bpp;
struct lcp_value_s *value_p;
uint16 negotiating;
{
register int o_type;
PPP_DEBUG_ROUTINES("lcp_makeoptions()");
for ( o_type = 1; o_type <= LCP_OPTION_LIMIT; o_type++ ) {
if (negotiating & (1 << o_type)) {
lcp_option( bpp, value_p,
o_type, option_length[ o_type ], NULL);
}
}
}
/************************************************************************/
/* Build a request to send to remote host */
static struct mbuf *
lcp_makereq(fsm_p)
struct fsm_s *fsm_p;
{
struct lcp_s *lcp_p = fsm_p->pdv;
struct mbuf *req_bp = NULL;
PPP_DEBUG_ROUTINES("lcp_makereq()");
lcp_makeoptions( &req_bp, &(lcp_p->local.work),
lcp_p->local.work.negotiate );
return(req_bp);
}
/************************************************************************/
/* Check the options, updating the working values.
* Returns -1 if ran out of data, ACK/NAK/REJ as appropriate.
*/
static int
lcp_check( bpp, lcp_p, side_p, option_p, request )
struct mbuf **bpp;
struct lcp_s *lcp_p;
struct lcp_side_s *side_p;
struct option_hdr *option_p;
int request;
{
int toss = option_p->len - OPTION_HDR_LEN;
int option_result = CONFIG_ACK; /* Assume good values */
switch(option_p->type) {
case LCP_MRU:
side_p->work.mru = pull16(bpp);
toss -= 2;
#ifdef PPP_DEBUG_OPTIONS
if (PPPtrace & PPP_DEBUG_OPTIONS)
trace_log(PPPiface, " checking MRU: %d", side_p->work.mru);
#endif
/* Check if new value is appropriate */
if (side_p->work.mru < LCP_MRU_LO) {
side_p->work.mru = LCP_MRU_LO;
option_result = CONFIG_NAK;
} else if (side_p->work.mru > LCP_MRU_HI) {
side_p->work.mru = LCP_MRU_HI;
option_result = CONFIG_NAK;
}
if ( request && (side_p->want.negotiate & LCP_N_MRU)
&& side_p->work.mru > side_p->want.mru ) {
side_p->work.mru = side_p->want.mru;
option_result = side_p->want.mru;
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -