pppbitsyncframing.c

这是全套的PPP协议的源码

	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;
    }