pppasyncframing.c

这是全套的PPP协议的源码

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