ppplcprx.c

来自「这是全套的PPP协议的源码」· C语言 代码 · 共 1,396 行 · 第 1/3 页

			    magic_number = htonl(magic_number);
			    memcpy(nakMagicOption->uptr_data,
				(char *)&magic_number,nakMagicOption->length);
			    add_entry_to_list (
				    (LINK *) &pStackData->option_lists.tx_nak,
						    (LINK *) nakMagicOption);
			    ppp_event = PPP_RECEIVE_CONFIGURE_REQUEST_BAD_EVENT;
			    }
			}
		    else
			{
			netMblkClChainFree(contiguousPacket);
			return;
			}
		    }
		}
	    }
#endif /* LOOP_BACK_DETECTION_USING_MAGIC_NUMBER */

	/* undo stripping of LCP header */

	contiguousPacket->mBlkHdr.mLen += LCP_PACKET_HEADER_SIZE;
	contiguousPacket->mBlkHdr.mData -= LCP_PACKET_HEADER_SIZE;

#ifdef PPP_DEBUG
	printf ("LCP configure request processed: time %ld, ID %d\n",tickGet(),
               sptr_lcp_rx_packet->lcp_header.id);
#endif /* PPP_DEBUG */

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

	pStackData->last_rxed_lcp_configuration_request_packet=contiguousPacket;

	if (pStackData->copy_of_initial_rxed_lcp_configuration_request_packet == NULL)
		{
		if ((pStackData->copy_of_initial_rxed_lcp_configuration_request_packet = 
			lcpRecvPcktCopy (pluginState->pluginObj->pfwObj, contiguousPacket)) == NULL)
			{
			printf ("LCP: failed to copy initial lcp request received packet\n");
			}
		}

	execute_ppp_state_machine (pluginState,ppp_event, NULL);
	}
    else
	{
	/* drop the packet */
	netMblkClChainFree(contiguousPacket);
	}
    }
/*******************************************************************************
* lcp_configure_ack_received -
*/
LOCAL void lcp_configure_ack_received
    (
    PFW_PLUGIN_OBJ_STATE * pluginState,
    M_BLK_ID packet
    )
    {
    M_BLK_ID contiguousPacket = packet;
    LCP_PACKET *sptr_lcp_rx_packet;
    LCP_PACKET *sptr_lcp_last_tx_packet;
    USHORT number_of_bytes_rxed;
    USHORT length_of_lcp_last_tx_packet;
    LCP_STACK_DATA *pStackData = (LCP_STACK_DATA *)pluginState->stackData;

    if (packet == NULL)
	return;

    sptr_lcp_rx_packet = mtod(packet,LCP_PACKET *);

#ifdef PPP_DEBUG
    printf ("LCP configure ack received: time %ld, ID %d\n",tickGet(),
           sptr_lcp_rx_packet->lcp_header.id);
#endif /* PPP_DEBUG */

    /* option processing expects a contiguous buffer */

    if (packet->mBlkHdr.mNext != NULL)
	{
	number_of_bytes_rxed = packet->mBlkPktHdr.len;
	contiguousPacket = m_pullup(packet, 
				ntohs(sptr_lcp_rx_packet->lcp_header.length));

	if (contiguousPacket == NULL)
	    return;
	}
    else
	number_of_bytes_rxed = packet->mBlkHdr.mLen;

    if (pStackData->last_txed_lcp_configuration_request_packet == NULL)
		{
		netMblkClChainFree (contiguousPacket);
		return;
		}
		
    if (number_of_bytes_rxed != 
	pStackData->last_txed_lcp_configuration_request_packet->mBlkHdr.mLen)
	{
	printf ("LCP:Config ACK received:bad length: expected %d: got %d:\
	    stack 0x%x\n",
	    pStackData->last_txed_lcp_configuration_request_packet->mBlkHdr.mLen,
	    number_of_bytes_rxed,
	    (UINT32)pluginState->stackObj);

	netMblkClChainFree (contiguousPacket);

	return;
	}

    sptr_lcp_rx_packet = mtod(contiguousPacket,LCP_PACKET *);
    sptr_lcp_rx_packet->lcp_header.code = CONFIGURE_REQUEST;

    length_of_lcp_last_tx_packet = 
	  pStackData->last_txed_lcp_configuration_request_packet->mBlkHdr.mLen;
    sptr_lcp_last_tx_packet = 
      mtod(pStackData->last_txed_lcp_configuration_request_packet,LCP_PACKET *);

    if (memcmp (sptr_lcp_rx_packet, sptr_lcp_last_tx_packet,
	    length_of_lcp_last_tx_packet) != 0x00)
	{
	printf ("LCP:Config ACK:ID = %d doesn't echo config request:stack 0x%x",
		sptr_lcp_rx_packet->lcp_header.id,
		(UINT32)pluginState->stackObj);

	netMblkClChainFree (contiguousPacket);
	return;
	}

    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;
	}

    netMblkClChainFree (contiguousPacket);

    execute_ppp_state_machine (pluginState,PPP_RECEIVE_CONFIGURE_ACK_EVENT,
				NULL);

    }
/*******************************************************************************
* lcp_configure_nak_received -
*/
static void lcp_configure_nak_received
    (
    PFW_PLUGIN_OBJ_STATE * pluginState,
    M_BLK_ID packet
    )
    {
    M_BLK_ID contiguousPacket = packet;
    LCP_PACKET *sptr_lcp_rx_packet;
    USHORT number_of_bytes_rxed;
    LCP_STACK_DATA *pStackData = (LCP_STACK_DATA *)pluginState->stackData;
    OPTION_PARSE_RESULT parseResult;

    if (packet == NULL)
	return;

    sptr_lcp_rx_packet = mtod(packet,LCP_PACKET *);

#ifdef PPP_DEBUG
    printf ("LCP configure nak received: time,%ld, ID %d\n",tickGet(),
           sptr_lcp_rx_packet->lcp_header.id);
#endif /* PPP_DEBUG */


    if (sptr_lcp_rx_packet->lcp_header.id != 
			pStackData->last_id_of_lcp_packet_sent)
	{
	netMblkClChainFree (packet);
	return;
	}
    /* option processing expects a contiguous buffer */

    if (packet->mBlkHdr.mNext != NULL)
	{
	number_of_bytes_rxed = packet->mBlkPktHdr.len;
	contiguousPacket = m_pullup (packet,
			    ntohs(sptr_lcp_rx_packet->lcp_header.length));

	if (contiguousPacket == NULL)
	    return;
	}
    else
	number_of_bytes_rxed = packet->mBlkHdr.mLen;

    sptr_lcp_rx_packet = mtod(contiguousPacket,LCP_PACKET *);

    /* strip LCP header */

    contiguousPacket->mBlkHdr.mLen -= LCP_PACKET_HEADER_SIZE;
    contiguousPacket->mBlkHdr.mData += LCP_PACKET_HEADER_SIZE;

    if (number_of_bytes_rxed > LCP_PACKET_HEADER_SIZE)
	{
	parseResult = parse_ppp_options_from_nak_configure (
					pluginState->pluginObj->pfwObj,
					&pStackData->option_lists,
					contiguousPacket, pluginState);
	}
    else
	{
	netMblkClChainFree(contiguousPacket);
	return;
	}

    if (parseResult == OPTION_PARSING_ERROR)
	{
	netMblkClChainFree(contiguousPacket);
	return;
	}

    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;
	}

    netMblkClChainFree (contiguousPacket);
    execute_ppp_state_machine (pluginState,PPP_RECEIVE_CONFIGURE_NAK_EVENT,
							   NULL);
    pStackData->number_of_configuration_requests = 0x0000;
    }

/*******************************************************************************
* lcp_configure_reject_received -
*/
LOCAL void lcp_configure_reject_received
    (
    PFW_PLUGIN_OBJ_STATE * pluginState,
    M_BLK_ID packet
    )
    {
    M_BLK_ID contiguousPacket = packet;
    LCP_PACKET *sptr_lcp_rx_packet;
    USHORT number_of_bytes_rxed;
    LCP_STACK_DATA *pStackData = (LCP_STACK_DATA *)pluginState->stackData;
    LCP_PROFILE_DATA *pProfileData = 
				(LCP_PROFILE_DATA *)pluginState->profileData;
    OPTION_PARSE_RESULT parseResult;

    sptr_lcp_rx_packet = mtod(packet,LCP_PACKET *);
#ifdef PPP_DEBUG
    printf ("LCP configure reject received: time,%ld, ID %d\n",tickGet(),
           sptr_lcp_rx_packet->lcp_header.id);
#endif /* PPP_DEBUG */


    /* option processing expects a contiguous buffer */

    if (packet->mBlkHdr.mNext != NULL)
	{
	number_of_bytes_rxed = packet->mBlkPktHdr.len;
	contiguousPacket = m_pullup(packet, 
				ntohs(sptr_lcp_rx_packet->lcp_header.length));

	if (contiguousPacket == NULL)
	    return;
	}
    else
	number_of_bytes_rxed = packet->mBlkHdr.mLen;

    sptr_lcp_rx_packet = mtod(contiguousPacket,LCP_PACKET *);

    if (sptr_lcp_rx_packet->lcp_header.id ==
				    pStackData->last_id_of_lcp_packet_sent)
	{
	if (pProfileData->send_id_enabled == TRUE)
	    {
	    send_lcp_id_packet (pluginState);
	    }

	/* strip LCP header */

	contiguousPacket->mBlkHdr.mLen -= LCP_PACKET_HEADER_SIZE;
	contiguousPacket->mBlkHdr.mData += LCP_PACKET_HEADER_SIZE;

	if (number_of_bytes_rxed > LCP_PACKET_HEADER_SIZE )
	    {
	    if ((parseResult = parse_ppp_options_from_reject_configure (
		    pluginState->pluginObj->pfwObj,
		    &pStackData->option_lists, contiguousPacket))
		== SOME_OPTIONS_ARE_REJECTED)
		{
		netMblkClChainFree (contiguousPacket);
		execute_ppp_state_machine (pluginState, PPP_CLOSE_EVENT, NULL);
		return;
		}
	    else if (parseResult == OPTION_PARSING_ERROR)
		{
		netMblkClChainFree(contiguousPacket);
		return;
		}
	    }

	netMblkClChainFree (contiguousPacket);

	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;
	    }

	execute_ppp_state_machine (pluginState,
			PPP_RECEIVE_CONFIGURE_REJECT_EVENT, NULL);

	pStackData->number_of_configuration_requests = 0x0000;
	}
    else
	netMblkClChainFree (contiguousPacket);
    }
/*******************************************************************************
* lcp_termination_request_received -
*/
LOCAL void lcp_termination_request_received
    (
    PFW_PLUGIN_OBJ_STATE * pluginState,
    M_BLK_ID packet
    )
    {
    LCP_STACK_DATA *pStackData = (LCP_STACK_DATA *)pluginState->stackData;
    LCP_PROFILE_DATA *pProfileData = 
			    (LCP_PROFILE_DATA *)pluginState->profileData;

    if (packet == NULL)
	return;

#ifdef PPP_DEBUG
    printf ("LCP:Termination request Received: stack 0x%x\n",
           (UINT32) pluginState->stackObj);
#endif /* PPP_DEBUG */

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

    pStackData->last_rxed_lcp_termination_request_packet = packet;
    execute_ppp_state_machine (pluginState,PPP_RECEIVE_TERMINATE_REQUEST_EVENT,
							    NULL);
    /*
     * wait 1 cycle for other side to terminate the link before trying to
     * reset so we can come back up. rfc 1661 sect. 3.7;
     *
     * generate TO- event
     */

    if ((pStackData->number_of_lcp_termination_requests == 0) &&
	(pStackData->stateData.state == PPP_STOPPING_STATE ||
	pStackData->stateData.state == PPP_CLOSING_STATE))
	{
	pStackData->number_of_lcp_termination_requests = 
		(USHORT) pProfileData->maximum_number_of_termination_requests;

	if (pfwTimerStart(pStackData->lcp_timer,PFW_SECOND,
			pProfileData->maximum_termination_request_send_interval,
			retry_lcp_termination_request,0) == ERROR)
	    {
	    printf ("generate TO- event: timerStart failed; state = %d\n",
		    pStackData->stateData.state);
	    }
	}
    }
/*******************************************************************************
* lcp_termination_ack_received -
*/
LOCAL void lcp_termination_ack_received 
    (
    PFW_PLUGIN_OBJ_STATE * pluginState,
    M_BLK_ID packet
    )
    {

    if (packet == NULL)
	return;
    
#if 0
    /* unsolicited termination acks means peer needs to restart */
    sptr_lcp_rx_packet = mtod(packet,LCP_PACKET *);
    if (sptr_lcp_rx_packet->lcp_header.id != 
			    pStackData->last_id_of_lcp_packet_sent)

	{
	netMblkClChainFree (packet);
	return;
	}
#endif

    netMblkClChainFree (packet);

#ifdef PPP_DEBUG
    printf ("LCP:Termination Ack Received: stack 0x%x\n",
            (UINT32)pluginState->stackObj);
#endif /* PPP_DEBUG */
    execute_ppp_state_machine(pluginState,PPP_RECEIVE_TERMINATE_ACK_EVENT,NULL);
	    
    }
/*******************************************************************************
* code_reject_received -
*/
LOCAL void code_reject_received
    (
    PFW_PLUGIN_OBJ_STATE * pluginState,
    M_BLK_ID packet
    )
    {
    CODE_REJECT_PACKET *sptr_lcp_rx_packet;
    LCP_STACK_DATA *pStackData = (LCP_STACK_DATA *)pluginState->stackData;
    char * rejectedPacket;
    UINT8 rejectedCode;

    if (packet == NULL)
	return;

    sptr_lcp_rx_packet = mtod(packet,CODE_REJECT_PACKET *);
    rejectedPacket = (char *)&sptr_lcp_rx_packet->rejected_packet;
    rejectedCode = rejectedPacket[0];

    if ((ntohs(sptr_lcp_rx_packet->length) - sizeof(LCP_HEADER))>
				pStackData->lcp_mibs.pppLinkStatusLocalMRU)
	{
	netMblkClChainFree(packet);
	}
    else if(rejectedCode > 0 && rejectedCode < NUMBER_OF_PPP_CONTROL_CODES)
	{
	netMblkClChainFree (packet);
	execute_ppp_state_machine (pluginState,
			    PPP_RECEIVE_CODE_REJECT_CATASTROPHIC_EVENT, NULL);
	}
    else
	{
	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;
	    }
	netMblkClChainFree (packet);
	execute_ppp_state_machine (pluginState,
				PPP_RECEIVE_CODE_REJECT_PERMITTED_EVENT, NULL);
	}
    }
/******************************************************************************
* protocol_reject_received -
*/
LOCAL void protocol_reject_received
    (
    PFW_PLUGIN_OBJ_STATE * pluginState,
    M_BLK_ID packet
    )
    {
    PROTOCOL_REJECT_PACKET * sptr_lcp_rx_packet;
    LCP_STACK_DATA *pStackData = (LCP_STACK_DATA *)pluginState->stackData;
    PPP_PROTOCOL_TYPE rejectedProtocol;

    if (packet == NULL)
	return;

    sptr_lcp_rx_packet = mtod(packet,PROTOCOL_REJECT_PACKET *);

    if (