lcpstate.c

这是全套的PPP协议的源码

/* LCPSTAte.c - LCP state machine actions */

/* Copyright 1999 Wind River Systems, Inc. */

#include "copyright_wrs.h"

/*
modification history
--------------------
01w,10jun03,ijm INET6 implies dual stack 
01v,17jan03,ijm removed IPV6CP component in mpStackConvert
01u,17dec02,ijm defined WIN2K_PPPOE_MRU_WORKAROUND to make it easier for users to
                connect PPPoE clients running on Windows 2000 and Windows XP
01t,05nov02,ijm added workaround for PPPoE clients running on Windows 2k.
                WIN2K_PPPOE_MRU_WORKAROUND assumes MRU of 1492, if not negotiated
01s,26jun02,rp  use proper "accepted" list for mibs
01r,28may02,rvr fixed build warnings 
01q,28may02,rvr fixed build errors with diab compiler
01p,17feb02,ak	support for dynamic assignment of MP Member Stack to Manager 
				Stack
01o,13jan02,ijm get ACC map options from the correct list in
                copy_negotiated_lcp_options_to_mib_variables
01n,21dec01,ijm don't free last_rxed_lcp_termination_request_packet
                in lcp_this_layer_down since packet will be reused
                to send termination ack
01m,13nov01,ijm free last_rxed_lcp_termination_request_packet
01l,06nov01,ijm free tx_accepted list in this_layer_finished.  If
                the local side was nacked, nak_option_selected
                field must be reset, SPR# 68164.
01k,01nov01,ijm increase size of authentication_option in
                copy_negotiated_lcp_options_to_mib_variables, SPR# 67937
01j,29sep00,sj  merging with TOR2_0-WINDNET_PPP-CUM_PATCH_2
01i,09aug00,adb  support opening connections in passive mode
01h,01aug00,adb  Merging with openstack view
01g,11jul00,md   netMblkClChainFree() initialReceived, lastReceived, and
                 lastSent lcp packets
01f,23feb00,sj  for PFC and ACC return 1 for enabled and 2 for disabled
01e,16feb00,sj  fixed MIB values for Transmit and Receive FCS size
01d,10feb00,sj  dont cancel lcp_timer in IRC, reset counters in state stopped_p
01c,17dec99,sj  reset nak counter on LCP down + copy callback and Self Desc. Pad
01b,09nov99,sj  fixes to copy.*mib
01a,07oct99,sj 	created
*/

#include "ppp/m2pppLinkGroup.h"
#include "private/ppp/pppstate.h"
#include "private/ppp/pppoptn.h"
#include "ppp/pppChecksum.h"
#include "private/ppp/pppLcpComponentP.h"

/* defines */

#define WIN2K_PPPOE_MRU_WORKAROUND

#define COPY_3BYTE_AUTH_PROTOCOL(src,dst)\
	    {\
	    dst = (ULONG)((src[0]<<16) | (src[1] << 8) | src[2]);\
	    }

#define COPY_2BYTE_AUTH_PROTOCOL(src,dst)\
	    {\
	    dst = (USHORT)((src[0]<<8) | src[1]);\
	    }

LOCAL void lcp_set_ppp_state
    (
    PFW_PLUGIN_OBJ_STATE * pluginState,
    M_BLK_ID  pMblk,
    PPP_STATE end_state
    );
LOCAL void lcp_this_layer_start(PFW_PLUGIN_OBJ_STATE * pluginObjState,
				    M_BLK_ID pMblk, PPP_STATE end_state);
LOCAL void lcp_this_layer_finished(PFW_PLUGIN_OBJ_STATE * pluginObjState,
				    M_BLK_ID pMblk, PPP_STATE end_state);
LOCAL void lcp_this_layer_up(PFW_PLUGIN_OBJ_STATE * pluginObjState,
				    M_BLK_ID pMblk, PPP_STATE end_state);
LOCAL void lcp_this_layer_down(PFW_PLUGIN_OBJ_STATE * pluginObjState,
				    M_BLK_ID pMblk, PPP_STATE end_state);
LOCAL void lcp_initialize_restart_counter(PFW_PLUGIN_OBJ_STATE * pluginObjState,
				    M_BLK_ID pMblk, PPP_STATE end_state);
LOCAL void lcp_zero_restart_counter(PFW_PLUGIN_OBJ_STATE * pluginObjState,
				    M_BLK_ID pMblk, PPP_STATE end_state);

LOCAL BOOL isMPLink (PFW_PLUGIN_OBJ_STATE *pState); 
LOCAL STATUS memberStackComponentRemove (PFW_STACK_OBJ * pfw,
                                   char * componentName);
STATUS mpStackConvert(PFW_STACK_OBJ * pMemberStackObj);
LOCAL STATUS mpInterfaceLayerToStackAdd (PFW_STACK_OBJ *); 

STATE_MACHINE_ACTION_TABLE lcpStateActionTable =
				{
				lcp_set_ppp_state,
				null_state,
				lcp_this_layer_start,
				lcp_this_layer_finished,
				lcp_this_layer_up,
				lcp_this_layer_down,
				lcp_initialize_restart_counter,
				lcp_zero_restart_counter,
				NULL,/* send_configuration_request */
				NULL,/* send_configuration_ack */
				NULL,/* send_configuration_nak */
				NULL,/* send_configuration_reject */
				NULL,/* send_termination_request */
				NULL,/* send_termination_ack */
				NULL,/* send_code_reject */
				NULL,/* send_echo_request */
				NULL /* send_echo_reply */
				};

LOCAL void copy_negotiated_lcp_options_to_mib_variables ( PFW_PLUGIN_OBJ_STATE
                                                                 * pluginState);
LOCAL void reset_counters_on_this_port ( PFW_PLUGIN_OBJ_STATE * pluginState);

/*******************************************************************************
* lcp_this_layer_start -
*/
LOCAL void lcp_this_layer_start
    (
    PFW_PLUGIN_OBJ_STATE * pluginState,
    M_BLK_ID  packet,
    PPP_STATE end_state
    )
    {
    if (packet != NULL)
	netMblkClChainFree (packet);
    }
/*******************************************************************************
* lcp_this_layer_finished -
*/
LOCAL void lcp_this_layer_finished
    (
    PFW_PLUGIN_OBJ_STATE *pluginState,
    M_BLK_ID packet,
    PPP_STATE end_state
    )
    {
    PPP_CONTROL_PROTOCOL_STATE_DATA *pStateData = 
	    (PPP_CONTROL_PROTOCOL_STATE_DATA *)pluginState->stackData;

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

    PARAMETER_NOT_USED (end_state);

    if ((pStateData->state == PPP_REQUEST_SENT_STATE) ||
	(pStateData->state == PPP_ACK_RECEIVED_STATE) ||
	(pStateData->state == PPP_ACK_SENT_STATE))
	{
	/* After the peer fails to respond to Configure-Requests, 
	   an implementation MAY wait passively for the peer to
	   send Configure-Requests. In this case, the This-Layer_Finsihed 
	   action is not used for the To- event in states Req-Sent, 
	   Ack-Rcvd and Ack-Sent. RFC1661 P.15 */

	if (packet != NULL)
	    netMblkClChainFree (packet);

	reset_counters_on_this_port(pluginState);
	}
    else 
	{
	/* cancel terminate request retry */

	pfwTimerCancel (pStackData->lcp_timer);

	/* cancel time remaining messages */

	pfwTimerCancel(pStackData->time_remaining_timer);

	if (packet != NULL)
	    netMblkClChainFree (packet);

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

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

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

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

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

        /* free tx_accepted list to allow fresh start from configured options */

        free_ppp_tx_accepted_option_list(&pStackData->option_lists.tx_accepted);

	/* tell layer that lcp is finished */
	pStackData->controlLayerInterface->protocolFinished(pluginState);

	}
    /* serial_driver should call you back with a down event - RFC1548 */
    }
/*******************************************************************************
* lcp_this_layer_up -
*/
LOCAL void lcp_this_layer_up
    (
    PFW_PLUGIN_OBJ_STATE *pluginState,
    M_BLK_ID packet,
    PPP_STATE end_state
    )
    {
    LCP_STACK_DATA *pStackData = (LCP_STACK_DATA *)pluginState->stackData;
    LCP_PROFILE_DATA * pProfileData = 
				(LCP_PROFILE_DATA *) pluginState->profileData;

    PARAMETER_NOT_USED (end_state);

    /* cancel config request retry */

    pfwTimerCancel(pStackData->lcp_timer);

    copy_negotiated_lcp_options_to_mib_variables (pluginState);

	if (isMPLink (pluginState))
		{
		if (!pStackData->isMpManagerStack)
			{
			mpStackConvert (pluginState->stackObj);	
			}
		}

    /* tell other components on this stack that LCP is done negotiating */

    pfwEventRaise(pluginState->stackObj,pStackData->lcpUpEventObj,
							    pluginState);
    if (packet != NULL)
	netMblkClChainFree (packet);

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

    /* start periodic echo request timer if configured */

    if (pProfileData->maximum_echo_request_send_interval > 0)
	if (pfwTimerStart(pStackData->lcp_timer,PFW_SECOND,
			pProfileData->maximum_echo_request_send_interval,
			periodic_lcp_echo_request,0) == ERROR)
	{
	printf("start periodic echo failed: state = %d stackObj = 0x%x\n",
		pStackData->stateData.state,(int)pluginState->stackObj);
	}

    /* start sending time remaining packets if configured */

    if (pProfileData->time_remaining_timeout > 0)
	if (pfwTimerStart(pStackData->time_remaining_timer,PFW_SECOND,
			pProfileData->time_remaining_timeout,
			(PFW_TIMER_HANDLER)send_lcp_time_remaining_packet,
			(int)pluginState) == ERROR)
	{
	printf("start Time remaining failed: state = %d\n",
		pStackData->stateData.state);
	}
    /* tell layer that LCP is up */

    pStackData->controlLayerInterface->protocolUp(pluginState);
    }
/*******************************************************************************
* lcp_this_layer_down -
*/
LOCAL void lcp_this_layer_down
    (
    PFW_PLUGIN_OBJ_STATE *pluginState,
    M_BLK_ID packet,
    PPP_STATE end_state
    )
    {
    LCP_STACK_DATA *pStackData = (LCP_STACK_DATA *)pluginState->stackData;
    PARAMETER_NOT_USED (end_state);

    /* cancel echo requests */

    pfwTimerCancel(pStackData->lcp_timer);

    /* cancel time remaining messages */

    pfwTimerCancel(pStackData->time_remaining_timer);

    reset_counters_on_this_port (pluginState);

    if (packet != NULL)
	netMblkClChainFree (packet);

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

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

#if 0
    if (pStackData->last_rxed_lcp_termination_request_packet != NULL)
        {
        netMblkClChainFree(pStackData->last_rxed_lcp_termination_request_packet);
        pStackData->last_rxed_lcp_termination_request_packet = NULL;
        }
#endif

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

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

    /* free tx_accepted list to allow fresh start from configured options */

    free_ppp_tx_accepted_option_list(&pStackData->option_lists.tx_accepted);

    /* tell layer that LCP is down */

    pStackData->controlLayerInterface->protocolDown(pluginState,end_state);
    }

/*******************************************************************************
* lcp_initialize_restart_counter -
*/
LOCAL void lcp_initialize_restart_counter
    (
    PFW_PLUGIN_OBJ_STATE *pluginState,
    M_BLK_ID packet,
    PPP_STATE end_state
    )
    {
    LCP_STACK_DATA *pStackData = (LCP_STACK_DATA *)pluginState->stackData;

    PARAMETER_NOT_USED (end_state);

    /*pfwTimerCancel(pStackData->lcp_timer);*/
    pStackData->number_of_configuration_requests = 0x0000;
    pStackData->number_of_lcp_termination_requests =  0x0000;

    if (packet != NULL)
	netMblkClChainFree (packet);
    }
/*******************************************************************************
* lcp_zero_restart_counter -
*/
LOCAL void lcp_zero_restart_counter
    (
    PFW_PLUGIN_OBJ_STATE *pluginState,
    M_BLK_ID packet,
    PPP_STATE end_state
    )
    {
    LCP_STACK_DATA *pStackData = (LCP_STACK_DATA *)pluginState->stackData;
    PARAMETER_NOT_USED (end_state);

    pfwTimerCancel(pStackData->lcp_timer);
    pStackData->number_of_configuration_requests = 0x0000;
    pStackData->number_of_configuration_naks = 0x0000;
    pStackData->number_of_lcp_termination_requests =  0x0000;

    if (packet != NULL)
	netMblkClChainFree (packet);
    }
/*******************************************************************************
* copy_negotiated_lcp_options_to_mib_variables -
*/
LOCAL void copy_negotiated_lcp_options_to_mib_variables 
    (
    PFW_PLUGIN_OBJ_STATE * pluginState
    )
    {
    BYTE authentication_option[12];
    BYTE fcs_size;
    USHORT MRU;
    ULONG  longValue;
    OPTION_LIST_ENTRY * negotiated_option;

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

    if (copy_option (&pStackData->option_lists.tx_accepted,
	LCP_MAXIMUM_RECEIVE_UNIT, &MRU,	
		sizeof (pStackData->lcp_mibs.pppLinkStatusLocalMRU)) == PASS)
	{
	pStackData->lcp_mibs.pppLinkStatusLocalMRU = (ULONG) ntohs (MRU);
	}

    if (copy_option (&pStackData->option_lists.rx_accepted,
		LCP_MAXIMUM_RECEIVE_UNIT, &MRU,
		sizeof (pStackData->lcp_mibs.pppLinkStatusRemoteMRU)) == PASS)
	{
	pStackData->lcp_mibs.pppLinkStatusRemoteMRU = (ULONG) ntohs (MRU);
	}
    else /* MRU was not negotiated */
        {
#ifdef WIN2K_PPPOE_MRU_WORKAROUND
        /*
         * This is a temporary hack to accomodate PPPoE clients running on Windows 2000
         * Professional SP 3. 
         *
         * Windows 2k PPPoE clients fail to negotiate MRU.
         * MTU on Ethernet is 1500. PPPoE header is 6 bytes and the PPP protocol header
         * is 2 bytes.  Thus, MRU for PPPoE must not exceed 1492. If vxWorks attempts
         * to negotiate MRU, some Windows 2k PPPoE clients nak and eventually reject
         * the MRU option, while other PPPoE clients reject MRU immediately
         * Although some Windows 2k PPPoE clients fail to properly negotiate MRU,
         * internally, they assume MRU of 1460 or less for the peer.
         *
         * For Win 2k peer, set MRU negotiation as Not Required in PPPoE profiles to
         * allow the connection, even if Windows rejects MRU.
         */

        PFW_OBJ * pfw;
        PFW_PLUGIN_OBJ * pPPPoEPlugin;

        pfw = pluginState->pluginObj->pfwObj;

        if ((pPPPoEPlugin = pfwPluginObjGet(pfw,"PPP_O_ETHERNET")) != NULL &&
	    (pfwPluginObjStateGet(pluginState->stackObj,pPPPoEPlugin) != NULL))
            {
            /*
             * PPPoE component exists in this stack implying that
             * the default MRU should be changed to 1492 from 1500
             */
             pStackData->lcp_mibs.pppLinkStatusRemoteMRU = 1492;
            }
        else
            {
            pStackData->lcp_mibs.pppLinkStatusRemoteMRU = DEFAULT_MAXIMUM_MRU;