for ( ; ia->ia_next; ia = ia->ia_next)					continue;				ia->ia_next = oia;			} else#ifdef VIRTUAL_STACK				_in_ifaddr = oia;#else				in_ifaddr = oia;#endif /* VIRTUAL_STACK */			ia = oia;			if ((ifa = ifp->if_addrlist)) {				for ( ; ifa->ifa_next; ifa = ifa->ifa_next)					continue;				ifa->ifa_next = (struct ifaddr *) ia;			} else				ifp->if_addrlist = (struct ifaddr *) ia;			ia->ia_ifa.ifa_addr = (struct sockaddr *)&ia->ia_addr;			ia->ia_ifa.ifa_dstaddr					= (struct sockaddr *)&ia->ia_dstaddr;			ia->ia_ifa.ifa_netmask					= (struct sockaddr *)&ia->ia_sockmask;			ia->ia_sockmask.sin_len = 8;			if (ifp->if_flags & IFF_BROADCAST) {				ia->ia_broadaddr.sin_len = sizeof(ia->ia_addr);				ia->ia_broadaddr.sin_family = AF_INET;			}			ia->ia_ifp = ifp;			if (ifp != loif)				in_interfaces++;		}		break;	case SIOCSIFBRDADDR:		if ((so->so_state & SS_PRIV) == 0)			return (EPERM);		/* FALLTHROUGH */	case SIOCGIFADDR:	case SIOCGIFNETMASK:	case SIOCGIFDSTADDR:	case SIOCGIFBRDADDR:		if (ia == (struct in_ifaddr *)0)                    {#ifdef WV_INSTRUMENTATION#ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */                    WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_ERROR, 8, 4,                                      WV_NETEVENT_INCTRL_SEARCHFAIL, cmd, ifp)#endif  /* INCLUDE_WVNET */#endif                    return (EADDRNOTAVAIL);                    }		break;	}	switch (cmd) {	case SIOCGIFADDR:		*((struct sockaddr_in *)&ifr->ifr_addr) = ia->ia_addr;		break;	case SIOCGIFBRDADDR:		if ((ifp->if_flags & IFF_BROADCAST) == 0)                    {#ifdef WV_INSTRUMENTATION#ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */                    WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_ERROR, 9, 5,                                      WV_NETEVENT_INCTRL_BADFLAGS, cmd, ifp)#endif  /* INCLUDE_WVNET */#endif                    return (EINVAL);                    }		*((struct sockaddr_in *)&ifr->ifr_dstaddr) = ia->ia_broadaddr;		break;	case SIOCGIFDSTADDR:		if ((ifp->if_flags & IFF_POINTOPOINT) == 0)                    {#ifdef WV_INSTRUMENTATION#ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */                    WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_ERROR, 9, 5,                                      WV_NETEVENT_INCTRL_BADFLAGS, cmd, ifp)#endif  /* INCLUDE_WVNET */#endif                    return (EINVAL);                    }		*((struct sockaddr_in *)&ifr->ifr_dstaddr) = ia->ia_dstaddr;		break;	case SIOCGIFNETMASK:		*((struct sockaddr_in *)&ifr->ifr_addr) = ia->ia_sockmask;		break;	case SIOCSIFDSTADDR:		if ((ifp->if_flags & IFF_POINTOPOINT) == 0)                    {#ifdef WV_INSTRUMENTATION#ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */                    WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_ERROR, 9, 5,                                      WV_NETEVENT_INCTRL_BADFLAGS, cmd, ifp)#endif  /* INCLUDE_WVNET */#endif                    return (EINVAL);                    }		oldaddr = ia->ia_dstaddr;		ia->ia_dstaddr = *(struct sockaddr_in *)&ifr->ifr_dstaddr;		if (ifp->if_ioctl && (error = (*ifp->if_ioctl)					(ifp, SIOCSIFDSTADDR, (caddr_t)ia))) {			ia->ia_dstaddr = oldaddr;			return (error);		}		if (ia->ia_flags & IFA_ROUTE) {			ia->ia_ifa.ifa_dstaddr = (struct sockaddr *)&oldaddr;			rtinit(&(ia->ia_ifa), (int)RTM_DELETE, RTF_HOST);			ia->ia_ifa.ifa_dstaddr =					(struct sockaddr *)&ia->ia_dstaddr;			rtinit(&(ia->ia_ifa), (int)RTM_ADD, RTF_HOST|RTF_UP);		}		break;	case SIOCSIFBRDADDR:		if ((ifp->if_flags & IFF_BROADCAST) == 0)                    {#ifdef WV_INSTRUMENTATION#ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */                    WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_ERROR, 9, 5,                                      WV_NETEVENT_INCTRL_BADFLAGS, cmd, ifp)#endif  /* INCLUDE_WVNET */#endif                    return (EINVAL);                    }		ia->ia_broadaddr = *(struct sockaddr_in *)&ifr->ifr_broadaddr;		break;	case SIOCSIFADDR:		return (in_ifinit(ifp, ia,		    (struct sockaddr_in *) &ifr->ifr_addr, 1));	case SIOCSIFNETMASK:		i = ifra->ifra_addr.sin_addr.s_addr;		ia->ia_subnetmask = ntohl(ia->ia_sockmask.sin_addr.s_addr = i);		in_socktrim (&ia->ia_sockmask);		break;	case SIOCAIFADDR:		maskIsNew = 0;		hostIsNew = 1;		error = 0;		if (ia->ia_addr.sin_family == AF_INET) {			if (ifra->ifra_addr.sin_len == 0) {				ifra->ifra_addr = ia->ia_addr;				hostIsNew = 0;			} else if (ifra->ifra_addr.sin_addr.s_addr ==					       ia->ia_addr.sin_addr.s_addr)				hostIsNew = 0;		}		if (ifra->ifra_mask.sin_len) {			in_ifscrub(ifp, ia);			ia->ia_sockmask = ifra->ifra_mask;			ia->ia_subnetmask =			     ntohl(ia->ia_sockmask.sin_addr.s_addr);			maskIsNew = 1;		}		if ((ifp->if_flags & IFF_POINTOPOINT) &&		    (ifra->ifra_dstaddr.sin_family == AF_INET)) {			in_ifscrub(ifp, ia);			ia->ia_dstaddr = ifra->ifra_dstaddr;			maskIsNew  = 1; /* We lie; but the effect's the same */		}		if (ifra->ifra_addr.sin_family == AF_INET &&		    (hostIsNew || maskIsNew))			error = in_ifinit(ifp, ia, &ifra->ifra_addr, 0);                /*                 * Ignore the report of an existing route entry if                 * this new (alias) IP address might use the same                 * logical subnet as another address/netmask pair.                 * The SIOCAIFADDR operation continues to provide                 * the duplicate route error when assigning the                 * initial address for an interface.                 */                if (error == EEXIST)                    {                    /*                     * The information necessary to determine whether this                     * address/netmask assignment absolutely requires an                     * associated route entry is not readily available.                     * This operation assumes existing routes to a logical                     * subnet use the same interface as the new address entry.                     * Under certain circumstances, the ability to ignore                     * existing routes when assigning additional IP addresses                     * might allow users to successfully configure interfaces                     * which are unable to transmit data.                     */                    if (newRouteFlag == FALSE)                        error = 0;                    }                /*                 * Replace the mask-based broadcast address if the                 * user provides a specific value.                 */                if ((ifp->if_flags & IFF_BROADCAST) &&                    (ifra->ifra_broadaddr.sin_family == AF_INET) &&                    (ifra->ifra_broadaddr.sin_addr.s_addr))                        ia->ia_broadaddr = ifra->ifra_broadaddr;		return (error);	case SIOCDIFADDR:		in_ifscrub(ifp, ia);		if ((ifa = ifp->if_addrlist) == (struct ifaddr *)ia)			ifp->if_addrlist = ifa->ifa_next;		else {			while (ifa->ifa_next &&			       (ifa->ifa_next != (struct ifaddr *)ia))				    ifa = ifa->ifa_next;			if (ifa->ifa_next)				ifa->ifa_next = ((struct ifaddr *)ia)->ifa_next;			else				logMsg("Couldn't unlink inifaddr from ifp\n",				       0,0,0,0,0,0);		}		oia = ia;#ifdef VIRTUAL_STACK		if (oia == (ia = _in_ifaddr))			_in_ifaddr = ia->ia_next;#else		if (oia == (ia = in_ifaddr))			in_ifaddr = ia->ia_next;#endif /* VIRTUAL_STACK */		else {			while (ia->ia_next && (ia->ia_next != oia))				ia = ia->ia_next;			if (ia->ia_next)				ia->ia_next = oia->ia_next;			else				logMsg("Didn't unlink inifadr from list\n",				       0,0,0,0,0,0);		}		IFAFREE((&oia->ia_ifa));		break;	default:		if (ifp == 0 || ifp->if_ioctl == 0)			return (EOPNOTSUPP);		return ((*ifp->if_ioctl)(ifp, cmd, data));	}	return (0);}/* * Delete any existing route for an interface. */voidin_ifscrub(ifp, ia)	register struct ifnet *ifp;	register struct in_ifaddr *ia;{#ifdef WV_INSTRUMENTATION#ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */        WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_VERBOSE, 19, 8,                          WV_NETEVENT_INROUTEDEL_START, ifp)#endif  /* INCLUDE_WVNET */#endif	if ((ia->ia_flags & IFA_ROUTE) == 0)		return;	if (ifp->if_flags & (IFF_LOOPBACK|IFF_POINTOPOINT))		rtinit(&(ia->ia_ifa), (int)RTM_DELETE, RTF_HOST);	else		rtinit(&(ia->ia_ifa), (int)RTM_DELETE, 0);	ia->ia_flags &= ~IFA_ROUTE;}/* * Initialize an interface's internet address * and routing table entry. */intin_ifinit(ifp, ia, sin, scrub)	register struct ifnet *ifp;	register struct in_ifaddr *ia;	struct sockaddr_in *sin;	int scrub;{	register u_long i = ntohl(sin->sin_addr.s_addr);	struct sockaddr_in oldaddr;	int s = splimp(), flags = RTF_UP, error, ether_output();#ifdef WV_INSTRUMENTATION#ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */    WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_VERBOSE, 20, 9,                      WV_NETEVENT_INIFINIT_START, ifp, sin->sin_addr.s_addr)#endif  /* INCLUDE_WVNET */#endif	oldaddr = ia->ia_addr;	ia->ia_addr = *sin;	/*	 * Give the interface a chance to initialize	 * if this is its first address,	 * and to validate the address if necessary.	 */	if (ifp->if_ioctl &&	    (error = (*ifp->if_ioctl)(ifp, SIOCSIFADDR, (caddr_t)ia))) {		splx(s);		ia->ia_addr = oldaddr;		return (error);	}	if (ifp->if_output == ether_output) { /* XXX: Another Kludge */		ia->ia_ifa.ifa_rtrequest = arp_rtrequest;		ia->ia_ifa.ifa_flags |= RTF_CLONING;	}	splx(s);	if (scrub) {		ia->ia_ifa.ifa_addr = (struct sockaddr *)&oldaddr;		in_ifscrub(ifp, ia);		ia->ia_ifa.ifa_addr = (struct sockaddr *)&ia->ia_addr;	}	if (IN_CLASSA(i))		ia->ia_netmask = IN_CLASSA_NET;	else if (IN_CLASSB(i))		ia->ia_netmask = IN_CLASSB_NET;	else		ia->ia_netmask = IN_CLASSC_NET;	/*	 * The subnet mask usually includes at least the standard network part,	 * but may may be smaller in the case of supernetting.	 * If it is set, we believe it.	 */	if (ia->ia_subnetmask == 0) {		ia->ia_subnetmask = ia->ia_netmask;		ia->ia_sockmask.sin_addr.s_addr = htonl(ia->ia_subnetmask);	} else		ia->ia_netmask &= ia->ia_subnetmask;	ia->ia_net = i & ia->ia_netmask;	ia->ia_subnet = i & ia->ia_subnetmask;	in_socktrim(&ia->ia_sockmask);	/*	 * Add route for the network.	 */	ia->ia_ifa.ifa_metric = ifp->if_metric;	if (ifp->if_flags & IFF_BROADCAST) {		ia->ia_broadaddr.sin_addr.s_addr =			htonl(ia->ia_subnet | ~ia->ia_subnetmask);		ia->ia_netbroadcast.s_addr =			htonl(ia->ia_net | ~ ia->ia_netmask);	} else if (ifp->if_flags & IFF_LOOPBACK) {		ia->ia_ifa.ifa_dstaddr = ia->ia_ifa.ifa_addr;		flags |= RTF_HOST;	} else if (ifp->if_flags & IFF_POINTOPOINT) {		if (ia->ia_dstaddr.sin_family != AF_INET)			return (0);		flags |= RTF_HOST;	}	if ((error = rtinit(&(ia->ia_ifa), (int)RTM_ADD, flags)) == 0)		ia->ia_flags |= IFA_ROUTE;	/*	 * If the interface supports multicast, join the "all hosts"	 * multicast group on that interface.	 */	if (ifp->if_flags & IFF_MULTICAST) {		struct in_addr addr;                struct in_multi * inm;		addr.s_addr = htonl(INADDR_ALLHOSTS_GROUP);                IN_LOOKUP_MULTI(addr, ifp, inm);                if (inm == NULL)             /* don't add if already there ... SPR#28903 */                    ifp->pInmMblk = in_addmulti (&addr, ifp, NULL); 	}	return (error);}/********************************************************************************* in_ifaddr_remove - remove an interface from the in_ifaddr list** This function removes the internet interface address given as an input* parameter, from the global linked-list of internet interface addresses* pointed by in_ifaddr. This function is called before dettaching an interface* This function also removes all the internet multicast addresses hooked to * the in_ifaddr. It calls in_delmulti() which in turn calls the ioctl for the* driver to remove the ethernet multicast addresses.* * NOMANUAL* * RETURNS: N/A*/ void in_ifaddr_remove     (    struct ifaddr * pIfAddr		/* pointer to interface address */    )     {    struct in_ifaddr ** pPtrInIfAddr; 	/* pointer to pointer to in_ifaddr */    struct in_ifaddr *  pInIfAddr; 	/* pointer to in_ifaddr */#ifdef WV_INSTRUMENTATION#ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */    WV_NET_MARKER_0 (NET_AUX_EVENT, WV_NET_VERBOSE, 21, 10,                      WV_NETEVENT_INIFADDRDEL_START)#endif  /* INCLUDE_WVNET */#endif