}/******************************************************************************** pppBitSyncSend -*/LOCAL STATUS pppBitSyncSend    (    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;    BSYNC_FRAMING_STACK_DATA *stackData = 				(BSYNC_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  & 0x00ff;	checksum[1] = (calculated32BitCkSum >>= 8) & 0x00ff;	checksum[2] = (calculated32BitCkSum >>= 8) & 0x00ff;	checksum[3] = (calculated32BitCkSum >>= 8) & 0x00ff;	/* 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)	{	logMsg("BitSyncFraming:Failed to get encoded frame for StackObj 0x%x\n",		    (int)state->stackObj,2,3,4,5,6);	endOfInPacket->mBlkHdr.mNext = NULL;	netMblkClChainFree(*packet);        RFC2233_COUNTER_UPDATE(stackData->pfwRFC2233CountTest, 				stackData->pfwRFC2233CountPair,                               M2_ctrId_ifOutDiscards, 1);	return ERROR;	}    /* 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 (convertNormalDataToSynchronousData (state,inPacket,outFrame) == ERROR)	{	netMblkClChainFree(outFrame);        endOfInPacket->mBlkHdr.mNext = NULL;        netMblkClChainFree(*packet);	return ERROR;	}    /*     * terminate original packet; strip reference to attached     * checksum mBlk if any     */    endOfInPacket->mBlkHdr.mNext = NULL;    /* free the original packet */    netMblkClChainFree(*packet);    /* point to the frame start byte in the out going frame */    outFrame->mBlkHdr.mData--;    outFrame->mBlkPktHdr.len++;    *packet = outFrame;    return (OK);    }/******************************************************************************** pppBitSyncReceive -*/LOCAL STATUS pppBitSyncReceive    (    PFW_PLUGIN_OBJ_STATE *state,    M_BLK_ID * packet    )    {    register M_BLK_ID inFrame, outPacket;    BSYNC_FRAMING_STACK_DATA *stackData = state->stackData;    USHORT calculated16BitCkSum;    UINT32 calculated32BitCkSum;    M_BLK_ID nextMblk;    int frameFlagsRemoved = 0;    int lengthOfEncodedData;    int sizeOfDecodedDataBuffer;    int decodedPktLen = 0;    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)	{	logMsg("BitSyncFraming:Failed to get decoded frame for StackObj 0x%x\n",		    (int)state->stackObj,2,3,4,5,6);	netMblkClChainFree(inFrame);        RFC2233_COUNTER_UPDATE(stackData->pfwRFC2233CountTest, 				stackData->pfwRFC2233CountPair,                               M2_ctrId_ifOutDiscards, 1);	return ERROR;	}    else	{	/* do this because mBlkGet does not set mLen to zero */	outPacket->mBlkHdr.mLen  = 0;        outPacket->mBlkPktHdr.len = 0;	}    if (stackData->peerToLocalACCompression == TRUE)	outPacket->mBlkHdr.mData += 2;    if (stackData->peerToLocalProtocolCompression == TRUE)	outPacket->mBlkHdr.mData += 1;    /* decode the packet by removing all the stuffed (0) bits */    if ((decodedPktLen = convertSynchronousDataToNormalData(state,						inFrame,outPacket)) == 0)	{	netMblkClChainFree(inFrame);	netMblkClChainFree(outPacket);	return ERROR;	}    /* free received Frame */    netMblkClChainFree(*packet);    if (stackData->receiveFcsSize == PPP_16BIT_FCS)	{	/* find the end of the decoded packet chain; use inFrame as temp store*/	inFrame = outPacket;	while(inFrame->mBlkHdr.mNext != NULL)	    inFrame = inFrame->mBlkHdr.mNext;	/* Check the FCS */	calculated16BitCkSum = calculate16BitFcs(PPPINITFCS16, outPacket);	if (calculated16BitCkSum != PPPGOODFCS16)	    {	    (counterInterface->pppLinkStatusBadFCSsIncrement)(				    stackData->pppLinkCounterInterface.state);#ifdef PPP_DEBUG	    logMsg ("PPP: Error: Bad 16 Bit Checksum on Synchronous port \n",		    1,2,3,4,5,6);#endif /* PPP_DEBUG */	    netMblkClChainFree(outPacket);	    RFC2233_COUNTER_UPDATE(stackData->pfwRFC2233CountTest, 				    stackData->pfwRFC2233CountPair,                                   M2_ctrId_ifInErrors, 1);	    return (ERROR);	    }	/* update length on trailing mBlk-clBlk-cluster */	inFrame->mBlkHdr.mLen -= 2; /* Length of the FCS field */        inFrame->mBlkPktHdr.len -= 2;	}    else if (stackData->receiveFcsSize == PPP_32BIT_FCS)	{	/* find the end of the decoded packet chain; use inFrame as temp store*/	inFrame = outPacket;	while(inFrame->mBlkHdr.mNext != NULL)	    inFrame = inFrame->mBlkHdr.mNext;	/* Check the FCS */	calculated32BitCkSum = calculate32BitFcs(PPPINITFCS32, outPacket);	if (calculated32BitCkSum != PPPGOODFCS32)	    {	    (counterInterface->pppLinkStatusBadFCSsIncrement)(				    stackData->pppLinkCounterInterface.state);#ifdef PPP_DEBUG	    logMsg ("PPP: Error: Bad 32 Bit Checksum on Synchronous port \n",		    1,2,3,4,5,6);#endif /* PPP_DEBUG */	    netMblkClChainFree(outPacket);	    RFC2233_COUNTER_UPDATE(stackData->pfwRFC2233CountTest, 				    stackData->pfwRFC2233CountPair,                                   M2_ctrId_ifInErrors, 1);	    return (ERROR);	    }	/* update length on trailing mBlk-clBlk-cluster */	inFrame->mBlkHdr.mLen -= 4; /* Length of the FCS field */        inFrame->mBlkPktHdr.len -= 4;	}    else if (stackData->receiveFcsSize != PPP_NULL_FCS) /* NULL FCS */	{	netMblkClChainFree(outPacket);        RFC2233_COUNTER_UPDATE(stackData->pfwRFC2233CountTest, 				stackData->pfwRFC2233CountPair,                               M2_ctrId_ifInErrors, 1);	return ERROR;	}    if (decompress_ppp_header(state,outPacket) == ERROR)	{	netMblkClChainFree(outPacket);	return ERROR;	}    /* strip HDLC header */    outPacket->mBlkHdr.mData +=2;    outPacket->mBlkHdr.mLen -=2;    outPacket->mBlkPktHdr.len -=2;    *packet = outPacket;    return (OK);    }/******************************************************************************** decompress_ppp_header -*/LOCAL STATUS decompress_ppp_header     (    PFW_PLUGIN_OBJ_STATE *state,    M_BLK_ID	packet    )    {    UCHAR protocol_type_in_bytes[sizeof (USHORT_ENUM (PPP_PROTOCOL_TYPE))];    BOOL address_and_control_fields_are_compressed;    BOOL protocol_field_is_compressed;    _PPP_HEADER ppp_header;    BSYNC_FRAMING_STACK_DATA *stackData = state->stackData;    _PPP_PACKET *sptr_rxed_packet = (_PPP_PACKET *)packet->mBlkHdr.mData;    int lengthAdj;    USHORT_ENUM (PPP_PROTOCOL_TYPE) protocol_type;         if ((sptr_rxed_packet->header.hdlc_address == HDLC_ADDRESS) &&	(sptr_rxed_packet->header.hdlc_control == UNNUMBERED_INFORMATION) &&	(sptr_rxed_packet->header.protocol_type == LCP_PROTOCOL))	{