pppvjc.c

这是全套的PPP协议的源码

                netMblkClChainFree (*packet);
                RFC2233_COUNTER_UPDATE(pVjcStackData->pfwRFC2233CountTest, 
                                       pVjcStackData->pfwRFC2233CountPair,
                                       M2_ctrId_ifInDiscards, 1); 
                return (ERROR);
                }

            dst = newMblk->mBlkHdr.mData + 4;
            memcpy (dst, mBlk->mBlkHdr.mData, mBlk->mBlkHdr.mLen);
            newMblk->mBlkHdr.mLen = mBlk->mBlkHdr.mLen;
	    newMblk->mBlkHdr.mData = dst;
	    newMblk->mBlkHdr.mNext = mBlk->mBlkHdr.mNext;
            
            if (mBlk->mBlkHdr.mFlags & M_PKTHDR)
	        {
		newMblk->mBlkPktHdr = mBlk->mBlkPktHdr;
		newMblk->mBlkHdr.mFlags = mBlk->mBlkHdr.mFlags;
		}
            
            netMblkClFree(mBlk);
            mBlk = newMblk;
            
#endif

	    }

        /* sl_uncompress_tcp takes a char ** argument.  It will update the
	 * mData pointer but it will NOT update the mLen value.
	 * newLen is the total mbuf's length after header decompression.
	 */

        newLen = sl_uncompress_tcp((u_char **)(&mBlk->mBlkHdr.mData), 
		    mBlk->mBlkHdr.mLen, COMPTYPE(proto), pSccomp);

	if (newLen == 0)
            {
            netMblkClChainFree(mBlk);
	    RFC2233_COUNTER_UPDATE(pVjcStackData->pfwRFC2233CountTest, 
				   pVjcStackData->pfwRFC2233CountPair,
                                   M2_ctrId_ifInErrors, 1);
            return ERROR;
            }


        /* adjust the first mbuf by the decompressed amount.
	 * TCP compressed packets are aligned on a 4 byte boundary.
	 * TCP uncompressed packets are returned with their original
	 * alignment --the only change is to put the TCP protocol number
	 * back in the ip_p field.
	 *    mLen is unchanged by sl_uncompress_tcp.
	 *    mData is pointing at the IP packet.
	 *    mBlkPktHdr.len was copied from the original packet and
	 *    includes the PPP_HEADER length.
	 */

        delta = newLen - mBlk->mBlkHdr.mLen;

        mBlk->mBlkHdr.mLen += sizeof (PPP_HEADER) + delta;
        mBlk->mBlkHdr.mData -= sizeof(PPP_HEADER);
        mBlk->mBlkPktHdr.len  += delta;

        proto = htons(PPP_IP_PROTOCOL);

        /* put the ppp header back in place */
        if (cp != mtod(mBlk, u_char *)) 
            {
            cp = mtod(mBlk, u_char *);
            cp[0] = 0;
            }
        cp[1] = 0x21;
	}

    *packet = mBlk;

#ifdef VJC_DEBUG
    if (vjcDebug)
        printPktHdrs("OUT OF vjcReceive", mBlk);
#endif

    return (OK);
    }


LOCAL STATUS vjcSend
    (
    PFW_PLUGIN_OBJ_STATE *state,
    M_BLK_ID *packet
    )
    {
    USHORT protocol = 0;
    USHORT type;
    u_char *cp;
    struct ip *ip;
    struct mbuf *mp;
    struct slcompress *pSccomp;
    VJC_STACK_DATA *pVjcStackData = (VJC_STACK_DATA *) state->stackData;
    UINT32 len = 0;
    int vjcConnCompress = (int) pVjcStackData->connIdCompress;
    int firstMbufLength;
    BOOL isTcpPacket;

    pSccomp = &pVjcStackData->sc_comp;

    mp = (struct mbuf *)*packet;
    cp = mtod(*packet, u_char *);
    protocol = (cp[0] << 8) + cp[1];

    ip = (struct ip *)(cp + sizeof (PPP_HEADER));

    isTcpPacket = (protocol == PPP_IP_PROTOCOL) &&
                   ((ip->ip_off & htons(0x3fff)) == 0) && 
                   (ip->ip_p == IPPROTO_TCP);

#ifdef VJC_DEBUG
    if (vjcDebug)
        printPktHdrs("SENDING", mp);
#endif

    if (isTcpPacket)
        {
	len = (UINT32) ((mp->mBlkHdr.mNext != NULL) ? mp->mBlkPktHdr.len:\
						      mp->mBlkHdr.mLen);

	if (len < (sizeof(struct ip) + sizeof (struct tcphdr) +
		   sizeof (PPP_HEADER)))
	    {
	    *packet = mp;
	    return (OK);
	    }

        mp = pppMPullup(mp, (sizeof(struct ip) + sizeof (struct tcphdr) +
			     sizeof (PPP_HEADER)));
			    
        if (mp == NULL)
	    {
	    RFC2233_COUNTER_UPDATE(pVjcStackData->pfwRFC2233CountTest, 
				   pVjcStackData->pfwRFC2233CountPair,
                                   M2_ctrId_ifOutDiscards, 1);
	    return (ERROR);
	    }

        cp = mtod(mp, u_char *);

        ip = (struct ip *)(cp + sizeof (PPP_HEADER));

        firstMbufLength = mp->mBlkHdr.mLen;

        /*
         * sl_compress_type takes an mbuf * as an argument.  It will update
         * the mLen and mData values.  It will not update the total length:
         * mBlkPktHdr.len.
         */

	type = sl_compress_tcp(mp, ip, pSccomp, vjcConnCompress);
	switch (type) 
	    {
	    case TYPE_UNCOMPRESSED_TCP:
		protocol = VAN_JACOBSON_UNCOMPRESSED_PROTOCOL;
		break;
	    case TYPE_COMPRESSED_TCP:
		protocol = VAN_JACOBSON_COMPRESSED_PROTOCOL;
		break;
	    }
        /* Update total packet length after compression of first
	 * mbuf
	 */

	if (mp->mBlkHdr.mFlags & M_PKTHDR)
	    mp->mBlkPktHdr.len -=  firstMbufLength - mp->mBlkHdr.mLen;

	cp = mtod(mp, u_char *);
	cp[0] = 0;
	cp[1] = protocol;   /* update protocol in PPP header */
	}

#ifdef VJC_DEBUG
    if (vjcDebug)
        printPktHdrs("OUT OF vjcSend", mp);
#endif
    *packet = mp;

    return (OK);
    }

LOCAL void vjcInit
   (
   PFW_PLUGIN_OBJ_STATE *state
   )
   {
   struct slcompress *pSccomp;
   VJC_STACK_DATA *pStackData;

   pStackData = (VJC_STACK_DATA *)state->stackData;

   pSccomp = &pStackData->sc_comp;

   ppp_sl_compress_init (pSccomp, pStackData->numberOfSlots); 
   }

LOCAL void ppp_sl_compress_init
    (
    struct slcompress *comp,
    BYTE numberOfSlots 
    )
    {
    register u_int i;
    register struct cstate *tstate = comp->tstate;

    bzero((char *)comp, sizeof(*comp));
    for (i = numberOfSlots - 1; i > 0; --i) {
	    tstate[i].cs_id = i;
	    tstate[i].cs_next = &tstate[i - 1];
    }
    tstate[0].cs_next = &tstate[numberOfSlots - 1];
    tstate[0].cs_id = 0;
    comp->last_cs = &tstate[0];
    comp->last_recv = 255;
    comp->last_xmit = 255;
    comp->flags = SLF_TOSS;
    }

/*******************************************************************************
*
* setSlotNumbers -
*/

LOCAL STATUS setSlotNumbers
    (
    PFW_PLUGIN_OBJ_STATE *state,
    int numberOfSlots
    )
    {
    VJC_STACK_DATA *stackData = (VJC_STACK_DATA *)state->stackData;

    if ((numberOfSlots < 0) || (numberOfSlots > MAX_STATES))
	return (ERROR);
    else
        stackData->numberOfSlots = numberOfSlots;
    return (OK);
    }

/*******************************************************************************
*
* setConnIdCompress -
*/

LOCAL STATUS setConnIdCompress
    (
    PFW_PLUGIN_OBJ_STATE *state,
    BOOL		  connIdCompress
    )
    {
    VJC_STACK_DATA * pStackData = (VJC_STACK_DATA *) state->stackData;

    pStackData->connIdCompress = connIdCompress;

    vjcInit (state);
    return (OK);
    }

/*******************************************************************************
*
* receivePathAcceptableProtocolsGet - get the acceptable protocol list
*
* This routines returns the protocols numbers which are acceptable to
* the VJC component on the receive path of the PPP stack
*/

LOCAL STATUS receivePathAcceptableProtocolsGet
    (
    PFW_PLUGIN_OBJ_STATE *state,
    ACCEPTABLE_PROTOCOLS_ARRAY **recvProtocols
    )
    {
    *recvProtocols= &recvAcceptableProtocols;

    return (OK);
    }

/*******************************************************************************
*
* sendPathAcceptableProtocolsGet - get the acceptable protocol list
*
* This routine returns the protocols numbers which are acceptable to the
* VJC component on the send path of the PPP stack
*/

LOCAL STATUS sendPathAcceptableProtocolsGet
    (
    PFW_PLUGIN_OBJ_STATE *state,
    ACCEPTABLE_PROTOCOLS_ARRAY **sendProtocols
    )
    {
    *sendProtocols = &sendAcceptableProtocols;

    return (OK);
    }
/*******************************************************************************
*
* pppMPullup - improved version of m_pullup
* 
*/

LOCAL M_BLK_ID pppMPullup
    (
    M_BLK_ID inMblk,
    int      len
    )
    {
    M_BLK_ID newMblk;
    int bytesCopied;
    NET_POOL_ID pNetPool = MBLK_TO_NET_POOL(inMblk);
    int requiredClusterSize;
    int copyLen;

    /* check if the requested number of bytes are already contiguous */

    if (inMblk->mBlkHdr.mLen >= len)
	return inMblk;

    /* check if we have sufficient space in the leading Mblk */

    if ((inMblk->mBlkHdr.mData + len ) <= 
	(inMblk->pClBlk->clNode.pClBuf + inMblk->pClBlk->clSize))
	{
	/*
	 * we have room;
	 * do we have a next Mblk to pullup from
	 */
	if (inMblk->mBlkHdr.mNext == NULL)
	    {
	    netMblkClFree(inMblk);
	    return NULL;
	    }

	if ((bytesCopied = netMblkOffsetToBufCopy (inMblk->mBlkHdr.mNext, 0,
			    &inMblk->mBlkHdr.mData[inMblk->mBlkHdr.mLen],
			    (copyLen = (len - inMblk->mBlkHdr.mLen)), NULL))
			    != copyLen)
	     {
	     netMblkClChainFree(inMblk);
	     return NULL;
	     }
	inMblk->mBlkHdr.mLen += bytesCopied;
	(inMblk->mBlkHdr.mNext)->mBlkHdr.mLen -= bytesCopied;
	(inMblk->mBlkHdr.mNext)->mBlkHdr.mData += bytesCopied;
	return inMblk;
	}
    else
	{
	/* allocate a new cluster */

	requiredClusterSize = max(len, 
		    ((inMblk->mBlkHdr.mNext != NULL) ? inMblk->mBlkPktHdr.len:\
		      inMblk->mBlkHdr.mLen));

	if ((newMblk = netTupleGet (pNetPool, requiredClusterSize,
				    M_DONTWAIT,MT_DATA,TRUE)) == NULL)
	   {
	   netMblkClChainFree (inMblk);
	   return (NULL);
	   }
	bytesCopied = netMblkToBufCopy(inMblk,newMblk->mBlkHdr.mData,NULL);
	newMblk->mBlkHdr.mLen = bytesCopied;

	/* Copy packet header information */

	if (inMblk->mBlkHdr.mFlags & M_PKTHDR)
	    {
	    newMblk->mBlkPktHdr = inMblk->mBlkPktHdr;
	    newMblk->mBlkHdr.mFlags = inMblk->mBlkHdr.mFlags;
	    }

        netMblkClChainFree(inMblk);
	return newMblk;
	}
    }

#ifdef VJC_DEBUG
/*******************************************************************************
*
* printPktHdrs - dump 60 bytes of PPP packet.
*
* NOMANUAL
*/

void printPktHdrs
    (
    char * message,
    M_BLK_ID inMblk
    )
    {
    u_char *p;
    int i;
    int j = 1;
    int stopPrinting = 0;  /* For now stop at 60 bytes per packet */
    M_BLK_ID pMbuf;
    u_char * pIpId = (inMblk->mBlkHdr.mData + sizeof(PPP_HEADER) + 4);

    printf("%s: Total Packet Length = %d IP packet ID # 0x%02x%02x\n\n", message,
           inMblk->mBlkPktHdr.len, pIpId[0], pIpId[1]);

    if (dumpHeaders)
        {
        for (pMbuf = inMblk; pMbuf != NULL; pMbuf = pMbuf->mBlkHdr.mNext)
            {
            printf("mbuf# %d length = %d:\n", j++, pMbuf->mBlkHdr.mLen);

            p = (u_char *) pMbuf->mBlkHdr.mData;

            printf("First 2 bytes: %02x %02x\n", p[0], p[1]);

            p += sizeof(PPP_HEADER);

            stopPrinting = 0;

	    if (pMbuf->mBlkHdr.mLen == 0)
		continue;

            for (i=0; i < pMbuf->mBlkHdr.mLen - 2; ++i)
                {
                if ((i%20) == 0)
                    printf ("\n");
                printf("%02x ", p[i]);
                stopPrinting++;
                if (stopPrinting == 60)
                    break;
                               }
                printf("\n\n");
                }
            printf("\n\n");
            }
        }
#endif