mp_fragment = (MP_FRAGMENT_CLASS *) SLL_FIRST 					(&(pStackData->bundle.receiving_end.buffer.ppp_fragments));	while (mp_fragment->indexInList != index_of_first_ending_fragment)		{		mp_fragment = (MP_FRAGMENT_CLASS *) SLL_NEXT 											((SL_NODE *) mp_fragment);		}	/* handling first and non end fragment loss */	if (M > mp_fragment->sequence_number)		{		does_M_bear_beginning_bit = does_fragment_bear_beginning_bit (mp_fragment_M);				discard_fragments_up_to_index (pMpFramingLayerState, index_of_M, TRUE);		if (does_M_bear_beginning_bit == FALSE)			{			discard_fragments_up_to_index (pMpFramingLayerState, 							pStackData->bundle.receiving_end.buffer.							number_of_ppp_fragments_buffered, TRUE);						pStackData->bundle.receiving_end.buffer.						receiver_is_resynchronizing = TRUE;			#ifdef PPP_DEBUG			printf ("MP: lost fragment. Discard up to 0x%x  bundle 0x%x\n",					 (int) M, (int) pMpFramingLayerState->stackObj);#endif /* PPP_DEBUG */			}		else			{			mp_reassemble_ppp_packet (pMpFramingLayerState, current_fragment_index);			#ifdef PPP_DEBUG			printf ("MP: lost fragment. Discard up to 0x%x  bundle 0x%x\n",					 (int) M, (int) pMpFramingLayerState->stackObj);#endif /* PPP_DEBUG */			}		}	}/********************************************************************************* discard_fragment_range - discrad the fragments buffered, in a particular range** RETURNS: N/A*/LOCAL void discard_fragment_range    ( 	PFW_PLUGIN_OBJ_STATE 	*pMpFramingLayerState,	ULONG 					first,	ULONG 					last,	BOOL					free_the_packet	)	{	MP_FRAGMENT_CLASS	*first_mp_fragment = NULL;	MP_FRAGMENT_CLASS	*last_mp_fragment = NULL;	MP_FRAGMENT_CLASS	*next_mp_fragment = NULL;	MP_FRAMING_LAYER_STACK_DATA *pStackData = (MP_FRAMING_LAYER_STACK_DATA *)												pMpFramingLayerState->stackData;	if (pMpFramingLayerState == NULL)		return;	/* get the first node in the list */	first_mp_fragment = (MP_FRAGMENT_CLASS *) SLL_FIRST 					(&(pStackData->bundle.receiving_end.buffer.ppp_fragments));	/* get the first node in the list */	last_mp_fragment = (MP_FRAGMENT_CLASS *) SLL_FIRST 					(&(pStackData->bundle.receiving_end.buffer.ppp_fragments));	/* traverse upto the index (first) in the list and get its pointer */	while (first_mp_fragment->indexInList != (USHORT) first)		{		first_mp_fragment = (MP_FRAGMENT_CLASS *) SLL_NEXT 								((SL_NODE *) first_mp_fragment);		}	/* traverse upto the index (last) in the list and get its pointer */		while (last_mp_fragment->indexInList != (USHORT) last)		{		last_mp_fragment = (MP_FRAGMENT_CLASS *) SLL_NEXT 								((SL_NODE *) last_mp_fragment);		}	/* traverse from first to last and discard the fragment everytime */	while (first_mp_fragment != last_mp_fragment)		{		next_mp_fragment = (MP_FRAGMENT_CLASS *) 							SLL_NEXT((SL_NODE *) first_mp_fragment);		discard_a_ppp_fragment (pMpFramingLayerState, 							first_mp_fragment, free_the_packet);		first_mp_fragment = next_mp_fragment;		}	/* we have not cleared the last one, clear it here */	discard_a_ppp_fragment (pMpFramingLayerState, last_mp_fragment, free_the_packet);	/* update the number of fragments buffered */	pStackData->bundle.receiving_end.buffer.number_of_ppp_fragments_buffered -= 	(USHORT) (last - first + 1);	}/********************************************************************************* discard_fragments_up_to_index - discard the fragments in the buffer upto the* the given index.** RETURNS: N/A*/LOCAL void discard_fragments_up_to_index    ( 	PFW_PLUGIN_OBJ_STATE 	*pMpFramingLayerState,	USHORT 					to_index,	BOOL					free_the_packet	)	{	MP_FRAGMENT_CLASS *temp_fragment = NULL;	MP_FRAGMENT_CLASS *temporary_fragment = NULL;	MP_FRAGMENT_CLASS *next_fragment = NULL;	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);	if (pMpFramingLayerState == NULL)		return;	if (to_index >= pStackData->bundle.receiving_end.buffer.						number_of_ppp_fragments_buffered)		{		while (mp_fragment != NULL)			{			/* from 0 to number of fragments buffered */			next_fragment = (MP_FRAGMENT_CLASS *) 							SLL_NEXT((SL_NODE *) mp_fragment);			discard_a_ppp_fragment (pMpFramingLayerState, 									mp_fragment, free_the_packet);			mp_fragment = next_fragment;			}		}	else		{		temp_fragment = mp_fragment;		while (mp_fragment->indexInList != to_index)			mp_fragment = (MP_FRAGMENT_CLASS *) SLL_NEXT ((SL_NODE *) mp_fragment);		while (temp_fragment != mp_fragment)			{			temporary_fragment = temp_fragment;			temp_fragment = (MP_FRAGMENT_CLASS *) SLL_NEXT 												((SL_NODE *) temp_fragment);						discard_a_ppp_fragment (pMpFramingLayerState, 									temporary_fragment, free_the_packet);			}		}	pStackData->bundle.receiving_end.buffer.number_of_ppp_fragments_buffered = 		(USHORT) (pStackData->bundle.receiving_end.buffer.						number_of_ppp_fragments_buffered - to_index);	}/********************************************************************************* discard_a_ppp_fragment - discrad a particular PPP fragement from the buffer** RETURNS: N/A*/LOCAL void discard_a_ppp_fragment    ( 	PFW_PLUGIN_OBJ_STATE 	*pMpFramingLayerState,	MP_FRAGMENT_CLASS		*mp_fragment,	BOOL					free_the_packet	)	{	MP_FRAGMENT_CLASS	*temp_fragment = NULL;	MP_FRAMING_LAYER_STACK_DATA *pStackData = (MP_FRAMING_LAYER_STACK_DATA *)												pMpFramingLayerState->stackData;	MP_FRAGMENT_CLASS	*prev_fragment = (MP_FRAGMENT_CLASS *) sllPrevious 				(&(pStackData->bundle.receiving_end.buffer.ppp_fragments), 				(SL_NODE *) mp_fragment);	if (mp_fragment == NULL)		return;		/* check for a fragment bearing a BEGIN Bit or ONLY_FRAGMENT(B & E) */	if (does_fragment_bear_beginning_bit (mp_fragment) == TRUE)		{		--pStackData->bundle.receiving_end.buffer.					number_of_beginning_fragments_buffered;		}	/* check for a fragment bearing an END Bit or ONLY_FRAGMENT(B & E) */	if (does_fragment_bear_ending_bit (mp_fragment) == TRUE)		{		--pStackData->bundle.receiving_end.buffer.					number_of_ending_fragments_buffered;		}	/* update the index numbers maintained in the structure */	temp_fragment = mp_fragment;	while (temp_fragment != NULL)		{		temp_fragment->indexInList = temp_fragment->indexInList - 1;		temp_fragment = (MP_FRAGMENT_CLASS *) SLL_NEXT 									((SL_NODE *) temp_fragment);		}		/* check and free the MBLKs */	if (free_the_packet == TRUE)		{		netMblkClChainFree (mp_fragment->mblk_fragment); 		}	/* remove the node from the list */	sllRemove (&(pStackData->bundle.receiving_end.buffer.ppp_fragments), 			(SL_NODE *) mp_fragment, (SL_NODE *) prev_fragment);	/* free the fragment */            pfwFree ((void *) mp_fragment);		mp_fragment = NULL;		}/********************************************************************************* mp_get_M - find the current minimum of the most recently received sequence* number over all the member links in the bundle.** RETURNS: M*/ULONG mp_get_M    ( 	PFW_PLUGIN_OBJ_STATE	*pMpFramingLayerState	)	{				ULONG	M = 0;	 /* current minimum of the most recently received sequence number				  * over all the member links in the bundle. RFC 1717,p.10.				  */	USHORT	current_link = 0;		MP_FRAMING_LAYER_STACK_DATA	*pStackData = (MP_FRAMING_LAYER_STACK_DATA	*)												pMpFramingLayerState->stackData;	M = 0xFFFFFFFF;		for (current_link = 0x0000;		current_link < pStackData->bundle.receiving_end.no_of_links;		++current_link)		{		if (pStackData->bundle.receiving_end.			links [current_link].most_recently_received_sequence_number < M)			{			M = pStackData->bundle.receiving_end.					links [current_link].most_recently_received_sequence_number;			}		}	return (M);	}/******************************************************************************* search_for_duplicate_entries - search for duplicate sequence number** This function searches the buffer of fragments for duplicate sequence number.* If there is a duplicate entry found, it discards the fragment and frees the* mblk associated with it.*/LOCAL USHORT search_for_duplicate_entries 	(		PFW_PLUGIN_OBJ_STATE *pMpFramingLayerState,	ULONG *begin_fragment_index,	ULONG *end_fragment_index	)	{	MP_FRAGMENT_CLASS *temp_fragment = NULL;	MP_FRAGMENT_CLASS *next_fragment = NULL;	MP_FRAMING_LAYER_STACK_DATA	*pStackData = (MP_FRAMING_LAYER_STACK_DATA	*)												pMpFramingLayerState->stackData;	USHORT no_of_dup_entries = 0;	if (*begin_fragment_index < *end_fragment_index) /* B...C...E */		{ 				temp_fragment = (MP_FRAGMENT_CLASS *) SLL_FIRST 							(&pStackData->bundle.receiving_end.buffer.ppp_fragments);		/* move upto the begin fragment index */		while (temp_fragment->indexInList != *begin_fragment_index)			{			temp_fragment = (MP_FRAGMENT_CLASS *) SLL_NEXT ((SL_NODE *) temp_fragment);			}				/* search from begin fragment to end fragment index */		while (temp_fragment->indexInList != *end_fragment_index)			{			next_fragment = (MP_FRAGMENT_CLASS *) SLL_NEXT ((SL_NODE *) temp_fragment);			if (next_fragment == NULL)				break;			if (next_fragment->sequence_number == temp_fragment->sequence_number)				{				discard_a_ppp_fragment (pMpFramingLayerState, next_fragment,										TRUE); 				/* update the end fragment index */				(*end_fragment_index)--;				no_of_dup_entries++;				pStackData->bundle.receiving_end.buffer.number_of_ppp_fragments_buffered--; 				}			temp_fragment = (MP_FRAGMENT_CLASS *) SLL_NEXT ((SL_NODE *) temp_fragment);			}		} 	else 		/* E....C....B */		{ 		/* search from begin fragment to the last (no. of fragments buffered) */		temp_fragment = (MP_FRAGMENT_CLASS *) SLL_FIRST 							(&pStackData->bundle.receiving_end.buffer.ppp_fragments);		while (temp_fragment->indexInList != *begin_fragment_index)			{			temp_fragment = (MP_FRAGMENT_CLASS *) SLL_NEXT ((SL_NODE *) temp_fragment);			}		while (temp_fragment != NULL)			{			next_fragment = (MP_FRAGMENT_CLASS *) SLL_NEXT ((SL_NODE *) temp_fragment);			if (next_fragment == NULL)				break;			if (next_fragment->sequence_number == temp_fragment->sequence_number)				{				discard_a_ppp_fragment (pMpFramingLayerState, next_fragment,										TRUE); 				no_of_dup_entries++;				pStackData->bundle.receiving_end.buffer.number_of_ppp_fragments_buffered--; 				}			temp_fragment = (MP_FRAGMENT_CLASS *) SLL_NEXT ((SL_NODE *) temp_fragment);			}		/* search from first (0) upto the end fragment index */		temp_fragment = (MP_FRAGMENT_CLASS *) SLL_FIRST 							(&pStackData->bundle.receiving_end.buffer.ppp_fragments);				while (temp_fragment->indexInList != *end_fragment_index)			{					next_fragment = (MP_FRAGMENT_CLASS *) SLL_NEXT ((SL_NODE *) temp_fragment);			if (next_fragment == NULL)				break;			if (next_fragment->sequence_number == temp_fragment->sequence_number)				{				discard_a_ppp_fragment (pMpFramingLayerState, next_fragment,										TRUE); 				/* update both "end" and "begin" fragment indices */				(*end_fragment_index)--;				(*begin_fragment_index)--;				no_of_dup_entries++;				pStackData->bundle.receiving_end.buffer.number_of_ppp_fragments_buffered--; 				}			temp_fragment = (MP_FRAGMENT_CLASS *) SLL_NEXT ((SL_NODE *) temp_fragment);			}		}	return no_of_dup_entries;}		#if 0/******************************************************************************** ppp_buffer_print - prints the buffer in the bundle.** used for testing only...!*/LOCAL void ppp_buffer_print (PFW_PLUGIN_OBJ_STATE	*pMpFramingLayerState)	{	MP_FRAMING_LAYER_STACK_DATA *pStackData = (MP_FRAMING_LAYER_STACK_DATA *)												pMpFramingLayerState->stackData;	MP_FRAGMENT_CLASS *temp_fragment;	M_BLK_ID			pMblk = NULL;	temp_fragment = (MP_FRAGMENT_CLASS *) SLL_FIRST 						(&pStackData->bundle.receiving_end.buffer.ppp_fragments);	while (temp_fragment != NULL)		{		printf ("The fragment details are\n");		printf ("SQ NO is => 0x%x::indexInList is => 0x%x::Fragment Flag is => 0x%x\n", 				temp_fragment->sequence_number, temp_fragment->indexInList,			    temp_fragment->fragment_flag);		pMblk = temp_fragment->mblk_fragment;		printf("Fragment Data:\n ");		if (pMblk->mBlkHdr.mLen < 50)			mp_dump_data ((BYTE *)pMblk->mBlkHdr.mData, pMblk->mBlkHdr.mLen);		temp_fragment = (MP_FRAGMENT_CLASS *) SLL_NEXT ((SL_NODE *)temp_fragment);		}	}#endif