X-Git-Url: https://git.subgeniuskitty.com/unix-history/.git/blobdiff_plain/fcfe450e4ae7bcb3ff4d45b10c8a7c30aa1b3c16..5548a02fb5c1a0399f9e8d8d90b4a0370bea6070:/usr/src/sys/netinet/in_pcb.c diff --git a/usr/src/sys/netinet/in_pcb.c b/usr/src/sys/netinet/in_pcb.c index 689cb62111..2c3dc3d8a6 100644 --- a/usr/src/sys/netinet/in_pcb.c +++ b/usr/src/sys/netinet/in_pcb.c @@ -1,36 +1,36 @@ -/* in_pcb.c 4.32 82/10/09 */ +/* + * Copyright (c) 1982, 1986, 1991 Regents of the University of California. + * All rights reserved. + * + * %sccs.include.redist.c% + * + * @(#)in_pcb.c 7.23 (Berkeley) %G% + */ -#include "../h/param.h" -#include "../h/systm.h" -#include "../h/dir.h" -#include "../h/user.h" -#include "../h/mbuf.h" -#include "../h/socket.h" -#include "../h/socketvar.h" -#include "../netinet/in.h" -#include "../netinet/in_systm.h" -#include "../net/if.h" -#include "../net/route.h" -#include "../netinet/in_pcb.h" -#include "../h/protosw.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include -struct in_addr zeroin_addr; +#include +#include -in_pcbreserve(so, sndcc, rcvcc) - struct socket *so; - int sndcc, rcvcc; -{ +#include +#include +#include +#include +#include - if (sbreserve(&so->so_snd, sndcc) == 0) - goto bad; - if (sbreserve(&so->so_rcv, rcvcc) == 0) - goto bad2; - return (0); -bad2: - sbrelease(&so->so_snd); -bad: - return (ENOBUFS); -} +#ifdef MULTICAST +#include +#endif + +struct in_addr zeroin_addr; in_pcballoc(so, head) struct socket *so; @@ -39,10 +39,10 @@ in_pcballoc(so, head) struct mbuf *m; register struct inpcb *inp; - m = m_getclr(M_DONTWAIT); - if (m == 0) + MALLOC(inp, struct inpcb *, sizeof(*inp), M_PCB, M_WAITOK); + if (inp == NULL) return (ENOBUFS); - inp = mtod(m, struct inpcb *); + bzero((caddr_t)inp, sizeof(*inp)); inp->inp_head = head; inp->inp_socket = so; insque(inp, head); @@ -59,45 +59,49 @@ in_pcbbind(inp, nam) register struct sockaddr_in *sin; u_short lport = 0; - if (ifnet == 0) + if (in_ifaddr == 0) return (EADDRNOTAVAIL); - if (inp->inp_lport || inp->inp_laddr.s_addr) + if (inp->inp_lport || inp->inp_laddr.s_addr != INADDR_ANY) return (EINVAL); if (nam == 0) goto noname; sin = mtod(nam, struct sockaddr_in *); if (nam->m_len != sizeof (*sin)) return (EINVAL); - if (sin->sin_addr.s_addr) { + if (sin->sin_addr.s_addr != INADDR_ANY) { int tport = sin->sin_port; sin->sin_port = 0; /* yech... */ - if (if_ifwithaddr((struct sockaddr *)sin) == 0) + if (ifa_ifwithaddr((struct sockaddr *)sin) == 0) return (EADDRNOTAVAIL); sin->sin_port = tport; } lport = sin->sin_port; if (lport) { - u_short aport = lport; + struct inpcb *t; + u_short aport = ntohs(lport); int wild = 0; -#if vax - aport = htons(aport); -#endif /* GROSS */ - if (aport < IPPORT_RESERVED && u.u_uid != 0) + if (aport < IPPORT_RESERVED && (so->so_state & SS_PRIV) == 0) return (EACCES); - if ((so->so_proto->pr_flags & PR_CONNREQUIRED) == 0) + /* even GROSSER, but this is the Internet */ + if ((so->so_options & SO_REUSEADDR) == 0 && + ((so->so_proto->pr_flags & PR_CONNREQUIRED) == 0 || + (so->so_options & SO_ACCEPTCONN) == 0)) wild = INPLOOKUP_WILDCARD; - if (in_pcblookup(head, - zeroin_addr, 0, sin->sin_addr, lport, wild)) + t = in_pcblookup(head, zeroin_addr, 0, + sin->sin_addr, lport, wild); + if (t && !((so->so_options & t->inp_socket->so_options) & + SO_REUSEPORT)) return (EADDRINUSE); } inp->inp_laddr = sin->sin_addr; noname: if (lport == 0) do { - if (head->inp_lport++ < IPPORT_RESERVED) + if (head->inp_lport++ < IPPORT_RESERVED || + head->inp_lport > IPPORT_USERRESERVED) head->inp_lport = IPPORT_RESERVED; lport = htons(head->inp_lport); } while (in_pcblookup(head, @@ -113,10 +117,10 @@ noname: * then pick one. */ in_pcbconnect(inp, nam) - struct inpcb *inp; + register struct inpcb *inp; struct mbuf *nam; { - struct ifnet *ifp; + struct in_ifaddr *ia; struct sockaddr_in *ifaddr; register struct sockaddr_in *sin = mtod(nam, struct sockaddr_in *); @@ -124,22 +128,98 @@ in_pcbconnect(inp, nam) return (EINVAL); if (sin->sin_family != AF_INET) return (EAFNOSUPPORT); - if (sin->sin_addr.s_addr == 0 || sin->sin_port == 0) + if (sin->sin_port == 0) return (EADDRNOTAVAIL); - if (inp->inp_laddr.s_addr == 0) { - ifp = if_ifonnetof(in_netof(sin->sin_addr)); - if (ifp == 0) { - /* - * We should select the interface based on - * the route to be used, but for udp this would - * result in two calls to rtalloc for each packet - * sent; hardly worthwhile... - */ - ifp = if_ifwithaf(AF_INET); - if (ifp == 0) + if (in_ifaddr) { + /* + * If the destination address is INADDR_ANY, + * use the primary local address. + * If the supplied address is INADDR_BROADCAST, + * and the primary interface supports broadcast, + * choose the broadcast address for that interface. + */ +#define satosin(sa) ((struct sockaddr_in *)(sa)) + if (sin->sin_addr.s_addr == INADDR_ANY) + sin->sin_addr = IA_SIN(in_ifaddr)->sin_addr; + else if (sin->sin_addr.s_addr == (u_long)INADDR_BROADCAST && + (in_ifaddr->ia_ifp->if_flags & IFF_BROADCAST)) + sin->sin_addr = satosin(&in_ifaddr->ia_broadaddr)->sin_addr; + } + if (inp->inp_laddr.s_addr == INADDR_ANY) { + register struct route *ro; + struct ifnet *ifp; + + ia = (struct in_ifaddr *)0; + /* + * If route is known or can be allocated now, + * our src addr is taken from the i/f, else punt. + */ + ro = &inp->inp_route; + if (ro->ro_rt && + (satosin(&ro->ro_dst)->sin_addr.s_addr != + sin->sin_addr.s_addr || + inp->inp_socket->so_options & SO_DONTROUTE)) { + RTFREE(ro->ro_rt); + ro->ro_rt = (struct rtentry *)0; + } + if ((inp->inp_socket->so_options & SO_DONTROUTE) == 0 && /*XXX*/ + (ro->ro_rt == (struct rtentry *)0 || + ro->ro_rt->rt_ifp == (struct ifnet *)0)) { + /* No route yet, so try to acquire one */ + ro->ro_dst.sa_family = AF_INET; + ro->ro_dst.sa_len = sizeof(struct sockaddr_in); + ((struct sockaddr_in *) &ro->ro_dst)->sin_addr = + sin->sin_addr; + rtalloc(ro); + } + /* + * If we found a route, use the address + * corresponding to the outgoing interface + * unless it is the loopback (in case a route + * to our address on another net goes to loopback). + */ + if (ro->ro_rt && (ifp = ro->ro_rt->rt_ifp) && + (ifp->if_flags & IFF_LOOPBACK) == 0 && + (ia = (struct in_ifaddr *)ro->ro_rt->rt_ifa) == 0) + for (ia = in_ifaddr; ia; ia = ia->ia_next) + if (ia->ia_ifp == ifp) + break; + if (ia == 0) { + int fport = sin->sin_port; + + sin->sin_port = 0; + ia = (struct in_ifaddr *) + ifa_ifwithdstaddr((struct sockaddr *)sin); + sin->sin_port = fport; + if (ia == 0) + ia = in_iaonnetof(in_netof(sin->sin_addr)); + if (ia == 0) + ia = in_ifaddr; + if (ia == 0) return (EADDRNOTAVAIL); } - ifaddr = (struct sockaddr_in *)&ifp->if_addr; +#ifdef MULTICAST + /* + * If the destination address is multicast and an outgoing + * interface has been set as a multicast option, use the + * address of that interface as our source address. + */ + if (IN_MULTICAST(ntohl(sin->sin_addr.s_addr)) && + inp->inp_moptions != NULL) { + struct ip_moptions *imo; + + imo = inp->inp_moptions; + if (imo->imo_multicast_ifp != NULL) { + ifp = imo->imo_multicast_ifp; + for (ia = in_ifaddr; ia; ia = ia->ia_next) + if (ia->ia_ifp == ifp) + break; + if (ia == 0) + return (EADDRNOTAVAIL); + } + } +#endif + ifaddr = (struct sockaddr_in *)&ia->ia_addr; } if (in_pcblookup(inp->inp_head, sin->sin_addr, @@ -148,8 +228,11 @@ in_pcbconnect(inp, nam) inp->inp_lport, 0)) return (EADDRINUSE); - if (inp->inp_laddr.s_addr == 0) + if (inp->inp_laddr.s_addr == INADDR_ANY) { + if (inp->inp_lport == 0) + (void)in_pcbbind(inp, (struct mbuf *)0); inp->inp_laddr = ifaddr->sin_addr; + } inp->inp_faddr = sin->sin_addr; inp->inp_fport = sin->sin_port; return (0); @@ -159,7 +242,7 @@ in_pcbdisconnect(inp) struct inpcb *inp; { - inp->inp_faddr.s_addr = 0; + inp->inp_faddr.s_addr = INADDR_ANY; inp->inp_fport = 0; if (inp->inp_socket->so_state & SS_NOFDREF) in_pcbdetach(inp); @@ -172,54 +255,156 @@ in_pcbdetach(inp) so->so_pcb = 0; sofree(so); + if (inp->inp_options) + (void)m_free(inp->inp_options); if (inp->inp_route.ro_rt) rtfree(inp->inp_route.ro_rt); +#ifdef MULTICAST + ip_freemoptions(inp->inp_moptions); +#endif remque(inp); - (void) m_free(dtom(inp)); + FREE(inp, M_PCB); } in_setsockaddr(inp, nam) register struct inpcb *inp; struct mbuf *nam; { - register struct sockaddr_in *sin = mtod(nam, struct sockaddr_in *); + register struct sockaddr_in *sin; nam->m_len = sizeof (*sin); sin = mtod(nam, struct sockaddr_in *); bzero((caddr_t)sin, sizeof (*sin)); sin->sin_family = AF_INET; + sin->sin_len = sizeof(*sin); sin->sin_port = inp->inp_lport; sin->sin_addr = inp->inp_laddr; } +in_setpeeraddr(inp, nam) + struct inpcb *inp; + struct mbuf *nam; +{ + register struct sockaddr_in *sin; + + nam->m_len = sizeof (*sin); + sin = mtod(nam, struct sockaddr_in *); + bzero((caddr_t)sin, sizeof (*sin)); + sin->sin_family = AF_INET; + sin->sin_len = sizeof(*sin); + sin->sin_port = inp->inp_fport; + sin->sin_addr = inp->inp_faddr; +} + /* - * Pass an error to all internet connections - * associated with address sin. Call the - * protocol specific routine to clean up the - * mess afterwards. + * Pass some notification to all connections of a protocol + * associated with address dst. The local address and/or port numbers + * may be specified to limit the search. The "usual action" will be + * taken, depending on the ctlinput cmd. The caller must filter any + * cmds that are uninteresting (e.g., no error in the map). + * Call the protocol specific routine (if any) to report + * any errors for each matching socket. + * + * Must be called at splnet. */ -in_pcbnotify(head, dst, errno, abort) +in_pcbnotify(head, dst, fport, laddr, lport, cmd, notify) struct inpcb *head; - register struct in_addr *dst; - int errno, (*abort)(); + struct sockaddr *dst; + u_short fport, lport; + struct in_addr laddr; + int cmd, (*notify)(); { register struct inpcb *inp, *oinp; - int s = splimp(); + struct in_addr faddr; + int errno; + int in_rtchange(); + extern u_char inetctlerrmap[]; + if ((unsigned)cmd > PRC_NCMDS || dst->sa_family != AF_INET) + return; + faddr = ((struct sockaddr_in *)dst)->sin_addr; + if (faddr.s_addr == INADDR_ANY) + return; + + /* + * Redirects go to all references to the destination, + * and use in_rtchange to invalidate the route cache. + * Dead host indications: notify all references to the destination. + * Otherwise, if we have knowledge of the local port and address, + * deliver only to that socket. + */ + if (PRC_IS_REDIRECT(cmd) || cmd == PRC_HOSTDEAD) { + fport = 0; + lport = 0; + laddr.s_addr = 0; + if (cmd != PRC_HOSTDEAD) + notify = in_rtchange; + } + errno = inetctlerrmap[cmd]; for (inp = head->inp_next; inp != head;) { - if (inp->inp_faddr.s_addr != dst->s_addr) { - next: + if (inp->inp_faddr.s_addr != faddr.s_addr || + inp->inp_socket == 0 || + (lport && inp->inp_lport != lport) || + (laddr.s_addr && inp->inp_laddr.s_addr != laddr.s_addr) || + (fport && inp->inp_fport != fport)) { inp = inp->inp_next; continue; } - if (inp->inp_socket == 0) - goto next; - inp->inp_socket->so_error = errno; oinp = inp; inp = inp->inp_next; - (*abort)(oinp); + if (notify) + (*notify)(oinp, errno); + } +} + +/* + * Check for alternatives when higher level complains + * about service problems. For now, invalidate cached + * routing information. If the route was created dynamically + * (by a redirect), time to try a default gateway again. + */ +in_losing(inp) + struct inpcb *inp; +{ + register struct rtentry *rt; + struct rt_addrinfo info; + + if ((rt = inp->inp_route.ro_rt)) { + inp->inp_route.ro_rt = 0; + bzero((caddr_t)&info, sizeof(info)); + info.rti_info[RTAX_DST] = + (struct sockaddr *)&inp->inp_route.ro_dst; + info.rti_info[RTAX_GATEWAY] = rt->rt_gateway; + info.rti_info[RTAX_NETMASK] = rt_mask(rt); + rt_missmsg(RTM_LOSING, &info, rt->rt_flags, 0); + if (rt->rt_flags & RTF_DYNAMIC) + (void) rtrequest(RTM_DELETE, rt_key(rt), + rt->rt_gateway, rt_mask(rt), rt->rt_flags, + (struct rtentry **)0); + else + /* + * A new route can be allocated + * the next time output is attempted. + */ + rtfree(rt); + } +} + +/* + * After a routing change, flush old routing + * and allocate a (hopefully) better one. + */ +in_rtchange(inp) + register struct inpcb *inp; +{ + if (inp->inp_route.ro_rt) { + rtfree(inp->inp_route.ro_rt); + inp->inp_route.ro_rt = 0; + /* + * A new route can be allocated the next time + * output is attempted. + */ } - splx(s); } struct inpcb * @@ -236,23 +421,23 @@ in_pcblookup(head, faddr, fport, laddr, lport, flags) if (inp->inp_lport != lport) continue; wildcard = 0; - if (inp->inp_laddr.s_addr != 0) { - if (laddr.s_addr == 0) + if (inp->inp_laddr.s_addr != INADDR_ANY) { + if (laddr.s_addr == INADDR_ANY) wildcard++; else if (inp->inp_laddr.s_addr != laddr.s_addr) continue; } else { - if (laddr.s_addr != 0) + if (laddr.s_addr != INADDR_ANY) wildcard++; } - if (inp->inp_faddr.s_addr != 0) { - if (faddr.s_addr == 0) + if (inp->inp_faddr.s_addr != INADDR_ANY) { + if (faddr.s_addr == INADDR_ANY) wildcard++; else if (inp->inp_faddr.s_addr != faddr.s_addr || inp->inp_fport != fport) continue; } else { - if (faddr.s_addr != 0) + if (faddr.s_addr != INADDR_ANY) wildcard++; } if (wildcard && (flags & INPLOOKUP_WILDCARD) == 0)