pppasyncframing.c

这是全套的PPP协议的源码

	netMblkClChainFree(inFrame);
        RFC2233_COUNTER_UPDATE(stackData->pfwRFC2233CountTest, 
				stackData->pfwRFC2233CountPair,
                               M2_ctrId_ifInDiscards, 1);
	return ERROR;
	}
    else
	{
	/* netTupleGet will not clear mLen */

	outPacket->mBlkHdr.mLen    = 0;
        outPacket->mBlkHdr.mFlags &= ~M_PKTHDR;
        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 AHDLC's escape chars */

    if (convertAsynchronousDataToNormalData(state,inFrame,outPacket)
	== ERROR)
	{
#ifdef PPP_DEBUG
	    printf ("PPP: Error: Bad data on asynchronous port \n");
#endif /* PPP_DEBUG */
	netMblkClChainFree(inFrame);
	netMblkClChainFree(outPacket);
	return ERROR;
	}

    /* free received Frame */
    netMblkClChainFree(inFrame);  

    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
	    printf ("PPP: Error: Bad 16 Bit Checksum on Asynchronous port \n");
#endif /* PPP_DEBUG */
	    netMblkClChainFree(outPacket);
	    RFC2233_COUNTER_UPDATE(stackData->pfwRFC2233CountTest, 
				    stackData->pfwRFC2233CountPair,
                                   M2_ctrId_ifInErrors, 1);
	    return (ERROR);
	    }

	/* delete 16-bit FCS from end of frame */

        m_adj(outPacket, -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
	    printf ("PPP: Error: Bad 32 Bit Checksum on Asynchronous port \n");
#endif /* PPP_DEBUG */
	    netMblkClChainFree(outPacket);
	    RFC2233_COUNTER_UPDATE(stackData->pfwRFC2233CountTest, 
				    stackData->pfwRFC2233CountPair,
                                   M2_ctrId_ifInErrors, 1);
	    return (ERROR);
	    }

	/* delete 32-bit FCS from end of frame */

        m_adj(outPacket, -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;

    /* Check if total packet length - protocol field exceeds local MRU */

    if (outPacket->mBlkPktHdr.len - sizeof (PPP_HEADER) >
        max (stackData->localMru,DEFAULT_MAXIMUM_MRU))
        {
        (counterInterface->pppLinkStatusPacketTooLongsIncrement)(
                                    stackData->pppLinkStatusInterface.state);
#ifdef PPP_DEBUG
            printf ("PPP: Error: Packet Too Long: Information  Field = %d \n",
                    outPacket->mBlkPktHdr.len - 2);
#endif /* PPP_DEBUG */

        RFC2233_COUNTER_UPDATE(stackData->pfwRFC2233CountTest,
                               stackData->pfwRFC2233CountPair,
                               M2_ctrId_ifInErrors, 1);
        netMblkClChainFree(outPacket);
        return (ERROR);
        }

    *packet = outPacket;
    return (OK);
    }


/*******************************************************************************
*
* convertAsynchronousDataToNormalData - convert asynchronous data to normal
*
* RETURNS: OK or ERROR
*/

LOCAL STATUS convertAsynchronousDataToNormalData 
    (
    PFW_PLUGIN_OBJ_STATE * state,
    M_BLK_ID	           inFrame,
    M_BLK_ID	           outPacket
    )
    {
    BYTE	actualByte = 0;
    USHORT	byteCounter;
    USHORT	numberOfBytes = 0;
    char	* pData = NULL;
    int		byteCount = 0;
    int		totalBytesDecoded = 0;
    BOOL        escape;
    M_BLK_ID	outPacketChainHead = outPacket;
    ASYNC_FRAMING_STACK_DATA *stackData = state->stackData;

    escape = FALSE;

    do
	{
	numberOfBytes = inFrame->mBlkHdr.mLen;
	pData = inFrame->mBlkHdr.mData;
 
	for (byteCounter = 0; byteCounter < numberOfBytes; 
	     ++byteCounter)
	    {
	    actualByte = *((BYTE *) ((ULONG) pData + byteCounter));

            switch (actualByte)
                {
                case HDLC_FLAG_SEQUENCE:
                    /*
                     *  Flags should only ever occur at the end of the frame
                     *  (otherwise something is wrong with the SIO adapter).
                     *
                     *  According to RFC1662, a control escape'd FLAG indicates
                     *  an aborted frame, which should be silently discarded.
                     *
                     *  In any case, FLAGs are never copied to the output mbuf.
                     */
                    if (escape)
                        {
                        printf ("PPP: flag after control escape.\n");

                        return (ERROR); /* escaped FLAG: discard frame */
                        }
                    else if ((byteCounter == numberOfBytes - 1) &&
                             (inFrame->mBlkHdr.mNext == NULL))
                        {
		        ;               /* elide end-of-frame FLAG */
                        }
                    else
                        {
                        printf ("PPP: Error: Flag in mid-frame.\n");

                        return (ERROR);
                        }
                    break;


	        case ASYNC_CONTROL_ESCAPE_SEQUENCE:
                    /*
                     *  Set the 'escape' state so the next byte is decoded.
                     *  Do not copy the control escape to the output mbuf.
                     *
                     *  It is an error for the control escape character to
                     *  appear in an escaped state.
                     */
                    if (escape)
                        {
		        printf ("PPP: Error: Consecutive control escape "
                                "sequences found in packet on Async port\n");


                        return (ERROR);
                        }

                    escape = TRUE;
                    break;

                default:
                    /*
                     *  Any other character: decode if it's escaped, and copy
                     *  to the output mbuf.
                     */

                    if ((actualByte < 0x20) &&
                        (stackData->peerToLocalACCMap & (1 << actualByte)))
                        {
                        continue;  /* ugh! (continue 'for' loop) */
                        }
                        
                    if (escape)
                        {
                        actualByte ^= ASYNC_SIXTH_BIT_COMPLEMENT;

                        escape = FALSE;
                        }

	            outPacket->mBlkHdr.mData [byteCount++] = actualByte;
	            outPacket->mBlkHdr.mLen++;
	            totalBytesDecoded++;

                    /*
                     *  If at the end of the current output mbuf, add another
                     *  one to the chain.
                     */
	            if ((outPacket->mBlkHdr.mData + byteCount) ==
		        (outPacket->pClBlk->clNode.pClBuf + 
                         outPacket->pClBlk->clSize))
		        {
		        M_BLK_ID pNextMblk;

		        if ((pNextMblk = netTupleGet (stackData->netPoolId,
                                                      outPacket->mBlkHdr.mLen,
					              M_DONTWAIT,
                                                      MT_DATA,
                                                      TRUE)) == NULL)
		            {
		            printf ("AsyncFraming:Failed to get another mBlk "
                                   "for decoded frame:Stack 0x%x\n",
			           (UINT32) state->stackObj);

		            return ERROR;
		            }

			/* netTupleGet will not clear mLen */

			pNextMblk->mBlkHdr.mLen  = 0;
			pNextMblk->mBlkHdr.mFlags  &= ~M_PKTHDR;
			pNextMblk->mBlkPktHdr.len  = 0;

		        outPacket->mBlkHdr.mNext = pNextMblk;
		        outPacket = outPacket->mBlkHdr.mNext;
		        byteCount = 0;
                        }
                    break;
		}
	    }
	} while ((inFrame = inFrame->mBlkHdr.mNext) != NULL);

    /*
     *  Check that the last byte seen was a FLAG - if not, the frame is
     *  damaged (i.e. the SIO adapter is broken).
     */
    if (actualByte != HDLC_FLAG_SEQUENCE)
        {
        printf ("PPP: Error: frame ends with non-FLAG.\n");

        return (ERROR);
        }

    outPacketChainHead->mBlkHdr.mFlags |= M_PKTHDR;
    outPacketChainHead->mBlkPktHdr.len = totalBytesDecoded;

    return (OK);
    }

/*******************************************************************************
*
* decompress_ppp_header - decompress the PPP header
*
* RETURNS: OK or ERROR
*/

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;
    ASYNC_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;    
    PPP_LINK_STATUS_COUNTER_INCREMENT_INTERFACE * counterInterface =
                    (PPP_LINK_STATUS_COUNTER_INCREMENT_INTERFACE*)
                                stackData->pppLinkCounterInterface.interfaceObj;


    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))
	{
	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
	    {
            USHORT protocol_type = sptr_rxed_packet->header.protocol_type;
	    memcpy (&protocol_type_in_bytes[0], 
                    &protocol_type,
                    sizeof (USHORT_ENUM (PPP_PROTOCOL_TYPE)));
	    }
	}
    else
	{
        /* Check address and control fields */

        if (sptr_rxed_packet->header.hdlc_address != HDLC_ADDRESS)
            {
            (counterInterface->pppLinkStatusBadAddressesIncrement)(
                                    stackData->pppLinkStatusInterface.state);
#ifdef PPP_DEBUG
            printf ("PPP: Error: Bad Address Field on Asynchronous port \n");
#endif /* PPP_DEBUG */

            RFC2233_COUNTER_UPDATE(stackData->pfwRFC2233CountTest,
                               stackData->pfwRFC2233CountPair,
                               M2_ctrId_ifInErrors, 1);
            return (ERROR); /* Discard frame */
            }

        if (sptr_rxed_packet->header.hdlc_control != UNNUMBERED_INFORMATION)
            {
            (counterInterface->pppLinkStatusBadControlsIncrement)(
                                    stackData->pppLinkStatusInterface.state);
#ifdef PPP_DEBUG
            printf ("PPP: Error: Bad Control Field on Asynchronous port \n");
#endif /* PPP_DEBUG */

            RFC2233_COUNTER_UPDATE(stackData->pfwRFC2233CountTest,
                               stackData->pfwRFC2233CountPair,
                               M2_ctrId_ifInErrors, 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,
                (void *)&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);
    }


/*******************************************************************************
* AsyncFrameEventHandler -
*
* This routine collects ppp attributes
*
*/
LOCAL STATUS AsyncFrameEventHandler
    (
    PFW_PLUGIN_OBJ_STATE * state,
    void *eventData
    )
    {
    PPP_ATTRIBUTES *p_ppp_attr_data = (PPP_ATTRIBUTES *)eventData;
    p_ppp_attr_data->framingType = PPP_ASYNC_FRAMING;

    return OK;
    }