int code,                   /* ioctl function code */    int arg                     /* some argument */    )    {    int status;    int hostAddr;    switch ((u_int) code)	{	case SIOCAIFADDR:	case SIOCDIFADDR:	case SIOCSIFADDR:	case SIOCSIFBRDADDR:	case SIOCSIFDSTADDR:	    /* verify Internet address is in correct format */	    if ((hostAddr = (int) inet_addr ((char *)arg)) == ERROR &&		(hostAddr = hostGetByName ((char *)arg)) == ERROR)		{		return (ERROR);		}	    status = ifIoctlSet (interfaceName, code, hostAddr);	    break;	case SIOCSIFNETMASK:        case SIOCSIFFLAGS:        case SIOCSIFMETRIC:	    status = ifIoctlSet (interfaceName, code, arg);	    break;	case SIOCGIFNETMASK:	case SIOCGIFFLAGS:	case SIOCGIFADDR:	case SIOCGIFBRDADDR:	case SIOCGIFDSTADDR:	case SIOCGIFMETRIC:	    status = ifIoctlGet (interfaceName, code, (int *)arg);	    break;	default:	    (void)errnoSet (EOPNOTSUPP); /* not supported operation */	    status = ERROR;	    break;	}    return (status);    }/********************************************************************************* ifIoctlSet - configure network interface** RETURNS: OK or ERROR*/LOCAL STATUS ifIoctlSet    (    char *interfaceName,        /* name of the network interface, i.e. ei0 */    int   code,                 /* network interface ioctl function code */    int   val                   /* value to be changed */    )    {    struct ifreq ifr;    strncpy (ifr.ifr_name, interfaceName, sizeof (ifr.ifr_name));    switch ((u_int) code)	{	case SIOCSIFFLAGS:	    ifr.ifr_flags = (short) val;	    break;        case SIOCSIFMETRIC:	    ifr.ifr_metric = val;	    break;        default:	    bzero ((caddr_t) &ifr.ifr_addr, sizeof (ifr.ifr_addr));	    ifr.ifr_addr.sa_len = sizeof (struct sockaddr_in);	    ifr.ifr_addr.sa_family = AF_INET;	    ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr = val;	    break;	}    return (ifIoctlCall (code, &ifr));    }/********************************************************************************* ifIoctlGet - retrieve information about the network interface** RETURNS: OK or ERROR*/LOCAL STATUS ifIoctlGet    (    char *interfaceName,        /* name of the network interface, i.e. ei0 */    int   code,                 /* network interface ioctl function code */    int  *val                   /* where to return result */    )    {    struct ifreq  ifr;    strncpy (ifr.ifr_name, interfaceName, sizeof (ifr.ifr_name));    if (ifIoctlCall (code, &ifr) == ERROR)	return (ERROR);    switch ((u_int) code)	{	case SIOCGIFFLAGS:	    *val = ifr.ifr_flags;	    break;        case SIOCGIFMETRIC:	    *val = ifr.ifr_metric;	    break;	default:	    *val = ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr;	    break;	}    return (OK);    }/********************************************************************************* ifIoctlCall - make ioctl call to socket layer** ifIoctlCall creates a dummy socket to get access to the socket layer* ioctl routines in order to manipulate the interface specific* configurations.** RETURNS: OK or ERROR*/LOCAL STATUS ifIoctlCall    (    int           code,         /* ioctl code */    struct ifreq *ifrp          /* pointer to the interface ioctl request */    )    {    int so;    int status;    if ((so = socket (AF_INET, SOCK_RAW, 0)) < 0)	return (ERROR);    status = ioctl (so, code, (int)ifrp);    (void)close (so);    if (status != 0)	{	if (status != ERROR)	/* iosIoctl() can return ERROR */	    (void)errnoSet (status);	return (ERROR);	}    return (OK);    }/********************************************************************************* ifRouteDelete - delete routes associated with a network interface** This routine deletes all routes that have been associated with the* specified interface. A route is associated with an interface if its * destination equals to the assigned address, or network number. This routine* does not remove routes to arbitrary destinations that through the* given interface.*** INTERNAL* This function only works for address families AF_INET** RETURNS:* The number of routes deleted, or ERROR if an interface is not specified.*/int ifRouteDelete    (    char *ifName,               /* name of the interface */    int   unit                  /* unit number for this interface */    )    {    FAST struct ifnet 		*ifp;    FAST struct ifaddr 		*ifa;    FAST struct in_ifaddr 	*ia = 0;    int 			deleted;    struct sockaddr_in		inetAddr;    if (ifName == NULL)	return (ERROR);    deleted = 0;#ifdef VIRTUAL_STACK    for (ifp = _ifnet; ifp; ifp = ifp->if_next)#else    for (ifp = ifnet; ifp; ifp = ifp->if_next)#endif /* VIRTUAL_STACK */	{	if (ifp->if_unit != unit || strcmp(ifName, ifp->if_name))	    continue;	for (ifa = ifp->if_addrlist; ifa; ifa = ifa->ifa_next)	    {            /* skip if address family does not belong to AF_INET */            if (ifa->ifa_addr->sa_family != AF_INET)                continue;            /*	     * Every element in the if_addrlist (type struct ifaddr) with	     * family AF_INET is actually the first part of a larger	     * in_ifaddr structure which includes the subnet mask. Access	     * that structure to use the mask value.	     */	    ia = (struct in_ifaddr *) ifa;	    /* 	     * The following is a sanity test.	     */#ifdef ROUTER_STACK 	/* UNNUMBERED_SUPPORT */ 	    /*	     * This test is to prevent an ipDetach on an unnumbered interface	     * from removing the routes generated by the real interface if that	     * interface is still up. See ifUnnumberedSet for the definition	     * of "real interface."	     */	    if (ifa == ifa_ifwithaddr (ifa->ifa_addr))#endif /* ROUTER_STACK */		{                if (mRouteEntryDelete (((struct sockaddr_in*)ifa->ifa_addr)->				    sin_addr.s_addr, 0, 0xffffffff, 0, RTF_HOST, 				    M2_ipRouteProto_local) == OK)                    ++deleted;                inetAddr.sin_addr.s_addr =                    htonl (ia->ia_subnetmask) &                    ((struct sockaddr_in *)ifa->ifa_addr)->sin_addr.s_addr;                if (mRouteEntryDelete (((struct sockaddr_in*)ifa->ifa_addr)->				    sin_addr.s_addr, 0, htonl(ia->ia_subnetmask), 				    0, 0, M2_ipRouteProto_local) == OK)                    ++deleted;		}	    if (ifp->if_flags & (IFF_POINTOPOINT|IFF_UNNUMBERED))		{                if (mRouteEntryDelete (((struct sockaddr_in*)ifa->ifa_dstaddr)->                                       sin_addr.s_addr,                                        ((struct sockaddr_in*)ifa->ifa_addr)->                                       sin_addr.s_addr, 0x0, 0,                                       RTF_HOST, M2_ipRouteProto_local) == OK)		    ++deleted;#ifdef ROUTER_STACK     /* UNNUMBERED_SUPPORT */		else		    {                    _arpCmd (SIOCDARP,                              &(((struct sockaddr_in *)                                ifa->ifa_dstaddr)->sin_addr), NULL, NULL);        		    deleted++;		    }#endif /* ROUTER_STACK */		}	    }	}    return (deleted);    }/********************************************************************************* routeNodeDelete - delete the route associated with the network interface** This routine deletes the route that has been associated with the* specified interface. Only the following route is deleted:* \ml * \m -* the network route added when the interface address is initialized* \m -* the static route added by the administrator that passes through the interface* \m -* ARP routes passing through the interface* \me* * Routes added by routing protocols are not deleted.* For the Router stack, this routine first scans all duplicate routes* to determine which ones need to be deleted, and then processes the primary* route. This special handling is needed because the way the duplicate* routes are organized, deleting the primary route first might lead* to memory corruption.** INTERNAL* This function only works for address families AF_INET** RETURNS:* 0*/LOCAL int routeNodeDelete    (    struct radix_node *	pRoute,    /* pointer to the node structure */    void *		pArg       /* pointer to the interface */    )    {    struct ifnet *		ifp =  (struct ifnet *)((int *)pArg)[0];    int   			type = ((int *)pArg)[1];    int	*			pDeleted = (int *)((int *)pArg)[2];    struct rtentry *		pRt;    FAST struct sockaddr *	destAddr = NULL;    FAST struct sockaddr *	gateAddr;    char 			aStr [INET_ADDR_LEN];#ifdef ROUTER_STACK    ROUTE_ENTRY * pHead;     ROUTE_ENTRY * pDiffSave;     ROUTE_ENTRY * pSameSave;     ROUTE_ENTRY * pNext;#endif /* ROUTER_STACK */    pRt = (struct rtentry *)pRoute;    destAddr = rt_key(pRt);		/* get the destination address */    gateAddr = pRt->rt_gateway;		/* get the gateway address */#ifdef DEBUG    inet_ntoa_b (((struct sockaddr_in *)destAddr)->sin_addr, aStr);    logMsg ("routeNodeDelete: Called for %s, if=%s%d, proto=%d, type = %s\n",             (int)aStr, (int)(pRt->rt_ifp->if_name), pRt->rt_ifp->if_unit,            RT_PROTO_GET (destAddr),             (int)(type == RT_ARP ? "ARP" : "NON_ARP"), 0); #endif /* DEBUG */    /* Just return if it is an ARP entry and we are not interested in it */    if (type != RT_ARP &&         ((pRt->rt_flags & RTF_HOST) &&          (pRt->rt_flags & RTF_LLINFO) &&          (pRt->rt_flags & RTF_GATEWAY) == 0 &&          gateAddr && (gateAddr->sa_family == AF_LINK)))        return(0);    /* Just return if we want an ARP entry, but this is not */    if (type == RT_ARP &&         !((pRt->rt_flags & RTF_HOST) &&           (pRt->rt_flags & RTF_LLINFO) &&           (pRt->rt_flags & RTF_GATEWAY) == 0 &&           gateAddr && (gateAddr->sa_family == AF_LINK)))        return(0);    /*      * If it is an ARP entry and it passes through the interface,      * delete the ARP entry      */    if ((pRt->rt_flags & RTF_HOST) &&        (pRt->rt_flags & RTF_LLINFO) &&        (pRt->rt_flags & RTF_GATEWAY) == 0 &&        gateAddr && (gateAddr->sa_family == AF_LINK))         {        if(pRt->rt_ifp == ifp)            {            inet_ntoa_b (((struct sockaddr_in *)destAddr)->sin_addr, aStr);#ifdef DEBUG            logMsg ("routeNodeDelete: deleting ARP entry for %s\n",                     (int)aStr,0,0,0,0,0); #endif /* DEBUG */            _arpCmd (SIOCDARP, &((struct sockaddr_in *)destAddr)->sin_addr,                      NULL, NULL);                    /* Increment the deletion counter */            ++(*pDeleted);            }        return (0);        }#ifdef ROUTER_STACK    /*      * Because of the way the duplicate route list is managed, we need to