return OK;    }/********************************************************************************* pppAsyncFramingLinkResetEventHandler - handle LCP link reset event** RETURNS: OK or ERROR*/LOCAL STATUS pppAsyncFramingLinkResetEventHandler    (    PFW_PLUGIN_OBJ_STATE * state,    void *eventData    )    {    ASYNC_FRAMING_STACK_DATA * pStackData = state->stackData;    pStackData->localMru = 1500;    pStackData->remoteMru = 1500;    pStackData->localToPeerACCMap  = DEFAULT_ASYNC_CONTROL_CHARACTER_MAP;    pStackData->peerToLocalACCMap  = DEFAULT_ASYNC_CONTROL_CHARACTER_MAP;    /* Address control and protocol compression is disabled by default */    pStackData->localToPeerACCompression = FALSE;    pStackData->peerToLocalACCompression = FALSE;    pStackData->localToPeerProtocolCompression = FALSE;    pStackData->peerToLocalProtocolCompression = FALSE;    pStackData->transmitFcsSize = PPP_16BIT_FCS;    pStackData->receiveFcsSize = PPP_16BIT_FCS;    return OK;    }/********************************************************************************* pppAsyncFramingSend - send data in asynchronous format** RETURNS: OK or ERROR*/LOCAL STATUS pppAsyncFramingSend    (    PFW_PLUGIN_OBJ_STATE *state,    M_BLK_ID * packet    )    {    register M_BLK_ID inPacket, outFrame;    M_BLK_ID endOfInPacket;    USHORT calculated16BitCkSum;    UINT32 calculated32BitCkSum;    char checksum[4] = {0,0,0,0};    char header[2];    UINT32 totalPacketLen = 0;    USHORT protocol;    ASYNC_FRAMING_STACK_DATA *stackData = (ASYNC_FRAMING_STACK_DATA *)					   state->stackData;    M_BLK pppHeader = {{NULL,NULL,NULL,2,MT_DATA,0,0},{NULL,0},NULL};    M_BLK pppCkSum  = {{NULL,NULL,NULL,2,MT_DATA,0,0},{NULL,0},NULL};    if (packet == NULL || (inPacket = *packet) == NULL)        {        RFC2233_COUNTER_UPDATE(stackData->pfwRFC2233CountTest, 				stackData->pfwRFC2233CountPair,                               M2_ctrId_ifOutErrors, 1);        return (ERROR);        }    else	endOfInPacket = inPacket;    pppHeader.mBlkHdr.mData = header;    pppCkSum.mBlkHdr.mData = checksum;    totalPacketLen = inPacket->mBlkPktHdr.len;    protocol = (USHORT)((inPacket->mBlkHdr.mData[0] << 8) |			inPacket->mBlkHdr.mData[1]);    /* check for Protocol compression */    if (stackData->localToPeerProtocolCompression == TRUE &&	inPacket->mBlkHdr.mData[0] == 0) /* first byte of protocol field == 0 */	{	inPacket->mBlkHdr.mData++;	inPacket->mBlkHdr.mLen--;        inPacket->mBlkPktHdr.len--;	totalPacketLen--;	}    /* check for Address and control field compression */    if ((protocol == LCP_PROTOCOL) ||	(stackData->localToPeerACCompression != TRUE))	{	header[0] = (char)PPP_ALLSTATIONS;	header[1] = PPP_UI;	/* header mBlk is now head of chain */	pppHeader.mBlkHdr.mNext = inPacket;	pppHeader.mBlkHdr.mFlags |= M_PKTHDR;	pppHeader.mBlkPktHdr.len = totalPacketLen + 2;	/* clear chain information from inPacket */	inPacket->mBlkPktHdr.len = 0;	inPacket->mBlkHdr.mFlags &= ~M_PKTHDR;	inPacket = &pppHeader;	totalPacketLen += 2;	}    if (stackData->transmitFcsSize == PPP_16BIT_FCS)	{	calculated16BitCkSum = calculate16BitFcs (PPPINITFCS16,inPacket);	calculated16BitCkSum = (USHORT) ~calculated16BitCkSum;	checksum[0] = calculated16BitCkSum & 0x00ff;	checksum[1] = (calculated16BitCkSum & 0xff00) >> 8;	/* find the end of the inPacket chain */	endOfInPacket = inPacket;	while(endOfInPacket->mBlkHdr.mNext != NULL)	    endOfInPacket = endOfInPacket->mBlkHdr.mNext;	/* link in the checksum bytes at the end of the chain */        pppCkSum.mBlkHdr.mLen = 2;	endOfInPacket->mBlkHdr.mNext = &pppCkSum;	inPacket->mBlkPktHdr.len +=2;	totalPacketLen += 2;	}    else if (stackData->transmitFcsSize == PPP_32BIT_FCS)	{	calculated32BitCkSum = calculate32BitFcs (PPPINITFCS32,inPacket);	calculated32BitCkSum ^= 0xffffffff;	checksum[0] = calculated32BitCkSum  & 0x000000ff;	checksum[1] = (calculated32BitCkSum & 0x0000ff00) >> 8;	checksum[2] = (calculated32BitCkSum & 0x00ff0000) >> 16;	checksum[3] = (calculated32BitCkSum & 0xff000000) >> 24;	/* find the end of the inPacket chain */	endOfInPacket = inPacket;	while(endOfInPacket->mBlkHdr.mNext != NULL)	    endOfInPacket = endOfInPacket->mBlkHdr.mNext;	/* link in the checksum bytes at the end of the chain */	pppCkSum.mBlkHdr.mLen = 4;	endOfInPacket->mBlkHdr.mNext = &pppCkSum;	inPacket->mBlkPktHdr.len +=4;	totalPacketLen += 4;	}    else if (stackData->transmitFcsSize != PPP_NULL_FCS)	{	netMblkClChainFree(*packet);        RFC2233_COUNTER_UPDATE(stackData->pfwRFC2233CountTest, 				stackData->pfwRFC2233CountPair,                               M2_ctrId_ifOutErrors, 1);	return ERROR;	}    /* allocate a new Mblk for the encoded frame */    if ((outFrame = netTupleGet(stackData->netPoolId,(totalPacketLen),				    M_DONTWAIT, MT_DATA ,TRUE)) == NULL)	{	printf ("AsyncFraming:Failed to get encoded frame for Stack 0x%x\n",			    (UINT32)state->stackObj);	endOfInPacket->mBlkHdr.mNext = NULL;	netMblkClChainFree(*packet);        RFC2233_COUNTER_UPDATE(stackData->pfwRFC2233CountTest, 				stackData->pfwRFC2233CountPair,                               M2_ctrId_ifOutDiscards, 1);	return ERROR;	}    else	{	/* netTupleGet will not clear mLen */	outFrame->mBlkHdr.mLen  = 0;	outFrame->mBlkHdr.mFlags  &= ~M_PKTHDR;	outFrame->mBlkPktHdr.len  = 0;	}    /* set Frame start flag */    outFrame->mBlkHdr.mData[0] = 0x7e;    outFrame->mBlkHdr.mLen = 1;    /* move past frame start and encode the PPP packet */    outFrame->mBlkHdr.mData++;    /* encode the header, payload and checksum */    if (convertNormalDataToAsynchronousData (state, inPacket, outFrame) 	== ERROR)	{	netMblkClChainFree(outFrame);        endOfInPacket->mBlkHdr.mNext = NULL;        netMblkClChainFree(*packet);	return ERROR;	}    /* strip reference to attached checksum mBlk. free the original packet */    endOfInPacket->mBlkHdr.mNext = NULL;    netMblkClChainFree(*packet);    /* point to the frame start byte in the out going frame */    outFrame->mBlkHdr.mData--;    outFrame->mBlkPktHdr.len++;    *packet = outFrame;    return (OK);    }/********************************************************************************* convertNormalDataToAsynchronousData - convert data to an asynchronous format** RETURNS: OK or ERROR*/LOCAL STATUS convertNormalDataToAsynchronousData    (    PFW_PLUGIN_OBJ_STATE *state,    M_BLK_ID srcPacket,    M_BLK_ID dstFrame    )    {    ASYNC_FRAMING_STACK_DATA *stackData = state->stackData;    BYTE actual_byte = 0;    USHORT byte_counter;    USHORT number_of_escape_sequences = 0;    int dstByteCount = 0;    int srcByteLen = 0;    ULONG async_control_character_map = stackData->localToPeerACCMap;    char * dstBuf = dstFrame->mBlkHdr.mData;    char * srcBuf = NULL;    M_BLK_ID dstFrameChainHead = dstFrame;    do	{	srcBuf = srcPacket->mBlkHdr.mData;	srcByteLen = srcPacket->mBlkHdr.mLen;	for (byte_counter = 0; byte_counter < srcByteLen; byte_counter++)	    {	    actual_byte = *((BYTE *)((ULONG)  srcBuf + byte_counter));	    if ((encode_byte (&async_control_character_map,			      actual_byte) == TRUE) || 		(actual_byte == HDLC_FLAG_SEQUENCE) || 		(actual_byte == ASYNC_CONTROL_ESCAPE_SEQUENCE))		{		dstFrame->mBlkHdr.mLen++;		*dstBuf++ = ASYNC_CONTROL_ESCAPE_SEQUENCE;		dstByteCount++ ;		++number_of_escape_sequences;		actual_byte ^= ASYNC_SIXTH_BIT_COMPLEMENT;		if (dstBuf ==		    (dstFrame->pClBlk->clNode.pClBuf + dstFrame->pClBlk->clSize))		    {		    M_BLK_ID pNextMblk;		    if ((pNextMblk = 			netTupleGet(stackData->netPoolId,dstFrame->mBlkHdr.mLen,					    M_DONTWAIT, MT_DATA ,TRUE)) == NULL)			{			printf ("AsyncFraming:Failed to get another mBlk for \				encoded frame:Stack 0x%x\n",				(UINT32) state->stackObj);			RFC2233_COUNTER_UPDATE(stackData->pfwRFC2233CountTest, 						stackData->pfwRFC2233CountPair,                                               M2_ctrId_ifOutDiscards, 1);			return ERROR;			}		    else			{			/* netTupleGet will not clear mLen */			pNextMblk->mBlkHdr.mLen  = 0;			pNextMblk->mBlkHdr.mFlags  &= ~M_PKTHDR;			pNextMblk->mBlkPktHdr.len  = 0;			}		    dstFrame->mBlkHdr.mNext = pNextMblk;		    dstFrame = dstFrame->mBlkHdr.mNext;		    dstBuf = dstFrame->mBlkHdr.mData;		    }		}	    *dstBuf++ = actual_byte;	    dstByteCount++ ;	    dstFrame->mBlkHdr.mLen++;	    if (dstBuf  ==		(dstFrame->pClBlk->clNode.pClBuf + dstFrame->pClBlk->clSize))		{		M_BLK_ID pNextMblk;		if ((pNextMblk = 			netTupleGet(stackData->netPoolId,dstFrame->mBlkHdr.mLen,					    M_DONTWAIT, MT_DATA ,TRUE)) == NULL)		    {		    printf ("AsyncFraming:Failed to get another mBlk for encoded \			frame:Stack 0x%x\n", (UINT32) state->stackObj);		    RFC2233_COUNTER_UPDATE(stackData->pfwRFC2233CountTest, 					    stackData->pfwRFC2233CountPair,                                           M2_ctrId_ifOutDiscards, 1);		    return ERROR;		    }		else		    {		    /* netTupleGet will not clear mLen */		    pNextMblk->mBlkHdr.mLen  = 0;		    pNextMblk->mBlkHdr.mFlags  &= ~M_PKTHDR;		    pNextMblk->mBlkPktHdr.len  = 0;		    }		dstFrame->mBlkHdr.mNext = pNextMblk;		dstFrame = dstFrame->mBlkHdr.mNext;		dstBuf = dstFrame->mBlkHdr.mData;		}	    }	} while ((srcPacket = srcPacket->mBlkHdr.mNext) != NULL);    *dstBuf++ = 0x7e;    dstByteCount++;    dstFrame->mBlkHdr.mLen++;    dstFrameChainHead->mBlkHdr.mFlags |= M_PKTHDR;    dstFrameChainHead->mBlkPktHdr.len = dstByteCount;    return (OK);    }/********************************************************************************* encode_byte - check on the byte encoding** RETURNS: TRUE or FALSE*/LOCAL BOOL encode_byte     (    ULONG *async_control_character_map,    BYTE byte_to_encode    )    {    if ((byte_to_encode >= 0x20) || 	(*async_control_character_map == 0x00000000L))	{	return (FALSE);	}    if (*async_control_character_map == DEFAULT_ASYNC_CONTROL_CHARACTER_MAP)	if (byte_to_encode < 0x20)	    {	    return (TRUE);	    }    if (((ULONG) 1 << byte_to_encode) & *async_control_character_map)	{	return (TRUE);	}    else	{	return (FALSE);	}    }/********************************************************************************* pppAsyncFramingReceive - receive data in asynchronous format** RETURNS: OK or ERROR*/LOCAL STATUS pppAsyncFramingReceive    (    PFW_PLUGIN_OBJ_STATE *state,    M_BLK_ID * packet    )    {    register M_BLK_ID inFrame, outPacket;    ASYNC_FRAMING_STACK_DATA *stackData = state->stackData;    USHORT calculated16BitCkSum;    UINT32 calculated32BitCkSum;    int frameFlagsRemoved = 0;    int lengthOfEncodedData;    int sizeOfDecodedDataBuffer;    M_BLK_ID nextMblk;    PPP_LINK_STATUS_COUNTER_INCREMENT_INTERFACE * counterInterface = 		    (PPP_LINK_STATUS_COUNTER_INCREMENT_INTERFACE*)				stackData->pppLinkCounterInterface.interfaceObj;    if (packet == NULL || (inFrame = *packet) == NULL)        {        RFC2233_COUNTER_UPDATE(stackData->pfwRFC2233CountTest, 				stackData->pfwRFC2233CountPair,                               M2_ctrId_ifInErrors, 1);        return (ERROR);        }    /* move past the frame Begin flag */    while (inFrame != NULL && *(inFrame->mBlkHdr.mData) == 0x7e)	{	inFrame->mBlkHdr.mData++;	frameFlagsRemoved++;	if (--inFrame->mBlkHdr.mLen == 0)	    {	    if ((nextMblk = inFrame->mBlkHdr.mNext) != NULL)		{		nextMblk->mBlkHdr.mFlags |= M_PKTHDR;		nextMblk->mBlkPktHdr.len = 				(inFrame->mBlkPktHdr.len - frameFlagsRemoved);		netMblkClFree(inFrame);		inFrame = nextMblk;		}	    else		{		netMblkClChainFree(inFrame);		RFC2233_COUNTER_UPDATE(stackData->pfwRFC2233CountTest, 					stackData->pfwRFC2233CountPair,                                       M2_ctrId_ifInErrors, 1);		return ERROR;		}	    frameFlagsRemoved = 0;	    }	}    if (inFrame->mBlkHdr.mNext != NULL)	{	inFrame->mBlkPktHdr.len -= frameFlagsRemoved;	lengthOfEncodedData = inFrame->mBlkPktHdr.len;	}    else	lengthOfEncodedData = inFrame->mBlkHdr.mLen;    sizeOfDecodedDataBuffer = min(lengthOfEncodedData,inFrame->pClBlk->clSize);    /* allocate a new Mblk for the decoded frame and allow for decompression */    if ((outPacket = netTupleGet(stackData->netPoolId,	    sizeOfDecodedDataBuffer, M_DONTWAIT, MT_DATA ,TRUE)) == NULL)	{	printf ("AsyncFraming:Failed to get decoded frame for StackObj 0x%x\n",		    (UINT32) state->stackObj);