![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to in_pcb.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / netinet|
Return to in_pcb.c CVS log | Up to [Apple XNU] / XNU / bsd / netinet |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * Copyright (c) 1982, 1986, 1991, 1993, 1995
24: * The Regents of the University of California. All rights reserved.
25: *
26: * Redistribution and use in source and binary forms, with or without
27: * modification, are permitted provided that the following conditions
28: * are met:
29: * 1. Redistributions of source code must retain the above copyright
30: * notice, this list of conditions and the following disclaimer.
31: * 2. Redistributions in binary form must reproduce the above copyright
32: * notice, this list of conditions and the following disclaimer in the
33: * documentation and/or other materials provided with the distribution.
34: * 3. All advertising materials mentioning features or use of this software
35: * must display the following acknowledgement:
36: * This product includes software developed by the University of
37: * California, Berkeley and its contributors.
38: * 4. Neither the name of the University nor the names of its contributors
39: * may be used to endorse or promote products derived from this software
40: * without specific prior written permission.
41: *
42: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
43: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
44: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
45: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
46: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
47: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
48: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
49: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
50: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
51: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
52: * SUCH DAMAGE.
53: *
54: * @(#)in_pcb.c 8.4 (Berkeley) 5/24/95
55: */
56:
57: #include <sys/param.h>
58: #include <sys/systm.h>
59: #include <sys/malloc.h>
60: #include <sys/mbuf.h>
61: #include <sys/protosw.h>
62: #include <sys/socket.h>
63: #include <sys/socketvar.h>
64: #include <sys/proc.h>
65: #include <sys/kernel.h>
66: #include <sys/sysctl.h>
67:
68: #include <machine/limits.h>
69:
70: #if ISFB31
71: #include <vm/vm_zone.h>
72: #else
73: #include <kern/zalloc.h>
74: #endif
75:
76: #include <net/if.h>
77: #include <net/route.h>
78:
79: #include <netinet/in.h>
80: #include <netinet/in_pcb.h>
81: #include <netinet/in_var.h>
82: #include <netinet/ip_var.h>
83:
84: struct in_addr zeroin_addr;
85:
86: static void in_pcbremlists __P((struct inpcb *));
87: static void in_rtchange __P((struct inpcb *, int));
88:
89:
90: /*
91: * These configure the range of local port addresses assigned to
92: * "unspecified" outgoing connections/packets/whatever.
93: */
94: static int ipport_lowfirstauto = IPPORT_RESERVED - 1; /* 1023 */
95: static int ipport_lowlastauto = IPPORT_RESERVEDSTART; /* 600 */
96: static int ipport_firstauto = IPPORT_RESERVED; /* 1024 */
97: static int ipport_lastauto = IPPORT_USERRESERVED; /* 5000 */
98: static int ipport_hifirstauto = IPPORT_HIFIRSTAUTO; /* 49152 */
99: static int ipport_hilastauto = IPPORT_HILASTAUTO; /* 65535 */
100:
101: #define RANGECHK(var, min, max) \
102: if ((var) < (min)) { (var) = (min); } \
103: else if ((var) > (max)) { (var) = (max); }
104:
105:
106: static int
107: sysctl_net_ipport_check SYSCTL_HANDLER_ARGS
108: {
109: int error = sysctl_handle_int(oidp,
110: oidp->oid_arg1, oidp->oid_arg2, req);
111: if (!error) {
112: RANGECHK(ipport_lowfirstauto, 1, IPPORT_RESERVED - 1);
113: RANGECHK(ipport_lowlastauto, 1, IPPORT_RESERVED - 1);
114: RANGECHK(ipport_firstauto, IPPORT_RESERVED, USHRT_MAX);
115: RANGECHK(ipport_lastauto, IPPORT_RESERVED, USHRT_MAX);
116: RANGECHK(ipport_hifirstauto, IPPORT_RESERVED, USHRT_MAX);
117: RANGECHK(ipport_hilastauto, IPPORT_RESERVED, USHRT_MAX);
118: }
119: return error;
120: }
121:
122: #undef RANGECHK
123:
124: SYSCTL_NODE(_net_inet_ip, IPPROTO_IP, portrange, CTLFLAG_RW, 0, "IP Ports");
125:
126: SYSCTL_PROC(_net_inet_ip_portrange, OID_AUTO, lowfirst, CTLTYPE_INT|CTLFLAG_RW,
127: &ipport_lowfirstauto, 0, &sysctl_net_ipport_check, "I", "");
128: SYSCTL_PROC(_net_inet_ip_portrange, OID_AUTO, lowlast, CTLTYPE_INT|CTLFLAG_RW,
129: &ipport_lowlastauto, 0, &sysctl_net_ipport_check, "I", "");
130: SYSCTL_PROC(_net_inet_ip_portrange, OID_AUTO, first, CTLTYPE_INT|CTLFLAG_RW,
131: &ipport_firstauto, 0, &sysctl_net_ipport_check, "I", "");
132: SYSCTL_PROC(_net_inet_ip_portrange, OID_AUTO, last, CTLTYPE_INT|CTLFLAG_RW,
133: &ipport_lastauto, 0, &sysctl_net_ipport_check, "I", "");
134: SYSCTL_PROC(_net_inet_ip_portrange, OID_AUTO, hifirst, CTLTYPE_INT|CTLFLAG_RW,
135: &ipport_hifirstauto, 0, &sysctl_net_ipport_check, "I", "");
136: SYSCTL_PROC(_net_inet_ip_portrange, OID_AUTO, hilast, CTLTYPE_INT|CTLFLAG_RW,
137: &ipport_hilastauto, 0, &sysctl_net_ipport_check, "I", "");
138:
139: /*
140: * in_pcb.c: manage the Protocol Control Blocks.
141: *
142: * NOTE: It is assumed that most of these functions will be called at
143: * splnet(). XXX - There are, unfortunately, a few exceptions to this
144: * rule that should be fixed.
145: */
146:
147: /*
148: * Allocate a PCB and associate it with the socket.
149: */
150: int
151: in_pcballoc(so, pcbinfo, p)
152: struct socket *so;
153: struct inpcbinfo *pcbinfo;
154: struct proc *p;
155: {
156: register struct inpcb *inp;
157:
158: inp = (struct inpcb *) zalloc(pcbinfo->ipi_zone);
159: if (inp == NULL)
160: return (ENOBUFS);
161: bzero((caddr_t)inp, sizeof(*inp));
162: inp->inp_gencnt = ++pcbinfo->ipi_gencnt;
163: inp->inp_pcbinfo = pcbinfo;
164: inp->inp_socket = so;
165: LIST_INSERT_HEAD(pcbinfo->listhead, inp, inp_list);
166: pcbinfo->ipi_count++;
167: so->so_pcb = (caddr_t)inp;
168: return (0);
169: }
170:
171: int
172: in_pcbbind(inp, nam, p)
173: register struct inpcb *inp;
174: struct sockaddr *nam;
175: struct proc *p;
176: {
177: register struct socket *so = inp->inp_socket;
178: u_short *lastport;
179: struct sockaddr_in *sin;
180: struct inpcbinfo *pcbinfo = inp->inp_pcbinfo;
181: u_short lport = 0;
182: int wild = 0, reuseport = (so->so_options & SO_REUSEPORT);
183: int error;
184:
185: if (TAILQ_EMPTY(&in_ifaddrhead)) /* XXX broken! */
186: return (EADDRNOTAVAIL);
187: if (inp->inp_lport || inp->inp_laddr.s_addr != INADDR_ANY)
188: return (EINVAL);
189: if ((so->so_options & (SO_REUSEADDR|SO_REUSEPORT)) == 0)
190: wild = 1;
191: if (nam) {
192: sin = (struct sockaddr_in *)nam;
193: if (nam->sa_len != sizeof (*sin))
194: return (EINVAL);
195: #ifdef notdef
196: /*
197: * We should check the family, but old programs
198: * incorrectly fail to initialize it.
199: */
200: if (sin->sin_family != AF_INET)
201: return (EAFNOSUPPORT);
202: #endif
203: lport = sin->sin_port;
204: if (IN_MULTICAST(ntohl(sin->sin_addr.s_addr))) {
205: /*
206: * Treat SO_REUSEADDR as SO_REUSEPORT for multicast;
207: * allow complete duplication of binding if
208: * SO_REUSEPORT is set, or if SO_REUSEADDR is set
209: * and a multicast address is bound on both
210: * new and duplicated sockets.
211: */
212: if (so->so_options & SO_REUSEADDR)
213: reuseport = SO_REUSEADDR|SO_REUSEPORT;
214: } else if (sin->sin_addr.s_addr != INADDR_ANY) {
215: sin->sin_port = 0; /* yech... */
216: if (ifa_ifwithaddr((struct sockaddr *)sin) == 0)
217: return (EADDRNOTAVAIL);
218: }
219: if (lport) {
220: struct inpcb *t;
221:
222: /* GROSS */
223: if (ntohs(lport) < IPPORT_RESERVED && p &&
224: suser(p->p_ucred, &p->p_acflag))
225: return (EACCES);
226: if (so->so_uid &&
227: !IN_MULTICAST(ntohl(sin->sin_addr.s_addr))) {
228: t = in_pcblookup_local(inp->inp_pcbinfo,
229: sin->sin_addr, lport, INPLOOKUP_WILDCARD);
230: if (t &&
231: (ntohl(sin->sin_addr.s_addr) != INADDR_ANY ||
232: ntohl(t->inp_laddr.s_addr) != INADDR_ANY ||
233: (t->inp_socket->so_options &
234: SO_REUSEPORT) == 0) &&
235: (so->so_uid != t->inp_socket->so_uid))
236: return (EADDRINUSE);
237: }
238: t = in_pcblookup_local(pcbinfo, sin->sin_addr,
239: lport, wild);
240: if (t && (reuseport & t->inp_socket->so_options) == 0)
241: return (EADDRINUSE);
242: }
243: inp->inp_laddr = sin->sin_addr;
244: }
245: if (lport == 0) {
246: u_short first, last;
247: int count;
248:
249: inp->inp_flags |= INP_ANONPORT;
250:
251: if (inp->inp_flags & INP_HIGHPORT) {
252: first = ipport_hifirstauto; /* sysctl */
253: last = ipport_hilastauto;
254: lastport = &pcbinfo->lasthi;
255: } else if (inp->inp_flags & INP_LOWPORT) {
256: if (p && (error = suser(p->p_ucred, &p->p_acflag)))
257: return error;
258: first = ipport_lowfirstauto; /* 1023 */
259: last = ipport_lowlastauto; /* 600 */
260: lastport = &pcbinfo->lastlow;
261: } else {
262: first = ipport_firstauto; /* sysctl */
263: last = ipport_lastauto;
264: lastport = &pcbinfo->lastport;
265: }
266: /*
267: * Simple check to ensure all ports are not used up causing
268: * a deadlock here.
269: *
270: * We split the two cases (up and down) so that the direction
271: * is not being tested on each round of the loop.
272: */
273: if (first > last) {
274: /*
275: * counting down
276: */
277: count = first - last;
278:
279: do {
280: if (count-- < 0) { /* completely used? */
281: /*
282: * Undo any address bind that may have
283: * occurred above.
284: */
285: inp->inp_laddr.s_addr = INADDR_ANY;
286: return (EAGAIN);
287: }
288: --*lastport;
289: if (*lastport > first || *lastport < last)
290: *lastport = first;
291: lport = htons(*lastport);
292: } while (in_pcblookup_local(pcbinfo,
293: inp->inp_laddr, lport, wild));
294: } else {
295: /*
296: * counting up
297: */
298: count = last - first;
299:
300: do {
301: if (count-- < 0) { /* completely used? */
302: /*
303: * Undo any address bind that may have
304: * occurred above.
305: */
306: inp->inp_laddr.s_addr = INADDR_ANY;
307: return (EAGAIN);
308: }
309: ++*lastport;
310: if (*lastport < first || *lastport > last)
311: *lastport = first;
312: lport = htons(*lastport);
313: } while (in_pcblookup_local(pcbinfo,
314: inp->inp_laddr, lport, wild));
315: }
316: }
317: inp->inp_lport = lport;
318: if (in_pcbinshash(inp) != 0) {
319: inp->inp_laddr.s_addr = INADDR_ANY;
320: inp->inp_lport = 0;
321: return (EAGAIN);
322: }
323: return (0);
324: }
325:
326: /*
327: * Transform old in_pcbconnect() into an inner subroutine for new
328: * in_pcbconnect(): Do some validity-checking on the remote
329: * address (in mbuf 'nam') and then determine local host address
330: * (i.e., which interface) to use to access that remote host.
331: *
332: * This preserves definition of in_pcbconnect(), while supporting a
333: * slightly different version for T/TCP. (This is more than
334: * a bit of a kludge, but cleaning up the internal interfaces would
335: * have forced minor changes in every protocol).
336: */
337:
338: int
339: in_pcbladdr(inp, nam, plocal_sin)
340: register struct inpcb *inp;
341: struct sockaddr *nam;
342: struct sockaddr_in **plocal_sin;
343: {
344: struct in_ifaddr *ia;
345: register struct sockaddr_in *sin = (struct sockaddr_in *)nam;
346:
347: if (nam->sa_len != sizeof (*sin))
348: return (EINVAL);
349: if (sin->sin_family != AF_INET)
350: return (EAFNOSUPPORT);
351: if (sin->sin_port == 0)
352: return (EADDRNOTAVAIL);
353: if (!TAILQ_EMPTY(&in_ifaddrhead)) {
354: /*
355: * If the destination address is INADDR_ANY,
356: * use the primary local address.
357: * If the supplied address is INADDR_BROADCAST,
358: * and the primary interface supports broadcast,
359: * choose the broadcast address for that interface.
360: */
361: #define satosin(sa) ((struct sockaddr_in *)(sa))
362: #define sintosa(sin) ((struct sockaddr *)(sin))
363: #define ifatoia(ifa) ((struct in_ifaddr *)(ifa))
364: if (sin->sin_addr.s_addr == INADDR_ANY)
365: sin->sin_addr = IA_SIN(in_ifaddrhead.tqh_first)->sin_addr;
366: else if (sin->sin_addr.s_addr == (u_long)INADDR_BROADCAST &&
367: (in_ifaddrhead.tqh_first->ia_ifp->if_flags & IFF_BROADCAST))
368: sin->sin_addr = satosin(&in_ifaddrhead.tqh_first->ia_broadaddr)->sin_addr;
369: }
370: if (inp->inp_laddr.s_addr == INADDR_ANY) {
371: register struct route *ro;
372:
373: ia = (struct in_ifaddr *)0;
374: /*
375: * If route is known or can be allocated now,
376: * our src addr is taken from the i/f, else punt.
377: */
378: ro = &inp->inp_route;
379: if (ro->ro_rt &&
380: (satosin(&ro->ro_dst)->sin_addr.s_addr !=
381: sin->sin_addr.s_addr ||
382: inp->inp_socket->so_options & SO_DONTROUTE)) {
383: RTFREE(ro->ro_rt);
384: ro->ro_rt = (struct rtentry *)0;
385: }
386: if ((inp->inp_socket->so_options & SO_DONTROUTE) == 0 && /*XXX*/
387: (ro->ro_rt == (struct rtentry *)0 ||
388: ro->ro_rt->rt_ifp == (struct ifnet *)0)) {
389: /* No route yet, so try to acquire one */
390: ro->ro_dst.sa_family = AF_INET;
391: ro->ro_dst.sa_len = sizeof(struct sockaddr_in);
392: ((struct sockaddr_in *) &ro->ro_dst)->sin_addr =
393: sin->sin_addr;
394: rtalloc(ro);
395: }
396: /*
397: * If we found a route, use the address
398: * corresponding to the outgoing interface
399: * unless it is the loopback (in case a route
400: * to our address on another net goes to loopback).
401: */
402: if (ro->ro_rt && !(ro->ro_rt->rt_ifp->if_flags & IFF_LOOPBACK))
403: ia = ifatoia(ro->ro_rt->rt_ifa);
404: if (ia == 0) {
405: u_short fport = sin->sin_port;
406:
407: sin->sin_port = 0;
408: ia = ifatoia(ifa_ifwithdstaddr(sintosa(sin)));
409: if (ia == 0)
410: ia = ifatoia(ifa_ifwithnet(sintosa(sin)));
411: sin->sin_port = fport;
412: if (ia == 0)
413: ia = in_ifaddrhead.tqh_first;
414: if (ia == 0)
415: return (EADDRNOTAVAIL);
416: }
417: /*
418: * If the destination address is multicast and an outgoing
419: * interface has been set as a multicast option, use the
420: * address of that interface as our source address.
421: */
422: if (IN_MULTICAST(ntohl(sin->sin_addr.s_addr)) &&
423: inp->inp_moptions != NULL) {
424: struct ip_moptions *imo;
425: struct ifnet *ifp;
426:
427: imo = inp->inp_moptions;
428: if (imo->imo_multicast_ifp != NULL) {
429: ifp = imo->imo_multicast_ifp;
430: for (ia = in_ifaddrhead.tqh_first; ia;
431: ia = ia->ia_link.tqe_next)
432: if (ia->ia_ifp == ifp)
433: break;
434: if (ia == 0)
435: return (EADDRNOTAVAIL);
436: }
437: }
438: /*
439: * Don't do pcblookup call here; return interface in plocal_sin
440: * and exit to caller, that will do the lookup.
441: */
442: *plocal_sin = &ia->ia_addr;
443:
444: }
445: return(0);
446: }
447:
448: /*
449: * Outer subroutine:
450: * Connect from a socket to a specified address.
451: * Both address and port must be specified in argument sin.
452: * If don't have a local address for this socket yet,
453: * then pick one.
454: */
455: int
456: in_pcbconnect(inp, nam, p)
457: register struct inpcb *inp;
458: struct sockaddr *nam;
459: struct proc *p;
460: {
461: struct sockaddr_in *ifaddr;
462: register struct sockaddr_in *sin = (struct sockaddr_in *)nam;
463: int error;
464:
465: /*
466: * Call inner routine, to assign local interface address.
467: */
468: if ((error = in_pcbladdr(inp, nam, &ifaddr)) != 0)
469: return(error);
470:
471: if (in_pcblookup_hash(inp->inp_pcbinfo, sin->sin_addr, sin->sin_port,
472: inp->inp_laddr.s_addr ? inp->inp_laddr : ifaddr->sin_addr,
473: inp->inp_lport, 0) != NULL) {
474: return (EADDRINUSE);
475: }
476: if (inp->inp_laddr.s_addr == INADDR_ANY) {
477: if (inp->inp_lport == 0)
478: (void)in_pcbbind(inp, (struct sockaddr *)0, p);
479: inp->inp_laddr = ifaddr->sin_addr;
480: }
481: inp->inp_faddr = sin->sin_addr;
482: inp->inp_fport = sin->sin_port;
483: in_pcbrehash(inp);
484: return (0);
485: }
486:
487: void
488: in_pcbdisconnect(inp)
489: struct inpcb *inp;
490: {
491:
492: inp->inp_faddr.s_addr = INADDR_ANY;
493: inp->inp_fport = 0;
494: in_pcbrehash(inp);
495: if (inp->inp_socket->so_state & SS_NOFDREF)
496: in_pcbdetach(inp);
497: }
498:
499: void
500: in_pcbdetach(inp)
501: struct inpcb *inp;
502: {
503: struct socket *so = inp->inp_socket;
504: struct inpcbinfo *ipi = inp->inp_pcbinfo;
505:
506: inp->inp_gencnt = ++ipi->ipi_gencnt;
507: in_pcbremlists(inp);
508: so->so_pcb = 0;
509: sofree(so);
510: if (inp->inp_options)
511: (void)m_free(inp->inp_options);
512: if (inp->inp_route.ro_rt)
513: rtfree(inp->inp_route.ro_rt);
514: ip_freemoptions(inp->inp_moptions);
515: zfree(ipi->ipi_zone, (vm_offset_t) inp);
516: }
517:
518: /*
519: * The calling convention of in_setsockaddr() and in_setpeeraddr() was
520: * modified to match the pru_sockaddr() and pru_peeraddr() entry points
521: * in struct pr_usrreqs, so that protocols can just reference then directly
522: * without the need for a wrapper function. The socket must have a valid
523: * (i.e., non-nil) PCB, but it should be impossible to get an invalid one
524: * except through a kernel programming error, so it is acceptable to panic
525: * (or in this case trap) if the PCB is invalid. (Actually, we don't trap
526: * because there actually /is/ a programming error somewhere... XXX)
527: */
528: int
529: in_setsockaddr(so, nam)
530: struct socket *so;
531: struct sockaddr **nam;
532: {
533: int s;
534: register struct inpcb *inp;
535: register struct sockaddr_in *sin;
536:
537: /*
538: * Do the malloc first in case it blocks.
539: */
540: MALLOC(sin, struct sockaddr_in *, sizeof *sin, M_SONAME, M_WAITOK);
541: bzero(sin, sizeof *sin);
542: sin->sin_family = AF_INET;
543: sin->sin_len = sizeof(*sin);
544:
545: s = splnet();
546: inp = sotoinpcb(so);
547: if (!inp) {
548: splx(s);
549: FREE(sin, M_SONAME);
550: return EINVAL;
551: }
552: sin->sin_port = inp->inp_lport;
553: sin->sin_addr = inp->inp_laddr;
554: splx(s);
555:
556: *nam = (struct sockaddr *)sin;
557: return 0;
558: }
559:
560: int
561: in_setpeeraddr(so, nam)
562: struct socket *so;
563: struct sockaddr **nam;
564: {
565: int s;
566: struct inpcb *inp;
567: register struct sockaddr_in *sin;
568:
569: /*
570: * Do the malloc first in case it blocks.
571: */
572: MALLOC(sin, struct sockaddr_in *, sizeof *sin, M_SONAME, M_WAITOK);
573: bzero((caddr_t)sin, sizeof (*sin));
574: sin->sin_family = AF_INET;
575: sin->sin_len = sizeof(*sin);
576:
577: s = splnet();
578: inp = sotoinpcb(so);
579: if (!inp) {
580: splx(s);
581: FREE(sin, M_SONAME);
582: return EINVAL;
583: }
584: sin->sin_port = inp->inp_fport;
585: sin->sin_addr = inp->inp_faddr;
586: splx(s);
587:
588: *nam = (struct sockaddr *)sin;
589: return 0;
590: }
591:
592: /*
593: * Pass some notification to all connections of a protocol
594: * associated with address dst. The local address and/or port numbers
595: * may be specified to limit the search. The "usual action" will be
596: * taken, depending on the ctlinput cmd. The caller must filter any
597: * cmds that are uninteresting (e.g., no error in the map).
598: * Call the protocol specific routine (if any) to report
599: * any errors for each matching socket.
600: */
601: void
602: in_pcbnotify(head, dst, fport_arg, laddr, lport_arg, cmd, notify)
603: struct inpcbhead *head;
604: struct sockaddr *dst;
605: u_int fport_arg, lport_arg;
606: struct in_addr laddr;
607: int cmd;
608: void (*notify) __P((struct inpcb *, int));
609: {
610: register struct inpcb *inp, *oinp;
611: struct in_addr faddr;
612: u_short fport = fport_arg, lport = lport_arg;
613: int errno, s;
614:
615: if ((unsigned)cmd > PRC_NCMDS || dst->sa_family != AF_INET)
616: return;
617: faddr = ((struct sockaddr_in *)dst)->sin_addr;
618: if (faddr.s_addr == INADDR_ANY)
619: return;
620:
621: /*
622: * Redirects go to all references to the destination,
623: * and use in_rtchange to invalidate the route cache.
624: * Dead host indications: notify all references to the destination.
625: * Otherwise, if we have knowledge of the local port and address,
626: * deliver only to that socket.
627: */
628: if (PRC_IS_REDIRECT(cmd) || cmd == PRC_HOSTDEAD) {
629: fport = 0;
630: lport = 0;
631: laddr.s_addr = 0;
632: if (cmd != PRC_HOSTDEAD)
633: notify = in_rtchange;
634: }
635: errno = inetctlerrmap[cmd];
636: s = splnet();
637: for (inp = head->lh_first; inp != NULL;) {
638: if (inp->inp_faddr.s_addr != faddr.s_addr ||
639: inp->inp_socket == 0 ||
640: (lport && inp->inp_lport != lport) ||
641: (laddr.s_addr && inp->inp_laddr.s_addr != laddr.s_addr) ||
642: (fport && inp->inp_fport != fport)) {
643: inp = inp->inp_list.le_next;
644: continue;
645: }
646: oinp = inp;
647: inp = inp->inp_list.le_next;
648: if (notify)
649: (*notify)(oinp, errno);
650: }
651: splx(s);
652: }
653:
654: /*
655: * Check for alternatives when higher level complains
656: * about service problems. For now, invalidate cached
657: * routing information. If the route was created dynamically
658: * (by a redirect), time to try a default gateway again.
659: */
660: void
661: in_losing(inp)
662: struct inpcb *inp;
663: {
664: register struct rtentry *rt;
665: struct rt_addrinfo info;
666:
667: if ((rt = inp->inp_route.ro_rt)) {
668: inp->inp_route.ro_rt = 0;
669: bzero((caddr_t)&info, sizeof(info));
670: info.rti_info[RTAX_DST] =
671: (struct sockaddr *)&inp->inp_route.ro_dst;
672: info.rti_info[RTAX_GATEWAY] = rt->rt_gateway;
673: info.rti_info[RTAX_NETMASK] = rt_mask(rt);
674: rt_missmsg(RTM_LOSING, &info, rt->rt_flags, 0);
675: if (rt->rt_flags & RTF_DYNAMIC)
676: (void) rtrequest(RTM_DELETE, rt_key(rt),
677: rt->rt_gateway, rt_mask(rt), rt->rt_flags,
678: (struct rtentry **)0);
679: else
680: /*
681: * A new route can be allocated
682: * the next time output is attempted.
683: */
684: rtfree(rt);
685: }
686: }
687:
688: /*
689: * After a routing change, flush old routing
690: * and allocate a (hopefully) better one.
691: */
692: static void
693: in_rtchange(inp, errno)
694: register struct inpcb *inp;
695: int errno;
696: {
697: if (inp->inp_route.ro_rt) {
698: rtfree(inp->inp_route.ro_rt);
699: inp->inp_route.ro_rt = 0;
700: /*
701: * A new route can be allocated the next time
702: * output is attempted.
703: */
704: }
705: }
706:
707: /*
708: * Lookup a PCB based on the local address and port.
709: */
710: struct inpcb *
711: in_pcblookup_local(pcbinfo, laddr, lport_arg, wild_okay)
712: struct inpcbinfo *pcbinfo;
713: struct in_addr laddr;
714: u_int lport_arg;
715: int wild_okay;
716: {
717: register struct inpcb *inp;
718: int matchwild = 3, wildcard;
719: u_short lport = lport_arg;
720:
721: if (!wild_okay) {
722: struct inpcbhead *head;
723: /*
724: * Look for an unconnected (wildcard foreign addr) PCB that
725: * matches the local address and port we're looking for.
726: */
727: head = &pcbinfo->hashbase[INP_PCBHASH(INADDR_ANY, lport, 0, pcbinfo->hashmask)];
728: for (inp = head->lh_first; inp != NULL; inp = inp->inp_hash.le_next) {
729: if (inp->inp_faddr.s_addr == INADDR_ANY &&
730: inp->inp_laddr.s_addr == laddr.s_addr &&
731: inp->inp_lport == lport) {
732: /*
733: * Found.
734: */
735: return (inp);
736: }
737: }
738: /*
739: * Not found.
740: */
741: return (NULL);
742: } else {
743: struct inpcbporthead *porthash;
744: struct inpcbport *phd;
745: struct inpcb *match = NULL;
746: /*
747: * Best fit PCB lookup.
748: *
749: * First see if this local port is in use by looking on the
750: * port hash list.
751: */
752: porthash = &pcbinfo->porthashbase[INP_PCBPORTHASH(lport,
753: pcbinfo->porthashmask)];
754: for (phd = porthash->lh_first; phd != NULL; phd = phd->phd_hash.le_next) {
755: if (phd->phd_port == lport)
756: break;
757: }
758: if (phd != NULL) {
759: /*
760: * Port is in use by one or more PCBs. Look for best
761: * fit.
762: */
763: for (inp = phd->phd_pcblist.lh_first; inp != NULL;
764: inp = inp->inp_portlist.le_next) {
765: wildcard = 0;
766: if (inp->inp_faddr.s_addr != INADDR_ANY)
767: wildcard++;
768: if (inp->inp_laddr.s_addr != INADDR_ANY) {
769: if (laddr.s_addr == INADDR_ANY)
770: wildcard++;
771: else if (inp->inp_laddr.s_addr != laddr.s_addr)
772: continue;
773: } else {
774: if (laddr.s_addr != INADDR_ANY)
775: wildcard++;
776: }
777: if (wildcard < matchwild) {
778: match = inp;
779: matchwild = wildcard;
780: if (matchwild == 0) {
781: break;
782: }
783: }
784: }
785: }
786: return (match);
787: }
788: }
789:
790: /*
791: * Lookup PCB in hash list.
792: */
793: struct inpcb *
794: in_pcblookup_hash(pcbinfo, faddr, fport_arg, laddr, lport_arg, wildcard)
795: struct inpcbinfo *pcbinfo;
796: struct in_addr faddr, laddr;
797: u_int fport_arg, lport_arg;
798: int wildcard;
799: {
800: struct inpcbhead *head;
801: register struct inpcb *inp;
802: u_short fport = fport_arg, lport = lport_arg;
803:
804: /*
805: * We may have found the pcb in the last lookup - check this first.
806: */
807:
808: if ((!IN_MULTICAST(laddr.s_addr)) && (pcbinfo->last_pcb)) {
809: if (faddr.s_addr == pcbinfo->last_pcb->inp_faddr.s_addr &&
810: laddr.s_addr == pcbinfo->last_pcb->inp_laddr.s_addr &&
811: fport_arg == pcbinfo->last_pcb->inp_fport &&
812: lport_arg == pcbinfo->last_pcb->inp_lport) {
813: /*
814: * Found.
815: */
816: return (pcbinfo->last_pcb);
817: }
818:
819: pcbinfo->last_pcb = 0;
820: }
821:
822: /*
823: * First look for an exact match.
824: */
825: head = &pcbinfo->hashbase[INP_PCBHASH(faddr.s_addr, lport, fport, pcbinfo->hashmask)];
826: for (inp = head->lh_first; inp != NULL; inp = inp->inp_hash.le_next) {
827: if (inp->inp_faddr.s_addr == faddr.s_addr &&
828: inp->inp_laddr.s_addr == laddr.s_addr &&
829: inp->inp_fport == fport &&
830: inp->inp_lport == lport) {
831: /*
832: * Found.
833: */
834: return (inp);
835: }
836: }
837: if (wildcard) {
838: struct inpcb *local_wild = NULL;
839:
840: head = &pcbinfo->hashbase[INP_PCBHASH(INADDR_ANY, lport, 0, pcbinfo->hashmask)];
841: for (inp = head->lh_first; inp != NULL; inp = inp->inp_hash.le_next) {
842: if (inp->inp_faddr.s_addr == INADDR_ANY &&
843: inp->inp_lport == lport) {
844: if (inp->inp_laddr.s_addr == laddr.s_addr)
845: return (inp);
846: else if (inp->inp_laddr.s_addr == INADDR_ANY)
847: local_wild = inp;
848: }
849: }
850: return (local_wild);
851: }
852:
853: /*
854: * Not found.
855: */
856: return (NULL);
857: }
858:
859: /*
860: * Insert PCB onto various hash lists.
861: */
862: int
863: in_pcbinshash(inp)
864: struct inpcb *inp;
865: {
866: struct inpcbhead *pcbhash;
867: struct inpcbporthead *pcbporthash;
868: struct inpcbinfo *pcbinfo = inp->inp_pcbinfo;
869: struct inpcbport *phd;
870:
871: pcbhash = &pcbinfo->hashbase[INP_PCBHASH(inp->inp_faddr.s_addr,
872: inp->inp_lport, inp->inp_fport, pcbinfo->hashmask)];
873:
874: pcbporthash = &pcbinfo->porthashbase[INP_PCBPORTHASH(inp->inp_lport,
875: pcbinfo->porthashmask)];
876:
877: /*
878: * Go through port list and look for a head for this lport.
879: */
880: for (phd = pcbporthash->lh_first; phd != NULL; phd = phd->phd_hash.le_next) {
881: if (phd->phd_port == inp->inp_lport)
882: break;
883: }
884: /*
885: * If none exists, malloc one and tack it on.
886: */
887: if (phd == NULL) {
888: MALLOC(phd, struct inpcbport *, sizeof(struct inpcbport), M_PCB, M_NOWAIT);
889: if (phd == NULL) {
890: return (ENOBUFS); /* XXX */
891: }
892: phd->phd_port = inp->inp_lport;
893: LIST_INIT(&phd->phd_pcblist);
894: LIST_INSERT_HEAD(pcbporthash, phd, phd_hash);
895: }
896: inp->inp_phd = phd;
897: LIST_INSERT_HEAD(&phd->phd_pcblist, inp, inp_portlist);
898: LIST_INSERT_HEAD(pcbhash, inp, inp_hash);
899: return (0);
900: }
901:
902: /*
903: * Move PCB to the proper hash bucket when { faddr, fport } have been
904: * changed. NOTE: This does not handle the case of the lport changing (the
905: * hashed port list would have to be updated as well), so the lport must
906: * not change after in_pcbinshash() has been called.
907: */
908: void
909: in_pcbrehash(inp)
910: struct inpcb *inp;
911: {
912: struct inpcbhead *head;
913:
914: head = &inp->inp_pcbinfo->hashbase[INP_PCBHASH(inp->inp_faddr.s_addr,
915: inp->inp_lport, inp->inp_fport, inp->inp_pcbinfo->hashmask)];
916:
917: if (inp == inp->inp_pcbinfo->last_pcb)
918: inp->inp_pcbinfo->last_pcb = 0;
919:
920: LIST_REMOVE(inp, inp_hash);
921: LIST_INSERT_HEAD(head, inp, inp_hash);
922: }
923:
924: /*
925: * Remove PCB from various lists.
926: */
927: static void
928: in_pcbremlists(inp)
929: struct inpcb *inp;
930: {
931: inp->inp_gencnt = ++inp->inp_pcbinfo->ipi_gencnt;
932: if (inp == inp->inp_pcbinfo->last_pcb)
933: inp->inp_pcbinfo->last_pcb = 0;
934:
935: if (inp->inp_lport) {
936: struct inpcbport *phd = inp->inp_phd;
937:
938: LIST_REMOVE(inp, inp_hash);
939: LIST_REMOVE(inp, inp_portlist);
940: if (phd->phd_pcblist.lh_first == NULL) {
941: LIST_REMOVE(phd, phd_hash);
942: FREE(phd, M_PCB);
943: }
944: }
945:
946: LIST_REMOVE(inp, inp_list);
947: inp->inp_pcbinfo->ipi_count--;
948: }
949:
950: int
951: in_pcb_grab_port __P((struct inpcbinfo *pcbinfo,
952: u_short options,
953: struct in_addr laddr,
954: u_short *lport,
955: struct in_addr faddr,
956: u_short fport,
957: u_int cookie,
958: u_char owner_id))
959: {
960: struct inpcb *pcb;
961: struct sockaddr_in sin;
962: struct proc *p = current_proc();
963: int stat;
964:
965:
966: pcbinfo->nat_dummy_socket.so_pcb = 0;
967: pcbinfo->nat_dummy_socket.so_options = 0;
968: if (*lport) {
969: /* The grabber wants a particular port */
970:
971: if (faddr.s_addr || fport) {
972: /*
973: * This is either the second half of an active connect, or
974: * it's from the acceptance of an incoming connection.
975: */
976: if (laddr.s_addr == 0) {
977: return EINVAL;
978: }
979:
980: if (in_pcblookup_hash(pcbinfo, faddr, fport,
981: laddr, *lport, 0) != NULL) {
982: if (!(IN_MULTICAST(ntohl(laddr.s_addr)))) {
983: return (EADDRINUSE);
984: }
985: }
986:
987: in_pcballoc(&pcbinfo->nat_dummy_socket, pcbinfo, p);
988: pcb = sotoinpcb(&pcbinfo->nat_dummy_socket);
989: pcb->inp_lport = *lport;
990: pcb->inp_laddr.s_addr = laddr.s_addr;
991:
992: pcb->inp_faddr = faddr;
993: pcb->inp_fport = fport;
994: in_pcbinshash(pcb);
995: }
996: else {
997: /*
998: * This is either a bind for a passive socket, or it's the
999: * first part of bind-connect sequence (not likely since an
1000: * ephemeral port is usually used in this case). Or, it's
1001: * the result of a connection acceptance when the foreign
1002: * address/port cannot be provided (which requires the SO_REUSEADDR
1003: * flag if laddr is not multicast).
1004: */
1005:
1006: in_pcballoc(&pcbinfo->nat_dummy_socket, pcbinfo, p);
1007: pcb = sotoinpcb(&pcbinfo->nat_dummy_socket);
1008:
1009: pcbinfo->nat_dummy_socket.so_options = options;
1010: bzero(&sin, sizeof(struct sockaddr_in));
1011: sin.sin_len = sizeof(struct sockaddr_in);
1012: sin.sin_family = AF_INET;
1013: sin.sin_addr.s_addr = laddr.s_addr;
1014: sin.sin_port = *lport;
1015:
1016: stat = in_pcbbind((struct inpcb *) pcbinfo->nat_dummy_socket.so_pcb,
1017: (struct sockaddr *) &sin, p);
1018: if (stat) {
1019: in_pcbdetach(pcb);
1020: return stat;
1021: }
1022: }
1023: }
1024: else {
1025: /* The grabber wants an ephemeral port */
1026:
1027: in_pcballoc(&pcbinfo->nat_dummy_socket, pcbinfo, p);
1028: pcb = sotoinpcb(&pcbinfo->nat_dummy_socket);
1029:
1030: bzero(&sin, sizeof(struct sockaddr_in));
1031: sin.sin_len = sizeof(struct sockaddr_in);
1032: sin.sin_family = AF_INET;
1033: sin.sin_addr.s_addr = laddr.s_addr;
1034: sin.sin_port = 0;
1035:
1036: if (faddr.s_addr || fport) {
1037: /*
1038: * Not sure if this case will be used - could occur when connect
1039: * is called, skipping the bind.
1040: */
1041:
1042: if (laddr.s_addr == 0) {
1043: in_pcbdetach(pcb);
1044: return EINVAL;
1045: }
1046:
1047: stat = in_pcbbind((struct inpcb *) pcbinfo->nat_dummy_socket.so_pcb,
1048: (struct sockaddr *) &sin, p);
1049: if (stat) {
1050: in_pcbdetach(pcb);
1051: return stat;
1052: }
1053:
1054: if (in_pcblookup_hash(pcbinfo, faddr, fport,
1055: pcb->inp_laddr, pcb->inp_lport, 0) != NULL) {
1056: in_pcbdetach(pcb);
1057: return (EADDRINUSE);
1058: }
1059:
1060: pcb->inp_faddr = faddr;
1061: pcb->inp_fport = fport;
1062: in_pcbrehash(pcb);
1063: }
1064: else {
1065: /*
1066: * This is a simple bind of an ephemeral port. The local addr
1067: * may or may not be defined.
1068: */
1069:
1070: stat = in_pcbbind((struct inpcb *) pcbinfo->nat_dummy_socket.so_pcb,
1071: (struct sockaddr *) &sin, p);
1072: if (stat) {
1073: in_pcbdetach(pcb);
1074: return stat;
1075: }
1076: }
1077: *lport = pcb->inp_lport;
1078: }
1079:
1080:
1081: pcb->nat_owner = owner_id;
1082: pcb->nat_cookie = cookie;
1083: pcb->inp_ppcb = (caddr_t) pcbinfo->dummy_cb;
1084: return 0;
1085: }
1086:
1087: int
1088: in_pcb_letgo_port __P((struct inpcbinfo *pcbinfo, struct in_addr laddr, u_short lport,
1089: struct in_addr faddr, u_short fport, u_char owner_id))
1090: {
1091: struct inpcbhead *head;
1092: register struct inpcb *inp;
1093:
1094:
1095: /*
1096: * First look for an exact match.
1097: */
1098: head = &pcbinfo->hashbase[INP_PCBHASH(faddr.s_addr, lport, fport, pcbinfo->hashmask)];
1099: for (inp = head->lh_first; inp != NULL; inp = inp->inp_hash.le_next) {
1100: if (inp->inp_faddr.s_addr == faddr.s_addr &&
1101: inp->inp_laddr.s_addr == laddr.s_addr &&
1102: inp->inp_fport == fport &&
1103: inp->inp_lport == lport &&
1104: inp->nat_owner == owner_id) {
1105: /*
1106: * Found.
1107: */
1108: in_pcbdetach(inp);
1109: return 0;
1110: }
1111: }
1112:
1113: return ENOENT;
1114: }
1115:
1116: u_char
1117: in_pcb_get_owner(struct inpcbinfo *pcbinfo,
1118: struct in_addr laddr, u_short lport,
1119: struct in_addr faddr, u_short fport,
1120: u_int *cookie)
1121:
1122: {
1123: struct inpcb *inp;
1124: u_char owner_id = INPCB_NO_OWNER;
1125: struct inpcbport *phd;
1126: struct inpcbporthead *porthash;
1127:
1128:
1129: if (IN_MULTICAST(laddr.s_addr)) {
1130: /*
1131: * Walk through PCB's looking for registered
1132: * owners.
1133: */
1134:
1135: porthash = &pcbinfo->porthashbase[INP_PCBPORTHASH(lport,
1136: pcbinfo->porthashmask)];
1137: for (phd = porthash->lh_first; phd != NULL; phd = phd->phd_hash.le_next) {
1138: if (phd->phd_port == lport)
1139: break;
1140: }
1141:
1142: if (phd == 0) {
1143: return INPCB_NO_OWNER;
1144: }
1145:
1146: owner_id = INPCB_NO_OWNER;
1147: for (inp = phd->phd_pcblist.lh_first; inp != NULL;
1148: inp = inp->inp_portlist.le_next) {
1149:
1150: if (inp->inp_laddr.s_addr == laddr.s_addr) {
1151: if (inp->nat_owner == 0)
1152: owner_id |= INPCB_OWNED_BY_X;
1153: else
1154: owner_id |= inp->nat_owner;
1155: }
1156: }
1157:
1158: return owner_id;
1159: }
1160: else {
1161: inp = in_pcblookup_hash(pcbinfo, faddr, fport,
1162: laddr, lport, 1);
1163: if (inp) {
1164: if (inp->nat_owner) {
1165: owner_id = inp->nat_owner;
1166: *cookie = inp->nat_cookie;
1167: }
1168: else {
1169: pcbinfo->last_pcb = inp;
1170: owner_id = INPCB_OWNED_BY_X;
1171: }
1172: }
1173: else
1174: owner_id = INPCB_NO_OWNER;
1175:
1176: return owner_id;
1177: }
1178: }
1179:
1180: int
1181: in_pcb_new_share_client(struct inpcbinfo *pcbinfo, u_char *owner_id)
1182: {
1183:
1184: int i;
1185:
1186:
1187: for (i=0; i < INPCB_MAX_IDS; i++) {
1188: if ((pcbinfo->all_owners & (1 << i)) == 0) {
1189: pcbinfo->all_owners |= (1 << i);
1190: *owner_id = (1 << i);
1191: return 0;
1192: }
1193: }
1194:
1195: return ENOSPC;
1196: }
1197:
1198: int
1199: in_pcb_rem_share_client(struct inpcbinfo *pcbinfo, u_char owner_id)
1200: {
1201: struct inpcb *inp;
1202:
1203:
1204: if (pcbinfo->all_owners & owner_id) {
1205: pcbinfo->all_owners &= ~owner_id;
1206: for (inp = pcbinfo->listhead->lh_first; inp != NULL; inp = inp->inp_list.le_next) {
1207: if (inp->nat_owner & owner_id) {
1208: if (inp->nat_owner == owner_id)
1209: /*
1210: * Deallocate the pcb
1211: */
1212: in_pcbdetach(inp);
1213: else
1214: inp->nat_owner &= ~owner_id;
1215: }
1216: }
1217: }
1218: else {
1219: return ENOENT;
1220: }
1221:
1222: return 0;
1223: }
1224:
1225: void in_pcb_nat_init(struct inpcbinfo *pcbinfo, int afamily,
1226: int pfamily, int protocol)
1227: {
1228: bzero(&pcbinfo->nat_dummy_socket, sizeof(struct socket));
1229: pcbinfo->nat_dummy_socket.so_proto = pffindproto(afamily, pfamily, protocol);
1230: pcbinfo->all_owners = 0;
1231: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.