/********************************************************************** * Copyright (c) Digital Equipment Corporation 1984, 1985, 1986. * * All Rights Reserved. * * Reference "/usr/src/COPYRIGHT" for applicable restrictions. * **********************************************************************/ /* * Copyright (c) 1982 Regents of the University of California. * All rights reserved. The Berkeley software License Agreement * specifies the terms and conditions for redistribution. * * SCCSID: @(#)in_pcb.c 3.0 4/21/86 * Based on: @(#)in_pcb.c 6.8 (Berkeley) 6/8/85 */ #include <sys/param.h> #include <sys/systm.h> #include <sys/dir.h> #include <sys/user.h> #include <sys/mbuf.h> #include <sys/socket.h> #include <sys/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 <sys/protosw.h> #include <netinet/in_var.h> struct in_addr zeroin_addr; in_pcballoc(so, head) struct socket *so; struct inpcb *head; { struct mbuf *m; register struct inpcb *inp; #ifndef pdp11 m = m_getclr(M_DONTWAIT, MT_PCB); if (m == NULL) return (ENOBUFS); inp = mtod(m, struct inpcb *); #else pdp11 MSGET(inp, struct inpcb, MT_PCB, 1, M_DONTWAIT); if (inp == NULL) return (ENOBUFS); #endif pdp11 inp->inp_head = head; inp->inp_socket = so; insque(inp, head); so->so_pcb = (caddr_t)inp; return (0); } in_pcbbind(inp, nam) register struct inpcb *inp; struct mbuf *nam; { register struct socket *so = inp->inp_socket; register struct inpcb *head = inp->inp_head; register struct sockaddr_in *sin; u_short lport = 0; #ifdef pdp11 segm map; int error; #endif pdp11 if (in_ifaddr == 0) return (EADDRNOTAVAIL); if (inp->inp_lport || inp->inp_laddr.s_addr != INADDR_ANY) return (EINVAL); if (nam == 0) goto noname; #ifdef pdp11 #define return(x) {error = x; goto bad;} saveseg5(map); #endif pdp11 sin = mtod(nam, struct sockaddr_in *); if (nam->m_len != sizeof (*sin)) return (EINVAL); if (sin->sin_addr.s_addr != INADDR_ANY) { int tport = sin->sin_port; sin->sin_port = 0; /* yech... */ if (ifa_ifwithaddr((struct sockaddr *)sin) == 0) return (EADDRNOTAVAIL); sin->sin_port = tport; } lport = sin->sin_port; if (lport) { u_short aport = ntohs(lport); int wild = 0; /* GROSS */ if (aport < IPPORT_RESERVED && u.u_uid != 0) return (EACCES); /* 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)) return (EADDRINUSE); } inp->inp_laddr = sin->sin_addr; #ifdef pdp11 #undef return restorseg5(map); #endif pdp11 noname: if (lport == 0) do { if (head->inp_lport++ < IPPORT_RESERVED) head->inp_lport = IPPORT_RESERVED; lport = htons(head->inp_lport); } while (in_pcblookup(head, zeroin_addr, 0, inp->inp_laddr, lport, 0)); inp->inp_lport = lport; return (0); #ifdef pdp11 bad: restorseg5(map); return(error); #endif pdp11 } /* * Connect from a socket to a specified address. * Both address and port must be specified in argument sin. * If don't have a local address for this socket yet, * then pick one. */ #ifndef pdp11 in_pcbconnect(inp, nam) struct inpcb *inp; struct mbuf *nam; #else pdp11 in_pcbconnect(inp, sin) struct inpcb *inp; register struct sockaddr_in *sin; #endif pdp11 { struct in_ifaddr *ia; struct sockaddr_in *ifaddr; #ifndef pdp11 register struct sockaddr_in *sin = mtod(nam, struct sockaddr_in *); if (nam->m_len != sizeof (*sin)) return (EINVAL); #endif pdp11 if (sin->sin_family != AF_INET) return (EAFNOSUPPORT); if (sin->sin_port == 0) return (EADDRNOTAVAIL); 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 == 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) { ia = (struct in_ifaddr *)ifa_ifwithnet((struct sockaddr *)sin); if (ia == (struct in_ifaddr *)0) { register struct route *ro; struct ifnet *ifp; /* * 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) { RTFREE(ro->ro_rt); ro->ro_rt = (struct rtentry *)0; } if ((ro->ro_rt == (struct rtentry *)0) || (ifp = ro->ro_rt->rt_ifp) == (struct ifnet *)0) { /* No route yet, so try to acquire one */ ro->ro_dst.sa_family = AF_INET; ((struct sockaddr_in *) &ro->ro_dst)->sin_addr = sin->sin_addr; rtalloc(ro); if (ro->ro_rt == 0) ifp = (struct ifnet *)0; else ifp = ro->ro_rt->rt_ifp; } if (ifp) { for (ia = in_ifaddr; ia; ia = ia->ia_next) if (ia->ia_ifp == ifp) break; } else ia = (struct in_ifaddr *)0; if (ia == 0) ia = in_ifaddr; if (ia == 0) return (EADDRNOTAVAIL); } ifaddr = (struct sockaddr_in *)&ia->ia_addr; } #ifndef pdp11 if (in_pcblookup(inp->inp_head, sin->sin_addr, sin->sin_port, inp->inp_laddr.s_addr ? inp->inp_laddr : ifaddr->sin_addr, inp->inp_lport, 0)) return (EADDRINUSE); #else pdp11 /* * for some reason the ritchie compiler doesn't like the above * ?: construct, so we do it this way to get things running. */ if (inp->inp_laddr.s_addr) { if (in_pcblookup(inp->inp_head, sin->sin_addr, sin->sin_port, inp->inp_laddr, inp->inp_lport, 0)) return (EADDRINUSE); } else { if (in_pcblookup(inp->inp_head, sin->sin_addr, sin->sin_port, ifaddr->sin_addr, inp->inp_lport, 0)) return (EADDRINUSE); } #endif if (inp->inp_laddr.s_addr == INADDR_ANY) { if (inp->inp_lport == 0) 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); } in_pcbdisconnect(inp) struct inpcb *inp; { inp->inp_faddr.s_addr = INADDR_ANY; inp->inp_fport = 0; if (inp->inp_socket->so_state & SS_NOFDREF) in_pcbdetach(inp); } in_pcbdetach(inp) struct inpcb *inp; { struct socket *so = inp->inp_socket; so->so_pcb = 0; sofree(so); if (inp->inp_route.ro_rt) rtfree(inp->inp_route.ro_rt); remque(inp); #ifndef pdp11 (void) m_free(dtom(inp)); #else pdp11 MSFREE(inp); #endif pdp11 } in_setsockaddr(inp, nam) register struct inpcb *inp; struct mbuf *nam; { register struct sockaddr_in *sin; #ifdef pdp11 MAPSAVE(); #endif pdp11 nam->m_len = sizeof (*sin); sin = mtod(nam, struct sockaddr_in *); bzero((caddr_t)sin, sizeof (*sin)); sin->sin_family = AF_INET; sin->sin_port = inp->inp_lport; sin->sin_addr = inp->inp_laddr; #ifdef pdp11 MAPREST(); #endif pdp11 } in_setpeeraddr(inp, nam) register struct inpcb *inp; struct mbuf *nam; { register struct sockaddr_in *sin; #ifdef pdp11 MAPSAVE(); #endif pdp11 nam->m_len = sizeof (*sin); sin = mtod(nam, struct sockaddr_in *); bzero((caddr_t)sin, sizeof (*sin)); sin->sin_family = AF_INET; sin->sin_port = inp->inp_fport; sin->sin_addr = inp->inp_faddr; #ifdef pdp11 MAPREST(); #endif pdp11 } /* * Pass some notification to all connections of a protocol * associated with address dst. Call the * protocol specific routine to handle each connection. */ in_pcbnotify(head, dst, errno, notify) struct inpcb *head; register struct in_addr *dst; int errno, (*notify)(); { register struct inpcb *inp, *oinp; int s = splimp(); for (inp = head->inp_next; inp != head;) { if (inp->inp_faddr.s_addr != dst->s_addr) { next: inp = inp->inp_next; continue; } if (inp->inp_socket == 0) goto next; if (errno) inp->inp_socket->so_error = errno; oinp = inp; inp = inp->inp_next; (*notify)(oinp); } splx(s); } /* * After a routing change, flush old routing * and allocate a (hopefully) better one. */ in_rtchange(inp) 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. */ } /* SHOULD NOTIFY HIGHER-LEVEL PROTOCOLS */ } struct inpcb * in_pcblookup(head, faddr, fport, laddr, lport, flags) struct inpcb *head; struct in_addr faddr, laddr; u_short fport, lport; int flags; { register struct inpcb *inp, *match = 0; int matchwild = 3, wildcard; for (inp = head->inp_next; inp != head; inp = inp->inp_next) { if (inp->inp_lport != lport) continue; wildcard = 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 != INADDR_ANY) wildcard++; } 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 != INADDR_ANY) wildcard++; } if (wildcard && (flags & INPLOOKUP_WILDCARD) == 0) continue; if (wildcard < matchwild) { match = inp; matchwild = wildcard; if (matchwild == 0) break; } } return (match); }