ppplcptx.c

这是全套的PPP协议的源码

	sptr_configured_option = find_matching_option (
				    &pStackData->option_lists.remote_configured,
				    sptr_accepted_option->type.generic);

	if (sptr_configured_option == NULL)
	    {
	    continue; /* this can never happen */
	    }
	sptr_configured_option->nak_option_selected = 0;
	sptr_accepted_option = sptr_accepted_option->sptr_forward_link;
	}
    sptr_configuration_ack_packet = mtod(packet,CONFIGURE_ACK_PACKET *);

    sptr_configuration_ack_packet->code = CONFIGURE_ACK;

#ifdef PPP_DEBUG
    printf("LCP configure ack sent: time %ld, ID %d\n",tickGet(),
				    sptr_configuration_ack_packet->id);
    printf("%s Tx configAck: ",pluginState->pluginObj->name);
    print_options_in_packet(packet);
#endif /* PPP_DEBUG  */

    pStackData->last_rxed_lcp_configuration_request_packet = NULL;
    pfwSend (pluginState,packet);
    }
/*******************************************************************************
* send_lcp_configuration_nak -
*/
LOCAL void send_lcp_configuration_nak
    (
    PFW_PLUGIN_OBJ_STATE * pluginState,
    M_BLK_ID pMblk,
    PPP_STATE end_state
    )
    {
    USHORT number_of_bytes_to_send;
    CONFIGURE_NAK_PACKET *sptr_configuration_nak_packet;
    LCP_PACKET *sptr_lcp_rx_packet;
    LCP_STACK_DATA * pStackData = (LCP_STACK_DATA *) pluginState->stackData;
    LCP_PROFILE_DATA * pProfileData = 
				(LCP_PROFILE_DATA *) pluginState->profileData;
    M_BLK_ID rx_packet = pStackData->last_rxed_lcp_configuration_request_packet;
    M_BLK_ID packet = NULL;
    BYTE rxed_identifier;

    PARAMETER_NOT_USED(end_state);
    PARAMETER_NOT_USED(pMblk);

    /* Max-Failure: discussion; RFC 1661, page 25 */

    if (++pStackData->number_of_configuration_naks >
		    pProfileData->maximum_number_of_configuration_failures)
	{
	copy_configuration_options_list(pluginState->pluginObj->pfwObj,
				    &pStackData->option_lists.tx_nak,
				    &pStackData->option_lists.tx_reject);

	/*free_ppp_option_list (&pStackData->option_lists.tx_nak);*/
	send_lcp_configuration_reject(pluginState,pMblk,end_state);
	return;
	}

    if (rx_packet == NULL)
	return;

    sptr_lcp_rx_packet = mtod(rx_packet,LCP_PACKET *);
    rxed_identifier = sptr_lcp_rx_packet->lcp_header.id;

    number_of_bytes_to_send = sizeof (PPP_HEADER) + sizeof (LCP_HEADER);
    number_of_bytes_to_send = (USHORT) (number_of_bytes_to_send +
		get_size_of_ppp_options (&pStackData->option_lists.tx_nak));

    if (rx_packet->pClBlk->clSize >= number_of_bytes_to_send)
	{
	rx_packet->mBlkHdr.mData = rx_packet->pClBlk->clNode.pClBuf;
	rx_packet->mBlkHdr.mLen = 0;
	packet = rx_packet;
	bzero(packet->mBlkHdr.mData,number_of_bytes_to_send);
	}
    else 
	{
	netMblkClChainFree (rx_packet);
	pStackData->last_rxed_lcp_configuration_request_packet = NULL;
	if ((packet = netTupleGet(pStackData->netPoolId,
		    number_of_bytes_to_send,M_DONTWAIT,MT_DATA,TRUE)) == NULL)
	    {
	    return;
	    }
	}

    sptr_configuration_nak_packet = mtod(packet,CONFIGURE_NAK_PACKET *);

    store_ppp_options_in_packet (&pStackData->option_lists.tx_nak,
		(PPP_OPTION *) &sptr_configuration_nak_packet->options);

    packet->mBlkHdr.mLen = number_of_bytes_to_send;

#ifdef PPP_DEBUG
    printf("LCP configure nak # %d sent:time %ld,ID %d\n",
	    pStackData->number_of_configuration_naks,tickGet(),rxed_identifier);
#endif /* PPP_DEBUG */

    pStackData->last_rxed_lcp_configuration_request_packet = NULL;
    send_lcp_packet (pluginState,packet, CONFIGURE_NAK,rxed_identifier);
    }

/******************************************************************************
* send_lcp_configuration_reject -
*/
LOCAL void send_lcp_configuration_reject
    (
    PFW_PLUGIN_OBJ_STATE * pluginState,
    M_BLK_ID pMblk,
    PPP_STATE end_state
    )
    {
    USHORT number_of_bytes_to_send;
    CONFIGURE_REJECT_PACKET *sptr_configuration_reject_packet;
    LCP_PACKET *sptr_lcp_rx_packet;
    LCP_STACK_DATA * pStackData = (LCP_STACK_DATA *) pluginState->stackData;
    M_BLK_ID rx_packet = pStackData->last_rxed_lcp_configuration_request_packet;
    M_BLK_ID packet = NULL;
    BYTE rxed_identifier;

    PARAMETER_NOT_USED(end_state);
    PARAMETER_NOT_USED(pMblk);

    if (rx_packet == NULL)
	return;

    sptr_lcp_rx_packet = mtod(rx_packet,LCP_PACKET *);
    rxed_identifier = sptr_lcp_rx_packet->lcp_header.id;

    number_of_bytes_to_send = sizeof (PPP_HEADER) + sizeof (LCP_HEADER);
    number_of_bytes_to_send = (USHORT) (number_of_bytes_to_send +
		get_size_of_ppp_options (&pStackData->option_lists.tx_reject));

    if (rx_packet->pClBlk->clSize >= number_of_bytes_to_send)
	{
	/* use received packet */

	rx_packet->mBlkHdr.mData = rx_packet->pClBlk->clNode.pClBuf;
	rx_packet->mBlkHdr.mLen = 0;
	packet = rx_packet;
	bzero(packet->mBlkHdr.mData,number_of_bytes_to_send);
	}
    else
	{
	netMblkClChainFree (rx_packet);
	pStackData->last_rxed_lcp_configuration_request_packet = NULL;
	if ((packet = netTupleGet(pStackData->netPoolId,
		    number_of_bytes_to_send,M_DONTWAIT,MT_DATA,TRUE)) == NULL)
	    {
	    return;
	    }
	}

    sptr_configuration_reject_packet = mtod(packet,CONFIGURE_REJECT_PACKET *);

    store_ppp_options_in_packet (&pStackData->option_lists.tx_reject,
		(PPP_OPTION *) &sptr_configuration_reject_packet->options);

    packet->mBlkHdr.mLen = number_of_bytes_to_send;
#ifdef PPP_DEBUG
    printf("LCP configure reject sent: time %ld, ID %d\n",
						tickGet(),rxed_identifier);
#endif /* PPP_DEBUG  */
    pStackData->last_rxed_lcp_configuration_request_packet = NULL;
    send_lcp_packet (pluginState, packet, CONFIGURE_REJECT, rxed_identifier);
    }

/*******************************************************************************
* send_lcp_echo_request -
*/
LOCAL void send_lcp_echo_request 
    (
    PFW_PLUGIN_OBJ_STATE * pluginState,
    M_BLK_ID retryPacket,
    PPP_STATE end_state
    )
    {
    ECHO_REQUEST_PACKET *sptr_echo_request_packet;
    LCP_STACK_DATA * pStackData = (LCP_STACK_DATA *) pluginState->stackData;
    LCP_PROFILE_DATA * pProfileData = 
				(LCP_PROFILE_DATA *) pluginState->profileData;
    M_BLK_ID packet = NULL;

    PARAMETER_NOT_USED(end_state);

    if (retryPacket != NULL)
	{
	if ((pStackData->last_txed_echo_request_packet = lcpDupPkt(retryPacket))
	    == NULL)
	    {
	    return;
	    }

	++pStackData->number_of_echo_requests;
	pfwSend(pluginState,retryPacket);

	if (pfwTimerStart(pStackData->lcp_timer,PFW_SECOND,
			pProfileData->maximum_echo_request_send_interval,
			periodic_lcp_echo_request,0) == ERROR)
	    {
	    printf ("send Echo Request: timerStart failed; state = %d\n",
		    pStackData->stateData.state);
	    }
#ifdef PPP_DEBUG
    printf("LCP Retry Echo Request sent: time %ld, ID %d,Remaining retries:%ld\n",
	    tickGet(), pStackData->last_id_of_lcp_packet_sent,
	    (pProfileData->maximum_number_of_unacknowledged_echo_requests -
	     pStackData->number_of_echo_requests)
	    );
#endif /* PPP_DEBUG  */
	return;
	}

    if ((packet = netTupleGet(pStackData->netPoolId,sizeof(ECHO_REQUEST_PACKET),
					    M_DONTWAIT,MT_DATA,TRUE)) == NULL)
	{
	return;
	}

    sptr_echo_request_packet = mtod(packet,ECHO_REQUEST_PACKET *);

    pStackData->id_sequence_number++;

    sptr_echo_request_packet->code = PPP_ECHO_REQUEST;
    sptr_echo_request_packet->id = pStackData->id_sequence_number;
    sptr_echo_request_packet->length = htons (sizeof (ECHO_REQUEST_PACKET) 
						- sizeof (PPP_HEADER));

    if (copy_option (&pStackData->option_lists.tx_accepted,LCP_MAGIC_NUMBER,
	    &sptr_echo_request_packet->magic_number,
	    sizeof (sptr_echo_request_packet->magic_number)) == FAIL)
	{
	memset(sptr_echo_request_packet->magic_number,0,4);
        /* = DEFAULT_MAGIC_NUMBER;*/
	}

    sptr_echo_request_packet->header.protocol_type = htons((USHORT)LCP_PROTOCOL);

    ++pStackData->number_of_echo_requests;
    pStackData->last_id_of_lcp_packet_sent = sptr_echo_request_packet->id;

    packet->mBlkHdr.mLen = sizeof (ECHO_REQUEST_PACKET);

    if ((pStackData->last_txed_echo_request_packet = lcpDupPkt(packet)) == NULL)
	{
	return;
	}
    pfwSend (pluginState,packet);

#ifdef PPP_DEBUG
    printf("LCP: Echo Request sent: time %ld, ID %d\n",
			    tickGet(), pStackData->last_id_of_lcp_packet_sent);
#endif /* PPP_DEBUG  */
    if (pfwTimerStart(pStackData->lcp_timer,PFW_SECOND,
			pProfileData->maximum_echo_request_send_interval,
			periodic_lcp_echo_request,0) == ERROR)
	{
	printf ("send Echo Request: timerStart failed; state = %d\n",
		pStackData->stateData.state);
	}
    }

/*******************************************************************************
* send_lcp_echo_reply -
*/
LOCAL void send_lcp_echo_reply
    (
    PFW_PLUGIN_OBJ_STATE * pluginState,
    M_BLK_ID pMblk,
    PPP_STATE end_state
    )
    {
    ECHO_REPLY_PACKET *sptr_echo_reply_packet;
    LCP_STACK_DATA * pStackData = (LCP_STACK_DATA *) pluginState->stackData;
    M_BLK_ID packet = pStackData->last_rxed_lcp_echo_request_packet;
    M_BLK_ID next;
    int packetLength;
    int truncatedLength;

    PARAMETER_NOT_USED(end_state);
    PARAMETER_NOT_USED(pMblk);

    if (packet == NULL)
	{
	return;
	}

    if (packet->mBlkHdr.mNext != NULL)
	packetLength = packet->mBlkPktHdr.len;
    else
	packetLength = packet->mBlkHdr.mLen;

    sptr_echo_reply_packet = mtod(packet,ECHO_REPLY_PACKET *);

    sptr_echo_reply_packet->code = PPP_ECHO_REPLY;

    if (copy_option (&pStackData->option_lists.tx_accepted,LCP_MAGIC_NUMBER,
	    &sptr_echo_reply_packet->magic_number,
	    sizeof (sptr_echo_reply_packet->magic_number)) == FAIL)
	{
	memset(sptr_echo_reply_packet->magic_number,0,4);
       /* = DEFAULT_MAGIC_NUMBER;*/
	}

    sptr_echo_reply_packet->header.protocol_type = htons((USHORT)LCP_PROTOCOL);
    pStackData->last_rxed_lcp_echo_request_packet = NULL;

    if ((truncatedLength = 
	    (packetLength - pStackData->lcp_mibs.pppLinkStatusRemoteMRU)) > 0)
	{
	if (packet->mBlkHdr.mNext != NULL)
	    {
	    packet->mBlkPktHdr.len = packetLength - truncatedLength;

	    /*
	     * the below does not cover the case that truncatedLength is greater
	     * than the length of the trailing MBLK
	     */

	    next = packet;
	    while(next->mBlkHdr.mNext != NULL)
		next = next->mBlkHdr.mNext;
	    next->mBlkHdr.mLen -= truncatedLength;
	    }
	else
	    packet->mBlkHdr.mLen -= truncatedLength;

	sptr_echo_reply_packet->length -= truncatedLength;
	}

    pfwSend (pluginState,packet);
#ifdef PPP_DEBUG
    printf("LCP: Echo Reply sent: time %ld, ID %d\n",
			    tickGet(), pStackData->last_id_of_lcp_packet_sent);
#endif /* PPP_DEBUG  */
    }
/*******************************************************************************
* send_lcp_termination_request -
*/
LOCAL void send_lcp_termination_request
    (
    PFW_PLUGIN_OBJ_STATE * pluginState,
    M_BLK_ID pMblk,
    PPP_STATE end_state
    )
    {
    LCP_STACK_DATA * pStackData = (LCP_STACK_DATA *) pluginState->stackData;
    M_BLK_ID packet = NULL;

    PARAMETER_NOT_USED(end_state);
    PARAMETER_NOT_USED(pMblk);

    if ((packet = netTupleGet(pStackData->netPoolId,sizeof(TERMINATE_REQUEST),
				    M_DONTWAIT, MT_DATA, TRUE)) == NULL)
	{
	return;
	}

    pStackData->id_sequence_number++;

    ++pStackData->number_of_lcp_termination_requests;

    pStackData->last_id_of_lcp_packet_sent = pStackData->id_sequence_number;

#ifdef RW_UPCALL
    if (ppp.fptr_event_upcall != NULL)
	{
	(*ppp.fptr_event_upcall)(PPP_EVENT_LCP_TERMINATION_REQUEST,
							real_port_number);
	}
#else
    (*pStackData->controlLayerInterface->pppLcpTerminationRequest)(pluginState);
#endif

    packet->mBlkHdr.mLen = sizeof(TERMINATE_REQUEST);
    send_lcp_packet (pluginState,packet, TERMINATION_REQUEST,
					    pStackData->id_sequence_number);
    }
/*******************************************************************************
* send_lcp_termination_ack -
*/
LOCAL void send_lcp_termination_ack
    (
    PFW_PLUGIN_OBJ_STATE * pluginState,
    M_BLK_ID pMblk,
    PPP_STATE end_state
    )
    {
    TERMINATE_ACK *sptr_termination_ack_packet;
    LCP_STACK_DATA * pStackData = (LCP_STACK_DATA *) pluginState->stackData;
    M_BLK_ID packet = pStackData->last_rxed_lcp_termination_request_packet;

    PARAMETER_NOT_USED(end_state);
    PARAMETER_NOT_USED(pMblk);

    if (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_configuration_request_packet != NULL)
            {
            netMblkClChainFree(
                pStackData->last_rxed_lcp_configuration_request_packet);
            pStackData->last_rxed_lcp_configuration_request_packet = NULL;
            }

        /* Do not send termination ack for now: CLOSED_STATE */

	return;
        }

    sptr_termination_ack_packet = mtod(packet,TERMINATE_ACK *);
    packet->mBlkHdr.mLen = sizeof (TERMINATE_ACK);

    pStackData->last_rxed_lcp_termination_request_packet = NULL;

    send_lcp_packet (pluginState,packet, TERMINATION_ACK,
				    sptr_termination_ack_packet->id);

    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_configuration_request_packet != NULL)
        {
        netMblkClChainFree(
            pStackData->last_rxed_lcp_configuration_request_packet);
        pStackData->last_rxed_lcp_configuration_request_packet = NULL;
        }
    }

/*******************************************************************************
* send_lcp_protocol_reject -
*/
void send_lcp_protocol_reject