pppipv6cpcomponent.c

这是全套的PPP协议的源码

/* pppIpv6cpComponent.c - PPP IPV6 Control Protocol */

/* Copyright 2002 Wind River Systems, Inc. */
#include "copyright_wrs.h"

/*
modification history
--------------------
01k,15may03,ijm removed adv_net.h
01j,12apr03,ijm fixed compiler warning
01i,26nov02,ijm added handler for PPP_LINK_RESET event
01h,01nov02,ijm include adv_net.h
01g,09aug02,adb DOC edits
01f,30jul02,ijm added pppIpv6cpComponent.h
01e,28jun02,ijm corrected pppstate.h name
01d,27jun02,ijm compile only for IPv6
01c,11jun02,vk  moved the state machine action table functions to the
                file pppIpStateMachineFunction.c
01b,22may02,vk  written state action table functions
01a,22may02,jr  created from the ipcpComponent.c as per the ipv6 requirement 
*/


/*
DESCRIPTION
This module implements IPV6CP specified in RFC 2472 

INCLUDE FILES pppIpv6cpComponent.h 
*/

#ifdef INET6

#include "vxWorks.h"
#include "ppp/kppp.h"      
#include "inetLib.h"
#include "ppp/rasamm.h"
#include "pfw/pfw.h"
#include "private/ppp/pppNcpLibP.h"
#include "ppp/pppIpv6cpComponent.h"
#include "private/ppp/pppIpv6cpComponentP.h"
#include "private/ppp/pppstate.h"
#include "ppp/interfaces/pppControlProtocolInterface.h"
#include "ppp/interfaces/pppHcInterfaces.h"
#include "private/ppp/pppIpState.h"
#include "logLib.h"



typedef struct ipv6cpParams
    {
    char * name;
    PFW_PARAMETER_HANDLER handler;
    } IPV6CP_PARAMS;



LOCAL STATUS ipv6cp_HC 
    ( 
    PFW_OBJ *                                pPfwObj,
    PFW_PARAMETER_OPERATION_TYPE             type, 
    void *                                   pProfileData, 
    char *                                   pValue
    );

LOCAL STATUS ipv6cp_optionsHandler 
    (
    PFW_OBJ *                                pPfwObj, 
    IPV6CP_OPTION_TYPE                       type,
    PFW_PARAMETER_OPERATION_TYPE             paramType,
    void *                                   pData, 
    char *                                   pValue
    );

LOCAL STATUS ipv6cp_maxConfigFailure 
    ( 
    PFW_OBJ *                                pPfwObj,
    PFW_PARAMETER_OPERATION_TYPE             type, 
    void *                                   pProfileData, 
    char *                                   pValue
    );

LOCAL STATUS ipv6cp_InterfaceIdentifier 
    ( 
    PFW_OBJ *                                pPfwObj,
    PFW_PARAMETER_OPERATION_TYPE             type, 
    void *                                   pProfileData, 
    char *                                   pValue
    );

/* Component Interfaces */

LOCAL STATUS ipv6cpOptionIndexGet 
    (
    IPV6CP_OPTION_TYPE                       optionType
    );

LOCAL  STATUS ipv6cpProfileDataConstruct 
    (
    PFW_OBJ *                                pPfw, 
    void *                                   pProfileData
    );

LOCAL STATUS ipv6cpProfileDataCopy 
    ( 
    PFW_OBJ *                                pPfw, 
    void *                                   pSrcProfileData,
    void *                                   pDstProfileData
    );

LOCAL  STATUS ipv6cpProfileDataDestruct 
    ( 
    PFW_OBJ *                                pPfw, 
    void *                                   pProfileData
    );
 
LOCAL STATUS ipv6cpSend 
    (
    PFW_PLUGIN_OBJ_STATE *                   pState, 
    M_BLK_ID *                               pPkt
    );

LOCAL STATUS ipv6cpReceive 
    (
    PFW_PLUGIN_OBJ_STATE *                   pState, 
    M_BLK_ID *                               pPkt
    );

LOCAL STATUS ipv6cpStackAdd 
    (
    PFW_PLUGIN_OBJ_STATE *                   pState, 
    PFW_PLUGIN_OBJ_CALLBACKS *               pCallbacks
    );

LOCAL STATUS ipv6cpStackDelete 
    (
    PFW_PLUGIN_OBJ_STATE *                   pState
    );

LOCAL STATUS ipv6cpStackDataDestruct 
    (
    PFW_OBJ *                                pPfw, 
    void *                                   pStackData, 
    void *                                   pProfileData
    );

LOCAL  STATUS ipv6cpStackDataConstruct 
    (
    PFW_OBJ *                                pPfw, 
    void *                                   pStackData, 
    void *                                   pProfileData
    );
 
LOCAL STATUS ipv6cpInterfaceBind 
    (
    PFW_PLUGIN_OBJ *                         pPluginObj
    );

/* event handlers */

LOCAL STATUS pppIpv6cpLinkResetHandler
    (
    PFW_PLUGIN_OBJ_STATE * componentState,
    void *eventData
    );

/* utilities */

LOCAL void removeAlternateValues 
    (
    IPV6CP_CONFIG_STRINGS *                  pIpv6cpOption,
    char *                                   pRemoteOrLocal
    );

LOCAL STATUS ipv6cp_setStackData 
    (
    PFW_OBJ *                                pPfw, 
    IPV6CP_PROFILE_DATA *                    pData,
    IPV6CP_CONFIG_OPTION *                   pIpv6cpOption, 
    char *                                   pValue
    );

LOCAL void ipv6cpOptionConfigStringsFree 
    (
    IPV6CP_CONFIG_STRINGS *                  pConfigString
    );

IMPORT void ncpLinkReset (NCP_STACK_DATA * pNcpStackData);

IMPORT void get_value_string 
    (
    UNION_OPTION_DATA_TYPES *                pData, 
    BYTE                                     length, 
    char *                                   pValue_type_string, 
    char *                                   pValue_string, 
    UNION_OPTION_TYPES                       optionType, 
    char *                                   pOptionName
    );

IMPORT void ipcpSetSendActionFunctions
    (
    STATE_MACHINE_ACTION_TABLE *             actionTable
    );

/* IPV6CP state Action table */

STATE_MACHINE_ACTION_TABLE ipv6cpStateActionTable =
    {
    ipv6cp_set_ppp_state,
    ipcp_null_state,
    ipcp_this_layer_start,
    ipcp_this_layer_finished,
    ipv6cp_this_layer_up,
    ipv6cp_this_layer_down,
    ipcp_initialize_restart_counter,
    ipcp_zero_restart_counter,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    };

LOCAL IPV6CP_PARAMS ipv6cpParams[] =
    {
	{"ipv6cp_ipv6InterfaceIdentifier",ipv6cp_InterfaceIdentifier},
	{"ipv6cp_hcParams",ipv6cp_HC},
	{"ipv6cp_maxConfigRequests",ipcp_maxConfigRequests},
	{"ipv6cp_configReqSendInterval",ipcp_configReqSendInterval},
	{"ipv6cp_maxTerminationRequests",ipcp_maxTerminationRequests},
	{"ipv6cp_terminationReqInterval",ipcp_TerminationReqInterval},
	{"ipv6cp_maxConfigFailure",ipv6cp_maxConfigFailure}
    }; 


LOCAL int numIpv6cpParams = NELEMENTS (ipv6cpParams);



/**************************************************************************
* pppIpv6cpComponentCreate - add the IPV6CP component to the framework
*                                      
* This component implements RFC 2472. The PFW_PLUGIN_OBJ data structure 
* representing the IPV6CP component is allocated and initialized. 
* The plug-in object specific configuration parameters
* and the component itself are added to the framework
* and the IPV6CP_UP_EVENT and IPV6CP_DOWN_EVENT events are published.
*
* RETURNS: OK or ERROR
*/

STATUS pppIpv6cpComponentCreate
    (
    PFW_OBJ *  pPfw         	  /* framework reference */
    )
    {
    PPP_IPV6CP_COMPONENT *    pComponent       = NULL;
    PFW_PLUGIN_OBJ *          pIpv6cpPluginObj = NULL;
    IPV6CP_CONFIG_OPTION *    pIpv6cpOption    = NULL;
    PPP_NCP_COMPONENT *       pNcpComponent    = NULL;
    int                       i                = 0; 

    pComponent = (PPP_IPV6CP_COMPONENT *) pfwMalloc (pPfw, 
                                  sizeof (PPP_IPV6CP_COMPONENT));

    if (NULL == pComponent)
        {
        printf ("pppIpv6cpInit - Unable to allocate memory\n");
        return (ERROR);
        }
    
    pNcpComponent = (PPP_NCP_COMPONENT *) &(pComponent->pppNcpComponent);

    bzero ((char *) pComponent, sizeof (PPP_IPV6CP_COMPONENT));

    pIpv6cpPluginObj = (PFW_PLUGIN_OBJ *) &(pNcpComponent->pfwComponentObj);

        /* Framework plugin-object function */

    strcpy (pIpv6cpPluginObj->name, "PPP_IPV6CP");
    pIpv6cpPluginObj->pfwObj               = pPfw;
    pIpv6cpPluginObj->profileDataSize      = sizeof (IPV6CP_PROFILE_DATA);
    pIpv6cpPluginObj->stackDataSize        = sizeof (IPV6CP_STACK_DATA);
    pIpv6cpPluginObj->profileDataConstruct = ipv6cpProfileDataConstruct;
    pIpv6cpPluginObj->profileDataCopy      = ipv6cpProfileDataCopy;
    pIpv6cpPluginObj->profileDataDestruct  = ipv6cpProfileDataDestruct;
    pIpv6cpPluginObj->receive              = ipv6cpReceive;
    pIpv6cpPluginObj->send                 = ipv6cpSend;
    pIpv6cpPluginObj->stackAdd             = ipv6cpStackAdd;
    pIpv6cpPluginObj->stackDelete          = ipv6cpStackDelete;
    pIpv6cpPluginObj->stackDataShow        = NULL;
    pIpv6cpPluginObj->stackDataConstruct   = ipv6cpStackDataConstruct;
    pIpv6cpPluginObj->stackDataDestruct    = ipv6cpStackDataDestruct;
    pIpv6cpPluginObj->interfaceBind        = ipv6cpInterfaceBind;

    pNcpComponent->pfwComponentObj.protocol = IPV6CP_PROTOCOL;
    pNcpComponent->pfwComponentObj.layerObj = (struct pfwLayerObj *)
                                  pfwLayerObjGet (pPfw, "CONTROL_LAYER");

    if (ERROR == pfwComponentAdd (&pNcpComponent->pfwComponentObj))
        {
        printf ("pppIpv6cpInit - IPV6CP could not be added to framework\n");
        return (ERROR);
        }

    /* Registering the parameter to the framework */

    for (i = 0; i < numIpv6cpParams; i++)
	{
	if (pfwParameterAdd (pIpv6cpPluginObj,
			    ipv6cpParams[i].name, ipv6cpParams[i].handler) == ERROR)
	    {
	    printf ("pppIpv6cpComponent - Parameter %s could not be added\n",
	            ipv6cpParams[i].name);

	    return (ERROR);
	    }
	}

    /* IPV6 Compression Option */

    pIpv6cpOption = &pComponent->
             option[ipv6cpOptionIndexGet (IPV6_COMPRESSION_PROTOCOL_OPTION_TYPE)];
    pIpv6cpOption->optionType = IPV6_COMPRESSION_PROTOCOL_OPTION_TYPE;
    bzero(pIpv6cpOption->
             optionTypeString,sizeof (pIpv6cpOption->optionTypeString));
    strcpy(pIpv6cpOption->optionTypeString,"NBO");
    bzero(pIpv6cpOption->name,sizeof (pIpv6cpOption->name));
    strcpy(pIpv6cpOption->name,"IP Compression");


    /* IPV6 Interface Identifier Option */

    pIpv6cpOption = &pComponent->
          option[ipv6cpOptionIndexGet (IPV6_INTERFACE_IDENTIFIER_OPTION_TYPE)];
    pIpv6cpOption->optionType = IPV6_INTERFACE_IDENTIFIER_OPTION_TYPE;
    bzero(pIpv6cpOption->
          optionTypeString,sizeof(pIpv6cpOption->optionTypeString));
    strcpy(pIpv6cpOption->optionTypeString,"IPV6");
    bzero(pIpv6cpOption->name,sizeof(pIpv6cpOption->name));
    strcpy(pIpv6cpOption->name,"IPV6 Address");

    ipcpSetSendActionFunctions (&ipv6cpStateActionTable);    



    /* Publishing IPV6 UP event, we'll raise when we attain OPENED state */

    if (pfwEventPublish (pPfw, "IPV6CP_UP_EVENT") == NULL)
	    {
	    return (ERROR);
	    }

    /* Publishing IPV6 DOWN event, we'll raise when we attain CLOSED state */

    if (pfwEventPublish (pPfw, "IPV6CP_DOWN_EVENT") == NULL)
	    {
	    return (ERROR);
	    }

	return (OK);
    }


/**************************************************************************
* pppIpv6cpComponentDelete - delete the IPV6CP component from the framework
*
* The IPV6CP plug-in object which is allocated by the pppIpv6cpComponentCreate 
* is freed if there is no active reference to it by a stack or
* profile object in the framework.
*
* RETURNS: OK or ERROR
*/

STATUS pppIpv6cpComponentDelete 
    (
    PFW_OBJ * pPfw            /* framework reference */
    )
    {
    PFW_COMPONENT_OBJ * pComponent = NULL;
     
    pComponent = pfwComponentObjGetByName (pPfw, "PPP_IPV6CP");

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

    /* delete the component */

    if (OK == pfwComponentDelete (pComponent))
        {
        if (NULL != pComponent)		
            {
            pfwFree (pComponent);
            pComponent = NULL;	
            }	
        return OK;
        }
    return (ERROR);
    }



/**************************************************************************
* ipv6cpInterfaceBind - bind to the interfaces
*
* The framework calls this function to bind the IPV6CP Plugin object to the 
* interfaces it implements. This function binds the interfaces 
* CONTROL_PROTOCOL_INTERFACE with the framework by calling pfwInterfaceBind ().
*
* RETURNS: OK or ERROR
*/

LOCAL STATUS ipv6cpInterfaceBind
    (
    PFW_PLUGIN_OBJ * pPluginObj     /* IPV6CP component object */
    )
    {
    CONTROL_PROTOCOL_INTERFACE * pIpv6cpControlInterface = NULL;
    PFW_OBJ *                pPfw       = pPluginObj->pfwObj;
    PPP_IPV6CP_COMPONENT *   pComponent = (PPP_IPV6CP_COMPONENT *) pPluginObj;
    int                          i      = 0;

    /* get CONTROL_PROTOCOL_INTERFACE ID and bind to it */
    
    if (0 < (i = pfwInterfaceIdGet (pPfw, "CONTROL_PROTOCOL_INTERFACE")))
        {
        pIpv6cpControlInterface = &pComponent->ipv6cpControlInterface;
        pIpv6cpControlInterface->interfaceObj.id        = i;
        pIpv6cpControlInterface->interfaceObj.pluginObj = pPluginObj;
        pIpv6cpControlInterface->pppPhaseGet            = ipcp_pppPhaseGet;
        pIpv6cpControlInterface->pppStateGet            = ipcp_pppStateGet;
        pIpv6cpControlInterface->executeStateMachine    = 
                                                 execute_ppp_state_machine;

        pfwInterfaceBind (&pIpv6cpControlInterface->interfaceObj);
        }

    return (OK);
    }