lcpinterfaces.c

这是全套的PPP协议的源码

    {
    LCP_STACK_DATA * pStackData = (LCP_STACK_DATA *)lcpState->stackData;
    OPTION_LIST_ENTRY * optionEntry = NULL;
    ALTERNATE_OPTION *alternateOption = NULL;

    UINT8 * data = NULL;
    UINT8   dataLen = 0;
    int     foundPref = -1;

   
    optionEntry = find_matching_option(&pStackData->option_lists.configured,
					LCP_AUTHENTICATION_PROTOCOL);

    if (NULL == optionEntry)
       {
       return -1;
       }

    if (preference == 0)
		{
		foundPref = 0;
		data = (UINT8 *)optionEntry->uptr_data;
		dataLen = (UINT8 )optionEntry->length;
		}
    else
		{

	/* find the corresponding entry in the alternateOption List */

		for (alternateOption =
		 	optionEntry->alternate_option_list.sptr_forward_link;
		 	alternateOption != NULL;
		 	alternateOption = alternateOption->links.sptr_forward_link)
			{
			if (alternateOption->preference == preference)
	 	   		{
				break;
		   		}
		 	}
		if (alternateOption == NULL)
			return -1;
		data = (UINT8 *)alternateOption->uptr_data;
		dataLen = (UINT8 )alternateOption->length;
		foundPref = alternateOption->preference;

		}

    memcpy(protocol,data,dataLen);
    *protocolLen = dataLen;

    return(foundPref);
    }

/*******************************************************************************
* pppSecurityConfigProtocolSet -
*/
LOCAL STATUS pppSecurityConfigProtocolSet
    (
    PFW_PLUGIN_OBJ_STATE * lcpState,
    ULONG preference,
    UINT8 * protocol,
    UINT8   protocolLen
    )
    {
    LCP_STACK_DATA * 		pStackData = (LCP_STACK_DATA *)lcpState->stackData;
    OPTION_LIST_ENTRY *	 	optionEntry = NULL;
    ALTERNATE_OPTION *		previous = NULL;
    ALTERNATE_OPTION *		alternateOption = NULL;
    PFW_OBJ 			* 	pfwObj = lcpState->pluginObj->pfwObj;
	PPP_LCP_COMPONENT	* 	pComponentData = NULL;
	LCP_CONFIG_OPTION	* 	lcpOption = NULL;
	
	int     stringLength = 0;
    char    partialString[256];
    void * 	data_buffer = NULL;
 
	pComponentData = (PPP_LCP_COMPONENT *) pfwPluginObjGet (pfwObj, "PPP_LCP");
	if (pComponentData == NULL)
		return ERROR;

	lcpOption = &pComponentData->option [LCP_AUTHENTICATION_PROTOCOL];
	if (lcpOption == NULL)
		return ERROR;

	if (pfwPluginObjStateLock(lcpState) != OK)
	return (ERROR);

    optionEntry = find_matching_option(&pStackData->option_lists.configured,
					LCP_AUTHENTICATION_PROTOCOL);

    bzero(partialString,256);

    if (preference == 0 || optionEntry == NULL)
	{
	sprintf(partialString,"Local:Negotiation Required,Negotiable:");
	stringLength = strlen(partialString);

	/*for (i = 0; i<protocolLen; i++)*/
	/* in the profile we only set protocol values as two bytes  */
	sprintf(&partialString[stringLength],"%04x",
			    (USHORT)(protocol[0] << 8 | protocol[1]));

	if (optionEntry == NULL)
	    {
	    if (generate_option_list_entry(pfwObj,&pStackData->option_lists,
					    partialString,
					    lcpOption->name,
					    lcpOption->optionType,"LCP",
					    lcpOption->optionTypeString) != OK)
			{
			pfwPluginObjStateRelease(lcpState);
			return ERROR;
			}
	    }
	else
	    {
	    if (optionEntry->length < protocolLen)
			{
			if ((data_buffer = pfwMalloc(pfwObj,protocolLen)) == NULL)
		 	   {
		  	  	pfwPluginObjStateRelease(lcpState);
		   	 	return ERROR;
		    	}
			if (optionEntry->uptr_data != NULL)
				{
				pfwFree(optionEntry->uptr_data);
				optionEntry->uptr_data = NULL;   
				}
			optionEntry->uptr_data = data_buffer;
			}
	    memcpy(optionEntry->uptr_data,(void *)protocol,protocolLen);
	    optionEntry->length = protocolLen;
	    }
	}


    if (preference > 0)
	{
		
	optionEntry = find_matching_option(&pStackData->option_lists.configured,
					LCP_AUTHENTICATION_PROTOCOL);

	for (alternateOption =
		 optionEntry->alternate_option_list.sptr_forward_link;
		 alternateOption != NULL;
		 alternateOption = alternateOption->links.sptr_forward_link)
		{
		if (alternateOption->preference >= preference)
	 	   	{
	  	  	break;
		   	}
		previous = alternateOption;
	    }

	/* now update the data in the alternate_option_list */

	if ((alternateOption != NULL))
		{
	  	if (alternateOption->preference == preference)
			{
			if (alternateOption->length < protocolLen)
				{
		 	 	if ((data_buffer = pfwMalloc(pfwObj,protocolLen)) == NULL)
					{
					printf("PPP: Out of Memory for data_buffer \r\n");
					return (FAIL);
					}
				bzero ((void *)data_buffer, protocolLen);
				if (alternateOption->uptr_data != NULL)
					pfwFree(alternateOption->uptr_data);
				alternateOption->uptr_data = NULL;    
   				alternateOption->uptr_data = data_buffer;
   				}
			memcpy(alternateOption->uptr_data,(void *)protocol,protocolLen);
			alternateOption->length = protocolLen;
			}
		else 
			{
			if (insertAlternateOptionToList (pfwObj,optionEntry,
				protocolLen, protocol,previous) == FAIL)
				{
				pfwPluginObjStateRelease(lcpState);
				return ERROR;
				}
		
			/* set the preference to the newley inserted alternate option list */
			if (previous != NULL)
				previous->links.sptr_forward_link->preference = preference ;
			else
				{
				optionEntry->alternate_option_list.sptr_forward_link->preference = preference;
				}
			}
		} 
		else 
			{
	 	   if (add_option_to_alternate_list (pfwObj,
				&pStackData->option_lists.configured,
				LCP_AUTHENTICATION_PROTOCOL, protocolLen,
				protocol) == FAIL)
		 	   {
		  	   pfwPluginObjStateRelease(lcpState);
		       return ERROR;
		       }

			/* set the preference to the newley added alternate option list */
			optionEntry->alternate_option_list.sptr_backward_link->preference = preference;
	    	}
			
	}
			    
    pfwPluginObjStateRelease(lcpState);
    return(OK);
    }

#if 0
/*******************************************************************************
* pppSecurityConfigStatusGet -
*/
LOCAL int  pppSecurityConfigStatusGet
    (
    PFW_PLUGIN_OBJ_STATE * lcpState,
    ULONG preference,
    ULONG *configStatus
    )
    {
    LCP_STACK_DATA * pStackData = (LCP_STACK_DATA *)lcpState->stackData;
    LCP_PROFILE_DATA * pProfileData = (LCP_PROFILE_DATA *)lcpState->profileData;
    OPTION_LIST_ENTRY * optionEntry;
    ALTERNATE_OPTION *alternateOption;
    ALTERNATE_OPTION_STRING *alternateString;
    ALTERNATE_OPTION_STRING *previousAlternateString;
    int     count;
    int foundPref = -1;

    if (pProfileData->option[LCP_AUTHENTICATION_PROTOCOL].configString
	    == NULL)
	return (-1);

    optionEntry = find_matching_option(&pStackData->option_lists.configured,
					LCP_AUTHENTICATION_PROTOCOL);

    if  (NULL == optionEntry)
        {
        return (-1);
        }

    if (preference == 0)
	{
	foundPref = 0;
	*configStatus = 2;
	}
    else
	{
	count = 0;

	alternateString = 
	pProfileData->option[LCP_AUTHENTICATION_PROTOCOL].alternateConfigString;

	previousAlternateString = NULL;
	while(alternateString && alternateString->preference < preference)
	    { 
	    previousAlternateString = alternateString;
	    alternateString = alternateString->next;
	    count++;
	    }

	if (alternateString != NULL)
	    foundPref = alternateString->preference;
	else
	    return (-1);

	for (alternateOption =
	     optionEntry->alternate_option_list.sptr_forward_link;
	     alternateOption != NULL;
	     alternateOption = alternateOption->links.sptr_forward_link)
	    {
	    if (count == 0)
		{
		break;
		}
	    count--;
	    }

	if (alternateOption == NULL)
	    return (-1);

	*configStatus = 2;
	}

    return foundPref;
    }
#endif

/*******************************************************************************
* pppSecurityConfigStatusSet - 
*/
LOCAL STATUS pppSecurityConfigStatusSet
    (
    PFW_PLUGIN_OBJ_STATE * lcpState,
    ULONG preference,
    UINT32 configStatus
    )
    {
    LCP_STACK_DATA 		* pStackData = (LCP_STACK_DATA *)lcpState->stackData;
    OPTION_LIST_ENTRY 	* optionEntry = NULL;
	ALTERNATE_OPTION 	* alternateOption = NULL;
    
  
    /* we cannot set entries to valid because we delete if invalid */

    if (configStatus == 2)
	return (ERROR);

    if (pfwPluginObjStateLock(lcpState) != OK)
	return (ERROR);

    optionEntry = find_matching_option(&pStackData->option_lists.configured,
					LCP_AUTHENTICATION_PROTOCOL);
    if (preference == 0)
	{
	/* if there are no alternate values delete from configured list */
		
		if (optionEntry->alternate_option_list.sptr_forward_link == NULL)
		    {
	 	   	delete_entry_from_list (
				(LINK *) &pStackData->option_lists.configured,
				(LINK *) optionEntry);

	    	if (optionEntry->length > 0x00)
				{
				if (optionEntry->uptr_data != NULL)
                    {
                    pfwFree ((void *)optionEntry->uptr_data);
                    optionEntry->uptr_data = NULL;     
                    }
                }
            if (optionEntry != NULL)
                {
                pfwFree(optionEntry);
                optionEntry = NULL;     
                }
            }
	
		else
	 	   {
			alternateOption = 
		 	   optionEntry->alternate_option_list.sptr_forward_link;
	   		pppSecurityConfigProtocolSet (
			    lcpState, preference,
			    (UINT8  *)alternateOption->uptr_data,
			    alternateOption->length);
			}
	}
    else
		{
		for (alternateOption =
		     optionEntry->alternate_option_list.sptr_forward_link;
	 	     alternateOption != NULL;
	  		 alternateOption = alternateOption->links.sptr_forward_link)
	    	{
			if (alternateOption->preference >= preference)
				{
				break;
				}
		    }

		if (alternateOption == NULL)
			{
	    	pfwPluginObjStateRelease(lcpState);
	    	return (ERROR);
	    	}
		
		if (alternateOption->preference != preference)
			{
	  		pfwPluginObjStateRelease(lcpState);
	    	return (ERROR);
	    	}
		delete_entry_from_list ((LINK *) &optionEntry->alternate_option_list,
			    (LINK *) &alternateOption->links.sptr_forward_link);

		if (alternateOption->length > 0)
			{
			if (alternateOption->uptr_data != NULL)
		    	pfwFree(alternateOption->uptr_data);
			alternateOption->uptr_data = NULL;
			}
        if (alternateOption != NULL)
            {
            pfwFree(alternateOption);
            alternateOption = NULL;    
            }
      
	}

    pfwPluginObjStateRelease(lcpState);
    return OK;
    }