ppppapcomponent.c

这是全套的PPP协议的源码

/* pppPapComponent.c - Password Authentication Protocol */

/* Copyright 1999 Wind River Systems, Inc. */
#include "copyright_wrs.h"

/*
modification history
--------------------
01v,12dec02,ijm merged fix for SPR# 76442, check password lengths
01u,05nov02,ijm use printf instead of logMsg
01t,28may02,rvr fixed build warnings
01s,23feb02,jr  setting the pointers to NULL after freeing
01r,19feb02,ak	input parameter validations in AUTH_INFO_INTERFACE functions
01q,12feb02,ijm corrected PPP_DEBUG message in pap_packet_received
01p,15jan02,ijm in pap_packet_received drop packet if unknown code 
01o,14nov01,ijm removed AUTH_INFO does not exist error message
01n,08nov01,ijm trim excess bytes from received packet,SPR#64334
01m,20jun01,ak  AUTH_INFO_INTERFACE
01l,28feb01,ijm release interfaces when stack is deleted (SPR# 63868)
01k,15dec00,sj  in sendAuthRequestRetry check if current retries >= max
                 retries
01j,29sep00,sj  merging with TOR2_0-WINDNET_PPP-CUM_PATCH_2
01i,10aug00,adb  fixed NAK packet assembly
01h,17apr00,sj  get mBufs from framework netpool
01g,20mar00,sj  free received ack and nak packets
01f,16mar00,sj  cancel timer on nak_received
01e,08mar00,cn  set protocol in network byte order in ACK and NAK messages;
             	fixed "padding" error in ACK and NAK messages
01d,07mar00,cn  changed auth-request id for retry packets.
01c,06mar00,cn  ignore auth-request, ack and nack for PAP client-only peers.
01b,16nov99,sj  state machine+retry fixes
01a,23oct99,sgv  created from routerware source
*/

/*
DESCRIPTION
This component implements Password Authentication Protocol specified in RFC 1334
*/

#include "vxWorks.h"
#include "logLib.h"
#include "tickLib.h"
#include "errnoLib.h"
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "ctype.h"
#include "memLib.h"
#include "netBufLib.h"
#include "sockLib.h"
#include "pfw/pfw.h"
#include "pfw/pfwStack.h"
#include "pfw/pfwProfile.h"
#include "pfw/pfwComponent.h"
#include "pfw/pfwLayer.h"
#include "pfw/pfwEvent.h"
#include "pfw/pfwTimer.h"
#include "pfw/pfwInterface.h"
#include "pfw/pfwMemory.h"
#include "ppp/kstart.h"
#include "ppp/kppp.h"
#include "private/ppp/vpppstr.h"
#include "private/ppp/vlcpstr.h"
#include "private/ppp/vpppastr.h"
#include "private/ppp/pppoptn.h"
#include "ppp/interfaces/pppControlLayerInterface.h"
#include "ppp/interfaces/pppControlProtocolInterface.h"
#include "ppp/interfaces/lcpInterfaces.h"
#include "ppp/pppPapComponent.h"
#include "ppp/interfaces/authInfoInterface.h" /* WindNet Multilink */

/* defines */

#define PAP_DEFAULT_MAX_AUTH_REQUEST_RETRIES 8
#define PAP_DEFAULT_AUTH_REQUEST_TIMEOUT 5

/* typedefs */

typedef struct pppPapComponent
    {
    PFW_COMPONENT_OBJ component;
    CONTROL_PROTOCOL_INTERFACE papControlInterface;
	AUTH_INFO_INTERFACE authMpInterface; /* WindNet Multilink */
    } PPP_PAP_COMPONENT;

typedef struct papProfileData
    {
    char                              	localUserName[NAME_SIZE];
    USHORT                              maxAuthRequestRetries;
    ULONG                       	authRequestInterval;
    } PAP_PROFILE_DATA;

typedef struct papStackData
    {
    PFW_PLUGIN_OBJ_CALLBACKS           *callbacks;
    PPP_STATE                           clientState;
    PPP_STATE                           serverState;
    PPP_STATE                           state;
    PPP_CONTROL_LAYER_INTERFACE        *controlLayerInterface;
    BOOL                                clientEnabled;
    BOOL                                serverEnabled;
    PFW_TIMER_OBJ                      *authRequestTimer;
    PFW_INTERFACE_STATE_PAIR            lcpNegotiatedAuthProtocols;
    char                                remoteUserName[NAME_SIZE];
    char                                remoteUserPassword[NAME_SIZE];
    USHORT                              currentAuthRequestRetries;
    ULONG                               number_of_authentication_requests;
    M_BLK_ID                            lastSentAuthRequestPacket;
    USHORT 			        lastSendAuthRequestPacketId;
    BYTE                                lastReceivedAuthRequestPacketId;
    BYTE                                id_sequence_number;
    } PAP_STACK_DATA;

LOCAL STATUS papSend (PFW_PLUGIN_OBJ_STATE *state, M_BLK_ID * packet);
LOCAL STATUS papReceive (PFW_PLUGIN_OBJ_STATE *state, M_BLK_ID * packet);
LOCAL void pap_packet_received (PFW_PLUGIN_OBJ_STATE * state, M_BLK_ID packet);
LOCAL void pap_authentication_request_received (PFW_PLUGIN_OBJ_STATE * state,
                                                M_BLK_ID packet);
LOCAL void pap_authentication_ack_received (PFW_PLUGIN_OBJ_STATE * state);
LOCAL void pap_authentication_nak_received (PFW_PLUGIN_OBJ_STATE * state);
LOCAL void send_pap_authentication_request (PFW_PLUGIN_OBJ_STATE * state);
LOCAL void send_pap_authentication_ack (PFW_PLUGIN_OBJ_STATE * state,
                                  BYTE id_from_request_packet);
LOCAL void send_pap_authentication_nak (PFW_PLUGIN_OBJ_STATE * state, 
                                  BYTE id_from_request_packet);
LOCAL STATUS profileDataConstruct (PFW_OBJ *pfw, void *profileData);
LOCAL STATUS stackAdd (PFW_PLUGIN_OBJ_STATE *state, 
	               PFW_PLUGIN_OBJ_CALLBACKS * callbacks);
LOCAL STATUS stackDataConstruct (PFW_OBJ *pfw, void * stackData,
    				 void * profileData);
LOCAL STATUS stackDelete (PFW_PLUGIN_OBJ_STATE *state);
LOCAL PPP_STATE pap_pppStateGet (PFW_PLUGIN_OBJ_STATE * state);
LOCAL PPP_CONTROL_PHASE pap_pppPhaseGet ();

LOCAL STATUS interfaceBind ( PFW_PLUGIN_OBJ *pluginObj);

/* parameter handlers */
LOCAL STATUS pap_localUserName (PFW_OBJ *,PFW_PARAMETER_OPERATION_TYPE, 
					    void * profileData, char * value);
LOCAL STATUS pap_maxAuthRequestRetries (PFW_OBJ *,PFW_PARAMETER_OPERATION_TYPE, 
					    void * profileData, char * value);
LOCAL STATUS pap_authRequestInterval (PFW_OBJ *,PFW_PARAMETER_OPERATION_TYPE,
					     void * profileData, char * value);

LOCAL STATUS sendAuthRequestRetry ( PFW_PLUGIN_OBJ_STATE *, int arg);

LOCAL void pap_initialize_restart_counter (PFW_PLUGIN_OBJ_STATE *pluginState);
LOCAL void papStateMachine (PFW_PLUGIN_OBJ_STATE *, PPP_EVENT, M_BLK_ID);
LOCAL M_BLK_ID papDupPkt ( M_BLK_ID pPacket);
LOCAL void authVerifyCallback (PFW_PLUGIN_OBJ_STATE *, BYTE id,
							TEST passOrFail);

/* WindNet Multilink */
void papLocalUserNameGet (PFW_PLUGIN_OBJ_STATE *, char *);
void papRemoteUserNameGet (PFW_PLUGIN_OBJ_STATE *, char *);
void papLocalUserNameSet (PFW_PLUGIN_OBJ_STATE *, char *);
/* WindNet Multilink */

/*******************************************************************************
* pppPapComponentCreate - initialize and add PAP component to the framework
*
* This Component implements PAP specified in RFC 1334
*/
STATUS pppPapComponentCreate
   (
   PFW_OBJ *pfw	/* framework */
   )
   {
   PPP_PAP_COMPONENT *papComponent;
   PFW_PLUGIN_OBJ *papPluginObj;

   papComponent = (PPP_PAP_COMPONENT *) pfwMalloc (pfw,
                                        sizeof (PPP_PAP_COMPONENT));

   if (papComponent == NULL)
       {
       printf ("pppPapInit - Unable to allocate memory of size %d byte s\n",
                (int)sizeof (PPP_PAP_COMPONENT));
       return (ERROR);
       }

   bzero((void *)papComponent,sizeof(PPP_PAP_COMPONENT));

   papPluginObj = (PFW_PLUGIN_OBJ *)&(papComponent->component);
  
   strcpy (papPluginObj->name, "PPP_PAP");
   papPluginObj->pfwObj = pfw;
   papComponent->component.layerObj = pfwLayerObjGet (pfw, "CONTROL_LAYER");
   papComponent->component.protocol = 0xC023;

   papPluginObj->profileDataSize = sizeof (PAP_PROFILE_DATA);
   papPluginObj->stackDataSize = sizeof (PAP_STACK_DATA);
   papPluginObj->profileDataConstruct = profileDataConstruct;
   papPluginObj->profileDataCopy = NULL;
   papPluginObj->profileDataDestruct = NULL;
   papPluginObj->interfaceBind = interfaceBind;
   papPluginObj->receive = papReceive;
   papPluginObj->send = papSend;
   papPluginObj->stackAdd = stackAdd;
   papPluginObj->stackDelete = stackDelete;
   papPluginObj->stackDataShow = NULL;
   papPluginObj->stackDataConstruct = stackDataConstruct;
   papPluginObj->stackDataDestruct = NULL;

   if (pfwComponentAdd (&papComponent->component) == ERROR)
        {
        printf ("pppPapInit - PAP could not be added to the framework\n");
        return (ERROR);
        }
   
   pfwParameterAdd (papPluginObj, "pap_localUserName", pap_localUserName);
   pfwParameterAdd (papPluginObj, "pap_maxAuthRequestRetries", 
		    pap_maxAuthRequestRetries);
   pfwParameterAdd (papPluginObj, "pap_authRequestInterval", 
		    pap_authRequestInterval);

   return (OK);
   }

/*******************************************************************************
* pppPapComponentDelete - delete PAP component from the framework
*
* The PAP plug-in component object allocated by pppPapComponentCreate() is 
* freed if there are no references to this object from a 
* Stack or Profile object in the framework.
*
* RETURNS: OK or ERROR
*/
STATUS pppPapComponentDelete
   (
   PFW_OBJ *pfw 	/* framework */
   )
   {
    PFW_COMPONENT_OBJ *pComponent;

    pComponent = pfwComponentObjGetByName(pfw,"PPP_PAP");

    if (pComponent == NULL)
	return ERROR;

    if (pfwComponentDelete(pComponent) == OK)
	{
        pfwFree(pComponent);
        pComponent = NULL;
	return OK;
	}
   return ERROR;
   }
/*******************************************************************************
*
* interfaceBind -
*/
LOCAL STATUS interfaceBind
    (
    PFW_PLUGIN_OBJ *pluginObj
    )
    {
    CONTROL_PROTOCOL_INTERFACE * papControlInterface;
    PPP_PAP_COMPONENT *papComponent = (PPP_PAP_COMPONENT *)pluginObj;
	AUTH_INFO_INTERFACE			*pAuthMpInterface; /* WindNet Multilink */
    unsigned int i;

   /* get CONTROL_PROTOCOL_INTERFACE ID and bind to it */

    if ((i = pfwInterfaceIdGet(pluginObj->pfwObj, "CONTROL_PROTOCOL_INTERFACE"))
	> 0)
        {
        papControlInterface = &papComponent->papControlInterface;

        papControlInterface->interfaceObj.id = i;
        papControlInterface->interfaceObj.pluginObj = pluginObj;
        papControlInterface->pppPhaseGet = pap_pppPhaseGet;
        papControlInterface->pppStateGet = pap_pppStateGet;
        papControlInterface->executeStateMachine = papStateMachine;

        pfwInterfaceBind (&papControlInterface->interfaceObj);
        }
   else 
       {
       pfwPrintError (__FILE__, "interfaceBind", __LINE__, pluginObj->pfwObj,
		      NULL,"CONTROL_PROTOCOL_INTERFACE does not exist");
       return (ERROR);
       }

/* WindNet Multilink */

	pAuthMpInterface = &papComponent->authMpInterface; 

    if ((i = pfwInterfaceIdGet(pluginObj->pfwObj,
					    "AUTH_INFO_INTERFACE")) > 0) 
        {
        pAuthMpInterface->interfaceObj.id = i;
        pAuthMpInterface->interfaceObj.pluginObj = pluginObj;
        pAuthMpInterface->localUserNameGet = papLocalUserNameGet;
        pAuthMpInterface->remoteUserNameGet = papRemoteUserNameGet;
        pAuthMpInterface->localUserNameSet = papLocalUserNameSet;

        pfwInterfaceBind (&pAuthMpInterface->interfaceObj);
        }

/* WindNet Multilink */

   return (OK);
   }


/*******************************************************************************
*
* papSend -
*/
LOCAL STATUS papSend
   (
   PFW_PLUGIN_OBJ_STATE *state,
   M_BLK_ID * packet
   )
   {
   return (OK);
   }

/*******************************************************************************
*
* papReceive -
*/
LOCAL STATUS papReceive
    (
    PFW_PLUGIN_OBJ_STATE *state,
    M_BLK_ID * packet
    )
    {
    if (packet == NULL || (*packet) == NULL)
	return ERROR;

    pap_packet_received (state, *packet);
    return (OK);
    }

/*******************************************************************************
*
* stackAdd -
*/
LOCAL STATUS stackAdd
    (
    PFW_PLUGIN_OBJ_STATE *state,
    PFW_PLUGIN_OBJ_CALLBACKS * callbacks
    )
    {
    int id;
    PAP_PROFILE_DATA *pPapProfileData;
    PAP_STACK_DATA *stackData;
    PFW_LAYER_OBJ * layerObj =
                    ((PFW_COMPONENT_OBJ *)state->pluginObj)->layerObj;
    pPapProfileData = (PAP_PROFILE_DATA *)state->profileData;

    stackData = (PAP_STACK_DATA *)state->stackData;

    stackData->callbacks = callbacks;

    if ((stackData->authRequestTimer = pfwTimerCreate(state)) == NULL)
        return ERROR;

    if ((id = pfwInterfaceIdGet(state->pluginObj->pfwObj,
                                "PPP_CONTROL_LAYER_INTERFACE")) > 0)
        {
        stackData->controlLayerInterface =
                    (PPP_CONTROL_LAYER_INTERFACE *)
                    pfwInterfaceObjGetViaPluginObj (&layerObj->pluginObj,id);
        }

    if ((id = pfwInterfaceIdGet(state->pluginObj->pfwObj,
                                "LCP_NEGOTIATED_AUTH_PROTOCOL_INTERFACE")) > 0)
        {
        if (pfwInterfaceObjAndStateGetViaStackObj(state->stackObj,
                            id, &stackData->lcpNegotiatedAuthProtocols) != OK)
            return ERROR;
        }

    if (stackData->callbacks && stackData->callbacks->stackAddComplete)
        (*stackData->callbacks->stackAddComplete)
                                                 (stackData->callbacks, state);
    else
        return ERROR;

    return (OK);
    }

/*******************************************************************************
*
* stackDelete -
*/
LOCAL STATUS stackDelete
    (
    PFW_PLUGIN_OBJ_STATE *state
    )
    {
    PAP_STACK_DATA *stackData;
    stackData = (PAP_STACK_DATA *)state->stackData;

    pfwTimerDelete (stackData->authRequestTimer);

    pfwInterfaceReferenceDelete(
		    stackData->lcpNegotiatedAuthProtocols.interfaceObj);

    pfwInterfaceReferenceDelete(
        (PFW_INTERFACE_OBJ *) stackData->controlLayerInterface);

    if (stackData->callbacks && stackData->callbacks->stackDeleteComplete)
        (*stackData->callbacks->stackDeleteComplete) (stackData->callbacks, 
                                                       state);
    else
        return ERROR;

    return (OK);
    }

/*******************************************************************************
*
* stackDataConstruct -
*/
LOCAL STATUS stackDataConstruct
    (
    PFW_OBJ *pfw,
    void * stackData,
    void * profileData
    )
    {
    PAP_STACK_DATA * pStackData = (PAP_STACK_DATA *) stackData;

    bzero(stackData, sizeof(PAP_STACK_DATA));

    pStackData->clientState = PPP_INITIAL_STATE;
    pStackData->serverState = PPP_INITIAL_STATE;
    pStackData->state = PPP_INITIAL_STATE;

    pStackData->id_sequence_number = (tickGet() & 0xff);

    return (OK);
    }

/*******************************************************************************
*
* profileDataConstruct -
*/
LOCAL STATUS profileDataConstruct
    (
    PFW_OBJ *pfw,
    void *profileData
    )
    {
    PAP_PROFILE_DATA *papProfileData;

    papProfileData = (PAP_PROFILE_DATA *)profileData;
    papProfileData->localUserName[0] = '\0';
    papProfileData->authRequestInterval = PAP_DEFAULT_AUTH_REQUEST_TIMEOUT;
    papProfileData->maxAuthRequestRetries = 
					   PAP_DEFAULT_MAX_AUTH_REQUEST_RETRIES;

    return (OK);
    }

/*******************************************************************************
* sendAuthRequestRetry -
*
*/
LOCAL STATUS sendAuthRequestRetry
    (
    PFW_PLUGIN_OBJ_STATE *pluginObjState,
    int retry
    )
    {
    PAP_STACK_DATA * stackData = pluginObjState->stackData;
    PAP_PROFILE_DATA * profileData = pluginObjState->profileData;
    AUTHENTICATION_REQUEST_PACKET *sptr_authentication_request_packet;
    M_BLK_ID packet;
    M_BLK_ID dupPkt;
 
    if (retry > 0)
	{
	if (++stackData->currentAuthRequestRetries >= 
					profileData->maxAuthRequestRetries)
	    {
	    pfwTimerCancel(stackData->authRequestTimer); 

	    if (stackData->lastSentAuthRequestPacket != NULL)
		{
		netMblkClChainFree(stackData->lastSentAuthRequestPacket);
		stackData->lastSentAuthRequestPacket = NULL;