pppipv6cpcomponent.c

这是全套的PPP协议的源码

/**************************************************************************
* ipv6cpSend - IPV6CP send interface
*
* RETURNS: OK or ERROR
*/

LOCAL STATUS ipv6cpSend
    (
    PFW_PLUGIN_OBJ_STATE * pPfwPlugingObjState,  /* state for this stack */
    M_BLK_ID *             ppMblk                 /* packet to send */
    )
    {
    return (OK);
    }

/**************************************************************************
* ipv6cpReceive - IPV6CP receive interface
*
* RETURNS: OK or ERROR
*/


LOCAL STATUS ipv6cpReceive
    (
    PFW_PLUGIN_OBJ_STATE * pPfwPlugingObjState,  /* state for this stack */
    M_BLK_ID *             ppMblk                /* packet received */
    )
    {
    ncp_packet_received(pPfwPlugingObjState, *ppMblk);

    return (OK);
    }


/**************************************************************************
* ipv6cpStackAdd - add IPV6CP to stack
*
* This function is called when the IPV6CP plug-in object is added to a stack  
* that is being built to support a connection. This function initializes the 
* ncp control layer, timers for use by IPV6CP, subscribes for the events and
* registers the interfaces implemented by the other components and calls 
* stackAddComplete () callback routine. 
*
* RETURNS: OK or ERROR
*/

LOCAL STATUS ipv6cpStackAdd
    (
    PFW_PLUGIN_OBJ_STATE *      pPfwPlugingObjState, /* state for this stack */
    PFW_PLUGIN_OBJ_CALLBACKS *  pCallbacks           /* callback routines */
    )
    {
    IPV6CP_STACK_DATA *    pIpv6cpStackData   = NULL;
    IPV6CP_PROFILE_DATA *  pIpv6cpProfileData = NULL;
    PFW_EVENT_OBJ *        pEventObj          = NULL;
    int                    id                 = 0;
    NCP_STACK_DATA *       pStackData         = NULL;
                           
    
    PPP_CONTROL_PROTOCOL_STATE_DATA  * pStateData = NULL; 
                          
    PFW_LAYER_OBJ * layerObj = 
             ((PFW_COMPONENT_OBJ *) pPfwPlugingObjState->pluginObj)->layerObj;

    pIpv6cpStackData   = (IPV6CP_STACK_DATA *) pPfwPlugingObjState->stackData;

    pIpv6cpProfileData = (IPV6CP_PROFILE_DATA *) pPfwPlugingObjState->profileData;

    pStackData = (NCP_STACK_DATA *) &pIpv6cpStackData->stackData;

    pIpv6cpProfileData->pIpv6cpStackData = pIpv6cpStackData;

   pStateData = (PPP_CONTROL_PROTOCOL_STATE_DATA *)pStackData;

   pStateData->state  = PPP_INITIAL_STATE;

    /* initialize the callback routines */
   pStackData->callbacks = pCallbacks;

    /* initialize the ncp control layer */

    initialize_ip_ncp (pPfwPlugingObjState);


    if (NULL == (pStackData->ncp_timer = 
                                  pfwTimerCreate(pPfwPlugingObjState)))
         return ERROR;

    copy_configuration_options_to_tx_accepted_options(
                                  pPfwPlugingObjState->pluginObj->pfwObj, 
                                  &pStackData->option_lists);

    /* Start the timers for config reqs */
  
#if 0
    pfwTimerStart(pIpv6cpStackData->stackData->ncp_timer,
                                  PFW_SECOND,1,ipv6cp_periodic_timer,0);
#endif

    pIpv6cpStackData->pppIpv6Interface.state 	    = NULL;
    pIpv6cpStackData->pppIpv6Interface.interfaceObj = NULL;

    /* get controlLayer interface */

    if (0 < (id = pfwInterfaceIdGet(pPfwPlugingObjState->pluginObj->pfwObj,
                                  "PPP_CONTROL_LAYER_INTERFACE")))
        {
        pStackData->pControlLayerInterface = (PPP_CONTROL_LAYER_INTERFACE *)
		             pfwInterfaceObjGetViaPluginObj (&layerObj->pluginObj,id);
        }

    if (NULL == (pEventObj = pfwEventObjGet (
                     pPfwPlugingObjState->pluginObj->pfwObj,"LCP_UP_EVENT")))
        return ERROR;


    if (NULL == (pEventObj = pfwEventObjGet (
                     pPfwPlugingObjState->pluginObj->pfwObj,"PPP_LINK_RESET_EVENT")))
        return ERROR;

    pfwEventStackSubscribe (pPfwPlugingObjState, pEventObj, pppIpv6cpLinkResetHandler);

    /* call the callback routine */

    if (pStackData->callbacks && 
                      pStackData->callbacks->stackAddComplete)
        {
 
        (*pStackData->callbacks->stackAddComplete)
                 (pStackData->callbacks, pPfwPlugingObjState);
        return (OK);
        }
    else
        return ERROR;
    }

/**************************************************************************
* ipv6cpStackDelete - delete IPV6CP from Stack
*
* The framework calls this function when the stack that contains the Plugin 
* object is deleted. This function deletes the references to the registered 
* interfaces, deletes the timers created, frees the memory and calls 
* the callback routine if provided.
*
* RETURNS: OK or ERROR
*/

LOCAL STATUS ipv6cpStackDelete
    (
    PFW_PLUGIN_OBJ_STATE *pState   /* state for the stack */
    )
    {
    IPV6CP_STACK_DATA *pStackData = (IPV6CP_STACK_DATA *) pState->stackData;
    NCP_STACK_DATA * pNcpStackData = (NCP_STACK_DATA *) &pStackData->stackData;

    ipcp_zero_restart_counter (pState, NULL, PPP_CLOSED_STATE);

    /* TO DO Remove the timers if present */

    pfwTimerDelete (pNcpStackData->ncp_timer);

    /* delete the reference to the interfaces */

    if (NULL != pStackData->pppIpv6Interface.interfaceObj)
           pfwInterfaceReferenceDelete 
                          (pStackData->pppIpv6Interface.interfaceObj);

    if (NULL != pNcpStackData->pControlLayerInterface)
	pfwInterfaceReferenceDelete(
	    (PFW_INTERFACE_OBJ *)pNcpStackData->pControlLayerInterface);


    if (pStackData->headerCompressionNegotiated &&
	pStackData->pppHCInterface.interfaceObj != NULL)
	pfwInterfaceReferenceDelete(pStackData->pppHCInterface.interfaceObj);


    if (NULL != pNcpStackData->last_txed_ncp_configuration_request_packet)
        {
	    netMblkClChainFree (
	                pNcpStackData->last_txed_ncp_configuration_request_packet);
	    pNcpStackData->last_txed_ncp_configuration_request_packet=NULL;
        }

    /* Inform the upper layers we are down */

    if (pNcpStackData->callbacks && 
                          pNcpStackData->callbacks->stackDeleteComplete)
        {
        (*pNcpStackData->callbacks->stackDeleteComplete)
                                 (pNcpStackData->callbacks , pState);
        return (OK);
        }
    else
        return ERROR;
    }


/**************************************************************************
* ipv6cp_InterfaceIdentifier -  Set the IPV6 address parameters
*
* This routine calls the ipv6cp_optionsHandler () to handle the option.
*
* RETURNS: OK or ERROR
*/
LOCAL STATUS ipv6cp_InterfaceIdentifier
    (
    PFW_OBJ *                       pPfw,    /* framework reference */
    PFW_PARAMETER_OPERATION_TYPE    type,    /* operation type */
    void *                          pData,   /* profile data */
    char *                          pValue   /* value for this parameter */
    )
    {

    return ipv6cp_optionsHandler (pPfw,
       ipv6cpOptionIndexGet (IPV6_INTERFACE_IDENTIFIER_OPTION_TYPE),
                                                       type,pData, pValue);
    }

/**************************************************************************
* ipv6cp_HC - Set the Header Compression parameters
*
* This routine calls the ipv6cp_optionsHandler () to handle the option.
*
* RETURNS: OK or ERROR
*/
LOCAL STATUS ipv6cp_HC
    (
    PFW_OBJ *                       pPfw,        /* framework reference */
    PFW_PARAMETER_OPERATION_TYPE    type,        /* operation type */
    void *                          pData,       /* profile data */
    char *                          pValue       /* value for this parameter */
    )
    {

    return ipv6cp_optionsHandler (pPfw, 
      ipv6cpOptionIndexGet (IPV6_COMPRESSION_PROTOCOL_OPTION_TYPE),
                                                       type, pData, pValue);
    }


/**************************************************************************
* ipv6cp_maxConfigFailure - get/set the IPV6CP max config failures 
*
* This routine gets or sets the value of the IPV6CP profile data parameter 
* ipv6cp_maxConfigFailure.

* RETURNS: OK or ERROR
*/

LOCAL int ipv6cp_maxConfigFailure
    (
    PFW_OBJ *                       pPfw,         /* framework reference */
    PFW_PARAMETER_OPERATION_TYPE    type,         /* operation type */
    void *                          pProfileData, /* profile data */
    char *                          pValue        /* value for this parameter */
    )
    {
    int configValue = 0;
    NCP_PROFILE_DATA *pNcp = (NCP_PROFILE_DATA *) pProfileData;

    if (type == PFW_PARAMETER_SET)
        {
        if (pValue == NULL)
            return ERROR;

        if ((configValue = atoi(pValue)) > 0)
            pNcp->maximum_number_of_configuration_failures = configValue;
        return (OK);
        }

    if (type == PFW_PARAMETER_GET)
        {
        sprintf(pValue,"%ld",pNcp->maximum_number_of_configuration_failures);
        return OK;
        }

    return (ERROR);
    }

/**************************************************************************
* ipv6cpOptionIndexGet - Get the index of the option
*
* RETURNS: OK or ERROR
*/


LOCAL STATUS ipv6cpOptionIndexGet
    (
    IPV6CP_OPTION_TYPE	         optionType	   /* option type */
    )
    {
    int	retVal = ERROR;

    switch (optionType)
        {

        case IPV6_COMPRESSION_PROTOCOL_OPTION_TYPE:

        case IPV6_INTERFACE_IDENTIFIER_OPTION_TYPE:

        retVal = optionType;
            break;

        default:
            break;

        }

    return (retVal);
    }


/**************************************************************************
* ipv6cpProfileDataConstruct - initialize IPV6CP profile data
*
* The framework calls this function when the first configuration parameter 
* associated with the Plugin object is added to the profile to initialize the 
* profile data associated with the Plugin object. This function initializes 
* the profile data parameters to their default values.
*
* RETURNS: OK or ERROR
*/


LOCAL  STATUS ipv6cpProfileDataConstruct 
    (
    PFW_OBJ *                        pPfw,          /* framework reference */
    void *                           pProfileData   /* profile data */ 
    )
    {
    IPV6CP_PROFILE_DATA *            pIpv6ProfileData = NULL;
    NCP_PROFILE_DATA *               pNcpProfileData =  NULL;


    pIpv6ProfileData = (IPV6CP_PROFILE_DATA *) pProfileData;
    pNcpProfileData = (NCP_PROFILE_DATA *) &pIpv6ProfileData->ncpProfileData;

    /* Intialize with zero for IPV6CP and NCP Profile Data */
	
    bzero ((char *) pIpv6ProfileData, sizeof (IPV6CP_PROFILE_DATA));
    bzero ((char *) pNcpProfileData, sizeof (NCP_PROFILE_DATA));

    pNcpProfileData->maximum_number_of_termination_requests = 
                                  MAXIMUM_TERMINATION_REQUESTS;
    pNcpProfileData->maximum_number_of_configuration_requests =
                                  MAXIMUM_CONFIGURATION_REQUESTS;
    pNcpProfileData->maximum_configuration_request_send_interval =
                                  MAXIMUM_CONFIGURATION_REQUEST_SEND_INTERVAL;
    pNcpProfileData->maximum_termination_request_send_interval =
                                  MAXIMUM_TERMINATION_REQUEST_SEND_INTERVAL;

    pNcpProfileData->maximum_number_of_configuration_failures =
                                  MAXIMUM_CONFIGURATION_FAILURES;

    pNcpProfileData->maximum_configuration_request_backoff_interval = 0;
                           /* MAXIMUM_CONFIGURATION_REQUEST_BACKOFF_INTERVAL */
  
    pIpv6ProfileData->pIpv6cpConfigStrings = pfwMalloc (pPfw, 
                                  sizeof (IPV6CP_CONFIG_STRINGS) 
                                   * (NUMBER_OF_IPV6CP_OPTIONS + 1)); 

    if (NULL == pIpv6ProfileData->pIpv6cpConfigStrings)
        return ERROR;

    bzero ((char *)pIpv6ProfileData->pIpv6cpConfigStrings, 
              sizeof (IPV6CP_CONFIG_STRINGS) * (NUMBER_OF_IPV6CP_OPTIONS + 1));


    return (OK);

    }

/**************************************************************************
* ipv6cpProfileDataCopy - profileData object copy constructor
*
* The framework calls this function to copy the profile data to another profile.
* This function copies profile data from a source profile to destination profile.
*
* RETURNS: OK or ERROR
*/

LOCAL STATUS ipv6cpProfileDataCopy
    (
    PFW_OBJ *                       pPfw,        /* framework reference */
    void *                          pSrcData,    /* source profile data */
    void *                          pDstData     /* destination profile data */
    )
    {
    IPV6CP_PROFILE_DATA *     pSrcProfileData        = 
                                  (IPV6CP_PROFILE_DATA *) pSrcData;
    IPV6CP_PROFILE_DATA *     pDstProfileData        = 
                                  (IPV6CP_PROFILE_DATA *) pDstData;
    IPV6CP_CONFIG_STRINGS *   pSrcOption             = NULL;
    IPV6CP_CONFIG_STRINGS *   pDstOption             = NULL;
    ALTERNATE_OPTION_STRING * pAlternateConfigString = NULL;
    ALTERNATE_OPTION_STRING * pNewAlternateString    = NULL;
    unsigned int              options                = 0;
    unsigned int              stringLength           = 0;

    bzero ((char *) pDstProfileData, sizeof (IPV6CP_PROFILE_DATA));
    bcopy ((char *)pSrcProfileData, (char *)pDstProfileData, sizeof (IPV6CP_PROFILE_DATA));

    if (!pSrcProfileData->pIpv6cpConfigStrings)
        {
        return OK;
        }

    pDstProfileData->pIpv6cpConfigStrings = pfwMalloc (pPfw, 
                                      sizeof (IPV6CP_CONFIG_STRINGS) * 
                                             (NUMBER_OF_IPV6CP_OPTIONS + 1)); 

    if (NULL == pDstProfileData->pIpv6cpConfigStrings)
        return ERROR;

    bzero ((char *)pDstProfileData->pIpv6cpConfigStrings, 
              sizeof (IPV6CP_CONFIG_STRINGS) * (NUMBER_OF_IPV6CP_OPTIONS + 1));

  
    for (options = IPV6_INTERFACE_IDENTIFIER_OPTION_TYPE;
         options <= NUMBER_OF_IPV6CP_OPTIONS; options++)

        {
        pSrcOption = &pSrcProfileData->pIpv6cpConfigStrings[options];
        pDstOption = &pDstProfileData->pIpv6cpConfigStrings[options];

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

            /* make a copy of the remote string */

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

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