xref: /dragonfly/sys/netinet/ip_demux.c (revision 0cfebe3d) 
1 /*
2  * Copyright (c) 2003, 2004 Jeffrey M. Hsu.  All rights reserved.
3  * Copyright (c) 2003, 2004 The DragonFly Project.  All rights reserved.
4  *
5  * This code is derived from software contributed to The DragonFly Project
6  * by Jeffrey M. Hsu.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. Neither the name of The DragonFly Project nor the names of its
17  *    contributors may be used to endorse or promote products derived
18  *    from this software without specific, prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
23  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
24  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
25  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
26  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
27  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
28  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
29  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
30  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  *
33  * $DragonFly: src/sys/netinet/ip_demux.c,v 1.37 2007/12/19 11:00:22 sephe Exp $
34  */
35 
36 #include "opt_inet.h"
37 
38 #include <sys/param.h>
39 #include <sys/systm.h>
40 #include <sys/kernel.h>
41 #include <sys/socket.h>
42 #include <sys/socketvar.h>
43 #include <sys/thread.h>
44 #include <sys/sysctl.h>
45 #include <sys/globaldata.h>
46 
47 #include <net/if.h>
48 #include <net/netisr.h>
49 
50 #include <netinet/in_systm.h>
51 #include <netinet/in.h>
52 #include <netinet/in_var.h>
53 #include <netinet/in_pcb.h>
54 #include <netinet/ip.h>
55 #include <netinet/ip_var.h>
56 #include <netinet/tcp.h>
57 #include <netinet/tcpip.h>
58 #include <netinet/tcp_var.h>
59 #include <netinet/udp.h>
60 #include <netinet/udp_var.h>
61 
62 extern struct thread netisr_cpu[];
63 
64 static struct thread tcp_thread[MAXCPU];
65 static struct thread udp_thread[MAXCPU];
66 
67 static __inline int
68 INP_MPORT_HASH(in_addr_t faddr, in_addr_t laddr,
69 	       in_port_t fport, in_port_t lport)
70 {
71 	/*
72 	 * Use low order bytes.
73 	 */
74 
75 #if (BYTE_ORDER == LITTLE_ENDIAN)
76 	KASSERT(ncpus2 < 256, ("need different hash function"));  /* XXX JH */
77 	return (((faddr >> 24) ^ (fport >> 8) ^ (laddr >> 24) ^ (lport >> 8)) &
78 		ncpus2_mask);
79 #else
80 	return ((faddr ^ fport ^ laddr ^ lport) & ncpus2_mask);
81 #endif
82 }
83 
84 boolean_t
85 ip_lengthcheck(struct mbuf **mp)
86 {
87 	struct mbuf *m = *mp;
88 	struct ip *ip;
89 	int iphlen, iplen;
90 	struct tcphdr *th;
91 	int thoff;				/* TCP data offset */
92 
93 	/* The packet must be at least the size of an IP header. */
94 	if (m->m_pkthdr.len < sizeof(struct ip)) {
95 		ipstat.ips_tooshort++;
96 		goto fail;
97 	}
98 
99 	/* The fixed IP header must reside completely in the first mbuf. */
100 	if (m->m_len < sizeof(struct ip)) {
101 		m = m_pullup(m, sizeof(struct ip));
102 		if (m == NULL) {
103 			ipstat.ips_toosmall++;
104 			goto fail;
105 		}
106 	}
107 
108 	ip = mtod(m, struct ip *);
109 
110 	/* Bound check the packet's stated IP header length. */
111 	iphlen = ip->ip_hl << 2;
112 	if (iphlen < sizeof(struct ip)) {	/* minimum header length */
113 		ipstat.ips_badhlen++;
114 		goto fail;
115 	}
116 
117 	/* The full IP header must reside completely in the one mbuf. */
118 	if (m->m_len < iphlen) {
119 		m = m_pullup(m, iphlen);
120 		if (m == NULL) {
121 			ipstat.ips_badhlen++;
122 			goto fail;
123 		}
124 		ip = mtod(m, struct ip *);
125 	}
126 
127 	iplen = ntohs(ip->ip_len);
128 
129 	/*
130 	 * Fragments other than the first fragment don't have much
131 	 * length information.
132 	 */
133 	if (ntohs(ip->ip_off) & IP_OFFMASK)
134 		goto ipcheckonly;
135 
136 	/*
137 	 * The TCP/IP or UDP/IP header must be entirely contained within
138 	 * the first fragment of a packet.  Packet filters will break if they
139 	 * aren't.
140 	 *
141 	 * Since the packet will be trimmed to ip_len we must also make sure
142 	 * the potentially trimmed down length is still sufficient to hold
143 	 * the header(s).
144 	 */
145 	switch (ip->ip_p) {
146 	case IPPROTO_TCP:
147 		if (iplen < iphlen + sizeof(struct tcphdr)) {
148 			++tcpstat.tcps_rcvshort;
149 			goto fail;
150 		}
151 		if (m->m_len < iphlen + sizeof(struct tcphdr)) {
152 			m = m_pullup(m, iphlen + sizeof(struct tcphdr));
153 			if (m == NULL) {
154 				tcpstat.tcps_rcvshort++;
155 				goto fail;
156 			}
157 			ip = mtod(m, struct ip *);
158 		}
159 		th = (struct tcphdr *)((caddr_t)ip + iphlen);
160 		thoff = th->th_off << 2;
161 		if (thoff < sizeof(struct tcphdr) ||
162 		    thoff + iphlen > ntohs(ip->ip_len)) {
163 			tcpstat.tcps_rcvbadoff++;
164 			goto fail;
165 		}
166 		if (m->m_len < iphlen + thoff) {
167 			m = m_pullup(m, iphlen + thoff);
168 			if (m == NULL) {
169 				tcpstat.tcps_rcvshort++;
170 				goto fail;
171 			}
172 		}
173 		break;
174 	case IPPROTO_UDP:
175 		if (iplen < iphlen + sizeof(struct udphdr)) {
176 			++udpstat.udps_hdrops;
177 			goto fail;
178 		}
179 		if (m->m_len < iphlen + sizeof(struct udphdr)) {
180 			m = m_pullup(m, iphlen + sizeof(struct udphdr));
181 			if (m == NULL) {
182 				udpstat.udps_hdrops++;
183 				goto fail;
184 			}
185 		}
186 		break;
187 	default:
188 ipcheckonly:
189 		if (iplen < iphlen) {
190 			++ipstat.ips_badlen;
191 			goto fail;
192 		}
193 		break;
194 	}
195 
196 	*mp = m;
197 	return TRUE;
198 
199 fail:
200 	if (m != NULL)
201 		m_freem(m);
202 	*mp = NULL;
203 	return FALSE;
204 }
205 
206 /*
207  * Map a packet to a protocol processing thread and return the thread's port.
208  * If an error occurs, the passed mbuf will be freed, *mptr will be set
209  * to NULL, and NULL will be returned.  If no error occurs, the passed mbuf
210  * may be modified and a port pointer will be returned.
211  */
212 lwkt_port_t
213 ip_mport(struct mbuf **mptr, int dir)
214 {
215 	struct ip *ip;
216 	int iphlen;
217 	struct tcphdr *th;
218 	struct udphdr *uh;
219 	struct mbuf *m;
220 	int thoff;				/* TCP data offset */
221 	lwkt_port_t port;
222 	int cpu;
223 
224 	if (!ip_lengthcheck(mptr))
225 		return (NULL);
226 
227 	m = *mptr;
228 	ip = mtod(m, struct ip *);
229 	iphlen = ip->ip_hl << 2;
230 
231 	/*
232 	 * XXX generic packet handling defrag on CPU 0 for now.
233 	 */
234 	if (ntohs(ip->ip_off) & (IP_MF | IP_OFFMASK))
235 		return (&netisr_cpu[0].td_msgport);
236 
237 	switch (ip->ip_p) {
238 	case IPPROTO_TCP:
239 		th = (struct tcphdr *)((caddr_t)ip + iphlen);
240 		thoff = th->th_off << 2;
241 		cpu = INP_MPORT_HASH(ip->ip_src.s_addr, ip->ip_dst.s_addr,
242 		    th->th_sport, th->th_dport);
243 		port = &tcp_thread[cpu].td_msgport;
244 		break;
245 	case IPPROTO_UDP:
246 		uh = (struct udphdr *)((caddr_t)ip + iphlen);
247 
248 		if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr)) ||
249 		    (dir == IP_MPORT_IN &&
250 		     in_broadcast(ip->ip_dst, m->m_pkthdr.rcvif))) {
251 			cpu = 0;
252 		} else {
253 			cpu = INP_MPORT_HASH(ip->ip_src.s_addr,
254 			    ip->ip_dst.s_addr, uh->uh_sport, uh->uh_dport);
255 		}
256 		port = &udp_thread[cpu].td_msgport;
257 		break;
258 	default:
259 		port = &netisr_cpu[0].td_msgport;
260 		break;
261 	}
262 
263 	return (port);
264 }
265 
266 lwkt_port_t
267 ip_mport_in(struct mbuf **mptr)
268 {
269 	return ip_mport(mptr, IP_MPORT_IN);
270 }
271 
272 /*
273  * Map a TCP socket to a protocol processing thread.
274  */
275 lwkt_port_t
276 tcp_soport(struct socket *so, struct sockaddr *nam __unused,
277 	   struct mbuf **dummy __unused, int req)
278 {
279 	struct inpcb *inp;
280 
281 	/* The following processing all take place on Protocol Thread 0. */
282 	if (req == PRU_BIND || req == PRU_CONNECT || req == PRU_ATTACH ||
283 	    req == PRU_LISTEN)
284 		return (&tcp_thread[0].td_msgport);
285 
286 	inp = so->so_pcb;
287 	if (!inp)		/* connection reset by peer */
288 		return (&tcp_thread[0].td_msgport);
289 
290 	/*
291 	 * Already bound and connected or listening.  For TCP connections,
292 	 * the (faddr, fport, laddr, lport) association cannot change now.
293 	 *
294 	 * Note: T/TCP code needs some reorganization to fit into
295 	 * this model.  XXX JH
296 	 *
297 	 * Rely on type-stable memory and check in protocol handler
298 	 * to fix race condition here w/ deallocation of inp.  XXX JH
299 	 */
300 	return (&tcp_thread[INP_MPORT_HASH(inp->inp_faddr.s_addr,
301 	    inp->inp_laddr.s_addr, inp->inp_fport, inp->inp_lport)].td_msgport);
302 }
303 
304 lwkt_port_t
305 tcp_addrport(in_addr_t faddr, in_port_t fport, in_addr_t laddr, in_port_t lport)
306 {
307 	return (&tcp_thread[tcp_addrcpu(faddr, fport,
308 					laddr, lport)].td_msgport);
309 }
310 
311 /*
312  * Map a UDP socket to a protocol processing thread.
313  */
314 lwkt_port_t
315 udp_soport(struct socket *so, struct sockaddr *nam __unused,
316 	   struct mbuf **dummy __unused, int req)
317 {
318 	struct inpcb *inp;
319 
320 	/*
321 	 * The following processing all take place on Protocol Thread 0:
322 	 *   bind() and connect()
323 	 *   attach() has a null socket parameter
324 	 *   Fast and slow timeouts pass in null socket parameter
325 	 */
326 	if (req == PRU_CONNECT || req == PRU_BIND || so == NULL)
327 		return (&udp_thread[0].td_msgport);
328 
329 	inp = so->so_pcb;
330 
331 	if (IN_MULTICAST(ntohl(inp->inp_laddr.s_addr)))
332 		return (&udp_thread[0].td_msgport);
333 
334 	/*
335 	 * Rely on type-stable memory and check in protocol handler
336 	 * to fix race condition here w/ deallocation of inp.  XXX JH
337 	 */
338 
339 	return (&udp_thread[INP_MPORT_HASH(inp->inp_faddr.s_addr,
340 	    inp->inp_laddr.s_addr, inp->inp_fport, inp->inp_lport)].td_msgport);
341 }
342 
343 /*
344  * Map a network address to a processor.
345  */
346 int
347 tcp_addrcpu(in_addr_t faddr, in_port_t fport, in_addr_t laddr, in_port_t lport)
348 {
349 	return (INP_MPORT_HASH(faddr, laddr, fport, lport));
350 }
351 
352 int
353 udp_addrcpu(in_addr_t faddr, in_port_t fport, in_addr_t laddr, in_port_t lport)
354 {
355 	if (IN_MULTICAST(ntohl(laddr)))
356 		return (0);
357 	else
358 		return (INP_MPORT_HASH(faddr, laddr, fport, lport));
359 }
360 
361 /*
362  * Return LWKT port for cpu.
363  */
364 lwkt_port_t
365 tcp_cport(int cpu)
366 {
367 	return (&tcp_thread[cpu].td_msgport);
368 }
369 
370 void
371 tcp_thread_init(void)
372 {
373 	int cpu;
374 
375 	for (cpu = 0; cpu < ncpus2; cpu++) {
376 		lwkt_create(tcpmsg_service_loop, NULL, NULL,
377 			&tcp_thread[cpu], 0, cpu, "tcp_thread %d", cpu);
378 		netmsg_service_port_init(&tcp_thread[cpu].td_msgport);
379 	}
380 }
381 
382 void
383 udp_thread_init(void)
384 {
385 	int cpu;
386 
387 	for (cpu = 0; cpu < ncpus2; cpu++) {
388 		lwkt_create(netmsg_service_loop, NULL, NULL,
389 			&udp_thread[cpu], 0, cpu, "udp_thread %d", cpu);
390 		netmsg_service_port_init(&udp_thread[cpu].td_msgport);
391 	}
392 }
393