ppplcpcomponent.c

这是全套的PPP协议的源码

					{
					return ERROR;
					}

	    		alternateConfigString = alternateConfigString->next;
	    		}
			}

		/* free the LCP config strings from the profile data */

    	for (options = 1; options <= NUMBER_OF_LCP_OPTIONS; options++)
			{
			lcpOptionConfigStringsFree 
								(&pProfileData->lcpConfigStrings[options]);
			}
        if (pProfileData->lcpConfigStrings != NULL)   
            {
            pfwFree (pProfileData->lcpConfigStrings);
		    pProfileData->lcpConfigStrings = NULL;    
            }
	}
	
  	pStackData->stateData.action_table = &lcpStateActionTable;

    return OK;
    }

/*******************************************************************************
*lcpProfileDataDestruct - clean up profile data 
*
*
*/
LOCAL STATUS lcpProfileDataDestruct
    (
    PFW_OBJ * pfw,
    void * profileData
    )
    {
    LCP_PROFILE_DATA * pProfileData = (LCP_PROFILE_DATA *) profileData;
    int options = 0;

	if (!pProfileData->lcpConfigStrings)
		return OK;

    /* free profile config strings */

  	for (options = 1; options <= NUMBER_OF_LCP_OPTIONS; options++)
	{
	lcpOptionConfigStringsFree (&pProfileData->lcpConfigStrings[options]);
	}

    if (pProfileData->lcpConfigStrings != NULL)   
        {
        pfwFree (pProfileData->lcpConfigStrings);
	    pProfileData->lcpConfigStrings = NULL;    
        }
    return OK;
    }

/*******************************************************************************
*lcpStackDataDestruct - clean up stack data 
*
*
*/
LOCAL STATUS lcpStackDataDestruct
    (
    PFW_OBJ * pfw,
    void * stackData,
    void * profileData
    )
    {
    LCP_STACK_DATA * pStackData = (LCP_STACK_DATA *) stackData;
    free_ppp_option_lists(&pStackData->option_lists);

    if (pStackData->copy_of_last_rxed_lcp_configuration_request_packet != NULL)
	{
	netMblkClChainFree(pStackData->copy_of_last_rxed_lcp_configuration_request_packet);
	pStackData->copy_of_last_rxed_lcp_configuration_request_packet = NULL;
	}

    if (pStackData->copy_of_last_txed_lcp_configuration_request_packet != NULL)
	{
	netMblkClChainFree(pStackData->copy_of_last_txed_lcp_configuration_request_packet);
	pStackData->copy_of_last_txed_lcp_configuration_request_packet = NULL;
	}
    if (pStackData->copy_of_initial_rxed_lcp_configuration_request_packet != NULL)
	{
	netMblkClChainFree(pStackData->copy_of_initial_rxed_lcp_configuration_request_packet);
	pStackData->copy_of_initial_rxed_lcp_configuration_request_packet = NULL;
	}

    return OK;
    }
/*******************************************************************************
* lcpStackDataShow - show connection data
*
*
*/
LOCAL STATUS lcpStackDataShow
    (
    PFW_PLUGIN_OBJ_STATE * pComponentState
    )
    {
    #if 0
    LCP_STACK_DATA * pStackData = (LCP_STACK_DATA *) pComponentState->stackData;
    #endif

    return OK;
    }

/*******************************************************************************
* lcpStackAdd - initiate link establishment
*
*
*/
LOCAL STATUS lcpStackAdd
    (
    PFW_PLUGIN_OBJ_STATE * pComponentState,
    PFW_PLUGIN_OBJ_CALLBACKS * callbacks
    )
    {
    int id = 0;
    PFW_EVENT_OBJ * pPfwEventObj = NULL;
    PFW_EVENT_OBJ * networkPhaseUpEvent = NULL;

    PFW_LAYER_OBJ * layerObj = 
		((PFW_COMPONENT_OBJ *)pComponentState->pluginObj)->layerObj;

    LCP_STACK_DATA * pStackData = (LCP_STACK_DATA *) pComponentState->stackData;
    
    initialize_lcp_statistics_counters (pComponentState);

    initialize_lcp_mibs (pComponentState);

    if ((pStackData->lcp_timer = pfwTimerCreate(pComponentState)) == NULL)
	return ERROR;

    if ((pStackData->time_remaining_timer = 
				    pfwTimerCreate(pComponentState)) == NULL)
	return ERROR;

    pStackData->callbacks = callbacks;

    /*
    copy_configuration_options_list (pComponentState->pluginObj->pfwObj,
				    &pStackData->option_lists.configured,
				    &pStackData->option_lists.tx_accepted);
    */
    /*
    copy_configuration_options_to_tx_accepted_options
	    (pComponentState->pluginObj->pfwObj, &pStackData->option_lists);
    */

    /* get controlLayer interface */

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

	}

    if ((networkPhaseUpEvent =pfwEventObjGet(pComponentState->pluginObj->pfwObj,
	"PPP_NETWORK_PHASE_UP")) == NULL)
	{
	logMsg("PPP: no PPP_NETWORK_PHASE_UP event\n",1,2,3,4,5,6);
	}
    else
	pfwEventStackSubscribe (pComponentState, networkPhaseUpEvent,
                                       networkPhaseUpEventHandler);

    if  (NULL != (pPfwEventObj =
                  pfwEventObjGet(pComponentState->pluginObj->pfwObj,
                                 "PPP_SUB_LAYER_DEAD_EVENT")))
        {
        pfwEventStackSubscribe(pComponentState, 
                               pPfwEventObj,
                               pppSubordinateLayerDeadEventHandler);
        }
     
    /* If the event is not published we do not return error! 
     * Howver, since the LCP component also publishes this event,
     * we expect that this event will be always published.
     */

    if (pStackData->callbacks && pStackData->callbacks->stackAddComplete)
	{
	(*pStackData->callbacks->stackAddComplete)
				    (pStackData->callbacks, pComponentState);
	return OK;
	}
    else
	return ERROR;
    }

/*******************************************************************************
* lcpStackDel - initiate link down
*
*
*/
LOCAL STATUS lcpStackDel
    (
    PFW_PLUGIN_OBJ_STATE * pComponentState
    )
    {
    LCP_STACK_DATA * pStackData = (LCP_STACK_DATA *) pComponentState->stackData;

    pfwTimerDelete(pStackData->lcp_timer);
    pfwTimerDelete(pStackData->time_remaining_timer);

    if (pStackData->last_txed_echo_request_packet != NULL)
	{
	netMblkClChainFree(pStackData->last_txed_echo_request_packet);
	pStackData->last_txed_echo_request_packet = NULL;
	}

    if (pStackData->copy_of_initial_rxed_lcp_configuration_request_packet != NULL)
	{
	netMblkClChainFree(pStackData->copy_of_initial_rxed_lcp_configuration_request_packet);
	pStackData->copy_of_initial_rxed_lcp_configuration_request_packet = NULL;
	}

    if (pStackData->copy_of_last_rxed_lcp_configuration_request_packet != NULL)
	{
	netMblkClChainFree(pStackData->copy_of_last_rxed_lcp_configuration_request_packet);
	pStackData->copy_of_last_rxed_lcp_configuration_request_packet = NULL;
	}

    if (pStackData->copy_of_last_txed_lcp_configuration_request_packet != NULL)
	{
	netMblkClChainFree(pStackData->copy_of_last_txed_lcp_configuration_request_packet);
	pStackData->copy_of_last_txed_lcp_configuration_request_packet = NULL;
	}

    if (pStackData->last_txed_lcp_configuration_request_packet != NULL)
	{
	netMblkClChainFree(pStackData->last_txed_lcp_configuration_request_packet);
	pStackData->last_txed_lcp_configuration_request_packet = NULL;
	}
    if (pStackData->last_rxed_lcp_configuration_request_packet != NULL)
	{
	netMblkClChainFree(pStackData->last_rxed_lcp_configuration_request_packet);
	pStackData->last_rxed_lcp_configuration_request_packet = NULL;
	}
    if (pStackData->last_rxed_lcp_termination_request_packet != NULL)
	{
	netMblkClChainFree(pStackData->last_rxed_lcp_termination_request_packet);
	pStackData->last_rxed_lcp_termination_request_packet = NULL;
	}
    if (pStackData->last_rxed_lcp_echo_request_packet != NULL)
	{
	netMblkClChainFree(pStackData->last_rxed_lcp_echo_request_packet);
	pStackData->last_rxed_lcp_echo_request_packet = NULL;
	}

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

    if (pStackData->callbacks && pStackData->callbacks->stackDeleteComplete)
	{
	(*pStackData->callbacks->stackDeleteComplete)
				    (pStackData->callbacks ,pComponentState);
	return OK;
	}
    else
	return ERROR;
    }

#if 0
/*******************************************************************************
* lcpSend - LCP send interface 
*
*
*/
LOCAL STATUS lcpSend
    (
    PFW_PLUGIN_OBJ_STATE * pComponentState,	/* state for this stack */
    M_BLK_ID * pMblkId                   	/* packet to send */
    )
    {
    #if 0
    LCP_STACK_DATA * pStackData = (LCP_STACK_DATA *) pComponentState->stackData;
    #endif

    return OK;
    }

#endif
/*******************************************************************************
* lcpReceive - LCP receive interface 
*
*
*/
LOCAL STATUS lcpReceive
    (
    PFW_PLUGIN_OBJ_STATE * pComponentState,	/* state for this stack */
    M_BLK_ID * pMblkId                   	/* packet received */
    )
    {
    unsigned int protocol = 0;
    M_BLK_ID m = *pMblkId; 

    if (pMblkId != NULL && *pMblkId != NULL)
	{
        /* get the protocol id from the packet */

	protocol = ((m->m_data[0]&0xff) << 8) + (m->m_data[1] & 0xff);

	if (protocol == LCP_PROTOCOL)
	    lcp_packet_received(pComponentState,*pMblkId);
	else
	   send_lcp_protocol_reject(pComponentState,*pMblkId);
	}

    return OK;
    }

/*******************************************************************************
* removeAlternateValues - removes alternate and range values for the option
*
* NOMANUAL
*/
void removeAlternateValues
    (
    LCP_CONFIG_STRINGS 	*lcpOption,
    char 				*remoteOrLocal
    )
    {
    ALTERNATE_OPTION_STRING * nextString = NULL;
    ALTERNATE_OPTION_STRING * alternateString = NULL;

    if ((strstr(remoteOrLocal,"Local") != NULL) && (strlen (remoteOrLocal) <= 6))
	{
	alternateString = lcpOption->localAlternateConfigString;
	lcpOption->localAlternateConfigString = NULL;
	}
    else if ((strstr(remoteOrLocal,"Remote") != NULL)
	&& (strlen (remoteOrLocal) <= 7))
	{
	alternateString = lcpOption->remoteAlternateConfigString;
	lcpOption->remoteAlternateConfigString = NULL;
	}
    else
	return;

    while(alternateString != NULL)
	{
	nextString = alternateString->next;
    if (alternateString != NULL)
        {
        pfwFree (alternateString);
		alternateString = NULL;
        }

	alternateString = nextString;
	}
    }

/*******************************************************************************
* lcp_optionsHandler - generic handler for all LCP options
*
*
*/
LOCAL STATUS lcp_optionsHandler 
    (
    PFW_OBJ                    		*pfw,
    LCP_OPTION_TYPE              	optionType,   /* option number 0x1 - 0x17 */
    PFW_PARAMETER_OPERATION_TYPE 	operType,     /* operation type */
    void                       		*pData,      /* profile data bucket */
    char                       		*value       /* value for this parameter */
    )
    {
    int 					stringLength = 0;
    char 					**pConfigString = NULL;
    char 					*alternateStringPtr = NULL;
    LCP_PROFILE_DATA 		*pProfileData = (LCP_PROFILE_DATA *)pData;
    int 					alternateLength = 0;
    ALTERNATE_OPTION_STRING	*previous = NULL;
    ALTERNATE_OPTION_STRING *alternateString = NULL;
    int 					valueLength = 0;
    BOOLEAN 				isLocalConfig=TRUE;
	LCP_CONFIG_STRINGS		*pOptionConfigStrings = NULL;
	PPP_LCP_COMPONENT		*pComponentData = NULL;
	LCP_CONFIG_OPTION		*pLcpOption = NULL;
	BOOLEAN					isTrue = TRUE;					
	char 					tempValue[MAX_VALUE_STRING_LENGTH];	
    LCP_STACK_DATA 			* pStackData = pProfileData->stackData;
    OPTION_LIST 			* optionList = NULL;
    OPTION_LIST_ENTRY 		* optionEntry = NULL;
	ALTERNATE_OPTION		*sptr_alternate_option = NULL;

	if (value == NULL)
		return ERROR;

	if (pfw == NULL)
		return ERROR;

	if (pProfileData == NULL)
		return ERROR;

	pComponentData = (PPP_LCP_COMPONENT *)pfwPluginObjGet (pfw, "PPP_LCP");

	if (pComponentData == NULL)
		return ERROR;

	pLcpOption = &pComponentData->option[optionType];
	if (pLcpOption == NULL)
		return ERROR;

	bzero (tempValue, sizeof (tempValue));

	if (pProfileData->lcpConfigStrings != NULL)
		pOptionConfigStrings = &pProfileData->lcpConfigStrings[optionType];

	if (operType == PFW_PARAMETER_SET)
	{
	if (pOptionConfigStrings == NULL)
		{
	   	return (lcp_setStackData(pfw, pProfileData, pLcpOption, value));
		}

	valueLength = strlen(value);