pppipstatemachinefunction.c

这是全套的PPP协议的源码

/* pppIpStateMachineFunction.c - IP & IPV6 state machine functions */

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

/*
modification history
--------------------
01j,26nov02,ijm added ncpLinkReset function
01i,04oct02,ijm restore default mib values if link is renegotiated, SPR#81713
01h,20aug02,ijm fixed compiler warnings for diab
01g,23jul02,vk  updated the check for protocol type using switch within the 
                ipcp_this_layer_up, ipcp_this_layer_down, ipv6cp_this_layer_up 
                and ipv6cp_this_layer_down functions 
01f,23jul02,as  added code for checking return status of hcInitialize
                and also hcShutdown
01e,19jul02,vk  resetting of previousNakSent in the function 
                ipcp_initialize_restart_counter ()
01d,18jul02,as  added hcComponentStackAdd () function
01c,28jun02,ijm corrected header file name from pppState.h to pppstate.h
01b,27jun02,ijm compile IPv6 code if INET6 is defined in the dual stack
01a,10jun02,vk  moved state machine functions for pppIpv6cpComponent.c
                and pppIpcpComponent.c into this common file. 

*/

/*
DESCRIPTION
This module implements IPV6CP & IPCP state machine functions

*/

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


#define SIZE_OF_VJC_PARAMS          4
#define COMPRESSION_PROTO_LENGTH    2

IMPORT void initialize_ipcp_mibs (PFW_PLUGIN_OBJ_STATE * pPfwPlugingObjState);

/* State machine utility functions */ 

LOCAL void build_ip_ppp_accepted_parameters 
    (
    PFW_PLUGIN_OBJ_STATE *                   pPfwPlugingObjState,
    M_BLK_ID                                 pMblk, 
    PPP_STATE                                end_state
    );

LOCAL void build_dns_addr_accepted_parameters
    (
    PFW_PLUGIN_OBJ_STATE *                   pPfwPlugingObjState,
    M_BLK_ID                                 pMblk, 
    PPP_STATE                                end_state
    );

LOCAL void copy_negotiated_ipcp_options_to_mib_variables 
    ( 
    PFW_PLUGIN_OBJ_STATE *                   pPfwPlugingObjState
    );

#ifdef INET6
LOCAL void copy_ppp_ipv6_accepted_parameters
    (
    PFW_PLUGIN_OBJ_STATE *                   pPfwPlugingObjState
    );
#endif /* INET6 */


LOCAL STATUS copyVJCOption 
    (
    PFW_PLUGIN_OBJ_STATE *                   pPfwPlugingObjState
    );


LOCAL STATUS copyHeaderCompressionOption 
    (
    PFW_PLUGIN_OBJ_STATE *                   pPfwPlugingObjState,
    PFW_INTERFACE_STATE_PAIR *               pHcInterfaceStatePair     
    );


LOCAL STATUS hcComponentStackAdd
    (
    PFW_STACK_OBJ *                          pPfwStackObj,
    PFW_PLUGIN_OBJ *                         pHcPfwPluginObj
    );

void ncpLinkReset (NCP_STACK_DATA * pNcpStackData);

/* IPCP state machine table functions */


/*******************************************************************************
* ipcp_set_ppp_state -
*/
void ipcp_set_ppp_state
    (
    PFW_PLUGIN_OBJ_STATE *    pluginState,
    M_BLK_ID                  pMblk,
    PPP_STATE                 end_state
    )
    {
    PPP_CONTROL_PROTOCOL_STATE_DATA *pStateData = 
                (PPP_CONTROL_PROTOCOL_STATE_DATA *)pluginState->stackData;

    PPP_STATE original_state = pStateData->state;

    IPCP_STACK_DATA *pStackData = (IPCP_STACK_DATA *)pluginState->stackData; 

    if (end_state == ILLEGAL_PPP_STATE)
        {
#ifdef PPP_DEBUG
        printf ("IPCP: Illegal transition; state %d, Event %d, stack 0x%x\n",
              original_state,(USHORT)NUMBER_OF_PPP_EVENTS ,
              (UINT32)pluginState->stackObj);
#endif /* PPP_DEBUG */

        if (pMblk != NULL)
            netMblkClChainFree (pMblk);
        return;
        }

    if (pStackData->useRasAddress && !pStackData->validRasAddress &&
        original_state  == PPP_CLOSED_STATE && end_state == PPP_REQUEST_SENT_STATE)
        {
#ifdef PPP_DEBUG
        printf ("RAS error: Execute close event for IPCP\n");
#endif
        pStateData->state = PPP_REQUEST_SENT_STATE;
        execute_ppp_state_machine (pluginState,PPP_CLOSE_EVENT,NULL);
        return;
        }

    pStateData->state = (BYTE_ENUM (PPP_STATE)) end_state;
    }


/*******************************************************************************
*
* ipcp_this_layer_up -
*/

void ipcp_this_layer_up 
    (
    PFW_PLUGIN_OBJ_STATE *                  pPluginState,
    M_BLK_ID                                pMblk,
    PPP_STATE                               end_state
    )
    {
    IPCP_STACK_DATA *      pStackData    = (IPCP_STACK_DATA *) pPluginState->stackData;
    NCP_STACK_DATA *       pNcpStackData = (NCP_STACK_DATA *) pPluginState->stackData;
    PPP_IP_INTERFACE *     pIpInterface  = NULL;
    PFW_PLUGIN_OBJ_STATE * pEndState     = NULL;
    int                    id            = 0;
    USHORT                 protocolType  = 0;
    BOOL                   compression_option_is_present;
    BYTE                   compressionProto [COMPRESSION_PROTO_LENGTH];

    /* PARAMETER_NOT_USED (end_state); */

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

    build_ip_ppp_accepted_parameters (pPluginState, pMblk, end_state);

    build_dns_addr_accepted_parameters (pPluginState, pMblk, end_state);

    /* Check if compression has been accepted */

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

    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) IP_COMPRESSION_OPTION_TYPE);

        if (NULL == sptr_matching_option)
            {
            printf ("ipcp_this_layer_up: no compression option in rx list \r\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 VAN_JACOBSON_COMPRESSED_PROTOCOL:
                if (ERROR == copyVJCOption (pPluginState))
                    {
                    printf ("ipcp_this_layer_up: Copy VJC Option failed \n");
                    return;
                    }
                break;

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

            default:
#ifdef PPP_DEBUG
                printf ("ipcp_this_layer_up: unknown compression proto 0x%x\n",
                        protocolType);
#endif
            return;
            }
        pStackData->hcConfigured = TRUE;
        pStackData->compressionProtocolId = protocolType;
        }

    if (pStackData->pppIpInterface.interfaceObj == NULL)
        {
        if ((id = pfwInterfaceIdGet (pPluginState->pluginObj->pfwObj,
                                                      "PPP_IP_INTERFACE")) > 0)
            {
            if (pfwInterfaceObjAndStateGetViaStackObj (pPluginState->stackObj,
					                    id, &pStackData->pppIpInterface) != OK)
                {
                pfwPrintError (__FILE__, "ipcp_this_layer_up", __LINE__, NULL,
				                pPluginState->stackObj, 
			                    "PPP_IP_INTERFACE get error");
                return;
                }
            }
        else
            return;
	    }
    
    pIpInterface = (PPP_IP_INTERFACE *) pStackData->pppIpInterface.interfaceObj;
    pEndState    = pStackData->pppIpInterface.state;
    pIpInterface->ipInterfaceUp (pEndState, pStackData->localAddr, 
                                                      pStackData->remoteAddr);

    copy_negotiated_ipcp_options_to_mib_variables (pPluginState);

    pNcpStackData->pControlLayerInterface->protocolUp (pPluginState);

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

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

    }


/*******************************************************************************
*
* ncpLinkReset - restore values for next connection
*
* NOMANUAL
*/

void ncpLinkReset
    (
    NCP_STACK_DATA * pNcpStackData
    )
    {

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

#if 0 /* do not free it here as it is reused when reply is sent to the peer */

    if (pNcpStackData->last_rxed_ncp_configuration_request_packet != NULL)
        {
        netMblkClChainFree (
            pNcpStackData->last_rxed_ncp_configuration_request_packet);
        pNcpStackData->last_rxed_ncp_configuration_request_packet=NULL;
        }
#endif

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

    free_ppp_tx_accepted_option_list(&pNcpStackData->option_lists.tx_accepted);

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

    return;

    }


/*******************************************************************************
*
* ipcp_this_layer_down -
*/

void ipcp_this_layer_down 
    (
    PFW_PLUGIN_OBJ_STATE *pPluginState,
    M_BLK_ID packet,
    PPP_STATE end_state
    )
    {
    IPCP_STACK_DATA *        pStackData        = 
                                  (IPCP_STACK_DATA *) pPluginState->stackData;
    NCP_STACK_DATA *         pNcpStackData     = 
                                  (NCP_STACK_DATA *) pPluginState->stackData;
    PPP_IP_INTERFACE *       pIpInterface      = NULL;
    PFW_PLUGIN_OBJ_STATE *   pEndState         = NULL;
    PFW_PLUGIN_OBJ_STATE *   pHcPluginObjState = NULL;
    PFW_PLUGIN_OBJ *         pVjcPluginObj     = NULL;
    PPP_HC_INTERFACE *       pHcInterface      = NULL;
    PFW_OBJ *                pPfwObj           = NULL;

    PARAMETER_NOT_USED (end_state);

    pPfwObj = pPluginState->pluginObj->pfwObj;

    /* If VJC is plugged into the stack, delete it here */

    if (pStackData->hcConfigured)
        {
        switch (pStackData->compressionProtocolId)
            {
            case VAN_JACOBSON_COMPRESSED_PROTOCOL:
                if ((pVjcPluginObj = (PFW_PLUGIN_OBJ *)pfwComponentObjGetByProtocol
                       (pPluginState->pluginObj->pfwObj, 
                     (UINT)pStackData->compressionProtocolId)) == NULL)
                    return;

                if (pfwStackPluginObjDelete (pPluginState->stackObj, 
                                             pVjcPluginObj) == ERROR)
                    return;

                break; 

            case IP_COMPRESSION_PROTOCOL:
                pHcInterface = (PPP_HC_INTERFACE *) 
                                pStackData->pppHCInterface.interfaceObj;
                pHcPluginObjState = pStackData->pppHCInterface.state;

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

        pfwInterfaceReferenceDelete (pStackData->pppHCInterface.interfaceObj); 
        pStackData->hcConfigured = FALSE;
        }

    pEndState    = pStackData->pppIpInterface.state;
    pIpInterface = (PPP_IP_INTERFACE*)pStackData->pppIpInterface.interfaceObj;

    pIpInterface->ipInterfaceDown (pEndState, pStackData->localAddr, 
                                                      pStackData->remoteAddr);
    ncpLinkReset (pNcpStackData);

    /* Set MIB variables to default values */

    initialize_ipcp_mibs (pPluginState);

    pNcpStackData->pControlLayerInterface->protocolDown (
                                pPluginState, end_state);

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

    pfwEventRaise (pPluginState->stackObj, 
                                pNcpStackData->pNcpDownEventObj, pPluginState);
    }




/* IPV6CP state machine table functions */

#ifdef INET6

/*************************************************************************
* ipv6cp_set_ppp_state - 
* 
* RETURNS: N/A
*/

void ipv6cp_set_ppp_state
    (
    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;

    PPP_STATE        original_state    = pStateData->state;

    if (ILLEGAL_PPP_STATE == pppEndState)
        {
        printf ("IPV6CP: Illegal transition; state %d, Event %d, stack 0x%x\n",
                original_state, (USHORT) NUMBER_OF_PPP_EVENTS, 
                (UINT32) pPfwPlugingObjState->stackObj);

        if (NULL != pMblk)
	        netMblkClChainFree (pMblk);
	    return;
        }

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

    }