mpreassemble.c

这是全套的PPP协议的源码

		else
			{
			last_fragment = (MP_FRAGMENT_CLASS *) SLL_LAST 
					(&pStackData->bundle.receiving_end.buffer.ppp_fragments);

			last_node_sequence_number = last_fragment->sequence_number;

			number_of_fragments_expected = (last_node_sequence_number - 
				beginning_fragment_sequence_number + 1) + 
				(end_fragment_sequence_number + 1);

			no_of_dup_entries = search_for_duplicate_entries 
							(pMpFramingLayerState, begin_fragment_index, end_fragment_index);

			number_of_fragments_received = pStackData->bundle.
						receiving_end.buffer.number_of_ppp_fragments_buffered
						- (*begin_fragment_index - *end_fragment_index - 1);
			}

		if (number_of_fragments_expected ==	number_of_fragments_received)
			{
#ifdef PPP_DEBUG
			printf ("MP: all fragments (0x%x -- 0x%x) received bundle 0x%x\n",
					 (int) *begin_fragment_index,
					 (int) *end_fragment_index, (int) pMpFramingLayerState->stackObj);
#endif /* PPP_DEBUG */

			return (PASS);
			}
		}

	return (FAIL);
	}

/*******************************************************************************
*
* search_for_beginning_fragment - search the buffer of fragments for the fragment
* bearing beginning bit.
*
* RETURNS: PASS or FAIL.
*/
LOCAL TEST search_for_beginning_fragment
    (
 	PFW_PLUGIN_OBJ_STATE 	*pMpFramingLayerState,
	ULONG 					start_position,
	ULONG 					*index_of_found_fragment,
	ULONG 					*sequence_number_of_found_fragment
	)
	{
	int 							index = 0;
	MP_FRAGMENT_CLASS				*temp_fragment = NULL;
	MP_FRAMING_LAYER_STACK_DATA 	*pStackData = (MP_FRAMING_LAYER_STACK_DATA *)
													pMpFramingLayerState->stackData;

	if ((pMpFramingLayerState == NULL) || (index_of_found_fragment == NULL) ||
		(sequence_number_of_found_fragment == NULL))
		return FAIL;

	if (start_position == 0)
		{
		temp_fragment = (MP_FRAGMENT_CLASS *) SLL_FIRST 
						(&pStackData->bundle.receiving_end.buffer.ppp_fragments);

		/*
		 * search the list from beginning to end
		 * and get the index at which beginning fragment is found
		 */

		index = 0;
		while (temp_fragment != NULL) 
			{
			if (does_fragment_bear_beginning_bit (temp_fragment) == TRUE) 
				{
				*index_of_found_fragment = index;
				*sequence_number_of_found_fragment = 
								temp_fragment->sequence_number;

				return (PASS);
				}
			temp_fragment = (MP_FRAGMENT_CLASS *) SLL_NEXT (temp_fragment);
			++index;
			}
		}
	else
		{
		temp_fragment = (MP_FRAGMENT_CLASS *) SLL_FIRST 
						(&pStackData->bundle.receiving_end.buffer.ppp_fragments);
		
		while (temp_fragment->indexInList != start_position)
			{
			temp_fragment = (MP_FRAGMENT_CLASS *) SLL_NEXT ((SL_NODE *) temp_fragment);
			}

		/* search from start position to 0 - backwards */

		index = start_position;
		while ((temp_fragment->indexInList >= 0) && (temp_fragment != NULL))
			{
			if (does_fragment_bear_beginning_bit (temp_fragment) == TRUE) 
				{
				*index_of_found_fragment = index;
				*sequence_number_of_found_fragment = 
								temp_fragment->sequence_number;

				return (PASS);
				}
			temp_fragment = (MP_FRAGMENT_CLASS *) sllPrevious 
							(&(pStackData->bundle.receiving_end.buffer.ppp_fragments),
							(SL_NODE *) temp_fragment);
			--index;
			}

		temp_fragment = (MP_FRAGMENT_CLASS *) SLL_LAST 
						(&(pStackData->bundle.receiving_end.buffer.ppp_fragments));

		/* search from max to start postion - backwards */

		index = temp_fragment->indexInList;

		while (temp_fragment->indexInList > start_position)
			{

			if (does_fragment_bear_beginning_bit (temp_fragment) == TRUE) 
				{
				*index_of_found_fragment = index;
				*sequence_number_of_found_fragment = 
								temp_fragment->sequence_number;

				return (PASS);
				}
			temp_fragment = (MP_FRAGMENT_CLASS *) sllPrevious 
							(&(pStackData->bundle.receiving_end.buffer.ppp_fragments),
							(SL_NODE *) temp_fragment);
			--index;
			}
		}

	return (FAIL);

	}

/*******************************************************************************
*
* search_for_end_fragment - search the buffer of fragments for the fragment
* bearing end bit.
*
* RETURNS: PASS or FAIL.
*/
LOCAL TEST search_for_end_fragment
    (
 	PFW_PLUGIN_OBJ_STATE 	*pMpFramingLayerState,
	ULONG 					start_position,
	ULONG 					*index_of_found_fragment,
	ULONG 					*sequence_number_of_found_fragment
	)
	{
	int 				index = 0;
	MP_FRAGMENT_CLASS	*temp_fragment = NULL;
	MP_FRAMING_LAYER_STACK_DATA *pStackData = (MP_FRAMING_LAYER_STACK_DATA *)
												pMpFramingLayerState->stackData;

	if ((pMpFramingLayerState == NULL) || (index_of_found_fragment == NULL) ||
		(sequence_number_of_found_fragment == NULL))
		return FAIL;

	if (start_position == 0)
		{
		temp_fragment = (MP_FRAGMENT_CLASS *) SLL_FIRST 
						(&pStackData->bundle.receiving_end.buffer.ppp_fragments);

		/*
		 * search the list from beginning to end
		 * and get the index at which beginning fragment is found
		 */

		index = 0;
		while (temp_fragment != NULL) 
			{
			if (does_fragment_bear_ending_bit (temp_fragment) == TRUE) 
				{
				*index_of_found_fragment = index;
				*sequence_number_of_found_fragment = 
								temp_fragment->sequence_number;
				return (PASS);
				}
			temp_fragment = (MP_FRAGMENT_CLASS *) SLL_NEXT (temp_fragment);
			++index;
			}
		}
	else
		{
		temp_fragment = (MP_FRAGMENT_CLASS *) SLL_FIRST
						(&pStackData->bundle.receiving_end.buffer.ppp_fragments);

		while (temp_fragment->indexInList != start_position)
			{
			temp_fragment = (MP_FRAGMENT_CLASS *) SLL_NEXT ((SL_NODE *) temp_fragment);
			}

		/* search from start position to the end of the list */

		index = start_position;
			
		while (temp_fragment != NULL)
			{
			if (does_fragment_bear_ending_bit (temp_fragment) == TRUE) 
				{
				*index_of_found_fragment = index;
				*sequence_number_of_found_fragment = 
								temp_fragment->sequence_number;
				return (PASS);
				}
			temp_fragment = (MP_FRAGMENT_CLASS *) SLL_NEXT (temp_fragment);
			++index;
			}
			
		temp_fragment = (MP_FRAGMENT_CLASS *) SLL_FIRST
						(&pStackData->bundle.receiving_end.buffer.ppp_fragments);
		
		/* search from 0 to start postion */

		index = 0;

		while (temp_fragment->indexInList < start_position)
			{
			if (does_fragment_bear_ending_bit (temp_fragment) == TRUE) 
				{
				*index_of_found_fragment = index;
				*sequence_number_of_found_fragment = 
								temp_fragment->sequence_number;
				return (PASS);
				}
			temp_fragment = (MP_FRAGMENT_CLASS *) SLL_NEXT (temp_fragment);
			++index;
			}
		}

	return (FAIL);

	}

/*******************************************************************************
*
* get_index_of_M - get the index of the fragment with sequence number M.
* 
* RETURNS: Index of M
*/
LOCAL USHORT get_index_of_M
    (
 	PFW_PLUGIN_OBJ_STATE	*pMpFramingLayerState,
	ULONG					M
	)
	{
	unsigned int	index = 0;
	MP_FRAMING_LAYER_STACK_DATA	*pStackData = (MP_FRAMING_LAYER_STACK_DATA	*)
												pMpFramingLayerState->stackData;
	
	MP_FRAGMENT_CLASS	*mp_fragment = (MP_FRAGMENT_CLASS *) SLL_FIRST 
						(&(pStackData->bundle.receiving_end.buffer.ppp_fragments));

	/*
	 * search the list from beginning to end
	 * and get the index at which M is found
	 */

	index = 0;
	while (mp_fragment != NULL)
		{
		if (mp_fragment->sequence_number == M)
			{
			return ((USHORT) index);
			}
		mp_fragment = mp_fragment->next;
		index++;
		}

	return (0xFFFF);
	}

/*******************************************************************************
*
* get_index_of_first_ending_fragment - get the index of the first fragment 
* in the buffer, bearing the ending bit.
*
* RETURNS: Index of the first ending fragment
*/
LOCAL USHORT get_index_of_first_ending_fragment
    (
 	PFW_PLUGIN_OBJ_STATE	*pMpFramingLayerState
	)
	{
	unsigned int	index = 0;
	MP_FRAMING_LAYER_STACK_DATA	*pStackData = (MP_FRAMING_LAYER_STACK_DATA	*)
												pMpFramingLayerState->stackData;
	
	MP_FRAGMENT_CLASS *mp_fragment = (MP_FRAGMENT_CLASS *) SLL_FIRST 
						(&(pStackData->bundle.receiving_end.buffer.ppp_fragments));

	index = 0;
	while (mp_fragment != NULL)
		{
		if (does_fragment_bear_ending_bit (mp_fragment) == TRUE)
			{
			return ((USHORT) index);
			}
		index++;
		mp_fragment = (MP_FRAGMENT_CLASS *) SLL_NEXT ((SL_NODE *) mp_fragment);
		}

	return (0xFFFF);	

	}

/*******************************************************************************
*
* does_fragment_bear_beginning_bit - check if the fragment bears the beginning
* bit in it.
*
* RETURNS: TRUE or FALSE
*/
LOCAL BOOL does_fragment_bear_beginning_bit
    (
	MP_FRAGMENT_CLASS		*mp_fragment
	)
	{

	if ((mp_fragment->fragment_flag == FIRST_FRAGMENT) ||
		(mp_fragment->fragment_flag == ONLY_FRAGMENT))
		{
		return TRUE;
		}
	else
		{
		return FALSE;
		}
	}

/*******************************************************************************
*
* does_fragment_bear_ending_bit - check if the fragment bears the ending
* bit in it.
*
* RETURNS: TRUE or FALSE
*/
LOCAL BOOL does_fragment_bear_ending_bit
    (
	MP_FRAGMENT_CLASS		*mp_fragment	
	)
	{

    if (mp_fragment == NULL)
        return FALSE;

	if ((mp_fragment->fragment_flag == LAST_FRAGMENT) ||
		(mp_fragment->fragment_flag == ONLY_FRAGMENT))
		{
		return TRUE;
		}
	else
		{
		return FALSE;
		}
	}

/*******************************************************************************
*
* mp_check_and_handle_frame_lost - check and handle the lost frame possibility.
* 
* RETURNS: N/A
*/
void mp_check_and_handle_frame_lost
    (
 	PFW_PLUGIN_OBJ_STATE 	*pMpFramingLayerState,
	ULONG 					M
	)
	{
	USHORT 	index_of_M = 0;
	USHORT 	index_of_first_ending_fragment = 0;
	BOOL 	does_M_bear_beginning_bit;
	ULONG 	current_fragment_index = 0;

	MP_FRAMING_LAYER_STACK_DATA *pStackData = (MP_FRAMING_LAYER_STACK_DATA *)
												pMpFramingLayerState->stackData;

	MP_FRAGMENT_CLASS *mp_fragment = NULL;
	MP_FRAGMENT_CLASS *prev_fragment = NULL;
	MP_FRAGMENT_CLASS *temp_fragment = NULL;
	MP_FRAGMENT_CLASS *mp_fragment_M = NULL;

	current_fragment_index = 0xFFFFFFFFL;
	
	if (pStackData->bundle.receiving_end.buffer.
				number_of_ppp_fragments_buffered == 0x0000)
		{
		return;
		}

	/* get the index of M, current minimum in the buffer */

	index_of_M = get_index_of_M (pMpFramingLayerState, M);

	mp_fragment = (MP_FRAGMENT_CLASS *) SLL_FIRST 
					(&(pStackData->bundle.receiving_end.buffer.ppp_fragments));
	
	if (index_of_M == 0xffff)
		{
		return;
		}

	while (mp_fragment->indexInList != index_of_M)
		mp_fragment = (MP_FRAGMENT_CLASS *) SLL_NEXT ((SL_NODE *) mp_fragment);

	mp_fragment_M = mp_fragment;

	/* handling END fragment loss */

	if ((does_fragment_bear_beginning_bit (mp_fragment) == TRUE)
		&& (index_of_M > 0x000))
		{
		prev_fragment = (MP_FRAGMENT_CLASS *) sllPrevious 
					(&(pStackData->bundle.receiving_end.buffer.ppp_fragments),
					(SL_NODE *) mp_fragment);

		temp_fragment = prev_fragment;

		if (temp_fragment->sequence_number != M - 0x0001)
			{

			discard_fragments_up_to_index (pMpFramingLayerState, 
											index_of_M, TRUE);

#ifdef PPP_DEBUG
			printf ("MP: (E) fragment lost. discard up to 0x%x bundle 0x%x\n",
					(int) M, (int) pMpFramingLayerState->stackObj);
#endif /* PPP_DEBUG */
				
			mp_reassemble_ppp_packet (pMpFramingLayerState, current_fragment_index);
			 
			return;
			}
		else
			{
			if (does_fragment_bear_ending_bit (prev_fragment) == FALSE)
				{
#ifdef PPP_DEBUG
				printf ("MP: non RFC1717 compliant fragment sequence found\n"); 
#endif /* PPP_DEBUG */
				}
			}
		}

	/* ...end of handling END fragment loss */


	index_of_first_ending_fragment = get_index_of_first_ending_fragment 
														(pMpFramingLayerState);

   	if (index_of_first_ending_fragment == 0xFFFF)
		{
  		return;
    	}