pppipv6cpcomponent.c

这是全套的PPP协议的源码

    pAlternateString = pIpv6cpOption->alternateConfigString;
    pPrevious        = NULL;
    while (pAlternateString)
        {
        if (NULL != strstr(pAlternateString->configString,pRemoteOrLocal))
            {
            if (NULL == pPrevious)
                {
                pIpv6cpOption->alternateConfigString = pAlternateString->next;
                pfwFree(pAlternateString);
                pAlternateString = NULL;     
                pAlternateString = pIpv6cpOption->alternateConfigString;
                continue;
                }
            else
                {
                pPrevious->next  = pAlternateString->next;
                pfwFree(pAlternateString);
                pAlternateString = NULL;    
                }
            }    
	    else
            pPrevious = pAlternateString;

        pAlternateString = pPrevious->next;
        }
    }

/**************************************************************************
* ipv6cp_optionsHandler - generic handler for all IPV6CP options
*
* If operation type is PFW_PARAMETER_SET, the options given in value are copied 
* into options structure of IPV6CP_PROFILE_DATA, if operation type is 
* PFW_PARAMETER_GET the options data is copied into the passed value. 

*
* RETURNS: OK or ERROR
*/

LOCAL  STATUS ipv6cp_optionsHandler 
    (
    PFW_OBJ * 			            pPfwObj,        /* framework reference */
    IPV6CP_OPTION_TYPE 	            optionType,     /* option type */
    PFW_PARAMETER_OPERATION_TYPE    type,           /* operation type */
    void *                          pData,          /* data reference */
    char *                          pVal            /* value for this parameter */
    )
    {
    IPV6CP_CONFIG_OPTION *     pIpv6cpOption          = NULL;
    char **                    ppConfigString         = NULL;
    char *                     pAlternateStringPtr    = NULL;
    ALTERNATE_OPTION_STRING *  pPrevious              = NULL;
    ALTERNATE_OPTION_STRING *  pAlternateString       = NULL;
    int                        alternateLength        = 0;
    int                        stringLength           = 0;
    int                        valueLength            = 0;
    IPV6CP_CONFIG_STRINGS *    pOptionConfigStrings   = NULL; 
    PPP_IPV6CP_COMPONENT *     pComponentData         = NULL;
    char                       configString[256];
    BOOLEAN                    isTrue                 = TRUE;
    char                       tempValue [MAXIMUM_LENGTH_OF_OPTION_STRING]; 					
    OPTION_LIST *              pOptionList            = NULL;
    OPTION_LIST_ENTRY *        pOptionEntry           = NULL;
    ALTERNATE_OPTION *         pSptr_alternate_option = NULL;
    BOOLEAN                    isLocalConfig          = TRUE;
    char *                     pValue                 = pVal;
    IPV6CP_PROFILE_DATA *      pProfileData = (IPV6CP_PROFILE_DATA *) pData;
    NCP_STACK_DATA *           pStackData = (NCP_STACK_DATA *) 
                                             pProfileData->pIpv6cpStackData;

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

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

    pComponentData = (PPP_IPV6CP_COMPONENT *) pfwPluginObjGet (
                                                  pPfwObj, "PPP_IPV6CP");

    if (NULL == pComponentData)
        return ERROR;

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

    if (NULL != pProfileData->pIpv6cpConfigStrings)
        pOptionConfigStrings = &pProfileData->pIpv6cpConfigStrings[optionType];
    
    if (type == PFW_PARAMETER_SET)
        {
        valueLength = strlen (pValue);
        if (NULL == pOptionConfigStrings)
            {
            return (ipv6cp_setStackData (pPfwObj, pProfileData, 
                                                pIpv6cpOption, pValue));
            }

        if (NULL != strstr(pValue,"Remote"))
            {
            if (valueLength <= 7) /* 7 ==> strlen("Remote:") */
                {
                if (NULL != pOptionConfigStrings->remoteConfigString)
                    {
                    pfwFree(pOptionConfigStrings->remoteConfigString);
                    pOptionConfigStrings->remoteConfigString = NULL;
                    }
                removeAlternateValues (pOptionConfigStrings,pValue);
                return (ipv6cp_setStackData(pPfwObj, pProfileData, 
                                                   pIpv6cpOption, pValue));
            	}
            ppConfigString = &pOptionConfigStrings->remoteConfigString;
           }
        else if (NULL != strstr (pValue,"Local"))
            {
            if (valueLength <= 6) /* 6 ==> strlen("Local:") */
                {
                if (NULL != pOptionConfigStrings->configString)
                    {
                    pfwFree(pOptionConfigStrings->configString);
                    pOptionConfigStrings->configString = NULL;
                    }
                removeAlternateValues (pOptionConfigStrings,pValue); 
                return (ipv6cp_setStackData (pPfwObj, pProfileData, 
                                                 pIpv6cpOption, pValue));
                }
                ppConfigString = &pOptionConfigStrings->configString;
            }
        else
            return ERROR;

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

            alternateLength = sizeof (ALTERNATE_OPTION_STRING) + valueLength;
            if (NULL == (pAlternateString = pfwMalloc (pPfwObj,alternateLength)))
                return ERROR;

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

            pAlternateStringPtr = pAlternateString->configString;
            ppConfigString = &pAlternateStringPtr;

            /* just to say that we already have a long enough buffer */

            memset (*ppConfigString,'e',valueLength);
            }

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

        if (NULL != *ppConfigString)
            {

            /* do we have a long enough buffer */

            if ((stringLength = strlen (*ppConfigString)) < valueLength)
                {
                if (NULL != *ppConfigString)      
                   {
                   pfwFree (*ppConfigString);
                   *ppConfigString = NULL;
                   }
                }
            }

        stringLength = valueLength;

        if (NULL == *ppConfigString)
            if ((*ppConfigString = pfwMalloc (pPfwObj,stringLength + 1)) == NULL)
                return ERROR;

        bzero (*ppConfigString,stringLength+1);
        strcpy (*ppConfigString,pValue);

        if (OK == ipv6cp_setStackData (pPfwObj, pProfileData, 
                                             pIpv6cpOption, pValue))
            return OK;
        else
            return ERROR; 
	    }

    else if (type == PFW_PARAMETER_GET)
        {
        if (NULL == pStackData)
            {
            if (NULL == pOptionConfigStrings)
                return ERROR;

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

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

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

                stringLength += strlen(pOptionConfigStrings->remoteConfigString)+2;
                }
            pAlternateString = pOptionConfigStrings->alternateConfigString;
            while (pAlternateString)
                {
                if ((stringLength + strlen(pAlternateString->configString)) <
                                                     MAX_VALUE_STRING_LENGTH)
                    {
                    sprintf(pValue+stringLength,",{%s}",
                                         pAlternateString->configString);
                    stringLength += strlen(pAlternateString->configString)+2;
                    }
                else
                    break;

                pAlternateString = pAlternateString->next;
                }

            return OK;
            }

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

                pOptionEntry = 
                   find_matching_option (pOptionList,pIpv6cpOption->optionType);

                if (NULL != pOptionEntry)									
                strcpy (pValue, "{Local:");
                }
            else
                {
                pOptionList = &pStackData->option_lists.remote_configured;  

                pOptionEntry = 
                     find_matching_option (pOptionList,pIpv6cpOption->optionType);

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

            if(NULL != pOptionEntry)											
                {
                if(PPP_FLAG_ON == 
                         pOptionEntry->option_flags.negotiation_required)
                    strcat (pValue, "Negotiation Required, ");
                else if (PPP_FLAG_OFF == 
                         pOptionEntry->option_flags.negotiation_required)
                    strcat (pValue, "Negotiation Not Required, ");
                else 
                    {
                    printf ("ipv6cp_optionsHandler: Error in flag\n");
                    return (ERROR);
                    }

                if(PPP_FLAG_ON == pOptionEntry->option_flags.negotiable)
                    strcat (pValue , "Negotiable");

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

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

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

                pOptionEntry = 
                     find_matching_option (pOptionList,pIpv6cpOption->optionType);
                }
            else
                {
                pOptionList = &pStackData->option_lists.remote_configured;  

                pOptionEntry = 
                    find_matching_option (pOptionList,pIpv6cpOption->optionType);

                isTrue = FALSE;
                }

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

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

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

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

                    strcat (pValue, tempValue);
                    strcat (pValue, ",");

                    bzero (tempValue, sizeof (tempValue));
                    get_value_string (pOptionEntry->range_option->uptr_highest_value,
                                pOptionEntry->length,
                                pIpv6cpOption->optionTypeString,
                                tempValue, 
                                *((UNION_OPTION_TYPES *) &pIpv6cpOption->optionType),
                                pIpv6cpOption->name); 
	
                    strcat (pValue, tempValue);
                    strcat (pValue, ",");

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

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

/***************************************************************************
*
* pppIpv6cpLinkResetHandler - reset default values when LCP goes down 
*
* This function is used to restore default values for the next connection. If 
* IPv6CP is in REQUEST_SENT, ACK_SENT, or ACK_RECVD when LCP goes down, this
* layer down would not be called.
*
*/

LOCAL STATUS pppIpv6cpLinkResetHandler
    (
    PFW_PLUGIN_OBJ_STATE * componentState,
    void *eventData
    )
    {
    IPV6CP_STACK_DATA *pIpv6cpStackData;
    NCP_STACK_DATA * pNcpStackData;

    pIpv6cpStackData = (IPV6CP_STACK_DATA *)componentState->stackData;
    pNcpStackData = (NCP_STACK_DATA *) &pIpv6cpStackData->stackData;

    ncpLinkReset (pNcpStackData);

    return (OK);
    }


#endif /* INET6 */