pppoptnp.c

这是全套的PPP协议的源码

     if (sptr_local_option->range_option == NULL)
       {
       return (FALSE);
       }

    if (sptr_local_option->length != sptr_remote_option->length)
	{
	return (FALSE);
	}

    bptr_step_option = (BYTE *) sptr_local_option->range_option->uptr_step;

    for (option_length = 0x0000; option_length < sptr_local_option->length;
	++option_length)
	{
	if (*bptr_step_option != 0x00)
	    {
	    stepIsZero = FALSE;
	    break;
	    }

	++bptr_step_option;
	}

    /*if (*bptr_step_option == 0x00)*/
      if (stepIsZero == TRUE)
	{
	switch (sptr_local_option->length)
	    {
    case sizeof (USHORT):
        if ((ntohs(sptr_local_option->
			range_option->uptr_lowest_value->_ushort) <=
		 	ntohs(sptr_remote_option->uptr_data->_ushort)) &&
		   	(ntohs(sptr_remote_option->uptr_data->_ushort) <=
		    	ntohs(sptr_local_option->
			range_option->uptr_highest_value->_ushort)))	
		    {
		    return (TRUE);
		    }
		break;

	    case sizeof (ULONG):
		if ((ntohl(sptr_local_option->
				range_option->uptr_lowest_value->_ulong) <=
		    	ntohl(sptr_remote_option->uptr_data->_ulong)) &&
		    	(ntohl(sptr_remote_option->uptr_data->_ulong) <=
		    	ntohl(sptr_local_option->range_option->
				uptr_highest_value->_ulong)))	
		    {
		    return (TRUE);
		    }

		break;

	    default:
		break;
	    }
	return FALSE;
	}

    for (uptr_matching_option_data = sptr_local_option->range_option
					->uptr_lowest_value;
	    memcmp (uptr_matching_option_data, 
			sptr_local_option->range_option->uptr_highest_value, 
			sptr_remote_option->length) != (int) NULL;
	    increment_range_option (uptr_matching_option_data,
			sptr_local_option->range_option->
			uptr_step,sptr_local_option->length)) 
		{
		if (memcmp (uptr_matching_option_data,
				sptr_remote_option->uptr_data,
				sptr_remote_option->length) == (int) NULL)
		    {
		    return (TRUE);
		    }
		}
		
    if (memcmp (uptr_matching_option_data,sptr_remote_option->uptr_data,
		sptr_remote_option->length) == (int) NULL)
	{
	return (TRUE);
	}

    return (FALSE);
    }
/*******************************************************************************
* increment_range_option -
*/
LOCAL void increment_range_option
    (
    UNION_OPTION_DATA_TYPES *uptr_matching_option_data,
    UNION_OPTION_DATA_TYPES *uptr_step_size,BYTE length
    )
    {
    BYTE *bptr_option_data = NULL;
    BYTE *bptr_step_data = NULL;
#if 0
    BYTE data_index;
#endif

    bptr_option_data = (BYTE *) uptr_matching_option_data;
    bptr_step_data = (BYTE *) uptr_step_size;

    switch (length)
        {
        case sizeof (USHORT):
             uptr_matching_option_data->_ushort =
                 htons (
                       ntohs(uptr_matching_option_data->_ushort) +
                       ntohs(uptr_step_size->_ushort)
                       );
#ifdef PPP_DEBUG
             printf ("range data %d step %d \n",
                      ntohs(uptr_matching_option_data->_ushort),
                      ntohs(uptr_step_size->_ushort));
#endif
             break;

        case sizeof (ULONG):
             uptr_matching_option_data->_ulong =
                 htonl (
                       ntohl(uptr_matching_option_data->_ulong) +
                       ntohl(uptr_step_size->_ulong)
                       );
#ifdef PPP_DEBUG
            printf ("range data %ld step %ld \n",
                      ntohl(uptr_matching_option_data->_ulong),
                      ntohl(uptr_step_size->_ulong));
#endif
             break;

        default:
                break;
        }

#if 0
    for (data_index = 0x00; data_index < length; 
					data_index = (BYTE) (data_index + 1))
	{
	*bptr_option_data = (BYTE) (*bptr_option_data + *bptr_step_data);

	++bptr_option_data;
	++bptr_step_data;
	}
#endif

    }


/*******************************************************************************
* set_option_values_from_nak - select acceptable value for the local side
*
* NOMANUAL
*/
TEST set_option_values_from_nak
    (
    PFW_OBJ * pfw,
    OPTION_LISTS *sptr_option_lists,
    OPTION_LIST_ENTRY *sptr_tx_accepted_option
    )
    {
    UNION_OPTION_DATA_TYPES *uptr_preferred_data = NULL;
    BYTE length_of_preferred_data = 0;
    ALTERNATE_OPTION *sptr_alternate_option = NULL;
    OPTION_LIST_ENTRY range_option;
    OPTION_LIST_ENTRY * sptr_configured_option = NULL;

    if (sptr_tx_accepted_option->nak_option_selected == 0x00)
        {
        /*
         * sptr_tx_accepted_option is an entry in the tx_accepted list.
         * The tx_accepted list is a copy by reference of the
         * configured list for the local options.
         * uptr_data and length are the only fields that
         * are not pointers.  uptr_data is overwritten if an
         * alternate or range value is proposed.  The first time
         * nak_option_selected is 0, uptr_data will be the
         * same as the main value in the configured list.
         * Subsequent times, the main value has to be copied. 
         * from the configured list.
         */
        
        sptr_configured_option = find_matching_option(
                                     &sptr_option_lists->configured,
                                     sptr_tx_accepted_option->type.generic);

        uptr_preferred_data = sptr_configured_option->uptr_data;
        length_of_preferred_data = sptr_configured_option->length;
        }
    else
        {
        sptr_alternate_option = find_alternate_option_to_nak_with (
            sptr_tx_accepted_option->nak_option_selected,
            sptr_tx_accepted_option);

        if (sptr_alternate_option == NULL)
            {
            find_range_option_to_nak_with (
                sptr_tx_accepted_option->nak_option_selected,
                sptr_tx_accepted_option,&range_option);

            if (range_option.uptr_data == NULL)
                {
                sptr_tx_accepted_option->nak_option_selected = 0x00;
                return (FAIL);
                }

            uptr_preferred_data = range_option.uptr_data;
            length_of_preferred_data = range_option.length;
            }
        else
            {
            uptr_preferred_data = sptr_alternate_option->uptr_data;
            length_of_preferred_data = sptr_alternate_option->length;
            }
        }

    if (sptr_tx_accepted_option->length == length_of_preferred_data)
        {
        memcpy (sptr_tx_accepted_option->uptr_data,
                uptr_preferred_data,length_of_preferred_data);
        }
    else
        {
        replace_data_field_in_option (pfw, sptr_tx_accepted_option,
                                      uptr_preferred_data,
                                      length_of_preferred_data);
        }

    if ((sptr_tx_accepted_option->option_flags.alternate_checking_enabled == 
		PPP_FLAG_ON) || 
		(sptr_tx_accepted_option->option_flags.range_checking_enabled == 
		PPP_FLAG_ON)) 
        {
        sptr_tx_accepted_option->nak_option_selected =
            (BYTE) (sptr_tx_accepted_option->nak_option_selected + 1);
        }

    return (PASS);
    }


/*******************************************************************************
* set_option_values_for_nak -
*/
TEST set_option_values_for_nak /* changed from static to non-static - 
								  WindNet Multilink */
    (
    PFW_OBJ * pfw,
    OPTION_LIST_ENTRY *sptr_local_option,
    OPTION_LIST_ENTRY *sptr_remote_option
    )
    {
    UNION_OPTION_DATA_TYPES *uptr_preferred_data = NULL;
    BYTE length_of_preferred_data = 0;
    ALTERNATE_OPTION *sptr_alternate_option = NULL;
    OPTION_LIST_ENTRY range_option;

    if (sptr_local_option->nak_option_selected == 0x00)
	{
	uptr_preferred_data = sptr_local_option->uptr_data;
	length_of_preferred_data = sptr_local_option->length;
	}
    else
	{
	sptr_alternate_option = find_alternate_option_to_nak_with (
		    sptr_local_option->nak_option_selected,sptr_local_option);

	if (sptr_alternate_option == NULL)
	    {
	    find_range_option_to_nak_with (
					sptr_local_option->nak_option_selected,
					sptr_local_option,&range_option);

	    if (range_option.uptr_data == NULL)
		{
		sptr_local_option->nak_option_selected = 0x00;
		return (FAIL);
		}

	    uptr_preferred_data = range_option.uptr_data;
	    length_of_preferred_data = range_option.length;
	    }
	else
	    {
	    uptr_preferred_data = sptr_alternate_option->uptr_data;
	    length_of_preferred_data = sptr_alternate_option->length;
	    }
	}

    if (sptr_local_option->length == sptr_remote_option->length)
	{
	memcpy (sptr_remote_option->uptr_data,
			    uptr_preferred_data,length_of_preferred_data);
	}
    else
	{
	replace_data_field_in_option (pfw, sptr_remote_option,
				uptr_preferred_data,length_of_preferred_data);
	}

    if ((sptr_local_option->option_flags.alternate_checking_enabled == 
		PPP_FLAG_ON) || (sptr_local_option->option_flags.range_checking_enabled
		== PPP_FLAG_ON)) 
	{
	sptr_local_option->nak_option_selected =
			    (BYTE) (sptr_local_option->nak_option_selected + 1);
	}

    return (PASS);
    }
/*******************************************************************************
* find_alternate_option_to_nak_with -
*/
LOCAL ALTERNATE_OPTION *find_alternate_option_to_nak_with
    (
    BYTE nak_option_number_to_match,
    OPTION_LIST_ENTRY *sptr_local_option
    )
    {
    ALTERNATE_OPTION *sptr_alternate_option = NULL;
    BYTE nak_option_selected = 0;

    nak_option_selected = 0x01;

    if (sptr_local_option->option_flags.alternate_checking_enabled == 
		PPP_FLAG_OFF) 
	{
	return (NULL);
	}

    for (sptr_alternate_option = 
	 sptr_local_option->alternate_option_list.sptr_forward_link; 
	 sptr_alternate_option != NULL;
	 sptr_alternate_option = sptr_alternate_option->links.sptr_forward_link)
	{
	if (nak_option_number_to_match == nak_option_selected)
	    {
	    break;
	    }

	nak_option_selected = (BYTE) (nak_option_selected + 1);
	}

    return (sptr_alternate_option);
    }
/*******************************************************************************
* find_range_option_to_nak_with -
*/
LOCAL void find_range_option_to_nak_with 
    (
    BYTE nak_option_number_to_match,
    OPTION_LIST_ENTRY *sptr_local_option,
    OPTION_LIST_ENTRY *sptr_range_option
    )
    {
    UNION_OPTION_DATA_TYPES *uptr_matching_option_data = NULL;
    BYTE nak_option_selected = 0;

    nak_option_selected = 0x01;

    sptr_range_option->uptr_data = NULL;

    if (sptr_local_option->option_flags.range_checking_enabled == PPP_FLAG_OFF)
	{
	return;
	}
    if (sptr_local_option->range_option == NULL)
        {
        return;
        }

    for (uptr_matching_option_data = sptr_local_option->
					range_option->uptr_lowest_value;
	 uptr_matching_option_data != NULL;
	 increment_range_option (uptr_matching_option_data,
				sptr_local_option->range_option->uptr_step,
				sptr_local_option->length))
	{
	if (nak_option_number_to_match == nak_option_selected)
	    {
	    return;
	    }

	nak_option_selected = (BYTE) (nak_option_selected + 1);
	}
    }

/*******************************************************************************
* ppp_negotiation_error - 
*/
void ppp_negotiation_error /* changed from static to non-static - 
							  WindNet Multilink */
    (
    PFW_PLUGIN_OBJ_STATE * pluginState,
    OPTION_LIST_ENTRY *sptr_received_option,
    OPTION_LISTS *sptr_option_lists
    )
    {
    BOOLEAN close_connection;
    #if 0
    PPP_CONTROL_OBJ_STATE_DATA *pStateData = 
			(PPP_CONTROL_OBJ_STATE_DATA *)pluginState->stackData;

    #endif
    close_connection = TRUE;
    #if 0
    if (pStateData->action_table->negotiation_error_exception != NULL)
	{
	close_connection = (BOOLEAN) 
		(*pStateData->action_table->negotiation_error_exception)
					(pluginState, ILLEGAL_PPP_STATE,NULL);
	}

    #endif
    execute_ppp_state_machine (pluginState, PPP_CLOSE_EVENT,NULL);
    }