lcpstate.c

这是全套的PPP协议的源码

            }
#else  
        pStackData->lcp_mibs.pppLinkStatusRemoteMRU = DEFAULT_MAXIMUM_MRU;
#endif /*  WIN2K_PPPOE_MRU_WORKAROUND */
        }

    /*
     * RFC 1662: ACC map option is configured to inform peer which
     * characters must be escaped when the peer sends them,section 7.1
     * ACCM from rx_accepted is how we need to trasnmit:localToPeer
     * ACCM from tx_accepted is how the peer will trasnmit to us:peerToLocal
     * ACCM option data is 4 bytes
     */ 

    if (copy_option (&pStackData->option_lists.tx_accepted,
	LCP_ASYNC_CONTROL_CHARACTER_MAP,&longValue,
	sizeof (pStackData->lcp_mibs.pppLinkStatusPeerToLocalACCMap)) == FAIL)
	{
	pStackData->lcp_mibs.pppLinkStatusPeerToLocalACCMap = 
					DEFAULT_ASYNC_CONTROL_CHARACTER_MAP;
	}
    else
	pStackData->lcp_mibs.pppLinkStatusPeerToLocalACCMap = ntohl(longValue);

    if (copy_option (&pStackData->option_lists.rx_accepted,
	LCP_ASYNC_CONTROL_CHARACTER_MAP,&longValue,
	sizeof (pStackData->lcp_mibs.pppLinkStatusLocalToPeerACCMap)) == FAIL)
	{
	pStackData->lcp_mibs.pppLinkStatusLocalToPeerACCMap =
					DEFAULT_ASYNC_CONTROL_CHARACTER_MAP;
	}
    else
	pStackData->lcp_mibs.pppLinkStatusLocalToPeerACCMap = ntohl(longValue);

    pStackData->lcp_mibs.pppLinkStatusRemoteToLocalProtocolCompression =
	(M2_PPP_OPTION_DISABLED - 
		    is_option_present (&pStackData->option_lists.tx_accepted,
					(BYTE) LCP_PROTOCOL_FIELD_COMPRESSION));
    pStackData->lcp_mibs.pppLinkStatusLocalToRemoteProtocolCompression =
	(M2_PPP_OPTION_DISABLED - 
		    is_option_present (&pStackData->option_lists.rx_accepted,
					(BYTE) LCP_PROTOCOL_FIELD_COMPRESSION));

    pStackData->lcp_mibs.pppLinkStatusRemoteToLocalACCompression =
	(M2_PPP_OPTION_DISABLED - 
		    is_option_present (&pStackData->option_lists.tx_accepted,
			    (BYTE) LCP_ADDRESS_AND_CONTROL_FIELD_COMPRESSION));

    pStackData->lcp_mibs.pppLinkStatusLocalToRemoteACCompression =
	(M2_PPP_OPTION_DISABLED - 
		    is_option_present (&pStackData->option_lists.rx_accepted,
			    (BYTE) LCP_ADDRESS_AND_CONTROL_FIELD_COMPRESSION));

    if (copy_option (&pStackData->option_lists.rx_accepted,
		LCP_FCS_ALTERNATIVES, &fcs_size, sizeof (BYTE)) == FAIL)
	{
	pStackData->lcp_mibs.pppLinkStatusReceiveFcsSize =PPP_DEFAULT_FCS_SIZE;
	}
    else
	{
	pStackData->lcp_mibs.pppLinkStatusReceiveFcsSize = 
				(ULONG)((fcs_size == 1) ? 0 : (fcs_size << 3));
	}

    if (copy_option (&pStackData->option_lists.tx_accepted,
		LCP_FCS_ALTERNATIVES, &fcs_size, sizeof (BYTE)) == FAIL)
	{
	pStackData->lcp_mibs.pppLinkStatusTransmitFcsSize =PPP_DEFAULT_FCS_SIZE;
	}
    else
	{
	pStackData->lcp_mibs.pppLinkStatusTransmitFcsSize = 
				(ULONG)((fcs_size == 1) ? 0 : (fcs_size << 3));
	}

    if ((negotiated_option =
	    find_matching_option(&pStackData->option_lists.tx_accepted,
				LCP_AUTHENTICATION_PROTOCOL)) == NULL)
	{
	pStackData->lcp_mibs.pppLocalAuthenticationProtocol = (ULONG) NULL;
	}
    else
	{
	memcpy(&authentication_option[0],negotiated_option->uptr_data,
					negotiated_option->length);
	COPY_2BYTE_AUTH_PROTOCOL(authentication_option,
		    pStackData->lcp_mibs.pppLocalAuthenticationProtocol);
	}

    if ((negotiated_option =
	    find_matching_option(&pStackData->option_lists.rx_accepted,
				LCP_AUTHENTICATION_PROTOCOL)) == NULL)
	{
	pStackData->lcp_mibs.pppRemoteAuthenticationProtocol = (ULONG) NULL;
	}
    else
	{
	memcpy(&authentication_option[0],negotiated_option->uptr_data,
					negotiated_option->length);
	COPY_2BYTE_AUTH_PROTOCOL(authentication_option,
		    pStackData->lcp_mibs.pppRemoteAuthenticationProtocol);
	}

    /* call back negotiation */

    if ((negotiated_option =
	    find_matching_option(&pStackData->option_lists.tx_accepted,
				LCP_CALLBACK)) == NULL)
	{
	pStackData->lcpExtensions.pppLocalToPeerCallbackOperation = (BYTE)255;
	}
    else
	{
	memcpy (&pStackData->lcpExtensions.pppLocalToPeerCallbackOperation,
	    negotiated_option->uptr_data, 1);
}

    if ((negotiated_option =
	    find_matching_option(&pStackData->option_lists.rx_accepted,
				LCP_CALLBACK)) == NULL)
	{
	pStackData->lcpExtensions.pppPeerToLocalCallbackOperation = (BYTE)255;
	}
    else
	{
	memcpy (&pStackData->lcpExtensions.pppPeerToLocalCallbackOperation,
	    negotiated_option->uptr_data, 1);

	memcpy (pStackData->lcpExtensions.pppPeerToLocalCallbackMsg,
	    &negotiated_option->uptr_data[1], negotiated_option->length - 1);
	}

    /* self describing padding */

    if (copy_option (&pStackData->option_lists.tx_accepted,
		LCP_SELF_DESCRIBING_PADDING, 
		&pStackData->lcpExtensions.pppLocalToPeerMaxSelfDescribingPad,
		sizeof (BYTE)) == FAIL)
	{
	pStackData->lcpExtensions.pppLocalToPeerMaxSelfDescribingPad = 0;
	}

    if (copy_option (&pStackData->option_lists.rx_accepted,
		LCP_SELF_DESCRIBING_PADDING, 
		&pStackData->lcpExtensions.pppPeerToLocalMaxSelfDescribingPad,
		sizeof (BYTE)) == FAIL)
	{
	pStackData->lcpExtensions.pppPeerToLocalMaxSelfDescribingPad = 0;
	}
    }

/*******************************************************************************
* lcpMIBPrint -
*/
void lcpMIBPrint
    (
    PFW_STACK_OBJ * stackObj
    )
    {
    PFW_PLUGIN_OBJ * pluginObj;
    PFW_PLUGIN_OBJ_STATE * pluginState;
    LCP_STACK_DATA * pStackData;

    if ((pluginObj = pfwPluginObjGet(pfwStackObjPfwGet(stackObj),"PPP_LCP"))
	== NULL)
	return;

    if ((pluginState = pfwPluginObjStateGet(stackObj,pluginObj)) == NULL)
	return;

    pStackData = (LCP_STACK_DATA *)pluginState->stackData;

    printf("Local MRU: %ld, Remote MRU: %ld\n",
		    pStackData->lcp_mibs.pppLinkStatusLocalMRU,
		    pStackData->lcp_mibs.pppLinkStatusRemoteMRU);

    printf("LocalToPeer ACCM: %ld, PeerToLocal ACCM: %ld\n",
		    pStackData->lcp_mibs.pppLinkStatusLocalToPeerACCMap,
		    pStackData->lcp_mibs.pppLinkStatusPeerToLocalACCMap);

    printf("LocalToRemote ProtocolComp.: %ld, RemoteToLocal ProtocolComp.: %ld\n",
	    pStackData->lcp_mibs.pppLinkStatusLocalToRemoteProtocolCompression,
	    pStackData->lcp_mibs.pppLinkStatusRemoteToLocalProtocolCompression);

    printf("LocalToRemote ACComp.: %ld, RemoteToLocal ACComp.: %ld\n",
		pStackData->lcp_mibs.pppLinkStatusLocalToRemoteACCompression,
		pStackData->lcp_mibs.pppLinkStatusRemoteToLocalACCompression);

    printf("LocalAuthProtocol .: %ld, RemoteAuthProtocol: %ld\n",
		pStackData->lcp_mibs.pppLocalAuthenticationProtocol,
		pStackData->lcp_mibs.pppRemoteAuthenticationProtocol);
    }
/*******************************************************************************
* reset_counters_on_this_port -
*/
LOCAL void reset_counters_on_this_port 
    (
    PFW_PLUGIN_OBJ_STATE * pluginState
    )
    {
    LCP_STACK_DATA * pStackData = (LCP_STACK_DATA *) pluginState->stackData;

    pStackData->number_of_configuration_requests = 0x0000;
    pStackData->number_of_configuration_naks = 0x0000;
    pStackData->number_of_echo_requests = 0x0000;
    pStackData->number_of_lcp_termination_requests = 0x0000;
    
    #if 0
    pStackData->configuration_request_send_interval = 0x0000;
    pStackData->configuration_request_backoff_interval = 0x0000;
    pStackData->time_to_send_LQR = 0x0000;
    #endif
    }
/*******************************************************************************
* lcp_set_ppp_state -
*/
LOCAL void lcp_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;

    if (end_state == ILLEGAL_PPP_STATE)
	{
	printf("PPP: %s: Illegal transition; state %d, Event %d, stack 0x%x\n",
		pluginState->pluginObj->name, original_state,
		(USHORT)NUMBER_OF_PPP_EVENTS , (UINT32)pluginState->stackObj);
	if (pMblk != NULL)
	    netMblkClChainFree (pMblk);
	return;
	}

    /* supporting opening connection in passive mode */

    if  ((PPP_REQUEST_SENT_STATE == end_state) &&
         (PPP_STOPPED_STATE != original_state) &&
         (0 == ((LCP_STACK_DATA *)
                (pluginState->stackData))->
               number_of_configuration_requests) &&
         (((LCP_PROFILE_DATA *)
           (pluginState->profileData))->
          passiveMode))
        {
#ifdef PPP_DEBUG
        printf("PPP_LCP: switching to STOPPED STATE due to passive mode\n");
#endif
        pStateData->state = PPP_STOPPED_STATE;
        return;
        }

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

/*******************************************************************************
* isMPStatck -
*/

LOCAL BOOL isMPLink
	(
	PFW_PLUGIN_OBJ_STATE	*pState
	)
	{
	LCP_STACK_DATA			*pStackData;

	pStackData = pState->stackData;

    if ((find_matching_option(&pStackData->option_lists.tx_accepted, 
				LCP_MULTILINK_MAXIMUM_RECEIVED_RECONSTRUCTED_UNIT) != NULL) ||
		 (find_matching_option(&pStackData->option_lists.rx_accepted, 
				LCP_MULTILINK_MAXIMUM_RECEIVED_RECONSTRUCTED_UNIT) != NULL)) 
		return TRUE;
	else
		return FALSE;

	}

/*******************************************************************************
* mpStackConvert - Converts a normal stack to MP stack
* 
* RETURNS: OK or ERROR
*
* NOMANUAL
*
*/

STATUS mpStackConvert
    (
    PFW_STACK_OBJ       *pMemberStackObj
    )
    {
    PFW_OBJ                     *pfwObj = NULL;
    STATUS                      status;

    if (pMemberStackObj == NULL)
        return ERROR;

    /* Get framework */

    pfwObj = pfwStackObjPfwGet (pMemberStackObj);

    if (pfwObj == NULL)
        {
        printf ("mpStackConvert: NULL Framework\n");
        return ERROR;
        }
   
    /* Remove conflicting DATA PLANE components from member stack */

    if (
        memberStackComponentRemove (pMemberStackObj,
                                    "INTERFACE_LAYER") == ERROR ||
        memberStackComponentRemove (pMemberStackObj, "PPP_IPCP") == ERROR ||
        memberStackComponentRemove (pMemberStackObj, "MP_FRAMING_LAYER") == ERROR
#ifdef INET6
        || memberStackComponentRemove (pMemberStackObj, "PPP_IPV6CP") == ERROR
#endif /* INET6 */
       )
        return ERROR;

    /*
     * Add the mpInterface layer dynamically, if it is not present in the Member
     * Stack
     */

    status = mpInterfaceLayerToStackAdd (pMemberStackObj);

    return (status);

    }



/*******************************************************************************
* memberStackComponentRemove - Delete component from given stack
*
* RETURNS: OK or ERROR
*/

LOCAL STATUS memberStackComponentRemove
    (
    PFW_STACK_OBJ *pStackObj, /* stack from which to remove component */
    char * componentName
    )
    {
    PFW_PLUGIN_OBJ          *pPluginObj = NULL;
    PFW_PLUGIN_OBJ_STATE    *pState = NULL;
    PFW_OBJ                 *pfwObj = NULL;
    STATUS                  status;

    if (pStackObj == NULL || componentName == NULL)
        {
        printf ("memberStackComponentRemove: NULL argument(s)\n");
        return ERROR;
        }

    /* Get framework obj */

    pfwObj = pfwStackObjPfwGet (pStackObj);
  
    if (pfwObj == NULL)
        {
        printf ("memberStackComponentRemove: Null framework object\n");
        return ERROR;
        }

    /* Remove component from member stack, if present */

    pPluginObj =
        (PFW_PLUGIN_OBJ *) pfwPluginObjGet (pfwObj, componentName);

    if (pPluginObj != NULL)
        {
        pState = pfwPluginObjStateGet (pStackObj, pPluginObj);

        if (pState != NULL)
            {
            status = pfwStackPluginObjDelete (pStackObj, pPluginObj);
            if (status == ERROR)
                {
                printf ("memberStackComponentRemove: Could not delete \
                     %s component from Member Stack 0x%x\n",
                     componentName, (int) pStackObj);
                return ERROR;
                }
            }

        }

    return OK;

    }


/*******************************************************************************
* mpInterfaceLayerToTheStackAdd - Add mpInterface layer to the given stack 
* 
* RETURNS: OK or ERROR
*/

LOCAL STATUS mpInterfaceLayerToStackAdd
	(
	PFW_STACK_OBJ *pStackObj /* stack from which interface layer need to be 
							    removed */
	)
	{
	PFW_PLUGIN_OBJ 			*pPluginObj = NULL;
	PFW_PLUGIN_OBJ_STATE	*pState = NULL;
	PFW_OBJ					*pfwObj = NULL;
	STATUS 					status;


	/* Get framework obj */

	pfwObj = pfwStackObjPfwGet (pStackObj);

	if (pfwObj == NULL)
		{
		pfwPrintError (__FILE__, "mpInterfaceLayerToStackAdd",__LINE__, 0, 0,
					   "NULL Framework reference");
		return ERROR;
		}

        pPluginObj = 
		(PFW_PLUGIN_OBJ *) pfwPluginObjGet (pfwObj, "MP_INTERFACE_LAYER");

	if (pPluginObj == NULL)
		{
		pfwPrintError (__FILE__, "mpInterfaceLayerToStackAdd",__LINE__, 0, 0,
					   "NULL Framework reference");
		return ERROR;
		}

	pState = pfwPluginObjStateGet (pStackObj, pPluginObj);
	
	if (pState == NULL)
		{
		status = pfwStackPluginObjAdd (pStackObj, pPluginObj);

		if (status == ERROR)
			{
			printf ("MP:mpInterfaceLayerToStackAdd():Error in adding mpInterface \n\
				layer to the Member Stack 0x%x\n", (UINT32) pStackObj); 
			return ERROR;
			}
		}

	return OK;
	}