pppipcpcomponent.c

这是全套的PPP协议的源码

    /* publish and bind our IPCP MIB interfaces */

    ipcpInterfacesInit(pComponent);

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

    if (m2pppIpcpGroupRegister (pfw) != OK)
	printf ("PPP_IPCP: WARNING! Failed to register MIB II interface\n");

    return (OK);
    }

/*******************************************************************************
*
* ipcpSend -
*/

LOCAL STATUS ipcpSend
   (
   PFW_PLUGIN_OBJ_STATE *state,
   M_BLK_ID        * pkt
   )
   {
   return (OK);
   }

/*******************************************************************************
*
* ipcpReceive -
*/

LOCAL STATUS ipcpReceive
   (
   PFW_PLUGIN_OBJ_STATE *state,
   M_BLK_ID        * pkt
   )
   {
   ncp_packet_received(state, *pkt);
   
   return (OK);
   }

/*******************************************************************************
* ipcp_VJC - Set the Header Compression parameters
*
*/
LOCAL STATUS ipcp_VJC
    (
    PFW_OBJ *pfw,
    PFW_PARAMETER_OPERATION_TYPE type,
    void *pData,
    char *value
    )
    {
    return ipcp_optionsHandler (pfw, 
				ipcpOptionIndexGet ("VJC", IP_COMPRESSION_OPTION_TYPE),
				type, pData, value);
    }

/*******************************************************************************
* ipcp_HC - Set the Header Compression parameters
*
*/
LOCAL STATUS ipcp_HC
    (
    PFW_OBJ *pfw,
    PFW_PARAMETER_OPERATION_TYPE type,
    void *pData,
    char *value
    )
    {

    return ipcp_optionsHandler (pfw, 
				ipcpOptionIndexGet ("HC",IP_COMPRESSION_OPTION_TYPE),
				type, pData, value);
    }


/*******************************************************************************
* ipcp_IpAddr - Set/Get the local IP address
*
*/
LOCAL STATUS ipcp_IpAddr
    (
    PFW_OBJ *pfw,
    PFW_PARAMETER_OPERATION_TYPE type,
    void *pData,
    char *value
    )
    {
    return ipcp_optionsHandler (pfw, 
				ipcpOptionIndexGet("IP", IP_ADDRESS_OPTION_TYPE),
				type,pData, value);
    }

LOCAL STATUS ipcp_primaryDnsAddr
    (
    PFW_OBJ *pfw,
    PFW_PARAMETER_OPERATION_TYPE type,
    void *pData,
    char *value
    )
    {
    return ipcp_optionsHandler (pfw, 
				ipcpOptionIndexGet ("DNS", PRIMARY_DNS_ADDRESS), 
				type,pData, value);
    }

LOCAL STATUS ipcp_secondaryDnsAddr
    (
    PFW_OBJ *pfw,
    PFW_PARAMETER_OPERATION_TYPE type,
    void *pData,
    char *value
    )
    {
    return ipcp_optionsHandler (pfw, 
				ipcpOptionIndexGet ("SDNS", SECONDARY_DNS_ADDRESS),
				type,pData, value);
    }

/*******************************************************************************
*
* ipcpOptionIndexGet - get the index in the option list table
*
* RETURNS: the index of the relevant option in the option list table, or
* ERROR.
*/

LOCAL STATUS ipcpOptionIndexGet
    (
    char *              optionName,  /* option name */
    IPCP_OPTION_TYPE	optionType	 /* option type */
    )
    {
    int	retVal = ERROR;

    switch (optionType)
        {
        case IP_ADDRESSES_OPTION_TYPE:
        case IP_ADDRESS_OPTION_TYPE:
	      retVal = optionType;
	      break;

        case IP_COMPRESSION_OPTION_TYPE:
            if (strcmp (optionName, "VJC") == 0)
                {
	          retVal = optionType;
	          break;
                }

            if (strcmp (optionName, "HC") == 0)
                {
                retVal = IP_HEADER_COMPRESSION_INDEX;
                break;
                }

        case PRIMARY_DNS_ADDRESS:
            retVal = IP_PRIMARY_DNS_ADDRESS_INDEX;
            break;

        case SECONDARY_DNS_ADDRESS:
            retVal = IP_SECONDARY_DNS_ADDRESS_INDEX;
            break;

        default:
            break;

        }

    return (retVal);
    }

/*******************************************************************************
* removeAlternateValues - removes alternate and range values for the option
*
*/
LOCAL void removeAlternateValues 
    (
    IPCP_CONFIG_STRINGS * ipcpOption,
    char * remoteOrLocal
    )
    {
    ALTERNATE_OPTION_STRING * previous = NULL;
    ALTERNATE_OPTION_STRING * alternateString = NULL;

	if ((ipcpOption == NULL) || (ipcpOption->alternateConfigString == NULL))
		return;

    alternateString = ipcpOption->alternateConfigString;
    previous = NULL;
    while(alternateString)
	{
	if (strstr(alternateString->configString,remoteOrLocal) != NULL)
	    {
	    if (previous == NULL)
		{
		ipcpOption->alternateConfigString = alternateString->next;
		pfwFree(alternateString);
        alternateString = NULL;     
		alternateString = ipcpOption->alternateConfigString;
		continue;
		}
	    else
		{
		previous->next = alternateString->next;
		pfwFree(alternateString);
        alternateString = NULL;    
		}
	    }
	else
	    previous = alternateString;

	alternateString = previous->next;
	}
    }

/*******************************************************************************
* ipcp_optionsHandler - generic handler for all IPCP options
*
*/
LOCAL STATUS ipcp_optionsHandler 
    (
    PFW_OBJ 			            *pfwObj,
    IPCP_OPTION_TYPE 		            optionType,
    PFW_PARAMETER_OPERATION_TYPE            type,
    void                                    *pData,
    char 			            *value
    )
    {
    IPCP_PROFILE_DATA           *profileData = ( IPCP_PROFILE_DATA *)pData;
    IPCP_CONFIG_OPTION          *ipcpOption = NULL;
    char                        **pConfigString = NULL;
    char                        *alternateStringPtr = NULL;
    ALTERNATE_OPTION_STRING     *previous = NULL;
    ALTERNATE_OPTION_STRING     *alternateString = NULL;
    int                         alternateLength = 0;
    int                         stringLength = 0;
    int                         valueLength = 0;
    IPCP_CONFIG_STRINGS		    *pOptionConfigStrings = NULL; 
    PPP_IPCP_COMPONENT		    *pComponentData = NULL;
    char                            configString[256];
    int                             which_config = 0;
    BOOLEAN			    isTrue = TRUE;					
    char 			    tempValue[MAXIMUM_LENGTH_OF_OPTION_STRING]; 					
    IPCP_STACK_DATA 	       	* pStackData = profileData->pIpcpStackData;
    OPTION_LIST 			    *optionList = NULL;
    OPTION_LIST_ENTRY 		    *optionEntry = NULL;
    ALTERNATE_OPTION		    *sptr_alternate_option = NULL;
    BOOLEAN						isLocalConfig = TRUE;
    char						*pValue = value;

    bzero (configString, sizeof (configString));
    bzero (tempValue, sizeof (tempValue));

    if (value == NULL)
	return (ERROR);

    pComponentData = (PPP_IPCP_COMPONENT *)pfwPluginObjGet (pfwObj, "PPP_IPCP");

	if (pComponentData == NULL)
		return ERROR;

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

	if (profileData->pIpcpConfigStrings != NULL)
  		pOptionConfigStrings = &profileData->pIpcpConfigStrings[optionType];
    
    if (type == PFW_PARAMETER_SET)
	    {
        valueLength = strlen(value);
        if (pOptionConfigStrings == NULL)
    		{
            return (ipcp_setStackData(pfwObj, profileData, 
                                      ipcpOption, value));
	   	    }

	    if (strstr(value,"Remote") != NULL)
            {
            if (valueLength <= 7) /* 7 ==> strlen("Remote:") */
                {
                if (pOptionConfigStrings->remoteConfigString != NULL)
                    {
                    pfwFree(pOptionConfigStrings->remoteConfigString);
                    pOptionConfigStrings->remoteConfigString = NULL;
                    }
                removeAlternateValues(pOptionConfigStrings,value);
				return (ipcp_setStackData(pfwObj, profileData, 
                                          ipcpOption, value));
                }
            pConfigString = &pOptionConfigStrings->remoteConfigString;
            }
        else if (strstr(value,"Local") != NULL)
            {
            if (valueLength <= 6) /* 6 ==> strlen("Local:") */
                {
                if (pOptionConfigStrings->configString != NULL)
                    {
                    pfwFree(pOptionConfigStrings->configString);
                    pOptionConfigStrings->configString = NULL;
                    }
                removeAlternateValues(pOptionConfigStrings,value); 
				return (ipcp_setStackData(pfwObj, profileData, 
										 ipcpOption, value));
                }
            pConfigString = &pOptionConfigStrings->configString;
            }
        /* use RAS-AMM for Local and Remote IP addresses */
        else if (strstr(value,"RAS-AMM") != NULL) 
            {
            if (valueLength <= 8) /* 8 ==> strlen("RAS-AMM:") Error */
                {
                if (pOptionConfigStrings->configString)
                    {
                        pfwFree(pOptionConfigStrings->configString);
                        pOptionConfigStrings->configString = NULL;
                    }
                removeAlternateValues(pOptionConfigStrings,"Local:"); 
                if (pOptionConfigStrings->remoteConfigString)
                    {
                        pfwFree(pOptionConfigStrings->remoteConfigString);
                        pOptionConfigStrings->remoteConfigString = NULL;
                    }
                removeAlternateValues(pOptionConfigStrings,"Remote:"); 

				return (ipcp_setStackData(pfwObj, profileData, 
	                                       ipcpOption, value));
                }

            value = configString;

do_ras_config_again:

            bzero(configString, 256);
            /* On the first pass, we set local.  On second pass, we set remote */
            if (!which_config)
                {
                /* now generate the config string for Local */
                which_config = 1;
                pConfigString = &pOptionConfigStrings->configString;
                sprintf(configString,
						"%s%s","Local:Negotiation Required, Not Negotiable:",
						pValue);

                valueLength = strlen (configString);
                }
            else
                {
                /* now generate the config string for remote */
                which_config = 0;
                pConfigString = &pOptionConfigStrings->remoteConfigString;
                sprintf(configString, "%s%s",
						"Remote:Negotiation Required, Not Negotiable:", 
						pValue);

                valueLength = strlen (configString);
                }
            }
        else
            return ERROR;

        if (strstr(value,"Alternate") != NULL || strstr(value,"Range") != NULL)
            {
            alternateString = pOptionConfigStrings->alternateConfigString;
            previous = NULL;
            while(alternateString != NULL)
                {
                if (strcmp(alternateString->configString,value) == 0)
					{
                    return OK;
					}
                previous = alternateString;
                alternateString = alternateString->next;
                }

            alternateLength = sizeof(ALTERNATE_OPTION_STRING) + valueLength;
            if ((alternateString = pfwMalloc(pfwObj,alternateLength)) == NULL)
                return ERROR;

            bzero((void *)alternateString,alternateLength);
	        if (previous != NULL)
	            previous->next = alternateString;
	        else
	            pOptionConfigStrings->alternateConfigString = alternateString;

            alternateStringPtr = alternateString->configString;
            pConfigString = &alternateStringPtr;

            /* just to say that we already have a long enough buffer */
            memset(*pConfigString,'e',valueLength);
            }

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

        if (*pConfigString != NULL)
            {
            /* do we have a long enough buffer */
            if ((stringLength = strlen(*pConfigString)) < valueLength)
                {
                if (*pConfigString != NULL)      
                   {
                   pfwFree(*pConfigString);
                   *pConfigString = NULL;
                   }
                }
            }

        stringLength = valueLength;

        if (*pConfigString == NULL)
            if ((*pConfigString = pfwMalloc(pfwObj,stringLength + 1)) == NULL)
                return ERROR;

        bzero(*pConfigString,stringLength+1);
        strcpy(*pConfigString,value);

        ipcp_setStackData(pfwObj, profileData, ipcpOption, value);

        if (!which_config)
			{
            return OK;
			}
        else
            goto do_ras_config_again;
        }

    else if (type == PFW_PARAMETER_GET)
	{