struct mbuf *reply_bp;
	int result;
	char *message;
	int mess_length;
	char *username = NULL;
	int userlen;
	char *password = NULL;
	int passwordlen;

	PPP_DEBUG_ROUTINES("pap_request()");

	/* Extract userID/password sent by remote host */
	if ( (userlen = pullchar(data)) != -1 ) {
		register int i;
		register char *cp;

		cp = username = mallocw(userlen+1);
		for ( i = userlen; i-- > 0; ) {
			*cp++ = PULLCHAR(data);
		}
		*cp = '\0';
	}

#ifdef PPP_DEBUG_OPTIONS
	if (PPPtrace & PPP_DEBUG_OPTIONS)
		trace_log(PPPiface,"    checking user: %s", username);
#endif

	if ( (passwordlen = pullchar(data)) != -1 ) {
		register int i;
		register char *cp;

		cp = password = mallocw(passwordlen+1);
		for ( i = passwordlen; i-- > 0; ) {
			*cp++ = PULLCHAR(data);
		}
		*cp = '\0';
	}

#ifdef PPP_DEBUG_OPTIONS
	if (PPPtrace & PPP_DEBUG_OPTIONS)
		trace_log(PPPiface,"    checking password: %s", password);
#endif

	if (pap_verify(username,password) == 0) {
		free( fsm_p->ppp_p->peername );
		fsm_p->ppp_p->peername = strdup(username);
		result = CONFIG_ACK;
		message = " Welcome";
	} else {
		result = CONFIG_NAK;
		message = " Invalid username or password";
	}

	/* the space at the beginning of the message is crucial */
	/* it is replaced with the length of the message */
	mess_length = strlen(message);
	reply_bp = qdata(message,mess_length);
	reply_bp->data[0] = (char)(mess_length - 1);

	fsm_send(fsm_p, result, hdr->id, &reply_bp);

	if (result == CONFIG_NAK) {
		if ( fsm_p->retry_nak > 0 ) {
			fsm_p->retry_nak--;
		} else {
			pap_shutdown(fsm_p);
		}
	}
	free_p(data);
	free(username);
	free(password);
	return (result != CONFIG_ACK);
}


/* Check acknowledgement from remote host */
static int
pap_check(
struct fsm_s *fsm_p,
struct config_hdr *hdr,
struct mbuf **data
){
	struct pap_s *pap_p = fsm_p->pdv;
	char *message;
	int mess_length;
	int full_length;
	int len;

	PPP_DEBUG_ROUTINES("pap_check()");

	/* ID field must match last request we sent */
	if (hdr->id != fsm_p->lastid) {
		PPP_DEBUG_CHECKS("PAP: wrong ID");
		printf ("id mismatch hdrid=%d, lastid=%d\n",
			hdr->id, fsm_p->lastid);
		free_p(data);
		return -1;
	}

	/* Log ASCII message from remote host, if any */
	if ( (mess_length = pullchar(data)) != -1 ) {
		message = mallocw( mess_length+1 );
		full_length = len_p(*data);
		len = pullup(data, message, mess_length);
		message[len] = '\0';

		free( pap_p->message );
		pap_p->message = message;

		if (PPPtrace) {
			trace_log(PPPiface,"%s PPP/PAP %s %s: %s",
				fsm_p->ppp_p->iface->name,
				(len < mess_length) ? "Short"
				   : (mess_length < full_length) ? "Long"
					: "Valid",
				(hdr->code == CONFIG_ACK) ? "Ack" : "Nak",
				message);
		}
		return (len < mess_length  ||  mess_length < full_length);
	}
	free_p(data);
	PPP_DEBUG_CHECKS( "PAP: missing message count" );
	return -1;
}


/************************************************************************/
/*			E V E N T   P R O C E S S I N G			*/
/************************************************************************/

/* Process incoming packet */
void
pap_proc(
struct fsm_s *fsm_p,
struct mbuf **bpp
){
	struct pap_s *pap_p = fsm_p->pdv;
	struct config_hdr hdr;

	PPPtrace = fsm_p->ppp_p->trace;
	PPPiface = fsm_p->ppp_p->iface;

	if ( ntohcnf(&hdr, bpp) == -1 )
		fsm_log( fsm_p, "short authentication packet" );

	if (PPPtrace > 1)
		trace_log(PPPiface, "%s PPP/%s Recv,"
			"  option: %s, id: %d, len: %d",
			fsm_p->ppp_p->iface->name,
			fsm_p->pdc->name,
			fsmCodes[hdr.code],
			hdr.id,	hdr.len);

	hdr.len -= CONFIG_HDR_LEN;		/* Length includes envelope */
	trim_mbuf(bpp, hdr.len);		/* Trim off padding */

	switch(hdr.code) {
	case CONFIG_REQ:
		if ( pap_request(fsm_p, &hdr, bpp) == 0) {
			pap_opening(fsm_p, PPP_AP_LOCAL);
		}
		break;

	case CONFIG_ACK:
		if (pap_check(fsm_p, &hdr, bpp) == 0) {
			alert ( pap_p->pp, -1 );
			pap_opening(fsm_p, PPP_AP_REMOTE);
		}
		break;

	case CONFIG_NAK:
		if (pap_check(fsm_p, &hdr, bpp) == 0) {
			stop_timer(&(fsm_p->timer));

			/* Must have sent a bad username or password */
			free ( pap_p->username );
			pap_p->username = NULL;
			free ( pap_p->password );
			pap_p->password = NULL;

			ksignal ( pap_p, 1 );
		}
		break;

	default:
		if (PPPtrace)
			trace_log(PPPiface, "%s PPP/Pap Unknown packet type: %d;"
				" dropping packet",
				fsm_p->ppp_p->iface->name,
				hdr.code);
		free_p(bpp);
		break;
	}
}


/* Timeout while waiting for reply from remote host */
static void
pap_timeout(vp)
void *vp;
{
	struct fsm_s *fsm_p = (struct fsm_s *)vp;
	struct pap_s *pap_p = fsm_p->pdv;

	PPPtrace = fsm_p->ppp_p->trace;
	PPPiface = fsm_p->ppp_p->iface;

	fsm_log( fsm_p, "Timeout" );

	if (fsm_p->retry > 0) {
		free ( pap_p->message );
		pap_p->message = strdup("Request timeout");
		ksignal ( pap_p, 1 );
	} else {
		free ( pap_p->message );
		pap_p->message = strdup("Request retry exceeded");
		ksignal ( pap_p, 1 );
		kwait ( NULL );
		fsm_log(fsm_p, "Request retry exceeded");
		pap_shutdown(fsm_p);
	}
}


/************************************************************************/
/*			I N I T I A L I Z A T I O N			*/
/************************************************************************/

void
pap_down(fsm_p)
struct fsm_s *fsm_p;
{
	struct pap_s *pap_p = fsm_p->pdv;

	if ( pap_p == NULL )
		return;

	PPPtrace = fsm_p->ppp_p->trace;
	PPPiface = fsm_p->ppp_p->iface;

	fsm_log(fsm_p, "Down");

	fsm_p->flags = FALSE;

	switch ( fsm_p->state ) {
	case fsmREQ_Sent:
		stop_timer(&(fsm_p->timer));
		alert ( pap_p->pp, EABORT );
		/* fallthru */
	case fsmOPENED:
	case fsmLISTEN:
	case fsmTERM_Sent:
		fsm_p->state = fsmCLOSED;
		break;

	case fsmCLOSED:
		/* Already closed; nothing to do */
		break;
	};
}


static void
pap_free(fsm_p)
struct fsm_s *fsm_p;
{
	struct pap_s *pap_p = fsm_p->pdv;

	free( pap_p->username );
	free( pap_p->password );
	free( pap_p->message );
}


/* Initialize configuration structure */
void
pap_init(ppp_p)
struct ppp_s *ppp_p;
{
	struct fsm_s *fsm_p = &(ppp_p->fsm[Pap]);
	struct timer *t;

	PPPtrace = ppp_p->trace;
	PPPiface = ppp_p->iface;

	PPP_DEBUG_ROUTINES("pap_init()");

	if (fsm_p->pdv != NULL)
		return;		/* already initialized */

	fsm_p->ppp_p = ppp_p;
	fsm_p->pdc = &pap_constants;
	fsm_p->pdv = callocw(1,sizeof(struct pap_s));

	fsm_p->try_req = fsm_p->pdc->try_req;
	fsm_p->try_nak = fsm_p->pdc->try_nak;
	fsm_p->try_terminate = fsm_p->pdc->try_terminate;

	fsm_p->state = fsmCLOSED;
	fsm_p->retry = fsm_p->try_req;
	fsm_p->retry_nak = fsm_p->try_nak;

	/* Initialize timer */
	t = &(fsm_p->timer);
	t->func = (void (*)())pap_timeout;
	t->arg = (void *)fsm_p;
	set_timer(t, fsm_p->pdc->timeout);
	fsm_timer(fsm_p);
	stop_timer(t);
}


/* Initialize state machine for local */
int
pap_local(ppp_p)
struct ppp_s *ppp_p;
{
	struct fsm_s *fsm_p = &(ppp_p->fsm[Pap]);

	PPPtrace = ppp_p->trace;

	PPP_DEBUG_ROUTINES("pap_local()");

	fsm_p->state = fsmLISTEN;
	fsm_p->flags |= PPP_AP_LOCAL;
	ppp_p->flags |= PPP_AP_LOCAL;
	fsm_p->retry = fsm_p->try_req;
	return 0;
}


/* Initialize state machine for remote */
int
pap_remote(ppp_p)
struct ppp_s *ppp_p;
{
	struct fsm_s *fsm_p = &(ppp_p->fsm[Pap]);
	struct pap_s *pap_p = fsm_p->pdv;
	char *ifn;

	PPPtrace = ppp_p->trace;

	PPP_DEBUG_ROUTINES("pap_remote()");

	fsm_p->state = fsmREQ_Sent;
	fsm_p->flags |= PPP_AP_REMOTE;
	ppp_p->flags |= PPP_AP_REMOTE;

	/* build a process/session to monitor user/password progress */
	ifn = if_name( ppp_p->iface, " PAP" );
	pap_p->pp = newproc( ifn,
		512, pap_monitor, 0, ppp_p->iface, fsm_p, 0);
	free( ifn );

	return 0;
}