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.27 2004/08/28 18:33:03 dillon Exp $ 34 */ 35 36 /* 37 * Copyright (c) 2003, 2004 Jeffrey M. Hsu. All rights reserved. 38 * 39 * License terms: all terms for the DragonFly license above plus the following: 40 * 41 * 4. All advertising materials mentioning features or use of this software 42 * must display the following acknowledgement: 43 * 44 * This product includes software developed by Jeffrey M. Hsu 45 * for the DragonFly Project. 46 * 47 * This requirement may be waived with permission from Jeffrey Hsu. 48 * This requirement will sunset and may be removed on July 8 2005, 49 * after which the standard DragonFly license (as shown above) will 50 * apply. 51 */ 52 53 #include "opt_inet.h" 54 55 #include <sys/param.h> 56 #include <sys/systm.h> 57 #include <sys/kernel.h> 58 #include <sys/socket.h> 59 #include <sys/socketvar.h> 60 #include <sys/thread.h> 61 #include <sys/sysctl.h> 62 #include <sys/globaldata.h> 63 64 #include <net/if.h> 65 #include <net/netisr.h> 66 67 #include <netinet/in_systm.h> 68 #include <netinet/in.h> 69 #include <netinet/in_var.h> 70 #include <netinet/in_pcb.h> 71 #include <netinet/ip.h> 72 #include <netinet/ip_var.h> 73 #include <netinet/tcp.h> 74 #include <netinet/tcpip.h> 75 #include <netinet/tcp_var.h> 76 #include <netinet/udp.h> 77 #include <netinet/udp_var.h> 78 79 extern struct thread netisr_cpu[]; 80 81 static struct thread tcp_thread[MAXCPU]; 82 static struct thread udp_thread[MAXCPU]; 83 84 static __inline int 85 INP_MPORT_HASH(in_addr_t faddr, in_addr_t laddr, 86 in_port_t fport, in_port_t lport) 87 { 88 /* 89 * Use low order bytes. 90 */ 91 92 #if (BYTE_ORDER == LITTLE_ENDIAN) 93 KASSERT(ncpus2 < 256, ("need different hash function")); /* XXX JH */ 94 return (((faddr >> 24) ^ (fport >> 8) ^ (laddr >> 24) ^ (lport >> 8)) & 95 ncpus2_mask); 96 #else 97 return ((faddr ^ fport ^ laddr ^ lport) & ncpus2_mask); 98 #endif 99 } 100 101 /* 102 * Map a packet to a protocol processing thread and return the thread's port. 103 * If an error occurs, the passed mbuf will be freed, *mptr will be set 104 * to NULL, and NULL will be returned. If no error occurs, the passed mbuf 105 * may be modified and a port pointer will be returned. 106 */ 107 lwkt_port_t 108 ip_mport(struct mbuf **mptr) 109 { 110 struct ip *ip; 111 int iphlen; 112 int iplen; 113 struct tcphdr *th; 114 struct udphdr *uh; 115 struct mbuf *m = *mptr; 116 int thoff; /* TCP data offset */ 117 lwkt_port_t port; 118 int cpu; 119 120 /* 121 * The packet must be at least the size of an IP header 122 */ 123 if (m->m_pkthdr.len < sizeof(struct ip)) { 124 ipstat.ips_tooshort++; 125 m_freem(m); 126 *mptr = NULL; 127 return (NULL); 128 } 129 130 /* 131 * The first mbuf must entirely contain the IP header 132 */ 133 if (m->m_len < sizeof(struct ip) && 134 (m = m_pullup(m, sizeof(struct ip))) == NULL) { 135 ipstat.ips_toosmall++; 136 *mptr = NULL; 137 return (NULL); 138 } 139 ip = mtod(m, struct ip *); 140 141 /* 142 * Extract the actual IP header length and do a bounds check. The 143 * first mbuf must entirely contain the extended IP header. 144 */ 145 iphlen = ip->ip_hl << 2; 146 iplen = ntohs(ip->ip_len); 147 if (iphlen < sizeof(struct ip)) { /* minimum header length */ 148 ipstat.ips_badhlen++; 149 m_freem(m); 150 return (NULL); 151 } 152 if (m->m_len < iphlen) { 153 m = m_pullup(m, iphlen); 154 if (m == NULL) { 155 ipstat.ips_badhlen++; 156 *mptr = NULL; 157 return (NULL); 158 } 159 ip = mtod(m, struct ip *); 160 } 161 162 /* 163 * The TCP/IP or UDP/IP header must be entirely contained within 164 * the first fragment of a packet. Packet filters will break if they 165 * aren't. 166 * 167 * Since the packet will be trimmed to ip_len we must also make sure 168 * the potentially trimmed down length is still sufficient to hold 169 * the header(s). 170 */ 171 if ((ntohs(ip->ip_off) & IP_OFFMASK) == 0) { 172 switch (ip->ip_p) { 173 case IPPROTO_TCP: 174 if (iplen < iphlen + sizeof(struct tcphdr)) { 175 ++tcpstat.tcps_rcvshort; 176 m_freem(m); 177 *mptr = NULL; 178 return (NULL); 179 } 180 if (m->m_len < iphlen + sizeof(struct tcphdr)) { 181 m = m_pullup(m, iphlen + sizeof(struct tcphdr)); 182 if (m == NULL) { 183 tcpstat.tcps_rcvshort++; 184 *mptr = NULL; 185 return (NULL); 186 } 187 ip = mtod(m, struct ip *); 188 } 189 break; 190 case IPPROTO_UDP: 191 if (iplen < iphlen + sizeof(struct udphdr)) { 192 ++udpstat.udps_hdrops; 193 m_freem(m); 194 *mptr = NULL; 195 return (NULL); 196 } 197 if (m->m_len < iphlen + sizeof(struct udphdr)) { 198 m = m_pullup(m, iphlen + sizeof(struct udphdr)); 199 if (m == NULL) { 200 udpstat.udps_hdrops++; 201 *mptr = NULL; 202 return (NULL); 203 } 204 ip = mtod(m, struct ip *); 205 } 206 break; 207 default: 208 if (iplen < iphlen) { 209 ++ipstat.ips_badlen; 210 m_freem(m); 211 *mptr = NULL; 212 return (NULL); 213 } 214 break; 215 } 216 } 217 218 /* 219 * XXX generic packet handling defrag on CPU 0 for now. 220 */ 221 if (ntohs(ip->ip_off) & (IP_MF | IP_OFFMASK)) { 222 *mptr = m; 223 return (&netisr_cpu[0].td_msgport); 224 } 225 226 switch (ip->ip_p) { 227 case IPPROTO_TCP: 228 th = (struct tcphdr *)((caddr_t)ip + iphlen); 229 thoff = th->th_off << 2; 230 if (thoff < sizeof(struct tcphdr) || 231 thoff > ntohs(ip->ip_len)) { 232 tcpstat.tcps_rcvbadoff++; 233 m_freem(m); 234 *mptr = NULL; 235 return (NULL); 236 } 237 if (m->m_len < iphlen + thoff) { 238 m = m_pullup(m, iphlen + thoff); 239 if (m == NULL) { 240 tcpstat.tcps_rcvshort++; 241 *mptr = NULL; 242 return (NULL); 243 } 244 ip = mtod(m, struct ip *); 245 th = (struct tcphdr *)((caddr_t)ip + iphlen); 246 } 247 248 cpu = INP_MPORT_HASH(ip->ip_src.s_addr, ip->ip_dst.s_addr, 249 th->th_sport, th->th_dport); 250 port = &tcp_thread[cpu].td_msgport; 251 break; 252 case IPPROTO_UDP: 253 uh = (struct udphdr *)((caddr_t)ip + iphlen); 254 255 if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr)) || 256 in_broadcast(ip->ip_dst, m->m_pkthdr.rcvif)) { 257 cpu = 0; 258 } else { 259 cpu = INP_MPORT_HASH(ip->ip_src.s_addr, 260 ip->ip_dst.s_addr, uh->uh_sport, uh->uh_dport); 261 } 262 port = &udp_thread[cpu].td_msgport; 263 break; 264 default: 265 port = &netisr_cpu[0].td_msgport; 266 break; 267 } 268 KKASSERT(port->mp_putport != NULL); 269 *mptr = m; 270 return (port); 271 } 272 273 /* 274 * Map a TCP socket to a protocol processing thread. 275 */ 276 lwkt_port_t 277 tcp_soport(struct socket *so, struct sockaddr *nam, 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 = sotoinpcb(so); 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, int req) 316 { 317 struct inpcb *inp; 318 319 /* 320 * The following processing all take place on Protocol Thread 0: 321 * only bind() and connect() have a non-null nam parameter 322 * attach() has a null socket parameter 323 * Fast and slow timeouts pass in two NULLs 324 */ 325 if (nam != NULL || so == NULL) 326 return (&udp_thread[0].td_msgport); 327 328 inp = sotoinpcb(so); 329 330 if (IN_MULTICAST(ntohl(inp->inp_laddr.s_addr))) 331 return (&udp_thread[0].td_msgport); 332 333 /* 334 * Rely on type-stable memory and check in protocol handler 335 * to fix race condition here w/ deallocation of inp. XXX JH 336 */ 337 338 return (&udp_thread[INP_MPORT_HASH(inp->inp_faddr.s_addr, 339 inp->inp_laddr.s_addr, inp->inp_fport, inp->inp_lport)].td_msgport); 340 } 341 342 /* 343 * Map a network address to a processor. 344 */ 345 int 346 tcp_addrcpu(in_addr_t faddr, in_port_t fport, in_addr_t laddr, in_port_t lport) 347 { 348 return (INP_MPORT_HASH(faddr, laddr, fport, lport)); 349 } 350 351 int 352 udp_addrcpu(in_addr_t faddr, in_port_t fport, in_addr_t laddr, in_port_t lport) 353 { 354 if (IN_MULTICAST(ntohl(laddr))) 355 return (0); 356 else 357 return (INP_MPORT_HASH(faddr, laddr, fport, lport)); 358 } 359 360 /* 361 * Return LWKT port for cpu. 362 */ 363 lwkt_port_t 364 tcp_cport(int cpu) 365 { 366 return (&tcp_thread[cpu].td_msgport); 367 } 368 369 void 370 tcp_thread_init(void) 371 { 372 int cpu; 373 374 for (cpu = 0; cpu < ncpus2; cpu++) { 375 lwkt_create(tcpmsg_service_loop, NULL, NULL, 376 &tcp_thread[cpu], 0, cpu, "tcp_thread %d", cpu); 377 tcp_thread[cpu].td_msgport.mp_putport = netmsg_put_port; 378 } 379 } 380 381 void 382 udp_thread_init(void) 383 { 384 int cpu; 385 386 for (cpu = 0; cpu < ncpus2; cpu++) { 387 lwkt_create(netmsg_service_loop, NULL, NULL, 388 &udp_thread[cpu], 0, cpu, "udp_thread %d", cpu); 389 udp_thread[cpu].td_msgport.mp_putport = netmsg_put_port; 390 } 391 } 392