pppipv6cpcomponent.c

这是全套的PPP协议的源码

        if (NULL != pSrcOption->configString)
            {            
            stringLength = strlen (pSrcOption->configString)+1;

            /* make a copy of the remote string */

            if (NULL == (pDstOption->configString = 
                                 pfwMalloc (pPfw,stringLength)))
                {
                ipv6cpProfileDataDestruct (pPfw,pDstProfileData);
                return ERROR;
                }

            bzero (pDstOption->configString,stringLength);
            strcpy (pDstOption->configString,pSrcOption->configString);
            }

        pAlternateConfigString = pSrcOption->alternateConfigString;
        pNewAlternateString    = NULL;

        while (NULL != pAlternateConfigString)
            {
            stringLength = strlen(pAlternateConfigString->configString) + 1;

            /* make a copy of the alternate config string */

            if (NULL != pNewAlternateString)
                {
                if(NULL == (pNewAlternateString->next = 
                                     pfwMalloc(pPfw,stringLength +
                                     sizeof(ALTERNATE_OPTION_STRING))))
                    {
                    ipv6cpProfileDataDestruct(pPfw,pDstProfileData);
                    return ERROR;
                    }
                else
                    pNewAlternateString = pNewAlternateString->next;
                }
            else 
                {
                if(NULL == (pNewAlternateString = pfwMalloc (pPfw,stringLength +
                                  sizeof (ALTERNATE_OPTION_STRING))))
                    {
                    ipv6cpProfileDataDestruct (pPfw,pDstProfileData);
                    return ERROR;
                    }
                else
                    pDstOption->alternateConfigString = pNewAlternateString;
                }

            bzero ((void *) pNewAlternateString,
                (stringLength + sizeof (ALTERNATE_OPTION_STRING)));
            strcpy (pNewAlternateString->configString,
                             pAlternateConfigString->configString);

            pAlternateConfigString = pAlternateConfigString->next;
            }
        }
    return OK;
    }

/******************************************************************************
* ipv6cpProfileDataDestruct - clean up profile data
*
* The framework calls this function before freeing the profile data so that all 
* the internal structures be freed. This function frees the memory held by the 
* option member ofIPV6CP_PROFILE_DATA structure.
*
* RETURNS: OK or ERROR
*/

LOCAL STATUS ipv6cpProfileDataDestruct 
    (
    PFW_OBJ *                                 pPfw,     /* framework reference */
    void *                                    pProfile  /* profile data */
    )
    {
    int                   options      = 0;
    IPV6CP_PROFILE_DATA * pProfileData = (IPV6CP_PROFILE_DATA *) pProfile;

    if (!pProfileData->pIpv6cpConfigStrings)
        return OK;

    /* free profile config strings */

    for (options = IPV6_INTERFACE_IDENTIFIER_OPTION_TYPE;
              options <= NUMBER_OF_IPV6CP_OPTIONS; options++)
        {
        ipv6cpOptionConfigStringsFree
                           (&pProfileData->pIpv6cpConfigStrings[options]);
        }
    if (NULL != pProfileData->pIpv6cpConfigStrings)     
        {
        pfwFree (pProfileData->pIpv6cpConfigStrings); 
        pProfileData->pIpv6cpConfigStrings = NULL;
        }

    return OK;
    }


/*******************************************************************************
* ipv6StackDataDestruct -  clean up stack data 
*
* When the IPV6CP plugin object is deleted from the stack, this function is called 
* to do the clean up. The memory used by the option_lists is freed. 
*
* RETURNS: OK or ERROR
*/


LOCAL STATUS ipv6cpStackDataDestruct
    (
    PFW_OBJ *                          pPfw,            /* framework reference */
    void *                             pStack,          /* stack data */
    void *                             pProfileData     /* profile data */
    )
    {

    IPV6CP_STACK_DATA * pIpv6cpSatckData = (IPV6CP_STACK_DATA *) pStack;
    NCP_STACK_DATA *    pStackData = (NCP_STACK_DATA *) 
                                             &pIpv6cpSatckData->stackData;

    /* free the option lists */

    free_ppp_option_lists (&pStackData->option_lists);

    return (OK);
    }

/**************************************************************************
* ipv6cpStackDataConstruct - initialize stack data 
*
* This function is called when a stack is created to initialize the stack data 
* of the IPV6CP component. The stack data structure members are initialized to 
* their initial values. Profile data is copied into the option_lists member of
* the stack data.
*
* RETURNS: OK or ERROR
*/

LOCAL STATUS ipv6cpStackDataConstruct
    (
    PFW_OBJ *                           pPfw,       /* framework reference */
    void *                              pStack,     /* stack data */
    void *                              pProfile    /* profile data */
    )
    {
    IPV6CP_STACK_DATA *       pStackData    = (IPV6CP_STACK_DATA *) pStack;
    NCP_STACK_DATA *          pNcpStackData = NULL;
    IPV6CP_PROFILE_DATA *     pProfileData  = (IPV6CP_PROFILE_DATA *) pProfile;
    IPV6CP_CONFIG_OPTION *    pIpv6cpOption =  NULL;
    ALTERNATE_OPTION_STRING * pAlternateConfigString = NULL;
    PPP_IPV6CP_COMPONENT *    pComponentData         = NULL;
    IPV6CP_CONFIG_STRINGS *   pIpv6cpConfigStrings   = NULL;
    int                       options                = 0;
    int                       stringLength           = 0;
    char                      partialString[256];


    bzero (partialString, sizeof (partialString));
    pComponentData = (PPP_IPV6CP_COMPONENT *) pfwPluginObjGet (pPfw, "PPP_IPV6CP");
    pNcpStackData = (NCP_STACK_DATA *) &pStackData->stackData;

    if (NULL == pComponentData)
        return ERROR;

    /* Intialize with zero for IPV6CP and NCP Stack Data */

    bzero ((char *) pStackData, sizeof (IPV6CP_STACK_DATA));
    bzero ((char *) pNcpStackData, sizeof (NCP_STACK_DATA));

    pNcpStackData->ncp_protocol = IPV6CP_PROTOCOL;

    if (NULL == (pNcpStackData->pNcpUpEventObj = 
                          pfwEventObjGet(pPfw,"IPV6CP_UP_EVENT")))
        {
        return ERROR;
        }

    if (NULL == (pNcpStackData->pNcpDownEventObj = 
                          pfwEventObjGet(pPfw,"IPV6CP_DOWN_EVENT")))
        {
        return ERROR;
        }

    /* copy the profile data option into option_lists */

    if (NULL != pProfileData->pIpv6cpConfigStrings)
        {
        for (options = IPV6_INTERFACE_IDENTIFIER_OPTION_TYPE;
                    options <= NUMBER_OF_IPV6CP_OPTIONS; options++)
            {
            pIpv6cpOption = &pComponentData->option[options];
            pIpv6cpConfigStrings = &pProfileData->pIpv6cpConfigStrings[options]; 

            if ((NULL == pIpv6cpConfigStrings->configString) && (NULL == 
                            pIpv6cpConfigStrings->remoteConfigString))
                continue;

            if (NULL != pIpv6cpConfigStrings->configString)
                {
                stringLength = strlen(pIpv6cpConfigStrings->configString) + 1;
                bzero(partialString,stringLength);
                strcpy(partialString,pIpv6cpConfigStrings->configString);

                if (OK != generate_option_list_entry(pPfw,
                        &pNcpStackData->option_lists,
                        partialString, pIpv6cpOption->name, 
                        pIpv6cpOption->optionType, "IPV6CP", 
                        pIpv6cpOption->optionTypeString))
                    {
                    return ERROR;
                    }
                }

            if (NULL != pIpv6cpConfigStrings->remoteConfigString)
                {
                stringLength = 
                         strlen(pIpv6cpConfigStrings->remoteConfigString)+1;
                bzero(partialString,stringLength);
                strcpy(partialString,
                                  pIpv6cpConfigStrings->remoteConfigString);

                if (OK != generate_option_list_entry(pPfw,
                        &pNcpStackData->option_lists,
                        partialString, pIpv6cpOption->name, 
                        pIpv6cpOption->optionType, "IPV6CP", 
                        pIpv6cpOption->optionTypeString))
                    {
                    return ERROR;
                    }
                }

            pAlternateConfigString = 
                               pIpv6cpConfigStrings->alternateConfigString;
            while (NULL != pAlternateConfigString)
                {
                stringLength = strlen(pAlternateConfigString->configString) + 1;
                bzero(partialString,stringLength);
                strcpy(partialString, pAlternateConfigString->configString);

                if (OK != generate_option_list_entry
                        (pPfw,&pNcpStackData->option_lists,
                        partialString, pIpv6cpOption->name,
                        pIpv6cpOption->optionType,"IPV6CP",
                        pIpv6cpOption->optionTypeString))
                    {
                    return ERROR;
                    }

                pAlternateConfigString = pAlternateConfigString->next;
                }
            }

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

        for (options = IPV6_INTERFACE_IDENTIFIER_OPTION_TYPE; 
                    options <= NUMBER_OF_IPV6CP_OPTIONS; options++)
            {
            ipv6cpOptionConfigStringsFree 
                (&pProfileData->pIpv6cpConfigStrings[options]);
            }
        if (NULL != pProfileData->pIpv6cpConfigStrings)    
            {
            pfwFree (pProfileData->pIpv6cpConfigStrings);
            pProfileData->pIpv6cpConfigStrings = NULL;
            }

        }
    pNcpStackData->stateData.action_table = &ipv6cpStateActionTable;

    return OK;
    }

/**************************************************************************
* ipv6cp_setStackData - initialize stack data 
*
*
*
* RETURNS: OK or ERROR
*/


LOCAL STATUS ipv6cp_setStackData
    (
    PFW_OBJ *                    pPfw,			/* framework reference */
    IPV6CP_PROFILE_DATA *        pProfileData,  /* profile data */
    IPV6CP_CONFIG_OPTION *       pIpv6cpOption, /* option */
    char *                       pVal           /* value for this parameter */ 
    )
    {

    IPV6CP_STACK_DATA * pIpv6StackData     = pProfileData->pIpv6cpStackData;		
    NCP_STACK_DATA *    pNcpStackData      = (NCP_STACK_DATA *) pIpv6StackData;
    OPTION_LIST *       pOptionList        = NULL;
    OPTION_LIST_ENTRY * pOptionEntry       = NULL;
    char                partialString[256]; 
    char                localOrRemote[10]; 
    char *              pValue             = pVal;
    BOOLEAN             isLocalConfig      = TRUE;
    BOOLEAN             bDeleteEntry       = FALSE;
    UINT                valueLength        = 0;


    /* Continue only if this profile is associated with stack */

    if (!pNcpStackData)
        {
        return OK;
        }

    bzero (localOrRemote, sizeof (localOrRemote));

    if (NULL == pValue)
        return ERROR;

    valueLength = strlen (pValue);

    if (NULL != strstr (pValue,"Remote"))
	    {
        isLocalConfig = FALSE;
	    if (valueLength <= 7) /* 7 ==> strlen("Remote:") */
            {
            bDeleteEntry = TRUE;
            }
        }
    else if (NULL != strstr (pValue, "Local"))
        {
        isLocalConfig = TRUE;
        if (valueLength <= 6) /* 6 ==> strlen("Local:") */
            {
            bDeleteEntry = TRUE;
            }
        }

    else
        return ERROR;

    pOptionList = (isLocalConfig) ? &pNcpStackData->option_lists.configured : 
                                &pNcpStackData->option_lists.remote_configured;

    if (bDeleteEntry)
        {

        pOptionEntry = find_matching_option
                                     (pOptionList,pIpv6cpOption->optionType);
        if (NULL != pOptionEntry)
            {
            delete_entry_from_list((LINK *) pOptionList,(LINK *) pOptionEntry);
            free_ppp_option_list_entry (pOptionEntry);
            }

        free_ppp_tx_accepted_option_list (&pNcpStackData->option_lists.tx_accepted);

        return OK;
        }

    bzero (partialString, sizeof (partialString));
    strcpy (partialString,pValue);

    if (OK != generate_option_list_entry(pPfw,&pNcpStackData->option_lists,
				    partialString,
				    pIpv6cpOption->name,
				    pIpv6cpOption->optionType,"IPV6CP",
				    pIpv6cpOption->optionTypeString))
        {
        return ERROR;
        }

    free_ppp_tx_accepted_option_list(
  		            &pNcpStackData->option_lists.tx_accepted);
    return OK;
    }

/**************************************************************************
* ipv6cpOptionConfigStringsFree - frees the IPV6CP option configuration string
*
* This routine frees the local, remote and alternate configstrings 
* and set to NULL.
*
* RETURNS: N/A
*/

LOCAL void ipv6cpOptionConfigStringsFree 
    (
    IPV6CP_CONFIG_STRINGS *pOptionConfigStrings		/* config strings */
    )
    {
    ALTERNATE_OPTION_STRING	* pAlternateConfigString = NULL;
    ALTERNATE_OPTION_STRING	* pNextAlternateString   = NULL;

    if (NULL != pOptionConfigStrings)
        {
        if (pOptionConfigStrings->configString)
            {
            pfwFree ((void *) pOptionConfigStrings->configString);
            pOptionConfigStrings->configString = NULL;
            }


        if (pOptionConfigStrings->remoteConfigString)
            {
            pfwFree ((void *) pOptionConfigStrings->remoteConfigString);
            pOptionConfigStrings->remoteConfigString = NULL;
            }

        if (pOptionConfigStrings->alternateConfigString)
            {
            pAlternateConfigString = 
                           pOptionConfigStrings->alternateConfigString;

            pOptionConfigStrings->alternateConfigString = NULL;

            while (NULL != pAlternateConfigString)
                {
                pNextAlternateString = pAlternateConfigString->next;
                pfwFree((void *) pAlternateConfigString);
                pAlternateConfigString = pNextAlternateString;
                }
            }

        }
    } 

/**************************************************************************
* removeAlternateValues - removes alternate and range values for the option
*
*
* RETURNS: N/A
*/

LOCAL void removeAlternateValues 
    (
    IPV6CP_CONFIG_STRINGS *              pIpv6cpOption,	 /* config strings */
    char *                               pRemoteOrLocal  /* local or remote */
    )
    {
    ALTERNATE_OPTION_STRING * pPrevious        =  NULL;
    ALTERNATE_OPTION_STRING * pAlternateString =  NULL;

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