in.c

vxworks5.5.1源代码。完整源代码

				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.
 */
void
in_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.
 */
int
in_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