pppbitsyncframing.c

这是全套的PPP协议的源码

    }

/*******************************************************************************
* 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))
	{