pppipstatemachinefunction.c

这是全套的PPP协议的源码

/*************************************************************************
* ipv6cp_this_layer_up - This layer UP action.
*
* This function is called when the IPV6CP is "UP". Compression option is
* checked and necessary compression component is dynamically added. 
* PPP_END component is informed through interface function PPP_IPV6_INTERFACE.
* Control layer's interface function is also called to inform the same.
*
* RETURNS: N/A
*/

void ipv6cp_this_layer_up
    (
    PFW_PLUGIN_OBJ_STATE * pPfwPlugingObjState,
    M_BLK_ID               pMblk,
    PPP_STATE              pppEndState
    )
    {
    IPV6CP_STACK_DATA *    pStackData    = 
                         (IPV6CP_STACK_DATA *) pPfwPlugingObjState->stackData;
    NCP_STACK_DATA *       pNcpStackData = 
                            &pStackData->stackData;
    PFW_OBJ *              pPfwObj = pPfwPlugingObjState->pluginObj->pfwObj;
    int                    pppIpInterfaceId  = 0;
    PFW_PLUGIN_OBJ_STATE * endState = NULL;
    BOOL                   compression_option_is_present;
    PPP_IPV6_INTERFACE *   pIpv6Interface = NULL;
    USHORT                 protocolType  = 0;
    BYTE                   compressionProto [COMPRESSION_PROTO_LENGTH];


    if (pMblk != NULL)
        m_freem (pMblk);

    copy_ppp_ipv6_accepted_parameters (pPfwPlugingObjState);

    /* Check if HC has been accepted */

    compression_option_is_present = is_option_present (
                                &pNcpStackData->option_lists.rx_accepted,
                                (BYTE) IPV6_COMPRESSION_PROTOCOL_OPTION_TYPE);

    /* Copy the HC configuration parameters */

    if (compression_option_is_present)
        {
        char *cp;
        OPTION_LIST_ENTRY * sptr_matching_option = NULL;

        sptr_matching_option = find_matching_option (
                               &pNcpStackData->option_lists.rx_accepted, 
                               (BYTE) IPV6_COMPRESSION_PROTOCOL_OPTION_TYPE);

        if (NULL == sptr_matching_option)
            {
            printf ("ipv6cp_this_layer_up: no compression option in rx list \n");
            return;
            }

        bzero ((char *) compressionProto, COMPRESSION_PROTO_LENGTH);
        memcpy (compressionProto, 
                   sptr_matching_option->uptr_data, COMPRESSION_PROTO_LENGTH);

        cp = (char *) &compressionProto [0];
        GETSHORT (protocolType, cp);

        switch (protocolType)
            {
            case IP_COMPRESSION_PROTOCOL:
                if (ERROR == copyHeaderCompressionOption (
                             pPfwPlugingObjState,&pStackData->pppHCInterface))
                    {
                    printf ("ipv6cp_this_layer_up: Copy HC Option failed \n");
                    return;
                    }
                break;

            default:
#ifdef PPP_DEBUG
                printf ("ipv6cp_this_layer_up: unknown compression protocol id 0x%x\n", 
                        protocolType);
#endif
            return;
            }

        pStackData->headerCompressionNegotiated = TRUE;
        pStackData->hcProtocolId = protocolType;
        }

    if (pStackData->pppIpv6Interface.interfaceObj == NULL)
        {
        pppIpInterfaceId = pfwInterfaceIdGet (pPfwObj, "PPP_IPV6_INTERFACE");
   
        if (pppIpInterfaceId == 0)
            {
            printf ("IPV6CP failed to get PPP_IPV6_INTERFACE \n");
            return;
            }   

        if (pfwInterfaceObjAndStateGetViaStackObj (
                pPfwPlugingObjState->stackObj, pppIpInterfaceId,
                &pStackData->pppIpv6Interface) != OK)
            {
            pfwPrintError (__FILE__, "ipv6cp_this_layer_up", __LINE__, NULL,
                pPfwPlugingObjState->stackObj, "PPP_IPV6_INTERFACE get error");
            return;
            }
        }

    pIpv6Interface = (PPP_IPV6_INTERFACE *) 
    pStackData->pppIpv6Interface.interfaceObj;

    endState = pStackData->pppIpv6Interface.state;

    pIpv6Interface->ipv6InterfaceUp (endState, pStackData->localAddr, 
                   pStackData->remoteAddr);

    pNcpStackData->pControlLayerInterface->protocolUp (pPfwPlugingObjState);

    /* Tell other components on this stack that IPV6CP is up */

    pfwEventRaise (pPfwPlugingObjState->stackObj, 
                   pNcpStackData->pNcpUpEventObj, pPfwPlugingObjState);

    }

/*************************************************************************
* ipv6cp_this_layer_down - This layer DOWN action
* 
* This function is called when the IPV6CP is "DOWN". Compression Protocol 
* id is verifyed for cleaning up using hcShutdown ().  
* PPP_END component and Control layer's interface function is informed to
* inform the same.
*
* RETURNS: N/A
*/

void ipv6cp_this_layer_down
    (
    PFW_PLUGIN_OBJ_STATE * pPfwPlugingObjState,
    M_BLK_ID               pMblk,
    PPP_STATE              pppEndState
    )
    {
    PFW_PLUGIN_OBJ_STATE * pEndPluginObjState = NULL;
    PFW_PLUGIN_OBJ_STATE * pHcPluginObjState  = NULL;
    PFW_OBJ	*              pPfwObj            = NULL;
    IPV6CP_STACK_DATA *    pStackData         = NULL;
    NCP_STACK_DATA *       pNcpStackData      = NULL;
    PPP_HC_INTERFACE *     pHcInterface       = NULL;
    PPP_IPV6_INTERFACE *   pIpv6Interface     = NULL;

    pPfwObj       = pPfwPlugingObjState->pluginObj->pfwObj;
    pStackData    = (IPV6CP_STACK_DATA *) pPfwPlugingObjState->stackData;
    pNcpStackData = (NCP_STACK_DATA *) &pStackData->stackData;

    /* If HC is plugged into the stack, shut it down for IPv6 */
 
    if (pStackData->headerCompressionNegotiated)
        {
        switch (pStackData->hcProtocolId)
            {
            case IP_COMPRESSION_PROTOCOL:
                pHcInterface = (PPP_HC_INTERFACE *) 
                                pStackData->pppHCInterface.interfaceObj;

                pHcPluginObjState = pStackData->pppHCInterface.state;

                if (ERROR == pHcInterface->hcShutdown (pHcPluginObjState, 
                                PPP_IPV6_PROTOCOL))
                    {
                    printf ("IPV6CP failed in shutdown HC interface: hcShutdown () \n");
                    return;
                    }

             }   

        pfwInterfaceReferenceDelete (pStackData->pppHCInterface.interfaceObj);

        pStackData->headerCompressionNegotiated = FALSE;
        }

    pEndPluginObjState = pStackData->pppIpv6Interface.state;

    pIpv6Interface = (PPP_IPV6_INTERFACE *) 
                                pStackData->pppIpv6Interface.interfaceObj;

    pIpv6Interface->ipv6InterfaceDown (pEndPluginObjState, 
                                pStackData->localAddr, pStackData->remoteAddr);

    ncpLinkReset (pNcpStackData);

    pNcpStackData->pControlLayerInterface->protocolDown (
                                 pPfwPlugingObjState, pppEndState);

    /* Tell other components on this stack that IPCP is down  */

    pfwEventRaise (pPfwPlugingObjState->stackObj, 
                   pNcpStackData->pNcpDownEventObj, pPfwPlugingObjState);

    }


/*******************************************************************************
* copy_ppp_ipv6_accepted_parameters - builds the ipv6 accepted parameters
*
*
* RETURNS: N/A
*/

LOCAL void copy_ppp_ipv6_accepted_parameters
    (
    PFW_PLUGIN_OBJ_STATE * pPfwPlugingObjState
    )
    {
    OPTION_LIST_ENTRY * pIpv6Option   = NULL;
    IPV6CP_STACK_DATA *   pStackData    = pPfwPlugingObjState->stackData;
    NCP_STACK_DATA *    pNcpStackData = (NCP_STACK_DATA *) pStackData;

    unsigned char *p;

    pIpv6Option = find_matching_option (
                      &pNcpStackData->option_lists.tx_accepted,
                      IPV6_INTERFACE_IDENTIFIER_OPTION_TYPE);

    if (NULL != pIpv6Option)
        {
        p = (unsigned char *) pIpv6Option->uptr_data->byte_array;

        sprintf (pStackData->localAddr,
                 "fe80::%02x%02x:%02x%02x:%02x%02x:%02x%02x",
                 p[0],p[1],p[2],p[3],p[4],p[5],p[6],p[7]);
        }

    pIpv6Option = find_matching_option (
                      &pNcpStackData->option_lists.rx_accepted,
                      IPV6_INTERFACE_IDENTIFIER_OPTION_TYPE);

    if (NULL != pIpv6Option)
        {
        p = (unsigned char *) pIpv6Option->uptr_data->byte_array;
        sprintf (pStackData->remoteAddr,
                 "fe80::%02x%02x:%02x%02x:%02x%02x:%02x%02x",
                 p[0],p[1],p[2],p[3],p[4],p[5],p[6],p[7]);
        }

#ifdef PPP_DEBUG
    printf ("local address is %s remote Addr is %s\n",
            pStackData->localAddr,pStackData->remoteAddr);
#endif /* PPP_DEBUG */
    }
#endif /* INET6 */


/* Common state machine functions for both IPCP and IPV6CP */

/*************************************************************************
* ipcp_this_layer_start - This layer start action.
* 
* This function is called when this layer moves on to start state. 
* stackData state is updated to the input state.
*
* RETURNS: N/A
*/

void ipcp_this_layer_start 
    (
    PFW_PLUGIN_OBJ_STATE * pPfwPlugingObjState,
    M_BLK_ID               pMblk,
    PPP_STATE              pppEndState
    )
    {
    PPP_CONTROL_PROTOCOL_STATE_DATA * pStateData =
            (PPP_CONTROL_PROTOCOL_STATE_DATA *) pPfwPlugingObjState->stackData;

    pStateData->state = (BYTE_ENUM (PPP_STATE)) pppEndState;

    if (pMblk != NULL)
        m_freem (pMblk);

    }


/*************************************************************************
* ipcp_this_layer_finished - This layer finished action.
* 
* This function is called when this layer moves on to finished state.
* Control layer's interface function is called to inform the same.
*
* RETURNS: N/A
*/

void ipcp_this_layer_finished 
    (
    PFW_PLUGIN_OBJ_STATE * pPfwPlugingObjState,
    M_BLK_ID               pMblk,
    PPP_STATE              pppEndState
    )
    {

    NCP_STACK_DATA *pStackData = (NCP_STACK_DATA *) 
                                        pPfwPlugingObjState->stackData;

    PARAMETER_NOT_USED (pppEndState);


    pStackData->number_of_ncp_configuration_requests = 0x0000;
    pStackData->number_of_ncp_termination_requests   = 0x0000;
    pStackData->number_of_ncp_configuration_naks     = 0x0000;

    pStackData->configuration_request_send_interval  = 0x0000;
    pStackData->termination_request_send_interval    = 0x0000;

    /*
     * free tx_accepted list to restore original configuration values
     * for the next connection 
     */


    free_ppp_tx_accepted_option_list (&pStackData->option_lists.tx_accepted);

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

    if (NULL != pStackData->last_rxed_ncp_configuration_request_packet)
        {
        netMblkClChainFree (
                       pStackData->last_rxed_ncp_configuration_request_packet);
        pStackData->last_rxed_ncp_configuration_request_packet = NULL;
        }
    pStackData->pControlLayerInterface->protocolFinished (pPfwPlugingObjState);
    }



/*************************************************************************
* ipcp_initialize_restart_counter - Initializing the restart counters
* 
* This function is called when IPV6CP is needed to go into initialization 
* STATE. All the necessary counters are initialized to zero.
*
* RETURNS: N/A
*/

void ipcp_initialize_restart_counter
    (
    PFW_PLUGIN_OBJ_STATE * pPfwPlugingObjState,
    M_BLK_ID               pMblk,
    PPP_STATE              pppEndState
    )
    {
    NCP_STACK_DATA * pStackData = (NCP_STACK_DATA *) 
                                        pPfwPlugingObjState->stackData;

    PARAMETER_NOT_USED (pppEndState);

    if (strcmp (pPfwPlugingObjState->pluginObj->name, "PPP_IPV6CP") == 0)
        {
        IPV6CP_STACK_DATA * pIpv6cpStackData = (IPV6CP_STACK_DATA *) 
                                        pPfwPlugingObjState->stackData;

        pIpv6cpStackData->previousNakSent = FALSE;
        }

    pStackData->number_of_ncp_configuration_requests = 0x0000;
    pStackData->number_of_ncp_termination_requests   = 0x0000;
    
    pStackData->configuration_request_send_interval  = 0x0000;
    pStackData->termination_request_send_interval    = 0x0000;

    }
 

/*************************************************************************
* ipcp_zero_restart_counter - Zero the restart counters
* 
* This function is called when this layer is needed to zero the various 
* counters. All the necessary counters are initialized to zero.
*
* RETURNS: N/A
*/

void ipcp_zero_restart_counter
    (
    PFW_PLUGIN_OBJ_STATE * pPfwPlugingObjState,
    M_BLK_ID               pMblk,
    PPP_STATE              pppEndState
    )
    {
    NCP_STACK_DATA *pStackData = (NCP_STACK_DATA *) 
                                        pPfwPlugingObjState->stackData;

    PARAMETER_NOT_USED (pppEndState);

    pStackData->number_of_ncp_configuration_requests = 0x0000;
    pStackData->number_of_ncp_termination_requests   = 0x0000;
    pStackData->number_of_ncp_configuration_naks     = 0x0000;
    pStackData->configuration_request_send_interval  = 0x0000;
    pStackData->termination_request_send_interval    = 0x0000;

    }


/*************************************************************************
* ipcp_null_state - NULL state function, Do nothing
* 
* RETURNS: N/A
*/

void ipcp_null_state 
    (
    PFW_PLUGIN_OBJ_STATE * pPfwPlugingObjState,
    M_BLK_ID               pMblk,
    PPP_STATE              pppEndState
    )
    {
    PARAMETER_NOT_USED (pppEndState);
    }




/* State machine utility functions */ 


/*******************************************************************************
*
* build_ip_ppp_accepted_parameters -
*/

LOCAL void build_ip_ppp_accepted_parameters 
    (
    PFW_PLUGIN_OBJ_STATE *                 pluginState,
    M_BLK_ID                               pMblk,
    PPP_STATE                              end_state
    )
    {
    IPCP_STACK_DATA *   pStackData    = (IPCP_STACK_DATA *) pluginState->stackData;
    NCP_STACK_DATA *    pNcpStackData = (NCP_STACK_DATA *) pluginState->stackData;