netpap.c

基于东南大学开发的SEP3203的ARM7中的所有驱动

/*****************************************************************************

* netpap.c - Network Password Authentication Protocol program file.

*

* portions Copyright (c) 1997 by Global Election Systems Inc.

*

* The authors hereby grant permission to use, copy, modify, distribute,

* and license this software and its documentation for any purpose, provided

* that existing copyright notices are retained in all copies and that this

* notice and the following disclaimer are included verbatim in any 

* distributions. No written agreement, license, or royalty fee is required

* for any of the authorized uses.

*

* THIS SOFTWARE IS PROVIDED BY THE 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 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.

*

******************************************************************************

* REVISION HISTORY

*

* 97-12-12 Guy Lancaster <[e-mail]>, Global Election Systems Inc.

*	Original.

*****************************************************************************/

/*

 * upap.c - User/Password Authentication Protocol.

 *

 * Copyright (c) 1989 Carnegie Mellon University.

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms are permitted

 * provided that the above copyright notice and this paragraph are

 * duplicated in all such forms and that any documentation,

 * advertising materials, and other materials related to such

 * distribution and use acknowledge that the software was developed

 * by Carnegie Mellon University.  The name of the

 * University may not be used to endorse or promote products derived

 * from this software without specific prior written permission.

 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED

 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.

 */



#include <string.h>

#include "netconf.h"

#include "net.h"

#include "nettimer.h"

#include "netbuf.h"

#include "netppp.h"

#include "netauth.h"

#include "netpap.h"



//#include <string.h>

#include <stdio.h>

#include "netdebug.h"





#if PAP_SUPPORT > 0



/***********************************/

/*** LOCAL FUNCTION DECLARATIONS ***/

/***********************************/

/*

 * Protocol entry points.

 */

static void upap_init __P((int));

static void upap_lowerup __P((int));

static void upap_lowerdown __P((int));

static void upap_input __P((int, u_char *, int));

static void upap_protrej __P((int));

static int  upap_printpkt __P((u_char *, int,

			       void (*) __P((void *, char *, ...)), void *));



static void upap_timeout __P((void *));

static void upap_reqtimeout __P((void *));

static void upap_rauthreq __P((upap_state *, u_char *, int, int));

static void upap_rauthack __P((upap_state *, u_char *, int, int));

static void upap_rauthnak __P((upap_state *, u_char *, int, int));

static void upap_sauthreq __P((upap_state *));

static void upap_sresp __P((upap_state *, u_char, u_char, char *, int));









/******************************/

/*** PUBLIC DATA STRUCTURES ***/

/******************************/

struct protent pap_protent = {

    PPP_PAP,

    upap_init,

    upap_input,

    upap_protrej,

    upap_lowerup,

    upap_lowerdown,

    NULL,

    NULL,

    upap_printpkt,

    NULL,

    1,

    "PAP",

    NULL,

    NULL,

    NULL

};



upap_state upap[NUM_PPP];		/* UPAP state; one for each unit */







/***********************************/

/*** PUBLIC FUNCTION DEFINITIONS ***/

/***********************************/

/*

 *  Set the default login name and password for the pap sessions

 */

void upap_setloginpasswd(int unit, const char *luser, const char *lpassword)

{

	upap_state *u = &upap[unit];

	

	/* Save the username and password we're given */

	u->us_user = luser;

	u->us_userlen = strlen(luser);

	u->us_passwd = lpassword;

	u->us_passwdlen = strlen(lpassword);

}





/*

 * upap_authwithpeer - Authenticate us with our peer (start client).

 *

 * Set new state and send authenticate's.

 */

void upap_authwithpeer(int unit, char *user, char *password)

{

	upap_state *u = &upap[unit];

	

	UPAPDEBUG((LOG_INFO, "upap_authwithpeer: %d user=%s password=%s s=%d",

				unit, user, password, u->us_clientstate));

	

	u->us_transmits = 0;

	

	/* Lower layer up yet? */

	if (u->us_clientstate == UPAPCS_INITIAL ||

			u->us_clientstate == UPAPCS_PENDING) {

		u->us_clientstate = UPAPCS_PENDING;

		return;

	}

	

	upap_sauthreq(u);			/* Start protocol */

}





/*

 * upap_authpeer - Authenticate our peer (start server).

 *

 * Set new state.

 */

void upap_authpeer(int unit)

{

	upap_state *u = &upap[unit];

	

	/* Lower layer up yet? */

	if (u->us_serverstate == UPAPSS_INITIAL ||

			u->us_serverstate == UPAPSS_PENDING) {

		u->us_serverstate = UPAPSS_PENDING;

		return;

	}

	

	u->us_serverstate = UPAPSS_LISTEN;

	if (u->us_reqtimeout > 0)

		TIMEOUT(upap_reqtimeout, u, u->us_reqtimeout);

}







/**********************************/

/*** LOCAL FUNCTION DEFINITIONS ***/

/**********************************/

/*

 * upap_init - Initialize a UPAP unit.

 */

static void upap_init(int unit)

{

	upap_state *u = &upap[unit];



	UPAPDEBUG((LOG_INFO, "upap_init: %d", unit));	

	u->us_unit = unit;

	u->us_user = NULL;

	u->us_userlen = 0;

	u->us_passwd = NULL;

	u->us_passwdlen = 0;

	u->us_clientstate = UPAPCS_INITIAL;

	u->us_serverstate = UPAPSS_INITIAL;

	u->us_id = 0;

	u->us_timeouttime = UPAP_DEFTIMEOUT;

	u->us_maxtransmits = 10;

	u->us_reqtimeout = UPAP_DEFREQTIME;

}



/*

 * upap_timeout - Retransmission timer for sending auth-reqs expired.

 */

static void upap_timeout(void *arg)

{

	upap_state *u = (upap_state *) arg;

	

	UPAPDEBUG((LOG_INFO, "upap_timeout: %d timeout %d expired s=%d", 

				u->us_unit, u->us_timeouttime, u->us_clientstate));

	

	if (u->us_clientstate != UPAPCS_AUTHREQ)

		return;

	

	if (u->us_transmits >= u->us_maxtransmits) {

		/* give up in disgust */

		trace(LOG_ERR, "No response to PAP authenticate-requests");

		u->us_clientstate = UPAPCS_BADAUTH;

		auth_withpeer_fail(u->us_unit, PPP_PAP);

		return;

	}

	

	upap_sauthreq(u);		/* Send Authenticate-Request */

}





/*

 * upap_reqtimeout - Give up waiting for the peer to send an auth-req.

 */

static void upap_reqtimeout(void *arg)

{

	upap_state *u = (upap_state *) arg;

	

	if (u->us_serverstate != UPAPSS_LISTEN)

		return;			/* huh?? */

	

	auth_peer_fail(u->us_unit, PPP_PAP);

	u->us_serverstate = UPAPSS_BADAUTH;

}





/*

 * upap_lowerup - The lower layer is up.

 *

 * Start authenticating if pending.

 */

static void upap_lowerup(int unit)

{

	upap_state *u = &upap[unit];

	

	UPAPDEBUG((LOG_INFO, "upap_lowerup: %d s=%d", unit, u->us_clientstate));

	

	if (u->us_clientstate == UPAPCS_INITIAL)

		u->us_clientstate = UPAPCS_CLOSED;

	else if (u->us_clientstate == UPAPCS_PENDING) {

		upap_sauthreq(u);	/* send an auth-request */

	}

	

	if (u->us_serverstate == UPAPSS_INITIAL)

		u->us_serverstate = UPAPSS_CLOSED;

	else if (u->us_serverstate == UPAPSS_PENDING) {

		u->us_serverstate = UPAPSS_LISTEN;

		if (u->us_reqtimeout > 0)

			TIMEOUT(upap_reqtimeout, u, u->us_reqtimeout);

	}

}





/*

 * upap_lowerdown - The lower layer is down.

 *

 * Cancel all timeouts.

 */

static void upap_lowerdown(int unit)

{

	upap_state *u = &upap[unit];

	

	UPAPDEBUG((LOG_INFO, "upap_lowerdown: %d s=%d", unit, u->us_clientstate));

	

	if (u->us_clientstate == UPAPCS_AUTHREQ)	/* Timeout pending? */

		UNTIMEOUT(upap_timeout, u);		/* Cancel timeout */

	if (u->us_serverstate == UPAPSS_LISTEN && u->us_reqtimeout > 0)

		UNTIMEOUT(upap_reqtimeout, u);

	

	u->us_clientstate = UPAPCS_INITIAL;

	u->us_serverstate = UPAPSS_INITIAL;

}





/*

 * upap_protrej - Peer doesn't speak this protocol.

 *

 * This shouldn't happen.  In any case, pretend lower layer went down.

 */

static void upap_protrej(int unit)

{

	upap_state *u = &upap[unit];