pppvsend.c

这是全套的PPP协议的源码

    RFC2233_COUNTER_UPDATE(stackData->pfwRFC2233CountTest, 
			    stackData->pfwRFC2233CountPair,
                           M2_ctrId_ifInUcastPkts, 1); 
    RFC2233_COUNTER_UPDATE(stackData->pfwRFC2233CountTest,
			    stackData->pfwRFC2233CountPair,
                           M2_ctrId_ifHCInUcastPkts, 1); 

    /* release received packet */

    netMblkClChainFree(packet);

    pfwPluginObjStateRelease(pDrvCtrl->state);
    return OK;
    }


/***************************************************************************
*
* pppMCastAddrAdd - add multicast address to device
*
* NOMANUAL
*/

LOCAL STATUS pppMCastAddrAdd 
    (
    PPP_DRV_CTRL* pDrvCtrl, 
    char* pAddress
    )
    {

    /* PPP VS END is a software END device: nothing to do */ 

    return (OK);
    }

/***************************************************************************
*
* pppMCastAddrDel - delete multicast address from device
*
* NOMANUAL
*/

LOCAL STATUS pppMCastAddrDel 
    (
    PPP_DRV_CTRL* pDrvCtrl, 
    char* pAddress
    )
    {

    /* PPP VS END is a software END device: nothing to do */ 

    return (OK);
    }

/***************************************************************************
*
* pppMCastAddrGet - retrieve list of multicast addresses from device
*
* NOMANUAL
*/

LOCAL STATUS pppMCastAddrGet 
    (
    PPP_DRV_CTRL* pDrvCtrl, 
    MULTI_TABLE* pTable
    )
    {

    /* PPP VS END is a software END device: nothing to do */ 

    return (OK);
    }


/***************************************************************************
*
* pppIoctl - support various END driver ioctl commands 
*
* NOMANUAL
*/

LOCAL int pppIoctl
    (
    END_OBJ * pEnd,             /* device receiving command */
    int cmd,                    /* ioctl command code */
    caddr_t data                /* command argument */
    )
    {
    int error = OK;
    long 	value;
    UINT32      oldFlags;
    PPP_DRV_CTRL *pDrvCtrl = (PPP_DRV_CTRL *) pEnd->devObject.pDevice;
    PPP_VS_END_STACK_DATA *stackData = 
        (PPP_VS_END_STACK_DATA *)pDrvCtrl->state->stackData;
    struct ifaddr *ifa = (struct ifaddr *)data;

#ifdef PPP_END_PMP_CAPABLE 
    MTU_QUERY * pMtuQuery;
    UINT32 dstIpAddr;
    PPP_DRV_CTRL *pDstDrvCtrl = NULL;
#endif /* PPP_END_PMP_CAPABLE */

    /*  Get the pDrvCtrl structure from the END_OBJ */

    if (pfwPluginObjStateLock (pDrvCtrl->state) != OK)
	return ERROR;

    switch ((UINT)cmd)
        {
 	case EIOCGFLAGS:
        *(int *)data = pEnd->flags;
        break;

	case EIOCSFLAGS:
	    oldFlags = pEnd->flags;

	    value = (long) data;
	    if (value < 0)
            {
            value = -value;
            value--;
            END_FLAGS_CLR (pEnd, value);
            }
	    else
            END_FLAGS_SET (pEnd, value);


        /* check if interface state has been toggled */

        if ((oldFlags ^ pEnd->flags) & IFF_UP)
            {
#ifdef PPP_DEBUG
            printf (" END Flags Changed: old 0x%lx, new 0x%lx: stack 0x%x\n",
                    (long unsigned int) oldFlags,pEnd->flags,
                   (UINT32) pDrvCtrl->state->stackObj);
#endif /* PPP_DEBUG */
            if (stackData->administrativeInterfaceControl == TRUE)
                {
                if (pEnd->flags & IFF_UP)
                    {
#ifdef PPP_DEBUG
                    printf ("PPP_VS_END: Interface up: stack 0x%x\n",
                            (UINT32) pDrvCtrl->state->stackObj);
#endif /* PPP_DEBUG */
                    pfwEventRaise(pDrvCtrl->state->stackObj,
                              stackData->interfaceUpEvent,0);
                    }
                else
                    {
#ifdef PPP_DEBUG
                    printf ("PPP_VS_END: Interface Down: stack 0x%x\n",
                           (UINT32) pDrvCtrl->state->stackObj);
#endif /* PPP_DEBUG */
                    pfwEventRaise(pDrvCtrl->state->stackObj,
                              stackData->interfaceDownEvent,0);
                    }
                }
            stackData->administrativeInterfaceControl = TRUE;
            }
	    break;

        case EIOCGHDRLEN:

            if (data == NULL)
                error = EINVAL;
            else
               *(int *)data = 48;
            break;

        case SIOCSIFDSTADDR:

            if (ifa->ifa_dstaddr->sa_family != AF_INET)
                error = EAFNOSUPPORT;
            break;

        case EIOCGMIB2:

            if (data == NULL)
                {
                error = EINVAL;
                }
            else
                bcopy((char *)&pEnd->mib2Tbl, (char *)data,
                       sizeof(pEnd->mib2Tbl));
            break;

        case EIOCGMIB2233:

            if  ((data == NULL) || (pEnd->pMib2Tbl == NULL))
                {
                error = EINVAL;
                }
            else
                {
                *((M2_ID **)data) = pEnd->pMib2Tbl;
                }
            break;

        case EIOCPOLLSTART:

            if (stackData->mode == END_POLLED_MODE)
                {
                error = ERROR;
                break;
                }
            else
                {
                /* set POLLED mode */
                stackData->mode = END_POLLED_MODE;
                }
            break;

        case EIOCPOLLSTOP:

            if (stackData->mode == END_NORMAL_MODE)
                {
                error = ERROR;
                break;
                }
            else
                {
                M_BLK_ID packet;
                M_BLK_ID pNextPkt;

                /* flush received packet queue and set normal mode */

                packet = stackData->receivedPacketQHead;
                while (packet != NULL)
                     {
                     pNextPkt = packet->mBlkHdr.mNextPkt;
                     netMblkClChainFree(packet);
                     packet = pNextPkt;
                     }
    
                 RFC2233_COUNTER_UPDATE(stackData->pfwRFC2233CountTest, 
                                        stackData->pfwRFC2233CountPair,
                                        M2_ctrId_ifInDiscards, 
                                        stackData->receivedPacketQSize);
       
                 stackData->receivedPacketQHead = NULL;
                 stackData->receivedPacketQTail = NULL;
                 stackData->receivedPacketQSize = 0;

                 stackData->mode = END_NORMAL_MODE;
                 }
            break;

#ifdef PPP_END_PMP_CAPABLE
        case EIOCGMTU:
            pMtuQuery = (MTU_QUERY *)data;
            dstIpAddr = pMtuQuery->dstIpAddr;
            if (stackData->supportPMP)
                {
                if (dstIpAddr == stackData->dstIpAddr)
                    {
                    pDstDrvCtrl = stackData->pDstDrvCtrl;
                    }
                else
                    {
                    pDstDrvCtrl = RAS_pmpGetDriver(stackData->rasPoolId, 
                                                   ntohl(dstIpAddr));
                    stackData->pDstDrvCtrl = pDstDrvCtrl;
                    stackData->dstIpAddr = dstIpAddr;
                    }
                if (!pDstDrvCtrl)
                    {
                    error = ERROR;
                    break;
                    }
                pMtuQuery->mtu =
                    pDstDrvCtrl->end.pMib2Tbl->m2Data.mibIfTbl.ifMtu;
                }
            break;
#endif /* PPP_END_PMP_CAPABLE */

        default:
            error = EINVAL;
            break;
        }

    pfwPluginObjStateRelease(pDrvCtrl->state);

    return (error);
    }


/***************************************************************************
*
* pppAddressForm - add addressing information to packet.
*
* The MUX calls this function for all network stack versions except
* the IPv4/IPv6 Dual Stack.                  
*
* NOMANUAL
*/

LOCAL M_BLK_ID pppAddressForm
    (
    M_BLK_ID pMblk,     /* pointer to packet mBlk */
    M_BLK_ID pSrcAddr,  /* structure containing source address */
    M_BLK_ID pDstAddr,   /* structure containing destination address */
    BOOL bcastFlag      /* use link-level broadcast? */
    )
    {
    BYTE *cp;
    int protocol = 0x21;

    /* find space to insert two byte protocol ID */

    M_PREPEND (pMblk, 2, M_DONTWAIT);

    if (pMblk == NULL)
        {
        return (NULL);
        }

    cp = mtod(pMblk, u_char *);

    /* Add the IP protocol to the header */

    *cp++ = protocol >> 8;
    *cp++ = protocol & 0xFF;

    pMblk->mBlkPktHdr.rcvif = NULL;

#ifdef PPP_END_PMP_CAPABLE
    /*
     * PMP: set pDstAddr in the unused rcvif field; we make the assumption
     * that (sizeof (struct ifnet *)) is 4 == IPV4_ADDR_LEN
     * 
     * NOTE: ipOutput/ipTxStartup in ipProto.c also use this field but
     * it is never for the same M_BLK so this is OK.
     */
     bcopy (pDstAddr->m_data, (char *)(&pMblk->mBlkPktHdr.rcvif),
            IPV4_ADDR_LEN);
#endif /* PPP_END_PMP_CAPABLE */

    return (pMblk);
    }


/***************************************************************************
*
* pppPacketDataGet -  extract addressing information from a packet
*
* NOMANUAL
*/

LOCAL STATUS pppPacketDataGet
    (
    M_BLK_ID pMblk,
    LL_HDR_INFO         *llHdrInfo
    )
    {
    u_char *cp;
    USHORT proto = 0;

    cp = mtod(pMblk, u_char *);
    proto = (cp[0] << 8) + cp[1];

    /* In PPP, the only llHdrInfo fields which are relevant are
       dataOffset and the packet type
     */

    memset (llHdrInfo, 0, sizeof (LL_HDR_INFO));

    if (proto == PPP_IP_PROTOCOL)
        llHdrInfo->pktType    = ETHERTYPE_IP;
#ifdef INET6
    else if (proto == PPP_IPV6_PROTOCOL) 
        llHdrInfo->pktType    = ETHERTYPE_IPV6;
#endif /*  INET6 */

    /* Offset the address, control and protocol field */

    llHdrInfo->dataOffset = 2;  	
    return (OK);
    }


/***************************************************************************
*
* pppBind - information exchange between network service and network driver
*
* NOMANUAL
*/

LOCAL STATUS pppBind 
   (
   PPP_DRV_CTRL * pDrvCtrl,
   void * pNetSvcInfo,         /* reference to data from network service */
   void * drvInfo,             /* reference to buffer for driver info */
   long type                   /* who's calling */
   )
   {
   return OK;
   }


/* PLUG-IN OBJECT SUPPORT FUNCTIONS */


/***************************************************************************
*
* pppEndPollRxQueueSizeHandle - handle requests for the receive queue size
*
* This routine handles requests for the poll mode receive queue size.
*
* RETURNS: OK, or ERROR.
*/

LOCAL STATUS pppEndPollRxQueueSizeHandle
    (
    PFW_OBJ * pfw,
    PFW_PARAMETER_OPERATION_TYPE type,
    void * pProfileData,	/* reference to profile data */
    char * value
    )
    {
    PPP_VS_END_PROFILE_DATA	* pEndProfileData =
        (PPP_VS_END_PROFILE_DATA *) pProfileData;

    if (type == PFW_PARAMETER_SET)
        {
        /* set to the requested value */

        pEndProfileData->pollRxQueueSize = atoi (value);
        }
    else if (type == PFW_PARAMETER_GET)
        {
        sprintf (value, "%d", pEndPr