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.33 2005/03/23 07:47:40 hsu 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 boolean_t 102 ip_lengthcheck(struct mbuf **mp) 103 { 104 struct mbuf *m = *mp; 105 struct ip *ip; 106 int iphlen, iplen; 107 struct tcphdr *th; 108 int thoff; /* TCP data offset */ 109 110 /* The packet must be at least the size of an IP header. */ 111 if (m->m_pkthdr.len < sizeof(struct ip)) { 112 ipstat.ips_tooshort++; 113 m_free(m); 114 return FALSE; 115 } 116 117 /* The fixed IP header must reside completely in the first mbuf. */ 118 if (m->m_len < sizeof(struct ip)) { 119 m = m_pullup(m, sizeof(struct ip)); 120 if (m == NULL) { 121 ipstat.ips_toosmall++; 122 return FALSE; 123 } 124 } 125 126 ip = mtod(m, struct ip *); 127 128 /* Bound check the packet's stated IP header length. */ 129 iphlen = ip->ip_hl << 2; 130 if (iphlen < sizeof(struct ip)) { /* minimum header length */ 131 ipstat.ips_badhlen++; 132 m_free(m); 133 return FALSE; 134 } 135 136 /* The full IP header must reside completely in the one mbuf. */ 137 if (m->m_len < iphlen) { 138 m = m_pullup(m, iphlen); 139 if (m == NULL) { 140 ipstat.ips_badhlen++; 141 return FALSE; 142 } 143 ip = mtod(m, struct ip *); 144 } 145 146 iplen = ntohs(ip->ip_len); 147 148 /* 149 * Fragments other than the first fragment don't have much 150 * length information. 151 */ 152 if (ntohs(ip->ip_off) & IP_OFFMASK) 153 goto ipcheckonly; 154 155 /* 156 * The TCP/IP or UDP/IP header must be entirely contained within 157 * the first fragment of a packet. Packet filters will break if they 158 * aren't. 159 * 160 * Since the packet will be trimmed to ip_len we must also make sure 161 * the potentially trimmed down length is still sufficient to hold 162 * the header(s). 163 */ 164 switch (ip->ip_p) { 165 case IPPROTO_TCP: 166 if (iplen < iphlen + sizeof(struct tcphdr)) { 167 ++tcpstat.tcps_rcvshort; 168 m_free(m); 169 return FALSE; 170 } 171 if (m->m_len < iphlen + sizeof(struct tcphdr)) { 172 m = m_pullup(m, iphlen + sizeof(struct tcphdr)); 173 if (m == NULL) { 174 tcpstat.tcps_rcvshort++; 175 return FALSE; 176 } 177 ip = mtod(m, struct ip *); 178 } 179 th = (struct tcphdr *)((caddr_t)ip + iphlen); 180 thoff = th->th_off << 2; 181 if (thoff < sizeof(struct tcphdr) || 182 thoff + iphlen > ntohs(ip->ip_len)) { 183 tcpstat.tcps_rcvbadoff++; 184 m_free(m); 185 return FALSE; 186 } 187 if (m->m_len < iphlen + thoff) { 188 m = m_pullup(m, iphlen + thoff); 189 if (m == NULL) { 190 tcpstat.tcps_rcvshort++; 191 return FALSE; 192 } 193 } 194 break; 195 case IPPROTO_UDP: 196 if (iplen < iphlen + sizeof(struct udphdr)) { 197 ++udpstat.udps_hdrops; 198 m_free(m); 199 return FALSE; 200 } 201 if (m->m_len < iphlen + sizeof(struct udphdr)) { 202 m = m_pullup(m, iphlen + sizeof(struct udphdr)); 203 if (m == NULL) { 204 udpstat.udps_hdrops++; 205 return FALSE; 206 } 207 } 208 break; 209 default: 210 ipcheckonly: 211 if (iplen < iphlen) { 212 ++ipstat.ips_badlen; 213 m_free(m); 214 return FALSE; 215 } 216 break; 217 } 218 219 *mp = m; 220 return TRUE; 221 } 222 223 /* 224 * Map a packet to a protocol processing thread and return the thread's port. 225 * If an error occurs, the passed mbuf will be freed, *mptr will be set 226 * to NULL, and NULL will be returned. If no error occurs, the passed mbuf 227 * may be modified and a port pointer will be returned. 228 */ 229 lwkt_port_t 230 ip_mport(struct mbuf **mptr) 231 { 232 struct ip *ip; 233 int iphlen; 234 struct tcphdr *th; 235 struct udphdr *uh; 236 struct mbuf *m; 237 int thoff; /* TCP data offset */ 238 lwkt_port_t port; 239 int cpu; 240 241 if (!ip_lengthcheck(mptr)) { 242 *mptr = NULL; 243 return (NULL); 244 } 245 246 m = *mptr; 247 ip = mtod(m, struct ip *); 248 iphlen = ip->ip_hl << 2; 249 250 /* 251 * XXX generic packet handling defrag on CPU 0 for now. 252 */ 253 if (ntohs(ip->ip_off) & (IP_MF | IP_OFFMASK)) 254 return (&netisr_cpu[0].td_msgport); 255 256 switch (ip->ip_p) { 257 case IPPROTO_TCP: 258 th = (struct tcphdr *)((caddr_t)ip + iphlen); 259 thoff = th->th_off << 2; 260 cpu = INP_MPORT_HASH(ip->ip_src.s_addr, ip->ip_dst.s_addr, 261 th->th_sport, th->th_dport); 262 port = &tcp_thread[cpu].td_msgport; 263 break; 264 case IPPROTO_UDP: 265 uh = (struct udphdr *)((caddr_t)ip + iphlen); 266 267 if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr)) || 268 in_broadcast(ip->ip_dst, m->m_pkthdr.rcvif)) { 269 cpu = 0; 270 } else { 271 cpu = INP_MPORT_HASH(ip->ip_src.s_addr, 272 ip->ip_dst.s_addr, uh->uh_sport, uh->uh_dport); 273 } 274 port = &udp_thread[cpu].td_msgport; 275 break; 276 default: 277 port = &netisr_cpu[0].td_msgport; 278 break; 279 } 280 281 return (port); 282 } 283 284 /* 285 * Map a TCP socket to a protocol processing thread. 286 */ 287 lwkt_port_t 288 tcp_soport(struct socket *so, struct sockaddr *nam, int req) 289 { 290 struct inpcb *inp; 291 292 /* The following processing all take place on Protocol Thread 0. */ 293 if (req == PRU_BIND || req == PRU_CONNECT || req == PRU_ATTACH || 294 req == PRU_LISTEN) 295 return (&tcp_thread[0].td_msgport); 296 297 inp = so->so_pcb; 298 if (!inp) /* connection reset by peer */ 299 return (&tcp_thread[0].td_msgport); 300 301 /* 302 * Already bound and connected or listening. For TCP connections, 303 * the (faddr, fport, laddr, lport) association cannot change now. 304 * 305 * Note: T/TCP code needs some reorganization to fit into 306 * this model. XXX JH 307 * 308 * Rely on type-stable memory and check in protocol handler 309 * to fix race condition here w/ deallocation of inp. XXX JH 310 */ 311 return (&tcp_thread[INP_MPORT_HASH(inp->inp_faddr.s_addr, 312 inp->inp_laddr.s_addr, inp->inp_fport, inp->inp_lport)].td_msgport); 313 } 314 315 lwkt_port_t 316 tcp_addrport(in_addr_t faddr, in_port_t fport, in_addr_t laddr, in_port_t lport) 317 { 318 return (&tcp_thread[tcp_addrcpu(faddr, fport, 319 laddr, lport)].td_msgport); 320 } 321 322 /* 323 * Map a UDP socket to a protocol processing thread. 324 */ 325 lwkt_port_t 326 udp_soport(struct socket *so, struct sockaddr *nam, int req) 327 { 328 struct inpcb *inp; 329 330 /* 331 * The following processing all take place on Protocol Thread 0: 332 * only bind() and connect() have a non-null nam parameter 333 * attach() has a null socket parameter 334 * Fast and slow timeouts pass in two NULLs 335 */ 336 if (nam != NULL || so == NULL) 337 return (&udp_thread[0].td_msgport); 338 339 inp = so->so_pcb; 340 341 if (IN_MULTICAST(ntohl(inp->inp_laddr.s_addr))) 342 return (&udp_thread[0].td_msgport); 343 344 /* 345 * Rely on type-stable memory and check in protocol handler 346 * to fix race condition here w/ deallocation of inp. XXX JH 347 */ 348 349 return (&udp_thread[INP_MPORT_HASH(inp->inp_faddr.s_addr, 350 inp->inp_laddr.s_addr, inp->inp_fport, inp->inp_lport)].td_msgport); 351 } 352 353 /* 354 * Map a network address to a processor. 355 */ 356 int 357 tcp_addrcpu(in_addr_t faddr, in_port_t fport, in_addr_t laddr, in_port_t lport) 358 { 359 return (INP_MPORT_HASH(faddr, laddr, fport, lport)); 360 } 361 362 int 363 udp_addrcpu(in_addr_t faddr, in_port_t fport, in_addr_t laddr, in_port_t lport) 364 { 365 if (IN_MULTICAST(ntohl(laddr))) 366 return (0); 367 else 368 return (INP_MPORT_HASH(faddr, laddr, fport, lport)); 369 } 370 371 /* 372 * Return LWKT port for cpu. 373 */ 374 lwkt_port_t 375 tcp_cport(int cpu) 376 { 377 return (&tcp_thread[cpu].td_msgport); 378 } 379 380 void 381 tcp_thread_init(void) 382 { 383 int cpu; 384 385 for (cpu = 0; cpu < ncpus2; cpu++) { 386 lwkt_create(tcpmsg_service_loop, NULL, NULL, 387 &tcp_thread[cpu], 0, cpu, "tcp_thread %d", cpu); 388 netmsg_service_port_init(&tcp_thread[cpu].td_msgport); 389 } 390 } 391 392 void 393 udp_thread_init(void) 394 { 395 int cpu; 396 397 for (cpu = 0; cpu < ncpus2; cpu++) { 398 lwkt_create(netmsg_service_loop, NULL, NULL, 399 &udp_thread[cpu], 0, cpu, "udp_thread %d", cpu); 400 netmsg_service_port_init(&udp_thread[cpu].td_msgport); 401 } 402 } 403