pppoptn.c

这是全套的PPP协议的源码

	{
	if (sptr_matching_option->type.generic == option_type)
	    {
	    return (TRUE);
	    }
	}

    return (FALSE);
    }
/*******************************************************************************
* copy_option -
*/
TEST copy_option
    (
    OPTION_LIST *sptr_option_list,
    BYTE option_type,
    void *vptr_destination,
    USHORT maximum_size
    )
    {
    OPTION_LIST_ENTRY *sptr_matching_option = NULL;

    sptr_matching_option = find_matching_option (sptr_option_list,option_type);

    if (sptr_matching_option != NULL)
	{
	if (maximum_size >= sptr_matching_option->length)
	    {
	    memcpy (vptr_destination,sptr_matching_option->uptr_data,
						sptr_matching_option->length);
	    return (PASS);
	    }
	else
	    {
	    printf ("PPP: Copy Option Length too small\r\n");
	    }
	}

    return (FAIL);
    }
/*******************************************************************************
* copy_option_from_entry -
*/
TEST copy_option_from_entry
    (
    OPTION_LIST_ENTRY *sptr_matching_option,
    void *vptr_destination,
    USHORT maximum_size
    )
    {
    if (maximum_size >= sptr_matching_option->length)
	{
	memcpy (vptr_destination,sptr_matching_option->uptr_data,
						sptr_matching_option->length);

	return (PASS);
	}
    else
	{
	printf("PPP: Copy Option Length too small\r\n");
	return (FAIL);
	}
    }
/*******************************************************************************
* copy_data_to_option -
*/
TEST copy_data_to_option
    (
    OPTION_LIST_ENTRY *sptr_matching_option,
    void *vptr_source,
    USHORT size
    )
    {
    if (size <= sptr_matching_option->length)
	{
	memcpy (sptr_matching_option->uptr_data,vptr_source,size);
	return (PASS);
	}
    else
	{
	printf ("PPP: Copy Option Length too small\r\n");
	return (FAIL);
	}
    }

/******************************************************************************
*
*
* check_options_from_reject_packet - validate options in packet
*
* This function checks if options contained in reject packet are a
* subset of options sent by this host in a previous configure request
* packet. Order of options must be the same.  RFC 1661,section 5.4.
*
* NOMANUAL
*/

TEST check_options_from_reject_packet
    (
    OPTION_LISTS *sptr_option_lists
    )
    {
    OPTION_LIST_ENTRY *sptr_tx_accepted_option = NULL;
    OPTION_LIST_ENTRY *sptr_received_option = NULL;

    sptr_received_option = (&sptr_option_lists->received)->sptr_forward_link;

    sptr_tx_accepted_option = find_matching_option (
                                  &sptr_option_lists->tx_accepted,
                                  sptr_received_option->type.generic);

    if (sptr_tx_accepted_option == NULL)
        return (FAIL);

    while (sptr_received_option != NULL)
        {
        if (
            sptr_tx_accepted_option == NULL ||
            (sptr_tx_accepted_option->length !=
             sptr_received_option->length) ||
            (memcmp (sptr_tx_accepted_option->uptr_data,
                     sptr_received_option->uptr_data,
                     sptr_tx_accepted_option->length) != (int) NULL)
           )
            {
            return (FAIL);
            }

        sptr_received_option = sptr_received_option->sptr_forward_link;

        if (sptr_received_option != NULL)
            {
            /*
             * calling find_matching_option_beyond ensures correct order
             * since the search starts not from the beginning of the list
             * as find_matching_option does, but from the last match
             */

            sptr_tx_accepted_option = find_matching_option_beyond (
                                          sptr_tx_accepted_option,
                                          sptr_received_option->type.generic);
            }
        }
    return (PASS);
    }

/*******************************************************************************
* parse_ppp_options_from_reject_configure -
*/
OPTION_PARSE_RESULT parse_ppp_options_from_reject_configure
    (
    PFW_OBJ * pfw,
    OPTION_LISTS *sptr_option_lists,
    M_BLK_ID packet
    )
    {
    OPTION_LIST_ENTRY *sptr_tx_accepted_option = NULL;
    OPTION_LIST_ENTRY *sptr_receive_list_option = NULL;
    OPTION_LIST_ENTRY *sptr_configured_option = NULL;
    OPTION_PARSE_RESULT  parseResult = OPTIONS_RECEIVED_ARE_OK;

    free_ppp_option_list (&sptr_option_lists->received);
    free_ppp_option_list (&sptr_option_lists->rx_reject);

#ifdef PPP_DEBUG
   printf ("Rx ConfigReject: ");
#endif /* PPP_DEBUG */

    if (parse_ppp_options_from_packet (pfw, &sptr_option_lists->received,
        packet) == FAIL)
        {
#ifdef PPP_DEBUG
        printf ("Dropping conf reject packet: OPTION_PARSING_ERROR\n");
#endif /* PPP_DEBUG */
        return (OPTION_PARSING_ERROR);
        }

#ifdef PPP_DEBUG
    option_list_print(&sptr_option_lists->received);
#endif /* PPP_DEBUG */

    if (check_options_from_reject_packet(sptr_option_lists)
         == FAIL)
        {
#ifdef PPP_DEBUG
        printf ("Dropping: rejected options don't match last confReq packet\n");
#endif /* PPP_DEBUG */
        free_ppp_option_list (&sptr_option_lists->received);
        return (OPTION_PARSING_ERROR);
        }

    sptr_receive_list_option = (OPTION_LIST_ENTRY *) get_entry_from_list
                               ((LINK *) &sptr_option_lists->received);

    sptr_tx_accepted_option = find_matching_option (
                                     &sptr_option_lists->tx_accepted,
                                     sptr_receive_list_option->type.generic);
    if (sptr_tx_accepted_option == NULL)
        {
        free_ppp_option_list (&sptr_option_lists->received);
        return (OPTION_PARSING_ERROR);
        }

    sptr_configured_option = find_matching_option (
                                 &sptr_option_lists->configured,
                                 sptr_receive_list_option->type.generic);

    while (sptr_receive_list_option != NULL)
        {
        if (sptr_tx_accepted_option == NULL || sptr_configured_option == NULL)
            {
            free_ppp_option_list (&sptr_option_lists->received);
            return (OPTION_PARSING_ERROR);
            }

        if (sptr_configured_option->option_flags.negotiation_required == TRUE)
            {
            /*free_ppp_option_list (&sptr_option_lists->received);*/
            parseResult =  SOME_OPTIONS_ARE_REJECTED;
            }
        else
            {
            add_entry_to_list ((LINK *) &sptr_option_lists->rx_reject,
                               (LINK *) sptr_receive_list_option);
            delete_entry_from_option_list (&sptr_option_lists->tx_accepted,
                                           sptr_tx_accepted_option);
            }

        sptr_receive_list_option = (OPTION_LIST_ENTRY *) get_entry_from_list
                                   ((LINK *) &sptr_option_lists->received);

        if (sptr_receive_list_option != NULL)
            {
            /*
             * check_options_from_reject_packet has already checked
             * that options are ordered the same as they were in
             * the last transmitted configure request packet.
             * At this point, since sptr_tx_accepted_option has been
             * deleted, it is unsafe and unnecessary to call
             * find_matching_option_beyond. find_matching_option
             * should be called instead
             */

            if ((sptr_tx_accepted_option = find_matching_option (
                                      &sptr_option_lists->tx_accepted,
                                      sptr_receive_list_option->type.generic))
                                      != NULL)
                {
                sptr_configured_option = find_matching_option_beyond (
                                      sptr_configured_option,
                                      sptr_receive_list_option->type.generic);
                }
            else
                {
                sptr_configured_option = NULL;
                }
            }
        }  /* while loop */

    return (parseResult);
    }

/*******************************************************************************
* delete_entry_from_option_list -
*/
void delete_entry_from_option_list
    (
    OPTION_LIST *sptr_option_list,
    OPTION_LIST_ENTRY *sptr_option_to_delete
    )
    {
    delete_entry_from_list ((LINK *) sptr_option_list,
			    (LINK *) sptr_option_to_delete);

    if (sptr_option_to_delete->length > 0x00)
		{
    	if (sptr_option_to_delete->uptr_data != NULL)       
			{
       		pfwFree((void *)sptr_option_to_delete->uptr_data);
       		sptr_option_to_delete->uptr_data = NULL;         
	   		}
    	if (sptr_option_to_delete != NULL)  
			{
  	      	pfwFree((void *)sptr_option_to_delete);
        	sptr_option_to_delete = NULL;  
        	}
    	}
	}   

/*******************************************************************************
* option_list_print -
*/
void option_list_print
    (
    OPTION_LIST *sptr_option_list
    )
    {
    OPTION_LIST_ENTRY *sptr_option = NULL;
    int i = 0;

    for (sptr_option = sptr_option_list->sptr_forward_link;
	 sptr_option != NULL;
	 sptr_option = sptr_option->sptr_forward_link)
	{
	printf ("<option: %d, ",sptr_option->type.generic);
	printf ("length: %d",sptr_option->length);

	if (sptr_option->length == sizeof(USHORT))
	    {
	    printf (", data: 0x%04x",ntohs(*(USHORT *)sptr_option->uptr_data));
	    }
	else if (sptr_option->length == sizeof(ULONG))
	    {
	    printf (", data: 0x%08lx",ntohl(*(ULONG *)sptr_option->uptr_data));
	    }
	else if (sptr_option->length > 0)
	    {
	    printf (", data: 0x");
	    for (i = 0; i<sptr_option->length; i++)
		{
		printf ("%02x",sptr_option->uptr_data->byte_array[i]);
		}
	    }
	printf (">");
	}
    printf("\n");
    }
   
#ifdef  PPP_DEBUG
/*******************************************************************************
* print_options_in_packet -
*/
void print_options_in_packet
    (
    M_BLK_ID packet
    )
    {
    int total_option_length = 0;
    UINT8 * _ppp_option = NULL; 
    UINT8 optionLength = 0;
    UINT8 optionDataLength = 0;
    UINT8 * optionData = NULL;

    if (packet == NULL)
	return;

    if ((UINT32)packet->mBlkHdr.mLen <= (sizeof(PPP_HEADER)))
	return;

    total_option_length = _PPP_PACKET_LENGTH(packet->mBlkHdr.mData) -
						    _PPP_PACKET_LENGTH_OFFSET;

    _ppp_option = (UINT8 *)(packet->mBlkHdr.mData + 
			    _PPP_PACKET_FIRST_OPTION_OFFSET);

    printf ("ID %d: ",_PPP_PACKET_ID(packet->mBlkHdr.mData));
    while (((optionLength = _PPP_OPTION_LENGTH(_ppp_option)) >= 2) && 
	    (total_option_length > 0) && _PPP_OPTION_VALID(_ppp_option,packet))
    {
	printf ("<option: %d, ",_PPP_OPTION_TYPE(_ppp_option));
	printf ("length: %d",
		(optionDataLength = _PPP_OPTION_DATA_LENGTH(_ppp_option)));

	if (optionDataLength > 0)
	    {
	    int i;
	    printf (", data: 0x");
	    optionData = _PPP_OPTION_DATA(_ppp_option);
	    for (i = 0; i <optionDataLength; i++)
		{
		printf ("%02x",optionData[i]);
		}
	    }
	printf (">");

	total_option_length -= optionLength;
	_ppp_option = _ppp_option + optionLength;
	}
    printf("\n");
    }
#endif /* PPP_DEBUG */