ipproto.c

VXWORKS源代码

            if ( (pIfp->if_flags & IFF_UP) ^ (newFlags & IFF_UP))
                {
                s = splimp ();

                if ( (pIfp->if_flags & IFF_UP) == 0)
                    if_up (pIfp);
                else
                    if_down (pIfp);

                splx (s);
                }

            /* Set interface flags to new values, if allowed. */

            newFlags = newFlags & ~IFF_CANTCHANGE;
            pIfp->if_flags &= IFF_CANTCHANGE;
            pIfp->if_flags = pIfp->if_flags | newFlags;

            break;
        case END_ERR_NO_BUF:
#ifdef IP_DEBUG
            if (ipDebug && pError->pMesg != NULL)
                logMsg ("NO_BUF: Device: %s Unit: %d Msg: %s\n",
                        (int)pEnd->devObject.name, pEnd->devObject.unit,
                        (int)pError->pMesg, 0, 0, 0);
#endif /* IP_DEBUG */
            ip_drain();                      /* empty the fragment Q */

            break;
        default:
#ifdef IP_DEBUG
            if (ipDebug && pError->pMesg != NULL)
                logMsg ("UNKOWN ERROR: Device: %s Unit: %d Msg: %s\n",
                        (int)pEnd->devObject.name, pEnd->devObject.unit,
                        (int)pError->pMesg, 0, 0, 0);
#endif /* IP_DEBUG */
            
		break;
        }
    }

/******************************************************************************
*
* ipAttach - a generic attach routine for the TCP/IP network stack
*
* This routine takes the unit number and device name of an END or NPT
* driver (e.g., "ln0", "ei0", etc.) and attaches the IP protocol to
* the corresponding device. Following a successful attachment IP will
* begin receiving packets from the devices.
*
* RETURNS: OK or ERROR
*/

int ipAttach
    (
    int unit,                   /* Unit number  */
    char *pDevice		/* Device name (i.e. ln, ei etc.). */
    )
    {
    long flags;
    M2_INTERFACETBL mib2Tbl;
    M2_ID * pM2ID; 
    IP_DRV_CTRL* pDrvCtrl;
#ifndef VIRTUAL_STACK
    IMPORT int          ipMaxUnits;
#endif
    struct ifnet* pIfp = NULL;
    char *pName = NULL;
    END_OBJ* pEnd;
    struct ifaddr *pIfa;
    struct sockaddr_dl *pSdl;
    CL_POOL_ID pClPoolId;
    int ifHdrLen;
    
    int count;
    int limit = ipMaxUnits;
    int freeslot = -1;
    
    pEnd = endFindByName (pDevice, unit);
    if (pEnd == NULL)
        {
        logMsg ("ipAttach: Can't attach %s (unit %d). It is not an END device.\n",
                (int)pDevice, unit, 0, 0, 0, 0);
        return (ERROR);
        }
    
    for (count = 0; count < limit; count++)
        {
        pDrvCtrl = &ipDrvCtrl [count];
        
        if (pDrvCtrl->attached)
            {
            /* Already attached to requested device? */
            
            if (PCOOKIE_TO_ENDOBJ (pDrvCtrl->pIpCookie) == pEnd)
                return (OK);
            }
        else if (freeslot == -1)
            freeslot = count;
        }
    
    if (freeslot == -1)
        {
        /* Too many attach attempts. */
        
        logMsg ("Protocol is out of space. Increase IP_MAX_UNITS.\n",
                0, 0, 0, 0, 0, 0);
        
        return (ERROR);
        }
    
    pDrvCtrl = &ipDrvCtrl [freeslot];
    bzero ( (char *)pDrvCtrl, sizeof (IP_DRV_CTRL));
    
    /*
     * Bind IP to the device using the appropriate routines for the driver
     * type. NPT devices use a different receive routine since those drivers
     * remove the link-level header before handing incoming data to the MUX
     * layer.
     */
    
    pDrvCtrl->nptFlag = FALSE;
    
    if (pEnd->pFuncTable->ioctl)
        {
        if ( (pEnd->pFuncTable->ioctl (pEnd, EIOCGNPT, NULL)) == OK)
            {
            /* NPT device. */
            pDrvCtrl->nptFlag = TRUE;
            }
        }
    
    if (pDrvCtrl->nptFlag)
        {
        /* NPT device */
        pDrvCtrl->pIpCookie = muxTkBind (pDevice, unit, ipTkReceiveRtn,
                                         ipTkShutdownRtn, ipTkTxRestart,
                                         ipTkError, ETHERTYPE_IP, 
                                         "IP 4.4 TCP/IP",
                                         pDrvCtrl, NULL, NULL);
        
        if (pDrvCtrl->pIpCookie == NULL)
            {
            logMsg ("TCP/IP could not bind to the MUX: muxTkBind! %s",
                    (int)pDevice, 0, 0, 0, 0, 0);
            goto ipAttachError;
            }
        }
    else
        {
        /* END device */
        pDrvCtrl->pIpCookie = muxBind (pDevice, unit, (FUNCPTR) ipReceiveRtn,
                                       (FUNCPTR) ipShutdownRtn, 
                                       (FUNCPTR) ipTxRestart,
                                       (VOIDFUNCPTR) ipError, ETHERTYPE_IP,
                                       "IP 4.4 TCP/IP", (void *) pDrvCtrl);
        if (pDrvCtrl->pIpCookie == NULL)
            {
            logMsg ("TCP/IP could not bind to the MUX! %s", (int)pDevice,
                    0, 0, 0, 0, 0);
            goto ipAttachError;
            }
        
        
        /*
         * END devices require additional memory to construct a
         * link-level header for outgoing data.
         */
        
        pDrvCtrl->pSrc = netMblkGet (_pNetDpool, M_DONTWAIT, MT_DATA);
        if (pDrvCtrl->pSrc == NULL)
            {
            goto ipAttachError;
            }
        
        pDrvCtrl->pDst = netMblkGet (_pNetDpool, M_DONTWAIT, MT_DATA);
        if (pDrvCtrl->pDst == NULL)
            {
            goto ipAttachError;
            }
        }
        
    /* Get storage for link-level destination addresses. */
    
    pClPoolId = netClPoolIdGet (_pNetDpool, MAX_ADDRLEN, TRUE);
    if (pClPoolId == NULL)
        {
        goto ipAttachError;
        }
    
    pDrvCtrl->pDstAddr = netClusterGet (_pNetDpool, pClPoolId);
    if (pDrvCtrl->pDstAddr == NULL)
        {
        goto ipAttachError;
        }
    
    /* Set the internal mBlk to access the link-level information. */
    
    if (!pDrvCtrl->nptFlag)
        pDrvCtrl->pDst->m_data = pDrvCtrl->pDstAddr;
    
    pName = KHEAP_ALLOC( (strlen (pDevice) + 1));    /* +1: EOS character */
    if (pName == NULL)
        {
        goto ipAttachError;
        }
    bzero (pName, strlen (pDevice) + 1);
    strcpy (pName, pDevice);

    /* Get all necessary lower-level device information. */
    
    muxIoctl (pDrvCtrl->pIpCookie, EIOCGFLAGS, (caddr_t)&flags);
    
    if (pEnd->flags & END_MIB_2233)
        {
        if (muxIoctl(pDrvCtrl->pIpCookie, EIOCGMIB2233,
                     (caddr_t)&pM2ID) == ERROR)
	    {
	    logMsg("ipAttach: could not get MIB2 Table for device %s #%d\n",
                   (int)pDevice,unit,3,4,5,6);
            
	    goto ipAttachError;
	    }
        
        memcpy(&mib2Tbl, &(pM2ID->m2Data.mibIfTbl), sizeof(M2_INTERFACETBL));
        }
    else /* (RFC1213 style of counters supported) XXX */
        {
        if (muxIoctl(pDrvCtrl->pIpCookie, EIOCGMIB2,
                     (caddr_t)&mib2Tbl) == ERROR)
	    {
	    logMsg("ipAttach: could not get MIB2 Table for device %s #%d\n",
                   (int)pDevice,unit,3,4,5,6);
            
	    goto ipAttachError;
	    }
        }

    pIfp = (IFNET *)&pDrvCtrl->idr;
    
    /* Hook up the interface pointers etc. */
    
#ifdef WV_INSTRUMENTATION
#ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
    WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_VERBOSE, 14, 17, 
                     WV_NETEVENT_ETHERATTACH_START, pIfp)
#endif  /* INCLUDE_WVNET */
#endif
        
        bzero ((char *) pIfp, sizeof (*pIfp));
    
#ifdef VIRTUAL_STACK
    virtualStackIdCheck();  /* make sure the myStackNum exists */
    pIfp->vsNum = myStackNum;
#endif /* VIRTUAL_STACK */
    
    pIfp->if_unit   = unit;
    pIfp->if_name   = pName;
    pIfp->if_mtu    = mib2Tbl.ifMtu;
    pIfp->if_baudrate = mib2Tbl.ifSpeed;
    pIfp->if_init   = NULL;
    pIfp->if_ioctl  = (FUNCPTR) ipIoctl;
    pIfp->if_output = ipOutput;
    pIfp->if_reset  = NULL;
    pIfp->if_resolve = muxAddrResFuncGet (mib2Tbl.ifType, ETHERTYPE_IP);
    pIfp->if_flags  = flags;
    pIfp->if_type = mib2Tbl.ifType;
    pIfp->if_addrlen = mib2Tbl.ifPhysAddress.addrLength;
    pIfp->pCookie = (void *)pDrvCtrl;

    /*
     * Store address information for supported devices (802.x addressing)
     * and bind ARP to the device using the appropriate receive routine.
     */

    switch (mib2Tbl.ifType)
        {
        case M2_ifType_ethernet_csmacd:
        case M2_ifType_iso88023_csmacd:
        case M2_ifType_iso88024_tokenBus:
        case M2_ifType_iso88025_tokenRing:
        case M2_ifType_iso88026_man:
        case M2_ifType_fddi:

            bcopy (mib2Tbl.ifPhysAddress.phyAddress, pDrvCtrl->idr.ac_enaddr,
                   pIfp->if_addrlen);
            
            if (pDrvCtrl->nptFlag)
                {
                pDrvCtrl->pArpCookie = muxTkBind (pDevice, unit,
                                                  ipTkReceiveRtn,
                                                  arpTkShutdownRtn,
                                                  ipTkTxRestart,
                                                  NULL, ETHERTYPE_ARP, 
                                                  "IP 4.4 ARP",
                                                  pDrvCtrl, NULL, NULL);
                if (pDrvCtrl->pArpCookie == NULL)
                    {
                    logMsg ("ARP could not bind to the MUX: muxTkBind! %s",
                            (int)pDevice, 0, 0, 0, 0, 0);
                    goto ipAttachError;
                    }
                }
            else     /* END device */
                {
                pDrvCtrl->pArpCookie = muxBind (pDevice, unit,
                                                (FUNCPTR) ipReceiveRtn,
                                                (FUNCPTR) arpShutdownRtn, 
                                                (FUNCPTR) ipTxRestart,
                                                NULL, ETHERTYPE_ARP, 
                                                "IP 4.4 ARP",
                                                pDrvCtrl);
                if (pDrvCtrl->pArpCookie == NULL)
                    {
                    logMsg ("ARP could not bind to the MUX! %s", (int)pDevice,
                            0, 0, 0, 0, 0);
                    goto ipAttachError;
                    }
                }
            break;

        default:
            break;
        }
    
    /* Get the length of the header. */

    if (muxIoctl (pDrvCtrl->pIpCookie, EIOCGHDRLEN, (caddr_t)&ifHdrLen) != OK)
        pIfp->if_hdrlen = 0;
    else
        pIfp->if_hdrlen = (short)ifHdrLen;

    
    /* Attach the interface. */
    /* NOTE: if_attach must come before "common duties" below.  see spr# 29152 */
    
    if (if_attach (pIfp) == ERROR)
        goto ipAttachError;
    
    /*
     * Perform common duties while attaching to interface list
     */

    for (pIfa = pIfp->if_addrlist; pIfa; pIfa = pIfa->ifa_next)
        {
        if ((pSdl = (struct sockaddr_dl *)pIfa->ifa_addr) &&
            pSdl->sdl_family == AF_LINK)
            {
            pSdl->sdl_type = pIfp->if_type;
            pSdl->sdl_alen = pIfp->if_addrlen;
            bcopy (mib2Tbl.ifPhysAddress.phyAddress,
                   LLADDR (pSdl), pSdl->sdl_alen);
            break;
            }
        }
    
    pIfp->if_start = (FUNCPTR)ipTxStartup;
    
    pDrvCtrl->attached = TRUE;
    
    return (OK);

    ipAttachError:
    
    /* Cleanup by removing any bound protocols and/or allocated memory. */
    
    if (pDrvCtrl->pDstAddr)
        netClFree (_pNetDpool, pDrvCtrl->pDstAddr);
    
    if (pDrvCtrl->nptFlag)
        {
        if (pDrvCtrl->pIpCookie)
            muxUnbind (pDrvCtrl->pIpCookie, ETHERTYPE_IP, ipTkReceiveRtn);
        
        if (pDrvCtrl->pArpCookie)
            muxUnbind (pDrvCtrl->pArpCookie, ETHERTYPE_IP, ipTkReceiveRtn);
        }
    else
        {
        if (pDrvCtrl->pIpCookie)
            muxUnbind (pDrvCtrl->pIpCookie, ETHERTYPE_IP, ipReceiveRtn);
        
        if (pDrvCtrl->pArpCookie)
            muxUnbind (pDrvCtrl->pArpCookie, ETHERTYPE_IP, ipReceiveRtn);
        }
    
    if (pDrvCtrl->pSrc)
        netMblkFree (_pNetDpool, pDrvCtrl->pSrc);
    
    if (pDrvCtrl->pDst)
        netMblkFree (_pNetDpool, pDrvCtrl->pDst);
    
    return (ERROR);
    }

/*******************************************************************************
*
* ipTxRestart - restart routine 
*
* NOMANUAL
*/

LOCAL int ipTxRestart
    (
    void * pCookie,	/* device identifier (from muxDevLoad) */
    IP_DRV_CTRL * pDrvCtrl
    )
    {
    if (pDrvCtrl == NULL)
        return (ERROR);
    
    ipTxStartup (pDrvCtrl);
    
    return (OK);