ppplcpcomponent.c

这是全套的PPP协议的源码

/* pppLcpComponent.c - Link Control Protocol */

/* Copyright 1999 Wind River Systems, Inc. */

#include "copyright_wrs.h"

/*
modification history
--------------------
02g,07aug03,rp  remove magic_init to avoid symbol conflict
02f,22oct02,ijm changed MP_PROFILE_STRING_SIZE to MAX_VALUE_STRING_LENGTH
02e,09jul02,as  Added the function getLcpOptionName() to get the lcp
                option name from the lcp component structure
02d,28may02,rvr fixed build warnings 
02c,26feb02,jr  Setting the pointer to NULL after freeing
02b,04feb02,vk  Modifications in PFW_PARAMETER_GET part in lcp_optionsHandler()
                to construct the configuration strings from option_list_entry
                structures
02a,04feb02,ak  modification as part of memory reduction process
01z,01nov01,ijm check for NULL values in lcp_timeRemainingMessage and
                lcp_timeRemainingInterval, SPR# 66097
01y,20jun01,ak  Proxy LCP Interface
01x,20jun01,sd  added support for MP and BACP options
01w,15mar01,ijm removed extra ; in function lcp_txIdentificationMessage
01v,20feb01,ijm removed extra comma after lcp_passiveMode parameter
		in lcpParams array definition.
01u,17dec00,md  free copies of last tx'd/rx'd config req pkts when NCPs are UP
01t,10nov00,sj  unregister with m2Lib before deleting component
01s,29sep00,sj  merging with TOR2_0-WINDNET_PPP-CUM_PATCH_2
01r,09aug00,adb support opening connections in passive mode
01q,07aug00,adb subscribe and respond to PPP_SUB_LAYER_DEAD_EVENT
01p,01aug00,adb Merging with openstack view
01o,13jul00,sj  merged from the PPP radius-ras branch
01n,11jul00,md  registered interface LCP_CONFIG_REQS_INTERFACE
01m,23jun00,sj  adding support for pfwStackParameterSet
01l,20mar00,sj  fixing description
01k,20mar00,sj  return OK on successful SET in callbackMessage handler
01j,10mar00,sj  remove configRequestBackoffInterval
01i,01mar00,sj  split alternateString List into LocalAlternate and
                RemoteAlternate
01h,28feb00,sj  preferences set for "Local" strings only 
01g,24feb00,sj  set default values for LinkGroup MIB variables
01f,22feb00,sj  added Security Config group registrations
01e,15feb00,sj  added call to m2pLinkGroupRegister
01d,08feb00,sj  added callback + SDP; added Ext. options and security interfaces
01c,16dec99,sj  if,else if mistake when copying alternate strings,in profileCopy
01b,09nov99,sj  send protocol reject
01a,28sep99,sj 	created
*/
/*
DESCRIPTION
This module implements LCP specified in RFC 1661 and extensions specified in 
RFC 1570

INCLUDE FILES pppLcpComponent.h 
*/

#include "ppp/pppLcpComponent.h"
#include "private/ppp/pppLcpComponentP.h"
#include "ppp/pppChecksum.h"
#include "ppp/m2pppLinkGroup.h"
#include "ppp/m2pppSecurityConfig.h"
#include "pfw/pfwProfile.h"

/* defines */

/* typedefs */

typedef struct lcpParams
    {
    char * name;
    PFW_PARAMETER_HANDLER handler;
    } LCP_PARAMS;

/* externs */

IMPORT STATE_MACHINE_ACTION_TABLE lcpStateActionTable;
IMPORT void send_lcp_protocol_reject(PFW_PLUGIN_OBJ_STATE *,M_BLK_ID rx_packet);

/* WindNet Multilink */

IMPORT STATUS lcpMpOptionsGet (PFW_PLUGIN_OBJ_STATE	*, LCP_BUNDLE_OPTIONS *);

IMPORT STATUS lcpProxyLcpDo 	(PFW_PLUGIN_OBJ_STATE *, PFW_PLUGIN_OBJ_STATE *);   
#if 0	/* Not supported in this MP Release */
IMPORT STATUS lcpMpLinkTime (PFW_PLUGIN_OBJ_STATE	*);
#endif /* Not supported in this MP Release */

/* WindNet Multilink */

void get_value_string 							
    (
	UNION_OPTION_DATA_TYPES		*data,	
	BYTE						length,
    char 						*value_type_string,
    char 						*value_string,
    UNION_OPTION_TYPES 			optionType,
	char 						*optionName
    );

/* locals and forwards */

LOCAL void initialize_lcp_statistics_counters (PFW_PLUGIN_OBJ_STATE * state);
LOCAL void initialize_lcp_mibs (PFW_PLUGIN_OBJ_STATE * state);

    /* PPP_NETWORK_PHASE_UP Event handlers */
LOCAL STATUS networkPhaseUpEventHandler(PFW_PLUGIN_OBJ_STATE *, void *);

    /* component interface  */

LOCAL STATUS lcpProfileDataConstruct (PFW_OBJ *, void * pProfileData);
LOCAL STATUS lcpProfileDataCopy (PFW_OBJ *,void * srcProfile,void * dstProfile);
LOCAL STATUS lcpProfileDataDestruct (PFW_OBJ *, void * pProfileData);
LOCAL STATUS lcpStackDataConstruct (PFW_OBJ *,  void * stackData,
						void * profileData);
LOCAL STATUS lcpStackDataDestruct (PFW_OBJ *,void * stackData,
					     void * profileData); 
LOCAL STATUS lcpInterfaceBind ( PFW_PLUGIN_OBJ * pluginObj);
LOCAL STATUS lcpStackAdd (PFW_PLUGIN_OBJ_STATE *,PFW_PLUGIN_OBJ_CALLBACKS *);
LOCAL STATUS lcpStackDel (PFW_PLUGIN_OBJ_STATE *);
LOCAL STATUS lcpReceive (PFW_PLUGIN_OBJ_STATE *, M_BLK_ID *);
#if 0
LOCAL STATUS lcpSend (PFW_PLUGIN_OBJ_STATE *, M_BLK_ID *);
#endif
LOCAL STATUS lcpStackDataShow (PFW_PLUGIN_OBJ_STATE *);

LOCAL STATUS lcp_setStackData (PFW_OBJ *, LCP_PROFILE_DATA *, 
			LCP_CONFIG_OPTION	*, char	*);

LOCAL void lcpOptionConfigStringsFree (LCP_CONFIG_STRINGS *);

    /* parameter handlers */

#define HANDLER LOCAL STATUS

HANDLER lcp_optionsHandler (PFW_OBJ *, LCP_OPTION_TYPE,
			    PFW_PARAMETER_OPERATION_TYPE, void *, char *);

HANDLER lcp_optionsHandlerX01 (PFW_OBJ *,PFW_PARAMETER_OPERATION_TYPE,void *,
									char *);
HANDLER lcp_optionsHandlerX02 (PFW_OBJ *,PFW_PARAMETER_OPERATION_TYPE,void *,
									char *);
HANDLER lcp_optionsHandlerX03 (PFW_OBJ *,PFW_PARAMETER_OPERATION_TYPE,void *,
									char *);
HANDLER lcp_optionsHandlerX04 (PFW_OBJ *,PFW_PARAMETER_OPERATION_TYPE,void *,
									char *);
HANDLER lcp_optionsHandlerX05 (PFW_OBJ *,PFW_PARAMETER_OPERATION_TYPE,void *,
									char *);
HANDLER lcp_optionsHandlerX07 (PFW_OBJ *,PFW_PARAMETER_OPERATION_TYPE,void *,
									char *);
HANDLER lcp_optionsHandlerX08 (PFW_OBJ *,PFW_PARAMETER_OPERATION_TYPE,void *,
									char *);
HANDLER lcp_optionsHandlerX09 (PFW_OBJ *,PFW_PARAMETER_OPERATION_TYPE,void *,
									char *);
HANDLER lcp_optionsHandlerX0a (PFW_OBJ *,PFW_PARAMETER_OPERATION_TYPE,void *,
									char *);
HANDLER lcp_optionsHandlerX0d (PFW_OBJ *,PFW_PARAMETER_OPERATION_TYPE,void *,
									char *);
HANDLER lcp_callbackMessage(PFW_OBJ *, PFW_PARAMETER_OPERATION_TYPE,void *,
								    char *);
HANDLER lcp_timeRemainingInterval(PFW_OBJ *,PFW_PARAMETER_OPERATION_TYPE,void *,
								    char *);
HANDLER lcp_timeRemainingMessage(PFW_OBJ *, PFW_PARAMETER_OPERATION_TYPE,void *,
								    char *);
HANDLER lcp_txIdentificationMessage(PFW_OBJ *, PFW_PARAMETER_OPERATION_TYPE,
							    void *, char *);
HANDLER lcp_maxConfigRequests(PFW_OBJ *, PFW_PARAMETER_OPERATION_TYPE,
							    void *, char *);
HANDLER lcp_maxConfigFailure(PFW_OBJ *, PFW_PARAMETER_OPERATION_TYPE,
							    void *, char *);
HANDLER lcp_configReqSendInterval(PFW_OBJ *, PFW_PARAMETER_OPERATION_TYPE,
							    void *, char *);
#if 0
HANDLER lcp_configReqBackoffInterval(PFW_OBJ *, PFW_PARAMETER_OPERATION_TYPE,
							    void *, char *);
#endif 
HANDLER lcp_maxTerminationRequests(PFW_OBJ *, PFW_PARAMETER_OPERATION_TYPE,
							    void *, char *);
HANDLER lcp_terminationReqInterval(PFW_OBJ *, PFW_PARAMETER_OPERATION_TYPE,
							    void *, char *);
HANDLER lcp_echoRequestSendInterval(PFW_OBJ *, PFW_PARAMETER_OPERATION_TYPE,
							    void *, char *);
HANDLER lcp_maxUnAckedEchoRequests(PFW_OBJ *, PFW_PARAMETER_OPERATION_TYPE,
							    void *, char *);
HANDLER lcp_passiveMode(PFW_OBJ *, PFW_PARAMETER_OPERATION_TYPE,
							    void *, char *);

#if 0 /* NOT SUPPORTED IN THIS RELEASE */
HANDLER lcp_optionsHandlerX0f (PFW_OBJ *,PFW_PARAMETER_OPERATION_TYPE,void *,
									char *);
HANDLER lcp_optionsHandlerX0b (PFW_OBJ *,PFW_PARAMETER_OPERATION_TYPE,void *,
									char *);
HANDLER lcp_optionsHandlerX0c (PFW_OBJ *,PFW_PARAMETER_OPERATION_TYPE,void *,
									char *);
HANDLER lcp_optionsHandlerX0e (PFW_OBJ *,PFW_PARAMETER_OPERATION_TYPE,void *,
									char *);
HANDLER lcp_optionsHandlerX10 (PFW_OBJ *,PFW_PARAMETER_OPERATION_TYPE,void *,
									char *);
#endif /* NOT SUPPORTED IN THIS RELEASE */

/* WindNet Multilink - Start */ 

HANDLER lcp_optionsHandlerX11 (PFW_OBJ *,PFW_PARAMETER_OPERATION_TYPE,void *,
									char *);
HANDLER lcp_optionsHandlerX12 (PFW_OBJ *,PFW_PARAMETER_OPERATION_TYPE,void *,
									char *);
HANDLER lcp_optionsHandlerX13 (PFW_OBJ *,PFW_PARAMETER_OPERATION_TYPE,void *,
								    char *);
HANDLER lcp_optionsHandlerX17 (PFW_OBJ *,PFW_PARAMETER_OPERATION_TYPE,void *,
									char *);
/* WindNet Multilink - End */

#if 0 /* NOT SUPPORTED IN THIS RELEASE */
HANDLER lcp_linkQualityReportingInterval(PFW_OBJ *,PFW_PARAMETER_OPERATION_TYPE,
                                void *, char *);
#endif /* NOT SUPPORTED IN THIS RELEASE */

#ifdef NOT_REQUIRED
HANDLER lcp_callbackOperation(PFW_OBJ *, PFW_PARAMETER_OPERATION_TYPE,void *,
								    char *);
#endif /* NOT_REQUIRED */


LOCAL PPP_CONTROL_PHASE lcp_pppPhaseGet ();
LOCAL PPP_STATE lcp_pppStateGet (PFW_PLUGIN_OBJ_STATE *);

LOCAL LCP_PARAMS lcpParams[] =
    {
	{"lcp_MRU",lcp_optionsHandlerX01},
	{"lcp_ACCM",lcp_optionsHandlerX02},
	{"lcp_authProtocol",lcp_optionsHandlerX03},
	{"lcp_qualityProtocol",lcp_optionsHandlerX04},
	{"lcp_magicNumber",lcp_optionsHandlerX05},
	{"lcp_PFCompression",lcp_optionsHandlerX07},
	{"lcp_ACFCompression",lcp_optionsHandlerX08},
	{"lcp_fcsAlternatives",lcp_optionsHandlerX09},
	{"lcp_selfDescribingPadding",lcp_optionsHandlerX0a},
	{"lcp_callbackOperation",lcp_optionsHandlerX0d},
/*
 * END of lcp negotiation options
 */
	{"lcp_callbackMessage",lcp_callbackMessage},
	{"lcp_timeRemainingInterval",lcp_timeRemainingInterval},
	{"lcp_timeRemainingMessage",lcp_timeRemainingMessage},
	{"lcp_txIdentMessage",lcp_txIdentificationMessage},
	{"lcp_maxConfigRequests",lcp_maxConfigRequests},
	{"lcp_maxConfigFailure",lcp_maxConfigFailure},
	{"lcp_configReqSendInterval",lcp_configReqSendInterval},
#if 0
	{"lcp_configReqBackoffInterval",lcp_configReqBackoffInterval},
#endif
	{"lcp_maxTerminationRequests",lcp_maxTerminationRequests},
	{"lcp_terminationReqInterval",lcp_terminationReqInterval},
	{"lcp_echoRequestSendInterval",lcp_echoRequestSendInterval},
	{"lcp_maxUnAckedEchoRequests",lcp_maxUnAckedEchoRequests},
        {"lcp_passiveMode",lcp_passiveMode}

#if 0 /* NOT SUPPORTED IN THIS RELEASE */
	, /* terminate previous entry */
	{"lcp_compoundFrames",lcp_optionsHandlerX0f},
	{"lcp_numberedMode",lcp_optionsHandlerX0b},
	{"lcp_multilinkProcedure",lcp_optionsHandlerX0c},
	{"lcp_connectTime",lcp_optionsHandlerX0e},
	{"lcp_nominalDataEncap.",lcp_optionsHandlerX10}
#endif /* NOT SUPPORTED IN THIS RELEASE */

/* WindNet Multilink - Start */
	, 
	{"lcp_ML_maxRcvdReconstructedUnit",lcp_optionsHandlerX11},
	{"lcp_ML_shortSeqNumberHdrFormat",lcp_optionsHandlerX12},
	{"lcp_endpointDiscriminator",lcp_optionsHandlerX13},
	{"lcp_linkDiscriminator",lcp_optionsHandlerX17},
/* WindNet Multilink - End */

#if 0 /* not supported in this release */ 
	{"lcp_LQReportingInterval",lcp_linkQualityReportingInterval}
#endif /* not supported in this release */

#ifdef NOT_REQUIRED
	, /* terminate previous entry */
	{"lcp_callbackOperation",lcp_callbackOperation}
#endif /* NOT_REQUIRED */
    }; 


LOCAL int numLcpParams = NELEMENTS (lcpParams);

LOCAL STATUS pppSubordinateLayerDeadEventHandler
    (
    PFW_PLUGIN_OBJ_STATE *  objState,
    void *                  eventData
    );  

/* globals */

char * getLcpOptionName 
    (
    PFW_OBJ *  pfw,
    char *     optionName
    );

extern void lcpInterfacesInit(PPP_LCP_COMPONENT *);

/*******************************************************************************
* lcpComponentCreate - initialize and add LCP component to framework 
*
* This component implements RFC 1661 and RFC 1548
*
* RETURNS: OK or ERROR
*/
STATUS lcpComponentCreate
    (
    PFW_OBJ * pfw	/* framework reference */
    )
    {
    PPP_LCP_COMPONENT 	*pComponent = NULL;
    PFW_PLUGIN_OBJ 		*lcpPluginObj = NULL;
    int 				i = 0;
	LCP_CONFIG_OPTION	*lcpOption = NULL;

    if (pfw == NULL)
	{
	return ERROR;
	}

    /* allocate the component object */

    if ( (pComponent = pfwMalloc(pfw,sizeof(PPP_LCP_COMPONENT))) == NULL)
	return ERROR;

    bzero((void *)pComponent,sizeof(PPP_LCP_COMPONENT));

    lcpPluginObj = (PFW_PLUGIN_OBJ *)&(pComponent->component);

    /* initialize our component object */

    bzero(lcpPluginObj->name, PFW_MAX_NAME_LENGTH);
    strncpy(lcpPluginObj->name,"PPP_LCP",(PFW_MAX_NAME_LENGTH -1));

    lcpPluginObj->pfwObj = pfw;
    lcpPluginObj->profileDataSize = sizeof (LCP_PROFILE_DATA);
    lcpPluginObj->stackDataSize = sizeof (LCP_STACK_DATA);
    lcpPluginObj->profileDataConstruct = lcpProfileDataConstruct;
    lcpPluginObj->profileDataCopy = lcpProfileDataCopy;
    lcpPluginObj->profileDataDestruct = lcpProfileDataDestruct;
    lcpPluginObj->stackDataConstruct = lcpStackDataConstruct;
    lcpPluginObj->stackDataDestruct = lcpStackDataDestruct;
    lcpPluginObj->interfaceBind = lcpInterfaceBind;
    lcpPluginObj->receive = lcpReceive;
    lcpPluginObj->send = NULL;
    lcpPluginObj->stackDataShow = lcpStackDataShow;
    lcpPluginObj->stackAdd = lcpStackAdd;
    lcpPluginObj->stackDelete = lcpStackDel;

    pComponent->component.protocol = LCP_PROTOCOL;
    pComponent->component.layerObj = pfwLayerObjGet(pfw,"CONTROL_LAYER");

    /* register this component with the framework */

    if (pfwComponentAdd (&pComponent->component) == ERROR)
	{
	logMsg ("pppOEthernetInit: Couldn't add LCP component to pfw 0x%x\n"
							,(int)pfw,2,3,4,5,6);
	return (ERROR);
	}

    /* add our parameters to the framework */

    for (i = 0; i < numLcpParams; i++)
	{
	if (pfwParameterAdd ((PFW_PLUGIN_OBJ *)pComponent,
			    lcpParams[i].name, lcpParams[i].handler) == ERROR)
	    {
	    logMsg ("pppLcpComponent - Parameter %s could not be added\n",
	    (int)lcpParams[i].name,2,3,4,5,6);

	    return (ERROR);
	    }
	}

	/* Initializing LCP options */
  
    lcpOption = &pComponent->option[LCP_MAXIMUM_RECEIVE_UNIT];
    lcpOption->optionType = LCP_MAXIMUM_RECEIVE_UNIT;
    bzero(lcpOption->optionTypeString,sizeof(lcpOption->optionTypeString));
    strcpy(lcpOption->optionTypeString,"D2S");
    bzero(lcpOption->name,sizeof(lcpOption->name));
    strcpy(lcpOption->name,"LMRU");

	lcpOption = &pComponent->option[LCP_ASYNC_CONTROL_CHARACTER_MAP];
    lcpOption->optionType = LCP_ASYNC_CONTROL_CHARACTER_MAP;
    bzero(lcpOption->optionTypeString,sizeof(lcpOption->optionTypeString));
    strcpy(lcpOption->optionTypeString,"H4S");
    bzero(lcpOption->name,sizeof(lcpOption->name));
    strcpy(lcpOption->name,"LACCM");

	lcpOption = &pComponent->option[LCP_AUTHENTICATION_PROTOCOL];
    lcpOption->optionType = LCP_AUTHENTICATION_PROTOCOL;
    bzero(lcpOption->optionTypeString,sizeof(lcpOption->optionTypeString));
    strcpy(lcpOption->optionTypeString,"H2");
    bzero(lcpOption->name,sizeof(lcpOption->name));
    strcpy(lcpOption->name,"LAP");

    lcpOption = &pComponent->option[LCP_QUALITY_PROTOCOL];
    lcpOption->optionType = LCP_QUALITY_PROTOCOL;
    bzero(lcpOption->optionTypeString,sizeof(lcpOption->optionTypeString));
    strcpy(lcpOption->optionTypeString,"H2S");
    bzero(lcpOption->name,sizeof(lcpOption->name));
    strcpy(lcpOption->name,"LQP");

    lcpOption = &pComponent->option[LCP_MAGIC_NUMBER];
    lcpOption->optionType = LCP_MAGIC_NUMBER;
    bzero(lcpOption->optionTypeString,sizeof(lcpOption->optionTypeString));
    strcpy(lcpOption->optionTypeString,"D4S");
    bzero(lcpOption->name,sizeof(lcpOption->name));
    strcpy(lcpOption->name,"Magic Number");

	lcpOption = &pComponent->option[LCP_PROTOCOL_FIELD_COMPRESSION];
    lcpOption->optionType = LCP_PROTOCOL_FIELD_COMPRESSION;
    bzero(lcpOption->optionTypeString,sizeof(lcpOption->optionTypeString));
    strcpy(lcpOption->optionTypeString,"D0");
    bzero(lcpOption->name,sizeof(lcpOption->name));
    strcpy(lcpOption->name,"LPFC");