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