return (OK);	}    address_and_control_fields_are_compressed = FALSE;    protocol_field_is_compressed = FALSE;    ppp_header.hdlc_address = HDLC_ADDRESS;    ppp_header.hdlc_control = UNNUMBERED_INFORMATION;    if (stackData->peerToLocalACCompression == TRUE)	{	if (sptr_rxed_packet->header.hdlc_address != HDLC_ADDRESS) 	    {	    address_and_control_fields_are_compressed = TRUE;	    memcpy (&protocol_type_in_bytes[0],(char *)sptr_rxed_packet,		    sizeof (USHORT_ENUM (PPP_PROTOCOL_TYPE)));	    }    	else	    {            protocol_type = sptr_rxed_packet->header.protocol_type;	    memcpy (&protocol_type_in_bytes[0], 	    		&protocol_type,	    		sizeof (USHORT_ENUM (PPP_PROTOCOL_TYPE)));	    }	}    else	{	if ((sptr_rxed_packet->header.hdlc_address != HDLC_ADDRESS) || 	    (sptr_rxed_packet->header.hdlc_control != UNNUMBERED_INFORMATION))            {	    RFC2233_COUNTER_UPDATE(stackData->pfwRFC2233CountTest, 				    stackData->pfwRFC2233CountPair,                                   M2_ctrId_ifInErrors, 1);	    RFC2233_COUNTER_UPDATE(stackData->pfwRFC2233CountTest, 				    stackData->pfwRFC2233CountPair,                                   M2_ctrId_ifInUnknownProtos, 1);	    return (ERROR); /* Discard frame */            }        protocol_type = sptr_rxed_packet->header.protocol_type;        	memcpy (&protocol_type_in_bytes[0],                &protocol_type,                sizeof (USHORT_ENUM (PPP_PROTOCOL_TYPE)));	}    if ((protocol_type_in_bytes[0] & 0x1) == 0)	{	memcpy (&protocol_type,&protocol_type_in_bytes[0],		sizeof (USHORT_ENUM (PPP_PROTOCOL_TYPE)));        ppp_header.protocol_type = protocol_type;	}    else	{	if (stackData->peerToLocalProtocolCompression != TRUE)            {	    RFC2233_COUNTER_UPDATE(stackData->pfwRFC2233CountTest, 				    stackData->pfwRFC2233CountPair,                                   M2_ctrId_ifInErrors, 1);	    RFC2233_COUNTER_UPDATE(stackData->pfwRFC2233CountTest, 				    stackData->pfwRFC2233CountPair,                                   M2_ctrId_ifInUnknownProtos, 1);	    return (ERROR); /* Discard frame */            }	protocol_field_is_compressed = TRUE;	*((char *) &ppp_header.protocol_type) = 0x00;	*(((char *) &ppp_header.protocol_type) + 1) = protocol_type_in_bytes[0];	}    if (address_and_control_fields_are_compressed == TRUE)	{	sptr_rxed_packet = (_PPP_PACKET *) (((ULONG) sptr_rxed_packet) -	(sizeof (ppp_header.hdlc_address) + sizeof (ppp_header.hdlc_control)));        lengthAdj = (USHORT) (sizeof (ppp_header.hdlc_address) +                     sizeof (ppp_header.hdlc_control));        packet->mBlkHdr.mLen += lengthAdj;        packet->mBlkPktHdr.len += lengthAdj;	}    if (protocol_field_is_compressed == TRUE)	{	sptr_rxed_packet = (_PPP_PACKET *) (((ULONG) sptr_rxed_packet) - 	                   sizeof (char));	packet->mBlkHdr.mLen += (USHORT) sizeof (char);        packet->mBlkPktHdr.len += (USHORT) sizeof (char);	}    memcpy ((char *)sptr_rxed_packet,&ppp_header,sizeof (_PPP_HEADER));    packet->mBlkHdr.mData = (char *)sptr_rxed_packet;    return (OK);    }/******************************************************************************** convertNormalDataToSynchronousData -*/LOCAL STATUS convertNormalDataToSynchronousData    (    PFW_PLUGIN_OBJ_STATE * state,    M_BLK_ID               srcPacket,    M_BLK_ID               dstFrame    )    {    char *srcByte;    BYTE srcBitIndex;    BYTE srcBitMask;    char *dstByte;    BYTE dstBitIndex;    BYTE oneBitCount;    BYTE codedByte;    char frameEnd = 0x7e;    BYTE bit;    M_BLK_ID dstFrameChainHead = dstFrame;    BSYNC_FRAMING_STACK_DATA *pStackData = state->stackData;    int srcByteCount;    int dstByteCount;    srcByteCount = srcPacket->mBlkHdr.mLen;    dstByteCount = 0;    srcByte = srcPacket->mBlkHdr.mData;    dstByte = dstFrame->mBlkHdr.mData;    oneBitCount = 0;    codedByte = 0;    dstBitIndex = 0;    srcBitIndex = 0;    srcBitMask = 0x1;    while(srcPacket != NULL && srcByteCount > 0)	{	if ((bit = (srcBitMask & *srcByte) ? 1 :0) == 1)	    {	    oneBitCount++;	    codedByte = (bit << dstBitIndex) | codedByte;	    }	if (++dstBitIndex == 8)	    {	    /* move to next byte in destination packet */	    *dstByte++ = codedByte;	    codedByte = 0;	    dstFrame->mBlkHdr.mLen++;	    dstByteCount++;	    if (dstByte ==		(dstFrame->pClBlk->clNode.pClBuf + dstFrame->pClBlk->clSize))		{		M_BLK_ID pNextMblk;		if ((pNextMblk = 		    netTupleGet(pStackData->netPoolId,dstFrame->mBlkHdr.mLen,					M_DONTWAIT, MT_DATA ,TRUE)) == NULL)		    {		    logMsg("BitSyncFraming:Failed to get another mBlk for \			    encoded frame:Stack %p\n",			    (int)state->stackObj,2,3,4,5,6);		    RFC2233_COUNTER_UPDATE(pStackData->pfwRFC2233CountTest, 					   pStackData->pfwRFC2233CountPair,                                           M2_ctrId_ifOutDiscards, 1);		    return ERROR;		    }		else		    pNextMblk->mBlkHdr.mLen = 0;		dstFrame->mBlkHdr.mNext = pNextMblk;		dstFrame = dstFrame->mBlkHdr.mNext;		dstByte = dstFrame->mBlkHdr.mData;		}	    dstBitIndex = 0;	    }	/* this allows us to add FRAME END byte at the end of the data bits*/	if (oneBitCount >= 6)	    {	    /* are we done with the trailing 0x7e? */	    if (srcBitMask != 0x80)		{		srcBitMask <<= 1;		continue;		}	    else		break;	    }	/* reset one bit count for zero data bits */	if (bit == 0)	    oneBitCount = 0;	/* stuff a 0 bit after 5 consecutive one bits */	if (oneBitCount == 5)	    {	    srcBitMask = 0;	    continue; 	    }	if (++srcBitIndex == 8)	    {	    /* move to next byte in source packet */	    srcByte++;	    if (--srcByteCount == 0)		{                /* The first IP fragment has mNext != NULL and mLen = 0.                 * Need to find the checksum appended in pppBitSyncSend.                 */                while((srcPacket->mBlkHdr.mNext != NULL)  &&                      ((srcPacket->mBlkHdr.mNext)->mBlkHdr.mLen == 0))                    {                    srcPacket = srcPacket->mBlkHdr.mNext;                    }		if (srcPacket->mBlkHdr.mNext != NULL)		    {		    srcPacket = srcPacket->mBlkHdr.mNext;		    srcByteCount = srcPacket->mBlkHdr.mLen;		    srcByte = srcPacket->mBlkHdr.mData;		    }		else		    {		    srcByteCount = 1;		    srcByte = &frameEnd;		    oneBitCount = 6;		    }		}	    srcBitIndex = 0;	    }	srcBitMask = (0x1 << srcBitIndex);	}    /* check if we have a partial last byte and bump byte count by 1 */    if (dstBitIndex > 0 && dstBitIndex < 8)	{	*dstByte = codedByte;	dstFrame->mBlkHdr.mLen++;	dstByteCount++;	}    dstFrameChainHead->mBlkHdr.mFlags |= M_PKTHDR;    dstFrameChainHead->mBlkPktHdr.len = dstByteCount;    return OK;    }/******************************************************************************** convertSynchronousDataToNormalData -*/LOCAL int convertSynchronousDataToNormalData    (    PFW_PLUGIN_OBJ_STATE * state,    M_BLK_ID               srcFrame,    M_BLK_ID               dstPacket    )    {    char *srcByte;    BYTE srcBitIndex;    BYTE srcBitMask;    char *dstByte;    BYTE dstBitIndex;    BYTE oneBitCount;    BYTE decodedByte;    BYTE bit;    M_BLK_ID dstPacketChainHead = dstPacket;    BSYNC_FRAMING_STACK_DATA *pStackData = state->stackData;    int srcByteCount;    int dstByteCount;    int decodedByteCount = 0;    srcByteCount = srcFrame->mBlkHdr.mLen;    dstByteCount = 0;    srcByte = srcFrame->mBlkHdr.mData;    dstByte = dstPacket->mBlkHdr.mData;    oneBitCount = 0;    decodedByte = 0;    dstBitIndex = 0;    srcBitIndex = 0;    srcBitMask = 0x1;    while(srcFrame != NULL && srcByteCount > 0)	{	srcBitMask = (0x1 << srcBitIndex);	if ((bit = (srcBitMask & *srcByte) ? 1 :0) == 1)	    oneBitCount++;	if (oneBitCount == 6)	    {	    /* end of frame */	    break;	    }	if (++srcBitIndex == 8)	    {	    /* move to next byte in source packet */	    srcByte++;	    if (--srcByteCount == 0)		{		if ((srcFrame = srcFrame->mBlkHdr.mNext) != NULL)		    {		    srcByteCount = srcFrame->mBlkHdr.mLen;		    srcByte = srcFrame->mBlkHdr.mData;		    }		else		    return 0;		}	    srcBitIndex = 0;	    }	if (bit == 0)	    {	    /* delete stuffed 0 bit after 5 consecutive ones */	    if (oneBitCount == 5)		{		oneBitCount = 0;		continue;		}	    /* reset one bit count for zero data bits */	    oneBitCount = 0;	    }	else	    decodedByte = (bit << dstBitIndex) | decodedByte;	if (++dstBitIndex == 8)	    {	    /* move to next destination byte */	    *dstByte++ = decodedByte;	    decodedByte = 0;	    dstPacket->mBlkHdr.mLen++;	    decodedByteCount++;	    dstByteCount++;	    if ((dstPacket->mBlkHdr.mData + dstByteCount) ==		(dstPacket->pClBlk->clNode.pClBuf + dstPacket->pClBlk->clSize))		{		M_BLK_ID pNextMblk;		if ((pNextMblk = 		    netTupleGet(pStackData->netPoolId,dstPacket->mBlkHdr.mLen,					M_DONTWAIT, MT_DATA ,TRUE)) == NULL)		    {		    logMsg("BitSyncFraming:Failed to get another mBlk for \			    decoded frame:Stack %p\n",			    (int)state->stackObj,2,3,4,5,6);		    RFC2233_COUNTER_UPDATE(pStackData->pfwRFC2233CountTest, 					    pStackData->pfwRFC2233CountPair,                                           M2_ctrId_ifInDiscards, 1);		    return ERROR;		    }		else		    pNextMblk->mBlkHdr.mLen = 0;		dstPacket->mBlkHdr.mNext = pNextMblk;		dstPacket = dstPacket->mBlkHdr.mNext;		dstByteCount = 0;		}	    dstBitIndex = 0;	    }	}    dstPacket->mBlkHdr.mLen = dstByteCount;    dstPacketChainHead->mBlkHdr.mFlags |= M_PKTHDR;    dstPacketChainHead->mBlkPktHdr.len = decodedByteCount;    return (decodedByteCount);    }/******************************************************************************** BitSyncFrameEventHandler -** This routine collects ppp attributes**/LOCAL STATUS BitSyncFrameEventHandler    (    PFW_PLUGIN_OBJ_STATE * state,    void *eventData    )    {    PPP_ATTRIBUTES *p_ppp_attr_data = (PPP_ATTRIBUTES *)eventData;    p_ppp_attr_data->framingType = PPP_SYNC_FRAMING;    return OK;    }