ppplcp.c

MCS51产单片机上实现的tcp/ip,很全的哦,需要的可以参考一下.

/*
 *  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;