pppipcpcomponent.c

这是全套的PPP协议的源码

	if (pStackData == NULL)
		{
		if (pOptionConfigStrings == NULL)
			return ERROR;

        stringLength = 0;
        if (pOptionConfigStrings->configString)
            {
            sprintf(value,"{%s}",pOptionConfigStrings->configString);
            stringLength = strlen(value);
            }

        if (pOptionConfigStrings->remoteConfigString)
            {
            if ((stringLength  + 
			strlen(pOptionConfigStrings->remoteConfigString)) <
                MAX_VALUE_STRING_LENGTH)

            sprintf(value+stringLength,"{%s}", 
					pOptionConfigStrings->remoteConfigString);

            stringLength += strlen(pOptionConfigStrings->remoteConfigString)+2;
            }
        alternateString = pOptionConfigStrings->alternateConfigString;
        while(alternateString)
            {
            if ((stringLength + strlen(alternateString->configString)) <
                MAX_VALUE_STRING_LENGTH)
                {
                sprintf(value+stringLength,",{%s}",
                                        alternateString->configString);
                stringLength += strlen(alternateString->configString)+2;
                }
            else
                break;
            alternateString = alternateString->next;
            }
        return OK;
		}

	while(isTrue == TRUE)
		{
		if (isLocalConfig == TRUE)
                { 														
		    optionList = &pStackData->stackData.option_lists.configured;  

                optionEntry = 
				find_matching_option(optionList,ipcpOption->optionType);
			
			
            /* 
             * If its a compression option type then check if IPCP Option name
             * matches with Option Entry name. If it doesn't match then 
             * assign optionEntry = NULL
             */
  
                if (ipcpOption->optionType == IP_COMPRESSION_OPTION_TYPE)
		        {
                    if (optionEntry != NULL )       
                        {
                        if (strcmp (ipcpOption->name, optionEntry->cptr_option_name) != 0)
                            {
				    optionEntry = NULL;
                            }
                        }
			  }

                if (optionEntry != NULL)									
		        strcpy(value, "{Local:");
		    }
		else
		    {
		    optionList = &pStackData->stackData.option_lists.remote_configured;  

		    optionEntry = 
				find_matching_option(optionList,ipcpOption->optionType);


		/* 
             * If its a compression option type then check if IPCP Option name
             * matches with Option Entry name. If it doesn't match then 
             * assign optionEntry = NULL
             */

                if (ipcpOption->optionType == IP_COMPRESSION_OPTION_TYPE)
		        {
	     		  if (optionEntry != NULL )       
                        if (strcmp (ipcpOption->name, optionEntry->cptr_option_name) != 0)
					    optionEntry = NULL;
                    }

		    if (optionEntry != NULL)									
			  strcat(value ,"{Remote:");
		    isTrue = FALSE;
		    }

		if(optionEntry != NULL)											
			{
			if(optionEntry->option_flags.negotiation_required == PPP_FLAG_ON)
				strcat(value, "Negotiation Required, ");

			else if (optionEntry->option_flags.negotiation_required == PPP_FLAG_OFF)
				strcat(value, "Negotiation Not Required, ");
	
			else 
				{
				printf("Error in flag\n");
				return(ERROR);
				}

			if(optionEntry->option_flags.negotiable == PPP_FLAG_ON)
				strcat(value , "Negotiable");

			else if (optionEntry->option_flags.negotiable == PPP_FLAG_OFF)
				strcat(value, "Not Negotiable");

			else 
				{
				printf("Error in flag\n");
				return(ERROR);
				}
			bzero (tempValue, sizeof (tempValue));
			get_value_string(optionEntry->uptr_data,
							optionEntry->length,
							ipcpOption->optionTypeString,
							tempValue,
							*((UNION_OPTION_TYPES *) &ipcpOption->optionType),
							ipcpOption->name);

			if (strlen(tempValue) != 0)
				{
				strcat(value,":");											
				strcat(value, tempValue);
				}
			strcat(value,"}");
			}
		isLocalConfig = FALSE;		
		}
	isTrue = TRUE;
	isLocalConfig = TRUE;
	while(isTrue == TRUE)
		{
		if (isLocalConfig == TRUE)
			{ 														
		    optionList = &pStackData->stackData.option_lists.configured;  

			optionEntry = 
				find_matching_option(optionList,ipcpOption->optionType);

		/* 
             * If its a compression option type then check if IPCP Option name
             * matches with Option Entry name. If it doesn't match then 
             * assign optionEntry = NULL
             */

                if (ipcpOption->optionType == IP_COMPRESSION_OPTION_TYPE)
                    {
                    if (optionEntry != NULL )                 
                        if (strcmp (ipcpOption->name, optionEntry->cptr_option_name) != 0)
                            optionEntry = NULL;
                    }
                }
		else
			{
		    optionList = &pStackData->stackData.option_lists.remote_configured;  

			optionEntry = 
				find_matching_option(optionList,ipcpOption->optionType);

		/* 
             * If its a compression option type then check if IPCP Option name
             * matches with Option Entry name. If it doesn't match then 
             * assign optionEntry = NULL
             */

                if (ipcpOption->optionType == IP_COMPRESSION_OPTION_TYPE)
                    {
                    if (optionEntry != NULL )    
                        if (strcmp (ipcpOption->name, optionEntry->cptr_option_name) != 0)
                            optionEntry = NULL;
                    }

                isTrue = FALSE;
                }

		if (optionEntry != NULL)
			{
			if(optionEntry->option_flags.alternate_checking_enabled == PPP_FLAG_ON)
				{
				for (sptr_alternate_option = 
					 		optionEntry->alternate_option_list.sptr_forward_link;
							sptr_alternate_option != NULL; )
					{
					if (isLocalConfig == TRUE)
						strcat(value, "{Local:Alternate:");
					else
						strcat(value, "{Remote:Alternate:");

					bzero (tempValue, sizeof (tempValue));
					get_value_string(sptr_alternate_option->uptr_data,
								sptr_alternate_option->length,
								ipcpOption->optionTypeString,
								tempValue, 
								*((UNION_OPTION_TYPES *) &ipcpOption->optionType),
								ipcpOption->name); 
	
					strcat(value, tempValue);
					strcat(value, "}");
					sptr_alternate_option = 
							sptr_alternate_option->links.sptr_forward_link;
					}			
				}

			if((optionEntry->option_flags.range_checking_enabled == PPP_FLAG_ON) &&
		   (optionEntry->range_option != NULL))
				{
				if (isLocalConfig == TRUE)
					strcat(value, "{Local:Range:");
				else
					strcat(value, "{Remote:Range:");

				bzero (tempValue, sizeof (tempValue));
				get_value_string(optionEntry->range_option->uptr_lowest_value,
								optionEntry->length,
								ipcpOption->optionTypeString,
								tempValue, 
								*((UNION_OPTION_TYPES *) &ipcpOption->optionType),
								ipcpOption->name); 

				strcat(value, tempValue);
				strcat(value, ",");

				bzero (tempValue, sizeof (tempValue));
				get_value_string(optionEntry->range_option->uptr_highest_value,
								optionEntry->length,
								ipcpOption->optionTypeString,
								tempValue, 
								*((UNION_OPTION_TYPES *) &ipcpOption->optionType),
								ipcpOption->name); 
	
				strcat(value, tempValue);
				strcat(value, ",");

				bzero (tempValue, sizeof (tempValue));
				get_value_string(optionEntry->range_option->uptr_step,
								optionEntry->length,
								ipcpOption->optionTypeString,
								tempValue, 
								*((UNION_OPTION_TYPES *) &ipcpOption->optionType),
								ipcpOption->name); 

				strcat(value, tempValue);
				strcat(value,"}");
				}
			}
		isLocalConfig = FALSE;		
		
		}	
    return OK;
	}
    return ERROR;
    }



/*******************************************************************************
*
* stackAdd -
*/
LOCAL STATUS stackAdd
    (
    PFW_PLUGIN_OBJ_STATE *state,
    PFW_PLUGIN_OBJ_CALLBACKS * callbacks
    )
    {
    IPCP_STACK_DATA *   pIpcpStackData   = (IPCP_STACK_DATA *) state->stackData;
    IPCP_PROFILE_DATA * pIpcpProfileData = (IPCP_PROFILE_DATA *) state->profileData;
    NCP_STACK_DATA  *   pNcpStackData    = (NCP_STACK_DATA *) state->stackData;

    int id = 0;
    PPP_CONTROL_PROTOCOL_STATE_DATA *pStateData = 
	    (PPP_CONTROL_PROTOCOL_STATE_DATA *) pNcpStackData;
    PFW_LAYER_OBJ * layerObj = 
			((PFW_COMPONENT_OBJ *)state->pluginObj)->layerObj;

    pStateData->state = PPP_INITIAL_STATE;

    /* Remember the stack object this profile belongs to */

    pIpcpProfileData->pIpcpStackData = pIpcpStackData;

    pNcpStackData->callbacks = callbacks;

    /* Call initialize_ip_ncp */

    initialize_ip_ncp (state);

    initialize_ipcp_mibs (state);

    if ((pNcpStackData->ncp_timer = pfwTimerCreate(state)) == NULL)
         return ERROR;

    copy_configuration_options_to_tx_accepted_options(
	state->pluginObj->pfwObj,&pNcpStackData->option_lists);

    /* Start the timers for config reqs */

#if 0
    pfwTimerStart(pIpcpStackData->ncp_timer,PFW_SECOND,1,ipcp_periodic_timer,0);
#endif

    pIpcpStackData->pppIpInterface.state 	= NULL;
    pIpcpStackData->pppIpInterface.interfaceObj = NULL;

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

    {
        PFW_EVENT_OBJ *eventObj;

        if ((eventObj = pfwEventObjGet(state->pluginObj->pfwObj,"LCP_UP_EVENT")) ==NULL)
            return ERROR;
        pfwEventStackSubscribe(state, eventObj, setStackLRIpAddrFromRAS);

        if ((eventObj = pfwEventObjGet(state->pluginObj->pfwObj,"PPP_LINK_RESET_EVENT")) ==NULL)
            return ERROR;
        pfwEventStackSubscribe(state, eventObj, relStackLRIpAddrToRAS);
    }

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

/*******************************************************************************
*
* stackDelete -
*/

LOCAL STATUS stackDelete
    (
    PFW_PLUGIN_OBJ_STATE *state
    )
    {
    IPCP_STACK_DATA * pStackData    = (IPCP_STACK_DATA *) state->stackData;
    NCP_STACK_DATA *  pNcpStackData = (NCP_STACK_DATA *) state->stackData;

    ipcp_zero_restart_counter (state, NULL, PPP_CLOSED_STATE);

    if (pStackData->useRasAddress && pStackData->validRasAddress)
        relStackLRIpAddrToRAS(state, NULL);


    /* TO DO Remove the timers if present */

    pfwTimerDelete (pNcpStackData->ncp_timer);


    if (pStackData->pppIpInterface.interfaceObj != NULL)
	pfwInterfaceReferenceDelete (pStackData->pppIpInterface.interfaceObj);


    if (pNcpStackData->pControlLayerInterface != NULL)
	pfwInterfaceReferenceDelete(
	    (PFW_INTERFACE_OBJ *)pNcpStackData->pControlLayerInterface);

    if (pStackData->hcConfigured &&
	pStackData->pppHCInterface.interfaceObj != NULL)
	pfwInterfaceReferenceDelete(pStackData->pppHCInterface.interfaceObj);

    if (pNcpStackData->last_txed_ncp_configuration_request_packet != NULL)
	{
	netMblkClChainFree (
	    pNcpStackData->last_txed_ncp_configuration_request_packet);
	pNcpStackData->last_txed_ncp_configuration_request_packet = NULL;
	}

    /* Inform the upper layers we are down */

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

/*******************************************************************************
*
* profileDataConstruct -
*/

LOCAL STATUS profileDataConstruct 
   (
   PFW_OBJ *pfw,
   void *profileData
   )
   {
   IPCP_PROFILE_DATA * pIpcpData = (IPCP_PROFILE_DATA *) profileData;
   NCP_PROFILE_DATA  * pData     = (NCP_PROFILE_DATA *) profileData;

#if 0
   bzero (profileData, sizeof (NCP_PROFILE_DATA));
#endif

   bzero ((char *) pIpcpData, sizeof (IPCP_PROFILE_DATA));

   pData->maximum_number_of_termination_requests 
			    = MAXIMUM_TERMINATION_REQUESTS;
   pData->maximum_number_of_configuration_requests
			    = MAXIMUM_CONFIGURATION_REQUESTS;
   pData->maximum_configuration_request_send_interval 
			    = MAXIMUM_CONFIGURATION_REQUEST_SEND_INTERVAL;
   pData->maximum_termination_request_send_interval 
			    = MAXIMUM_TERMINATION_REQUEST_SEND_INTERVAL;

   pData->maximum_number_of_configuration_failures
                            = MAXIMUM_CONFIGURATION_FAILURES;

   pData->maximum_configuration_request_backoff_interval = 0;
                            /* MAXIMUM_CONFIGURATION_REQUEST_BACKOFF_INTERVAL*/
   
   pIpcpData->pIpcpConfigStrings = pfwMalloc (pfw, 
               sizeof (IPCP_CONFIG_STRINGS)	* (NUMBER_OF_IPCP_OPTIONS + 1));

   if (pIpcpData->pIpcpConfigStrings == NULL)