ppplcpcomponent.c

这是全套的PPP协议的源码

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

    lcpOption = &pComponent->option[LCP_FCS_ALTERNATIVES];
    lcpOption->optionType = LCP_FCS_ALTERNATIVES;
    bzero(lcpOption->optionTypeString,sizeof(lcpOption->optionTypeString));
    strcpy(lcpOption->optionTypeString,"D1");
    bzero(lcpOption->name,sizeof(lcpOption->name));
    strcpy(lcpOption->name,"LFA");

    lcpOption = &pComponent->option[LCP_SELF_DESCRIBING_PADDING];
    lcpOption->optionType = LCP_SELF_DESCRIBING_PADDING;
    bzero(lcpOption->optionTypeString,sizeof(lcpOption->optionTypeString));
    strcpy(lcpOption->optionTypeString,"D1");
    bzero(lcpOption->name,sizeof(lcpOption->name));
    strcpy(lcpOption->name,"LSDP");

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

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

    lcpOption = &pComponent->option[LCP_CALLBACK];
    lcpOption->optionType = LCP_CALLBACK;
    bzero(lcpOption->optionTypeString,sizeof(lcpOption->optionTypeString));
    strcpy(lcpOption->optionTypeString,"D1");
    bzero(lcpOption->name,sizeof(lcpOption->name));
    strcpy(lcpOption->name,"LCB");

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

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

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

	/* WindNet Multilink */

	lcpOption = 
      &pComponent->option[LCP_MULTILINK_MAXIMUM_RECEIVED_RECONSTRUCTED_UNIT];

    lcpOption->optionType = LCP_MULTILINK_MAXIMUM_RECEIVED_RECONSTRUCTED_UNIT;
    bzero(lcpOption->optionTypeString,sizeof(lcpOption->optionTypeString));
    strcpy(lcpOption->optionTypeString,"D2S");
    bzero(lcpOption->name,sizeof(lcpOption->name));
    strcpy(lcpOption->name,"LMMRRU");

    lcpOption = 
      &pComponent->option[LCP_MULTILINK_SHORT_SEQUENCE_NUMBER_HEADER_FORMAT];

    lcpOption->optionType = LCP_MULTILINK_SHORT_SEQUENCE_NUMBER_HEADER_FORMAT;
    bzero(lcpOption->optionTypeString,sizeof(lcpOption->optionTypeString));
    strcpy(lcpOption->optionTypeString,"D0");
    bzero(lcpOption->name,sizeof(lcpOption->name));
    strcpy(lcpOption->name,"LMSSNHF");

	lcpOption = &pComponent->option[LCP_ENDPOINT_DISCRIMINATOR];
    lcpOption->optionType = LCP_ENDPOINT_DISCRIMINATOR;
    bzero(lcpOption->optionTypeString,sizeof(lcpOption->optionTypeString));
    strcpy(lcpOption->optionTypeString,"EID");
    bzero(lcpOption->name,sizeof(lcpOption->name));
    strcpy(lcpOption->name,"LED");

    lcpOption = &pComponent->option[LCP_LINK_DISCRIMINATOR];
    lcpOption->optionType = LCP_LINK_DISCRIMINATOR;
    bzero(lcpOption->optionTypeString,sizeof(lcpOption->optionTypeString));
    strcpy(lcpOption->optionTypeString,"D2S");
    bzero(lcpOption->name,sizeof(lcpOption->name));
    strcpy(lcpOption->name,"LLD");

	/* WindNet Multilink */

    /* publish the event we'll raise when we attain OPENED state */

    if (pfwEventPublish(pfw,"LCP_UP_EVENT") == NULL)
	{
	return ERROR;
	}

#if 0 /* WindNet Multilink - Not supported in this MP release */

    /* publish the event we'll raise when echo reply is received and MP is 
	  timing the link */ 

    if (pfwEventPublish(pfw,"LCP_ECHO_REPLY_RECEIVED_EVENT") == NULL)
	{
	return ERROR;
	}

#endif /* WindNet Multilink - Not supported in this MP release */

    /* publish events that we need to be available to subscribe to them */

    if (pfwEventPublish(pfw,"PPP_SUB_LAYER_DEAD_EVENT") == NULL)
	{
	return ERROR;
	}

    lcpSetSendActionFunctions(&lcpStateActionTable);
    lcpSetReceiveFunctions(pComponent);

    return OK;
    }

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

    pComponent = pfwComponentObjGetByName(pfw,"PPP_LCP");

    if (pComponent == NULL)
	return ERROR;

    m2pppLinkGroupUnregister(pfw);
    m2pppSecurityConfigUnregister(pfw);

    if (pfwComponentDelete(pComponent) == OK)
	{
        pfwFree(pComponent);
        pComponent = NULL;  
	return OK;
	}
    return ERROR;
    }
/*******************************************************************************
* lcpInterfaceBind -
*/
LOCAL STATUS lcpInterfaceBind
    (
    PFW_PLUGIN_OBJ * pluginObj
    )
    {
    PPP_LCP_COMPONENT * pComponent = (PPP_LCP_COMPONENT *)pluginObj;
    CONTROL_PROTOCOL_INTERFACE * lcpControlInterface = NULL;
    PPP_LINK_STATUS_ENTRY_INTERFACE * pppLinkStatusEntry = NULL;
    PPP_LINK_CONFIG_ENTRY_INTERFACE * pppLinkConfigEntry = NULL;
    PPP_LINK_STATUS_COUNTER_INCREMENT_INTERFACE * lcpLinkCounters = NULL;
    LCP_NEGOTIATED_AUTH_PROTOCOL_INTERFACE * lcpNegotiatedAuthProtocols = NULL;
    LCP_EXTENDED_OPTIONS_INTERFACE * lcpExtendedOptions = NULL;
    LCP_CONFIG_REQS_INTERFACE * lcpConfReqGet = NULL;
    LCP_PACKET_SEND_INTERFACE * lcpPacketSend = NULL;
    PPP_SECURITY_CONFIG_ENTRY_INTERFACE * pppSecurityConfig = NULL;
    PFW_OBJ * pfw = pluginObj->pfwObj;
    int i = 0;

/* WindNet Multilink - Start */

	LCP_PROXYLCP_INTERFACE	 *pLcpProxyLcp = NULL;
	LCP_BUNDLE_OPTIONS_INTERFACE *pLcpBundleOptions = NULL;
#if 0 /* Not supported in this MP Release */
	LCP_MP_TIME_INTERFACE   *pMpLinkTime = NULL;
#endif /* Not supported in this MP Release */

/* WindNet Multilink - End */

    /* get CONTROL_PROTOCOL_INTERFACE ID and bind to it */

    if ((i = pfwInterfaceIdGet(pfw, "CONTROL_PROTOCOL_INTERFACE")) > 0) 
	{
	lcpControlInterface = &pComponent->lcpControlInterface;

	lcpControlInterface->interfaceObj.id = i;
	lcpControlInterface->interfaceObj.pluginObj = 
						(PFW_PLUGIN_OBJ *)pComponent;
	lcpControlInterface->pppPhaseGet = lcp_pppPhaseGet;
	lcpControlInterface->pppStateGet = lcp_pppStateGet;
	lcpControlInterface->executeStateMachine = execute_ppp_state_machine;

	pfwInterfaceBind (&lcpControlInterface->interfaceObj);
	}

    /* publish and bind our link status interfaces */

    lcpInterfacesInit(pComponent);

    if ((i = pfwInterfaceRegister(pfw, "PPP_LINK_STATUS_ENTRY_INTERFACE")) > 0) 
	{
	pppLinkStatusEntry = &pComponent->lcpLinkStatusEntry;
	pppLinkStatusEntry->interfaceObj.id = i;
	pppLinkStatusEntry->interfaceObj.pluginObj = 
					(PFW_PLUGIN_OBJ *)pComponent;
	pfwInterfaceBind(&pppLinkStatusEntry->interfaceObj);
	}

    if ((i = pfwInterfaceRegister(pfw, "PPP_LINK_CONFIG_ENTRY_INTERFACE")) > 0) 
	{
	pppLinkConfigEntry = &pComponent->lcpLinkConfigEntry;
	pppLinkConfigEntry->interfaceObj.id = i;
	pppLinkConfigEntry->interfaceObj.pluginObj = 
					(PFW_PLUGIN_OBJ *)pComponent;
	pfwInterfaceBind(&pppLinkConfigEntry->interfaceObj);
	}

    if ((i = pfwInterfaceRegister(pfw,"LCP_NEGOTIATED_AUTH_PROTOCOL_INTERFACE"))
	> 0) 
	{
	lcpNegotiatedAuthProtocols = &pComponent->lcpNegotiatedAuthProtocols;
	lcpNegotiatedAuthProtocols->interfaceObj.id = i;
	lcpNegotiatedAuthProtocols->interfaceObj.pluginObj = 
					(PFW_PLUGIN_OBJ *)pComponent;
	pfwInterfaceBind(&lcpNegotiatedAuthProtocols->interfaceObj);
	}

    if ((i = pfwInterfaceRegister(pfw,"LCP_EXTENDED_OPTIONS_INTERFACE"))
	> 0) 
	{
	lcpExtendedOptions = &pComponent->lcpExtendedOptions;
	lcpExtendedOptions->interfaceObj.id = i;
	lcpExtendedOptions->interfaceObj.pluginObj = 
					(PFW_PLUGIN_OBJ *)pComponent;
	pfwInterfaceBind(&lcpExtendedOptions->interfaceObj);
	}

    if ((i = pfwInterfaceRegister(pfw,"LCP_CONFIG_REQS_INTERFACE"))
	> 0)
	{
	lcpConfReqGet = &pComponent->lcpConfReqGet;
	lcpConfReqGet->interfaceObj.id = i;
	lcpConfReqGet->interfaceObj.pluginObj =
					(PFW_PLUGIN_OBJ *)pComponent;
        pfwInterfaceBind(&lcpConfReqGet->interfaceObj);
	}

    if ((i = pfwInterfaceRegister(pfw,"LCP_PACKET_SEND_INTERFACE"))
	> 0) 
	{
	lcpPacketSend = &pComponent->lcpPacketSend;
	lcpPacketSend->interfaceObj.id = i;
	lcpPacketSend->interfaceObj.pluginObj = 
					(PFW_PLUGIN_OBJ *)pComponent;
	pfwInterfaceBind(&lcpPacketSend->interfaceObj);
	}

    if ((i = pfwInterfaceRegister(pfw,
			"PPP_LINK_STATUS_COUNTER_INCREMENT_INTERFACE")) > 0) 
	{
	lcpLinkCounters = &pComponent->lcpLinkCounters;
	lcpLinkCounters->interfaceObj.id = i;
	lcpLinkCounters->interfaceObj.pluginObj = 
					(PFW_PLUGIN_OBJ *)pComponent;
	pfwInterfaceBind(&lcpLinkCounters->interfaceObj);
	}

    if ((i = pfwInterfaceRegister(pfw,
			"PPP_SECURITY_CONFIG_ENTRY_INTERFACE")) > 0) 
	{
	pppSecurityConfig = &pComponent->pppSecurityConfigEntry;
	pppSecurityConfig->interfaceObj.id = i;
	pppSecurityConfig->interfaceObj.pluginObj = 
					(PFW_PLUGIN_OBJ *)pComponent;
	pfwInterfaceBind(&pppSecurityConfig->interfaceObj);
	}

/* WindNet Multilink - Start */

    if ((i = pfwInterfaceRegister(pfw,
			"LCP_PROXYLCP_INTERFACE")) > 0) 
	{
	pLcpProxyLcp = &pComponent->lcpProxyLcp;
	pLcpProxyLcp->interfaceObj.id = i;
	pLcpProxyLcp->interfaceObj.pluginObj = 
					(PFW_PLUGIN_OBJ *)pComponent;
	pLcpProxyLcp->lcpProxyLcpDo = lcpProxyLcpDo;
	if (pfwInterfaceBind(&pLcpProxyLcp->interfaceObj) == ERROR)
		printf ("Error in binding LCP_PROXYLCP_INTERFACE\n");		

	}
	else
		{
		printf ("Error in registering LCP_PROXYLCP_INTERFACE\n");		
		}

    if ((i = pfwInterfaceRegister(pfw,
			"LCP_BUNDLE_OPTIONS_INTERFACE")) > 0) 
	{
	pLcpBundleOptions = &pComponent->lcpBundleOptions;
	pLcpBundleOptions->interfaceObj.id = i;
	pLcpBundleOptions->interfaceObj.pluginObj = 
					(PFW_PLUGIN_OBJ *)pComponent;

	pLcpBundleOptions->lcpMpOptionsGet = lcpMpOptionsGet; 

	if (pfwInterfaceBind(&pLcpBundleOptions->interfaceObj) == ERROR)
		printf ("Error in binding LCP_BUNDLE_OPTIONS_INTERFACE\n");		

	}
	else
		{
		printf ("Error in registering LCP_BUNDLE_OPTIONS_INTERFACE\n");		
		}

#if 0 /* Not supported in this MP Release */
    if ((i = pfwInterfaceRegister(pfw,
			"LCP_MP_TIME_INTERFACE")) > 0) 
	{
	pMpLinkTime = &pComponent->lcpMpTimeInterface;
	pMpLinkTime->interfaceObj.id = i;
	pMpLinkTime->interfaceObj.pluginObj = 
					(PFW_PLUGIN_OBJ *)pComponent;

	pMpLinkTime->lcpMPLinkTime = lcpMpLinkTime;

	if (pfwInterfaceBind(&pMpLinkTime->interfaceObj) == ERROR)
		printf ("Error in binding LCP_MP_TIME_INTERFACE\n");		
	}
	else
		{
		printf ("Error in registering LCP_MP_TIME_INTERFACE\n");		
		}
#endif /* Not supported in this MP Release */

/* WindNet Multilink - End */	

    /* register our interfaces with SNMP */

    if (m2pppLinkGroupRegister(pfw) != OK)
	logMsg("PPP_LCP:WARNING! Failed to register Link Group MIB II interfaces\n", 1,2,3,4,5,6);

    if (m2pppSecurityConfigRegister(pfw) != OK)
	logMsg("PPP_LCP:WARNING! Failed to register Security Config MIB II interfaces\n", 1,2,3,4,5,6);

    return OK;
    }

/*******************************************************************************
*lcpProfileDataConstruct - initialize LCP profile data
*
*
*/
LOCAL STATUS lcpProfileDataConstruct 
    (
    PFW_OBJ * pfw,
    void * pData
    )
    {
  	LCP_PROFILE_DATA * pProfileData = (LCP_PROFILE_DATA *) pData;

    bzero(pData, sizeof(LCP_PROFILE_DATA));

    pProfileData->maximum_number_of_configuration_requests =
				    MAXIMUM_CONFIGURATION_REQUESTS;
    pProfileData->maximum_number_of_configuration_failures =
				    MAXIMUM_CONFIGURATION_FAILURES;
    pProfileData->maximum_configuration_request_send_interval = 
				    MAXIMUM_CONFIGURATION_REQUEST_SEND_INTERVAL;
    pProfileData->maximum_configuration_request_backoff_interval = 0;
			    /*MAXIMUM_CONFIGURATION_REQUEST_BACKOFF_INTERVAL;*/
    pProfileData->maximum_number_of_termination_requests = 
		    		MAXIMUM_TERMINATION_REQUESTS;
    pProfileData->maximum_termination_request_send_interval = 
				    MAXIMUM_TERMINATION_REQUEST_SEND_INTERVAL;
    pProfileData->maximum_echo_request_send_interval = 
				    MAXIMUM_ECHO_REQUEST_SEND_INTERVAL;
    pProfileData->maximum_number_of_unacknowledged_echo_requests = 
				    MAXIMUM_ECHO_REQUESTS_NOT_ACKNOWLEDGED;

    pProfileData->send_id_enabled = FALSE;

    pProfileData->passiveMode = FALSE;

	/* generate config string structures for the LCP options */

	pProfileData->lcpConfigStrings = pfwMalloc (pfw, sizeof (LCP_CONFIG_STRINGS)
												 * (NUMBER_OF_LCP_OPTIONS + 1)); 

	if (pProfileData->lcpConfigStrings == NULL)
		return ERROR;

	bzero ((char *)pProfileData->lcpConfigStrings, 
		   sizeof (LCP_CONFIG_STRINGS) * (NUMBER_OF_LCP_OPTIONS + 1));


    /* set a default value to LCP options */

    lcp_optionsHandler (pfw,LCP_MAXIMUM_RECEIVE_UNIT,PFW_PARAMETER_SET,
		    pProfileData,"Local:Negotiation Required,Negotiable:1500");

    lcp_optionsHandler (pfw,LCP_MAXIMUM_RECEIVE_UNIT,PFW_PARAMETER_SET,
		pProfileData,"Remote:Negotiation Not Required,Negotiable");

    lcp_optionsHandler (pfw,LCP_ASYNC_CONTROL_CHARACTER_MAP,PFW_PARAMETER_SET,
	    pProfileData,"Remote:Negotiation Not Required,Negotiable");