1 /* 2 * INET An implementation of the TCP/IP protocol suite for the LINUX 3 * operating system. INET is implemented using the BSD Socket 4 * interface as the means of communication with the user level. 5 * 6 * Implementation of the Transmission Control Protocol(TCP). 7 * 8 * Version: $Id: tcp_ipv4.c,v 1.240 2002/02/01 22:01:04 davem Exp $ 9 * 10 * IPv4 specific functions 11 * 12 * 13 * code split from: 14 * linux/ipv4/tcp.c 15 * linux/ipv4/tcp_input.c 16 * linux/ipv4/tcp_output.c 17 * 18 * See tcp.c for author information 19 * 20 * This program is free software; you can redistribute it and/or 21 * modify it under the terms of the GNU General Public License 22 * as published by the Free Software Foundation; either version 23 * 2 of the License, or (at your option) any later version. 24 */ 25 26 /* 27 * Changes: 28 * David S. Miller : New socket lookup architecture. 29 * This code is dedicated to John Dyson. 30 * David S. Miller : Change semantics of established hash, 31 * half is devoted to TIME_WAIT sockets 32 * and the rest go in the other half. 33 * Andi Kleen : Add support for syncookies and fixed 34 * some bugs: ip options weren't passed to 35 * the TCP layer, missed a check for an 36 * ACK bit. 37 * Andi Kleen : Implemented fast path mtu discovery. 38 * Fixed many serious bugs in the 39 * request_sock handling and moved 40 * most of it into the af independent code. 41 * Added tail drop and some other bugfixes. 42 * Added new listen sematics. 43 * Mike McLagan : Routing by source 44 * Juan Jose Ciarlante: ip_dynaddr bits 45 * Andi Kleen: various fixes. 46 * Vitaly E. Lavrov : Transparent proxy revived after year 47 * coma. 48 * Andi Kleen : Fix new listen. 49 * Andi Kleen : Fix accept error reporting. 50 * YOSHIFUJI Hideaki @USAGI and: Support IPV6_V6ONLY socket option, which 51 * Alexey Kuznetsov allow both IPv4 and IPv6 sockets to bind 52 * a single port at the same time. 53 */ 54 55 #include <linux/config.h> 56 57 #include <linux/types.h> 58 #include <linux/fcntl.h> 59 #include <linux/module.h> 60 #include <linux/random.h> 61 #include <linux/cache.h> 62 #include <linux/jhash.h> 63 #include <linux/init.h> 64 #include <linux/times.h> 65 66 #include <net/icmp.h> 67 #include <net/inet_hashtables.h> 68 #include <net/tcp.h> 69 #include <net/transp_v6.h> 70 #include <net/ipv6.h> 71 #include <net/inet_common.h> 72 #include <net/xfrm.h> 73 74 #include <linux/inet.h> 75 #include <linux/ipv6.h> 76 #include <linux/stddef.h> 77 #include <linux/proc_fs.h> 78 #include <linux/seq_file.h> 79 80 int sysctl_tcp_tw_reuse; 81 int sysctl_tcp_low_latency; 82 83 /* Check TCP sequence numbers in ICMP packets. */ 84 #define ICMP_MIN_LENGTH 8 85 86 /* Socket used for sending RSTs */ 87 static struct socket *tcp_socket; 88 89 void tcp_v4_send_check(struct sock *sk, struct tcphdr *th, int len, 90 struct sk_buff *skb); 91 92 struct inet_hashinfo __cacheline_aligned tcp_hashinfo = { 93 .lhash_lock = RW_LOCK_UNLOCKED, 94 .lhash_users = ATOMIC_INIT(0), 95 .lhash_wait = __WAIT_QUEUE_HEAD_INITIALIZER(tcp_hashinfo.lhash_wait), 96 .portalloc_lock = SPIN_LOCK_UNLOCKED, 97 .port_rover = 1024 - 1, 98 }; 99 100 static int tcp_v4_get_port(struct sock *sk, unsigned short snum) 101 { 102 return inet_csk_get_port(&tcp_hashinfo, sk, snum); 103 } 104 105 static void tcp_v4_hash(struct sock *sk) 106 { 107 inet_hash(&tcp_hashinfo, sk); 108 } 109 110 void tcp_unhash(struct sock *sk) 111 { 112 inet_unhash(&tcp_hashinfo, sk); 113 } 114 115 static inline __u32 tcp_v4_init_sequence(struct sock *sk, struct sk_buff *skb) 116 { 117 return secure_tcp_sequence_number(skb->nh.iph->daddr, 118 skb->nh.iph->saddr, 119 skb->h.th->dest, 120 skb->h.th->source); 121 } 122 123 /* called with local bh disabled */ 124 static int __tcp_v4_check_established(struct sock *sk, __u16 lport, 125 struct inet_timewait_sock **twp) 126 { 127 struct inet_sock *inet = inet_sk(sk); 128 u32 daddr = inet->rcv_saddr; 129 u32 saddr = inet->daddr; 130 int dif = sk->sk_bound_dev_if; 131 INET_ADDR_COOKIE(acookie, saddr, daddr) 132 const __u32 ports = INET_COMBINED_PORTS(inet->dport, lport); 133 const int hash = inet_ehashfn(daddr, lport, saddr, inet->dport, tcp_hashinfo.ehash_size); 134 struct inet_ehash_bucket *head = &tcp_hashinfo.ehash[hash]; 135 struct sock *sk2; 136 const struct hlist_node *node; 137 struct inet_timewait_sock *tw; 138 139 write_lock(&head->lock); 140 141 /* Check TIME-WAIT sockets first. */ 142 sk_for_each(sk2, node, &(head + tcp_hashinfo.ehash_size)->chain) { 143 tw = inet_twsk(sk2); 144 145 if (INET_TW_MATCH(sk2, acookie, saddr, daddr, ports, dif)) { 146 const struct tcp_timewait_sock *tcptw = tcp_twsk(sk2); 147 struct tcp_sock *tp = tcp_sk(sk); 148 149 /* With PAWS, it is safe from the viewpoint 150 of data integrity. Even without PAWS it 151 is safe provided sequence spaces do not 152 overlap i.e. at data rates <= 80Mbit/sec. 153 154 Actually, the idea is close to VJ's one, 155 only timestamp cache is held not per host, 156 but per port pair and TW bucket is used 157 as state holder. 158 159 If TW bucket has been already destroyed we 160 fall back to VJ's scheme and use initial 161 timestamp retrieved from peer table. 162 */ 163 if (tcptw->tw_ts_recent_stamp && 164 (!twp || (sysctl_tcp_tw_reuse && 165 xtime.tv_sec - 166 tcptw->tw_ts_recent_stamp > 1))) { 167 tp->write_seq = tcptw->tw_snd_nxt + 65535 + 2; 168 if (tp->write_seq == 0) 169 tp->write_seq = 1; 170 tp->rx_opt.ts_recent = tcptw->tw_ts_recent; 171 tp->rx_opt.ts_recent_stamp = tcptw->tw_ts_recent_stamp; 172 sock_hold(sk2); 173 goto unique; 174 } else 175 goto not_unique; 176 } 177 } 178 tw = NULL; 179 180 /* And established part... */ 181 sk_for_each(sk2, node, &head->chain) { 182 if (INET_MATCH(sk2, acookie, saddr, daddr, ports, dif)) 183 goto not_unique; 184 } 185 186 unique: 187 /* Must record num and sport now. Otherwise we will see 188 * in hash table socket with a funny identity. */ 189 inet->num = lport; 190 inet->sport = htons(lport); 191 sk->sk_hashent = hash; 192 BUG_TRAP(sk_unhashed(sk)); 193 __sk_add_node(sk, &head->chain); 194 sock_prot_inc_use(sk->sk_prot); 195 write_unlock(&head->lock); 196 197 if (twp) { 198 *twp = tw; 199 NET_INC_STATS_BH(LINUX_MIB_TIMEWAITRECYCLED); 200 } else if (tw) { 201 /* Silly. Should hash-dance instead... */ 202 inet_twsk_deschedule(tw, &tcp_death_row); 203 NET_INC_STATS_BH(LINUX_MIB_TIMEWAITRECYCLED); 204 205 inet_twsk_put(tw); 206 } 207 208 return 0; 209 210 not_unique: 211 write_unlock(&head->lock); 212 return -EADDRNOTAVAIL; 213 } 214 215 static inline u32 connect_port_offset(const struct sock *sk) 216 { 217 const struct inet_sock *inet = inet_sk(sk); 218 219 return secure_tcp_port_ephemeral(inet->rcv_saddr, inet->daddr, 220 inet->dport); 221 } 222 223 /* 224 * Bind a port for a connect operation and hash it. 225 */ 226 static inline int tcp_v4_hash_connect(struct sock *sk) 227 { 228 const unsigned short snum = inet_sk(sk)->num; 229 struct inet_bind_hashbucket *head; 230 struct inet_bind_bucket *tb; 231 int ret; 232 233 if (!snum) { 234 int low = sysctl_local_port_range[0]; 235 int high = sysctl_local_port_range[1]; 236 int range = high - low; 237 int i; 238 int port; 239 static u32 hint; 240 u32 offset = hint + connect_port_offset(sk); 241 struct hlist_node *node; 242 struct inet_timewait_sock *tw = NULL; 243 244 local_bh_disable(); 245 for (i = 1; i <= range; i++) { 246 port = low + (i + offset) % range; 247 head = &tcp_hashinfo.bhash[inet_bhashfn(port, tcp_hashinfo.bhash_size)]; 248 spin_lock(&head->lock); 249 250 /* Does not bother with rcv_saddr checks, 251 * because the established check is already 252 * unique enough. 253 */ 254 inet_bind_bucket_for_each(tb, node, &head->chain) { 255 if (tb->port == port) { 256 BUG_TRAP(!hlist_empty(&tb->owners)); 257 if (tb->fastreuse >= 0) 258 goto next_port; 259 if (!__tcp_v4_check_established(sk, 260 port, 261 &tw)) 262 goto ok; 263 goto next_port; 264 } 265 } 266 267 tb = inet_bind_bucket_create(tcp_hashinfo.bind_bucket_cachep, head, port); 268 if (!tb) { 269 spin_unlock(&head->lock); 270 break; 271 } 272 tb->fastreuse = -1; 273 goto ok; 274 275 next_port: 276 spin_unlock(&head->lock); 277 } 278 local_bh_enable(); 279 280 return -EADDRNOTAVAIL; 281 282 ok: 283 hint += i; 284 285 /* Head lock still held and bh's disabled */ 286 inet_bind_hash(sk, tb, port); 287 if (sk_unhashed(sk)) { 288 inet_sk(sk)->sport = htons(port); 289 __inet_hash(&tcp_hashinfo, sk, 0); 290 } 291 spin_unlock(&head->lock); 292 293 if (tw) { 294 inet_twsk_deschedule(tw, &tcp_death_row);; 295 inet_twsk_put(tw); 296 } 297 298 ret = 0; 299 goto out; 300 } 301 302 head = &tcp_hashinfo.bhash[inet_bhashfn(snum, tcp_hashinfo.bhash_size)]; 303 tb = inet_csk(sk)->icsk_bind_hash; 304 spin_lock_bh(&head->lock); 305 if (sk_head(&tb->owners) == sk && !sk->sk_bind_node.next) { 306 __inet_hash(&tcp_hashinfo, sk, 0); 307 spin_unlock_bh(&head->lock); 308 return 0; 309 } else { 310 spin_unlock(&head->lock); 311 /* No definite answer... Walk to established hash table */ 312 ret = __tcp_v4_check_established(sk, snum, NULL); 313 out: 314 local_bh_enable(); 315 return ret; 316 } 317 } 318 319 /* This will initiate an outgoing connection. */ 320 int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len) 321 { 322 struct inet_sock *inet = inet_sk(sk); 323 struct tcp_sock *tp = tcp_sk(sk); 324 struct sockaddr_in *usin = (struct sockaddr_in *)uaddr; 325 struct rtable *rt; 326 u32 daddr, nexthop; 327 int tmp; 328 int err; 329 330 if (addr_len < sizeof(struct sockaddr_in)) 331 return -EINVAL; 332 333 if (usin->sin_family != AF_INET) 334 return -EAFNOSUPPORT; 335 336 nexthop = daddr = usin->sin_addr.s_addr; 337 if (inet->opt && inet->opt->srr) { 338 if (!daddr) 339 return -EINVAL; 340 nexthop = inet->opt->faddr; 341 } 342 343 tmp = ip_route_connect(&rt, nexthop, inet->saddr, 344 RT_CONN_FLAGS(sk), sk->sk_bound_dev_if, 345 IPPROTO_TCP, 346 inet->sport, usin->sin_port, sk); 347 if (tmp < 0) 348 return tmp; 349 350 if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) { 351 ip_rt_put(rt); 352 return -ENETUNREACH; 353 } 354 355 if (!inet->opt || !inet->opt->srr) 356 daddr = rt->rt_dst; 357 358 if (!inet->saddr) 359 inet->saddr = rt->rt_src; 360 inet->rcv_saddr = inet->saddr; 361 362 if (tp->rx_opt.ts_recent_stamp && inet->daddr != daddr) { 363 /* Reset inherited state */ 364 tp->rx_opt.ts_recent = 0; 365 tp->rx_opt.ts_recent_stamp = 0; 366 tp->write_seq = 0; 367 } 368 369 if (tcp_death_row.sysctl_tw_recycle && 370 !tp->rx_opt.ts_recent_stamp && rt->rt_dst == daddr) { 371 struct inet_peer *peer = rt_get_peer(rt); 372 373 /* VJ's idea. We save last timestamp seen from 374 * the destination in peer table, when entering state TIME-WAIT 375 * and initialize rx_opt.ts_recent from it, when trying new connection. 376 */ 377 378 if (peer && peer->tcp_ts_stamp + TCP_PAWS_MSL >= xtime.tv_sec) { 379 tp->rx_opt.ts_recent_stamp = peer->tcp_ts_stamp; 380 tp->rx_opt.ts_recent = peer->tcp_ts; 381 } 382 } 383 384 inet->dport = usin->sin_port; 385 inet->daddr = daddr; 386 387 tp->ext_header_len = 0; 388 if (inet->opt) 389 tp->ext_header_len = inet->opt->optlen; 390 391 tp->rx_opt.mss_clamp = 536; 392 393 /* Socket identity is still unknown (sport may be zero). 394 * However we set state to SYN-SENT and not releasing socket 395 * lock select source port, enter ourselves into the hash tables and 396 * complete initialization after this. 397 */ 398 tcp_set_state(sk, TCP_SYN_SENT); 399 err = tcp_v4_hash_connect(sk); 400 if (err) 401 goto failure; 402 403 err = ip_route_newports(&rt, inet->sport, inet->dport, sk); 404 if (err) 405 goto failure; 406 407 /* OK, now commit destination to socket. */ 408 sk_setup_caps(sk, &rt->u.dst); 409 410 if (!tp->write_seq) 411 tp->write_seq = secure_tcp_sequence_number(inet->saddr, 412 inet->daddr, 413 inet->sport, 414 usin->sin_port); 415 416 inet->id = tp->write_seq ^ jiffies; 417 418 err = tcp_connect(sk); 419 rt = NULL; 420 if (err) 421 goto failure; 422 423 return 0; 424 425 failure: 426 /* This unhashes the socket and releases the local port, if necessary. */ 427 tcp_set_state(sk, TCP_CLOSE); 428 ip_rt_put(rt); 429 sk->sk_route_caps = 0; 430 inet->dport = 0; 431 return err; 432 } 433 434 /* 435 * This routine does path mtu discovery as defined in RFC1191. 436 */ 437 static inline void do_pmtu_discovery(struct sock *sk, struct iphdr *iph, 438 u32 mtu) 439 { 440 struct dst_entry *dst; 441 struct inet_sock *inet = inet_sk(sk); 442 struct tcp_sock *tp = tcp_sk(sk); 443 444 /* We are not interested in TCP_LISTEN and open_requests (SYN-ACKs 445 * send out by Linux are always <576bytes so they should go through 446 * unfragmented). 447 */ 448 if (sk->sk_state == TCP_LISTEN) 449 return; 450 451 /* We don't check in the destentry if pmtu discovery is forbidden 452 * on this route. We just assume that no packet_to_big packets 453 * are send back when pmtu discovery is not active. 454 * There is a small race when the user changes this flag in the 455 * route, but I think that's acceptable. 456 */ 457 if ((dst = __sk_dst_check(sk, 0)) == NULL) 458 return; 459 460 dst->ops->update_pmtu(dst, mtu); 461 462 /* Something is about to be wrong... Remember soft error 463 * for the case, if this connection will not able to recover. 464 */ 465 if (mtu < dst_mtu(dst) && ip_dont_fragment(sk, dst)) 466 sk->sk_err_soft = EMSGSIZE; 467 468 mtu = dst_mtu(dst); 469 470 if (inet->pmtudisc != IP_PMTUDISC_DONT && 471 tp->pmtu_cookie > mtu) { 472 tcp_sync_mss(sk, mtu); 473 474 /* Resend the TCP packet because it's 475 * clear that the old packet has been 476 * dropped. This is the new "fast" path mtu 477 * discovery. 478 */ 479 tcp_simple_retransmit(sk); 480 } /* else let the usual retransmit timer handle it */ 481 } 482 483 /* 484 * This routine is called by the ICMP module when it gets some 485 * sort of error condition. If err < 0 then the socket should 486 * be closed and the error returned to the user. If err > 0 487 * it's just the icmp type << 8 | icmp code. After adjustment 488 * header points to the first 8 bytes of the tcp header. We need 489 * to find the appropriate port. 490 * 491 * The locking strategy used here is very "optimistic". When 492 * someone else accesses the socket the ICMP is just dropped 493 * and for some paths there is no check at all. 494 * A more general error queue to queue errors for later handling 495 * is probably better. 496 * 497 */ 498 499 void tcp_v4_err(struct sk_buff *skb, u32 info) 500 { 501 struct iphdr *iph = (struct iphdr *)skb->data; 502 struct tcphdr *th = (struct tcphdr *)(skb->data + (iph->ihl << 2)); 503 struct tcp_sock *tp; 504 struct inet_sock *inet; 505 int type = skb->h.icmph->type; 506 int code = skb->h.icmph->code; 507 struct sock *sk; 508 __u32 seq; 509 int err; 510 511 if (skb->len < (iph->ihl << 2) + 8) { 512 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS); 513 return; 514 } 515 516 sk = inet_lookup(&tcp_hashinfo, iph->daddr, th->dest, iph->saddr, 517 th->source, inet_iif(skb)); 518 if (!sk) { 519 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS); 520 return; 521 } 522 if (sk->sk_state == TCP_TIME_WAIT) { 523 inet_twsk_put((struct inet_timewait_sock *)sk); 524 return; 525 } 526 527 bh_lock_sock(sk); 528 /* If too many ICMPs get dropped on busy 529 * servers this needs to be solved differently. 530 */ 531 if (sock_owned_by_user(sk)) 532 NET_INC_STATS_BH(LINUX_MIB_LOCKDROPPEDICMPS); 533 534 if (sk->sk_state == TCP_CLOSE) 535 goto out; 536 537 tp = tcp_sk(sk); 538 seq = ntohl(th->seq); 539 if (sk->sk_state != TCP_LISTEN && 540 !between(seq, tp->snd_una, tp->snd_nxt)) { 541 NET_INC_STATS(LINUX_MIB_OUTOFWINDOWICMPS); 542 goto out; 543 } 544 545 switch (type) { 546 case ICMP_SOURCE_QUENCH: 547 /* Just silently ignore these. */ 548 goto out; 549 case ICMP_PARAMETERPROB: 550 err = EPROTO; 551 break; 552 case ICMP_DEST_UNREACH: 553 if (code > NR_ICMP_UNREACH) 554 goto out; 555 556 if (code == ICMP_FRAG_NEEDED) { /* PMTU discovery (RFC1191) */ 557 if (!sock_owned_by_user(sk)) 558 do_pmtu_discovery(sk, iph, info); 559 goto out; 560 } 561 562 err = icmp_err_convert[code].errno; 563 break; 564 case ICMP_TIME_EXCEEDED: 565 err = EHOSTUNREACH; 566 break; 567 default: 568 goto out; 569 } 570 571 switch (sk->sk_state) { 572 struct request_sock *req, **prev; 573 case TCP_LISTEN: 574 if (sock_owned_by_user(sk)) 575 goto out; 576 577 req = inet_csk_search_req(sk, &prev, th->dest, 578 iph->daddr, iph->saddr); 579 if (!req) 580 goto out; 581 582 /* ICMPs are not backlogged, hence we cannot get 583 an established socket here. 584 */ 585 BUG_TRAP(!req->sk); 586 587 if (seq != tcp_rsk(req)->snt_isn) { 588 NET_INC_STATS_BH(LINUX_MIB_OUTOFWINDOWICMPS); 589 goto out; 590 } 591 592 /* 593 * Still in SYN_RECV, just remove it silently. 594 * There is no good way to pass the error to the newly 595 * created socket, and POSIX does not want network 596 * errors returned from accept(). 597 */ 598 inet_csk_reqsk_queue_drop(sk, req, prev); 599 goto out; 600 601 case TCP_SYN_SENT: 602 case TCP_SYN_RECV: /* Cannot happen. 603 It can f.e. if SYNs crossed. 604 */ 605 if (!sock_owned_by_user(sk)) { 606 TCP_INC_STATS_BH(TCP_MIB_ATTEMPTFAILS); 607 sk->sk_err = err; 608 609 sk->sk_error_report(sk); 610 611 tcp_done(sk); 612 } else { 613 sk->sk_err_soft = err; 614 } 615 goto out; 616 } 617 618 /* If we've already connected we will keep trying 619 * until we time out, or the user gives up. 620 * 621 * rfc1122 4.2.3.9 allows to consider as hard errors 622 * only PROTO_UNREACH and PORT_UNREACH (well, FRAG_FAILED too, 623 * but it is obsoleted by pmtu discovery). 624 * 625 * Note, that in modern internet, where routing is unreliable 626 * and in each dark corner broken firewalls sit, sending random 627 * errors ordered by their masters even this two messages finally lose 628 * their original sense (even Linux sends invalid PORT_UNREACHs) 629 * 630 * Now we are in compliance with RFCs. 631 * --ANK (980905) 632 */ 633 634 inet = inet_sk(sk); 635 if (!sock_owned_by_user(sk) && inet->recverr) { 636 sk->sk_err = err; 637 sk->sk_error_report(sk); 638 } else { /* Only an error on timeout */ 639 sk->sk_err_soft = err; 640 } 641 642 out: 643 bh_unlock_sock(sk); 644 sock_put(sk); 645 } 646 647 /* This routine computes an IPv4 TCP checksum. */ 648 void tcp_v4_send_check(struct sock *sk, struct tcphdr *th, int len, 649 struct sk_buff *skb) 650 { 651 struct inet_sock *inet = inet_sk(sk); 652 653 if (skb->ip_summed == CHECKSUM_HW) { 654 th->check = ~tcp_v4_check(th, len, inet->saddr, inet->daddr, 0); 655 skb->csum = offsetof(struct tcphdr, check); 656 } else { 657 th->check = tcp_v4_check(th, len, inet->saddr, inet->daddr, 658 csum_partial((char *)th, 659 th->doff << 2, 660 skb->csum)); 661 } 662 } 663 664 /* 665 * This routine will send an RST to the other tcp. 666 * 667 * Someone asks: why I NEVER use socket parameters (TOS, TTL etc.) 668 * for reset. 669 * Answer: if a packet caused RST, it is not for a socket 670 * existing in our system, if it is matched to a socket, 671 * it is just duplicate segment or bug in other side's TCP. 672 * So that we build reply only basing on parameters 673 * arrived with segment. 674 * Exception: precedence violation. We do not implement it in any case. 675 */ 676 677 static void tcp_v4_send_reset(struct sk_buff *skb) 678 { 679 struct tcphdr *th = skb->h.th; 680 struct tcphdr rth; 681 struct ip_reply_arg arg; 682 683 /* Never send a reset in response to a reset. */ 684 if (th->rst) 685 return; 686 687 if (((struct rtable *)skb->dst)->rt_type != RTN_LOCAL) 688 return; 689 690 /* Swap the send and the receive. */ 691 memset(&rth, 0, sizeof(struct tcphdr)); 692 rth.dest = th->source; 693 rth.source = th->dest; 694 rth.doff = sizeof(struct tcphdr) / 4; 695 rth.rst = 1; 696 697 if (th->ack) { 698 rth.seq = th->ack_seq; 699 } else { 700 rth.ack = 1; 701 rth.ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin + 702 skb->len - (th->doff << 2)); 703 } 704 705 memset(&arg, 0, sizeof arg); 706 arg.iov[0].iov_base = (unsigned char *)&rth; 707 arg.iov[0].iov_len = sizeof rth; 708 arg.csum = csum_tcpudp_nofold(skb->nh.iph->daddr, 709 skb->nh.iph->saddr, /*XXX*/ 710 sizeof(struct tcphdr), IPPROTO_TCP, 0); 711 arg.csumoffset = offsetof(struct tcphdr, check) / 2; 712 713 ip_send_reply(tcp_socket->sk, skb, &arg, sizeof rth); 714 715 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS); 716 TCP_INC_STATS_BH(TCP_MIB_OUTRSTS); 717 } 718 719 /* The code following below sending ACKs in SYN-RECV and TIME-WAIT states 720 outside socket context is ugly, certainly. What can I do? 721 */ 722 723 static void tcp_v4_send_ack(struct sk_buff *skb, u32 seq, u32 ack, 724 u32 win, u32 ts) 725 { 726 struct tcphdr *th = skb->h.th; 727 struct { 728 struct tcphdr th; 729 u32 tsopt[3]; 730 } rep; 731 struct ip_reply_arg arg; 732 733 memset(&rep.th, 0, sizeof(struct tcphdr)); 734 memset(&arg, 0, sizeof arg); 735 736 arg.iov[0].iov_base = (unsigned char *)&rep; 737 arg.iov[0].iov_len = sizeof(rep.th); 738 if (ts) { 739 rep.tsopt[0] = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) | 740 (TCPOPT_TIMESTAMP << 8) | 741 TCPOLEN_TIMESTAMP); 742 rep.tsopt[1] = htonl(tcp_time_stamp); 743 rep.tsopt[2] = htonl(ts); 744 arg.iov[0].iov_len = sizeof(rep); 745 } 746 747 /* Swap the send and the receive. */ 748 rep.th.dest = th->source; 749 rep.th.source = th->dest; 750 rep.th.doff = arg.iov[0].iov_len / 4; 751 rep.th.seq = htonl(seq); 752 rep.th.ack_seq = htonl(ack); 753 rep.th.ack = 1; 754 rep.th.window = htons(win); 755 756 arg.csum = csum_tcpudp_nofold(skb->nh.iph->daddr, 757 skb->nh.iph->saddr, /*XXX*/ 758 arg.iov[0].iov_len, IPPROTO_TCP, 0); 759 arg.csumoffset = offsetof(struct tcphdr, check) / 2; 760 761 ip_send_reply(tcp_socket->sk, skb, &arg, arg.iov[0].iov_len); 762 763 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS); 764 } 765 766 static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb) 767 { 768 struct inet_timewait_sock *tw = inet_twsk(sk); 769 const struct tcp_timewait_sock *tcptw = tcp_twsk(sk); 770 771 tcp_v4_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt, 772 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale, tcptw->tw_ts_recent); 773 774 inet_twsk_put(tw); 775 } 776 777 static void tcp_v4_reqsk_send_ack(struct sk_buff *skb, struct request_sock *req) 778 { 779 tcp_v4_send_ack(skb, tcp_rsk(req)->snt_isn + 1, tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd, 780 req->ts_recent); 781 } 782 783 /* 784 * Send a SYN-ACK after having received an ACK. 785 * This still operates on a request_sock only, not on a big 786 * socket. 787 */ 788 static int tcp_v4_send_synack(struct sock *sk, struct request_sock *req, 789 struct dst_entry *dst) 790 { 791 const struct inet_request_sock *ireq = inet_rsk(req); 792 int err = -1; 793 struct sk_buff * skb; 794 795 /* First, grab a route. */ 796 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL) 797 goto out; 798 799 skb = tcp_make_synack(sk, dst, req); 800 801 if (skb) { 802 struct tcphdr *th = skb->h.th; 803 804 th->check = tcp_v4_check(th, skb->len, 805 ireq->loc_addr, 806 ireq->rmt_addr, 807 csum_partial((char *)th, skb->len, 808 skb->csum)); 809 810 err = ip_build_and_send_pkt(skb, sk, ireq->loc_addr, 811 ireq->rmt_addr, 812 ireq->opt); 813 if (err == NET_XMIT_CN) 814 err = 0; 815 } 816 817 out: 818 dst_release(dst); 819 return err; 820 } 821 822 /* 823 * IPv4 request_sock destructor. 824 */ 825 static void tcp_v4_reqsk_destructor(struct request_sock *req) 826 { 827 if (inet_rsk(req)->opt) 828 kfree(inet_rsk(req)->opt); 829 } 830 831 static inline void syn_flood_warning(struct sk_buff *skb) 832 { 833 static unsigned long warntime; 834 835 if (time_after(jiffies, (warntime + HZ * 60))) { 836 warntime = jiffies; 837 printk(KERN_INFO 838 "possible SYN flooding on port %d. Sending cookies.\n", 839 ntohs(skb->h.th->dest)); 840 } 841 } 842 843 /* 844 * Save and compile IPv4 options into the request_sock if needed. 845 */ 846 static inline struct ip_options *tcp_v4_save_options(struct sock *sk, 847 struct sk_buff *skb) 848 { 849 struct ip_options *opt = &(IPCB(skb)->opt); 850 struct ip_options *dopt = NULL; 851 852 if (opt && opt->optlen) { 853 int opt_size = optlength(opt); 854 dopt = kmalloc(opt_size, GFP_ATOMIC); 855 if (dopt) { 856 if (ip_options_echo(dopt, skb)) { 857 kfree(dopt); 858 dopt = NULL; 859 } 860 } 861 } 862 return dopt; 863 } 864 865 struct request_sock_ops tcp_request_sock_ops = { 866 .family = PF_INET, 867 .obj_size = sizeof(struct tcp_request_sock), 868 .rtx_syn_ack = tcp_v4_send_synack, 869 .send_ack = tcp_v4_reqsk_send_ack, 870 .destructor = tcp_v4_reqsk_destructor, 871 .send_reset = tcp_v4_send_reset, 872 }; 873 874 int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb) 875 { 876 struct inet_request_sock *ireq; 877 struct tcp_options_received tmp_opt; 878 struct request_sock *req; 879 __u32 saddr = skb->nh.iph->saddr; 880 __u32 daddr = skb->nh.iph->daddr; 881 __u32 isn = TCP_SKB_CB(skb)->when; 882 struct dst_entry *dst = NULL; 883 #ifdef CONFIG_SYN_COOKIES 884 int want_cookie = 0; 885 #else 886 #define want_cookie 0 /* Argh, why doesn't gcc optimize this :( */ 887 #endif 888 889 /* Never answer to SYNs send to broadcast or multicast */ 890 if (((struct rtable *)skb->dst)->rt_flags & 891 (RTCF_BROADCAST | RTCF_MULTICAST)) 892 goto drop; 893 894 /* TW buckets are converted to open requests without 895 * limitations, they conserve resources and peer is 896 * evidently real one. 897 */ 898 if (inet_csk_reqsk_queue_is_full(sk) && !isn) { 899 #ifdef CONFIG_SYN_COOKIES 900 if (sysctl_tcp_syncookies) { 901 want_cookie = 1; 902 } else 903 #endif 904 goto drop; 905 } 906 907 /* Accept backlog is full. If we have already queued enough 908 * of warm entries in syn queue, drop request. It is better than 909 * clogging syn queue with openreqs with exponentially increasing 910 * timeout. 911 */ 912 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1) 913 goto drop; 914 915 req = reqsk_alloc(&tcp_request_sock_ops); 916 if (!req) 917 goto drop; 918 919 tcp_clear_options(&tmp_opt); 920 tmp_opt.mss_clamp = 536; 921 tmp_opt.user_mss = tcp_sk(sk)->rx_opt.user_mss; 922 923 tcp_parse_options(skb, &tmp_opt, 0); 924 925 if (want_cookie) { 926 tcp_clear_options(&tmp_opt); 927 tmp_opt.saw_tstamp = 0; 928 } 929 930 if (tmp_opt.saw_tstamp && !tmp_opt.rcv_tsval) { 931 /* Some OSes (unknown ones, but I see them on web server, which 932 * contains information interesting only for windows' 933 * users) do not send their stamp in SYN. It is easy case. 934 * We simply do not advertise TS support. 935 */ 936 tmp_opt.saw_tstamp = 0; 937 tmp_opt.tstamp_ok = 0; 938 } 939 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp; 940 941 tcp_openreq_init(req, &tmp_opt, skb); 942 943 ireq = inet_rsk(req); 944 ireq->loc_addr = daddr; 945 ireq->rmt_addr = saddr; 946 ireq->opt = tcp_v4_save_options(sk, skb); 947 if (!want_cookie) 948 TCP_ECN_create_request(req, skb->h.th); 949 950 if (want_cookie) { 951 #ifdef CONFIG_SYN_COOKIES 952 syn_flood_warning(skb); 953 #endif 954 isn = cookie_v4_init_sequence(sk, skb, &req->mss); 955 } else if (!isn) { 956 struct inet_peer *peer = NULL; 957 958 /* VJ's idea. We save last timestamp seen 959 * from the destination in peer table, when entering 960 * state TIME-WAIT, and check against it before 961 * accepting new connection request. 962 * 963 * If "isn" is not zero, this request hit alive 964 * timewait bucket, so that all the necessary checks 965 * are made in the function processing timewait state. 966 */ 967 if (tmp_opt.saw_tstamp && 968 tcp_death_row.sysctl_tw_recycle && 969 (dst = inet_csk_route_req(sk, req)) != NULL && 970 (peer = rt_get_peer((struct rtable *)dst)) != NULL && 971 peer->v4daddr == saddr) { 972 if (xtime.tv_sec < peer->tcp_ts_stamp + TCP_PAWS_MSL && 973 (s32)(peer->tcp_ts - req->ts_recent) > 974 TCP_PAWS_WINDOW) { 975 NET_INC_STATS_BH(LINUX_MIB_PAWSPASSIVEREJECTED); 976 dst_release(dst); 977 goto drop_and_free; 978 } 979 } 980 /* Kill the following clause, if you dislike this way. */ 981 else if (!sysctl_tcp_syncookies && 982 (sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) < 983 (sysctl_max_syn_backlog >> 2)) && 984 (!peer || !peer->tcp_ts_stamp) && 985 (!dst || !dst_metric(dst, RTAX_RTT))) { 986 /* Without syncookies last quarter of 987 * backlog is filled with destinations, 988 * proven to be alive. 989 * It means that we continue to communicate 990 * to destinations, already remembered 991 * to the moment of synflood. 992 */ 993 LIMIT_NETDEBUG(KERN_DEBUG "TCP: drop open " 994 "request from %u.%u.%u.%u/%u\n", 995 NIPQUAD(saddr), 996 ntohs(skb->h.th->source)); 997 dst_release(dst); 998 goto drop_and_free; 999 } 1000 1001 isn = tcp_v4_init_sequence(sk, skb); 1002 } 1003 tcp_rsk(req)->snt_isn = isn; 1004 1005 if (tcp_v4_send_synack(sk, req, dst)) 1006 goto drop_and_free; 1007 1008 if (want_cookie) { 1009 reqsk_free(req); 1010 } else { 1011 inet_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT); 1012 } 1013 return 0; 1014 1015 drop_and_free: 1016 reqsk_free(req); 1017 drop: 1018 TCP_INC_STATS_BH(TCP_MIB_ATTEMPTFAILS); 1019 return 0; 1020 } 1021 1022 1023 /* 1024 * The three way handshake has completed - we got a valid synack - 1025 * now create the new socket. 1026 */ 1027 struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb, 1028 struct request_sock *req, 1029 struct dst_entry *dst) 1030 { 1031 struct inet_request_sock *ireq; 1032 struct inet_sock *newinet; 1033 struct tcp_sock *newtp; 1034 struct sock *newsk; 1035 1036 if (sk_acceptq_is_full(sk)) 1037 goto exit_overflow; 1038 1039 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL) 1040 goto exit; 1041 1042 newsk = tcp_create_openreq_child(sk, req, skb); 1043 if (!newsk) 1044 goto exit; 1045 1046 sk_setup_caps(newsk, dst); 1047 1048 newtp = tcp_sk(newsk); 1049 newinet = inet_sk(newsk); 1050 ireq = inet_rsk(req); 1051 newinet->daddr = ireq->rmt_addr; 1052 newinet->rcv_saddr = ireq->loc_addr; 1053 newinet->saddr = ireq->loc_addr; 1054 newinet->opt = ireq->opt; 1055 ireq->opt = NULL; 1056 newinet->mc_index = inet_iif(skb); 1057 newinet->mc_ttl = skb->nh.iph->ttl; 1058 newtp->ext_header_len = 0; 1059 if (newinet->opt) 1060 newtp->ext_header_len = newinet->opt->optlen; 1061 newinet->id = newtp->write_seq ^ jiffies; 1062 1063 tcp_sync_mss(newsk, dst_mtu(dst)); 1064 newtp->advmss = dst_metric(dst, RTAX_ADVMSS); 1065 tcp_initialize_rcv_mss(newsk); 1066 1067 __inet_hash(&tcp_hashinfo, newsk, 0); 1068 __inet_inherit_port(&tcp_hashinfo, sk, newsk); 1069 1070 return newsk; 1071 1072 exit_overflow: 1073 NET_INC_STATS_BH(LINUX_MIB_LISTENOVERFLOWS); 1074 exit: 1075 NET_INC_STATS_BH(LINUX_MIB_LISTENDROPS); 1076 dst_release(dst); 1077 return NULL; 1078 } 1079 1080 static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb) 1081 { 1082 struct tcphdr *th = skb->h.th; 1083 struct iphdr *iph = skb->nh.iph; 1084 struct sock *nsk; 1085 struct request_sock **prev; 1086 /* Find possible connection requests. */ 1087 struct request_sock *req = inet_csk_search_req(sk, &prev, th->source, 1088 iph->saddr, iph->daddr); 1089 if (req) 1090 return tcp_check_req(sk, skb, req, prev); 1091 1092 nsk = __inet_lookup_established(&tcp_hashinfo, skb->nh.iph->saddr, 1093 th->source, skb->nh.iph->daddr, 1094 ntohs(th->dest), inet_iif(skb)); 1095 1096 if (nsk) { 1097 if (nsk->sk_state != TCP_TIME_WAIT) { 1098 bh_lock_sock(nsk); 1099 return nsk; 1100 } 1101 inet_twsk_put((struct inet_timewait_sock *)nsk); 1102 return NULL; 1103 } 1104 1105 #ifdef CONFIG_SYN_COOKIES 1106 if (!th->rst && !th->syn && th->ack) 1107 sk = cookie_v4_check(sk, skb, &(IPCB(skb)->opt)); 1108 #endif 1109 return sk; 1110 } 1111 1112 static int tcp_v4_checksum_init(struct sk_buff *skb) 1113 { 1114 if (skb->ip_summed == CHECKSUM_HW) { 1115 skb->ip_summed = CHECKSUM_UNNECESSARY; 1116 if (!tcp_v4_check(skb->h.th, skb->len, skb->nh.iph->saddr, 1117 skb->nh.iph->daddr, skb->csum)) 1118 return 0; 1119 1120 LIMIT_NETDEBUG(KERN_DEBUG "hw tcp v4 csum failed\n"); 1121 skb->ip_summed = CHECKSUM_NONE; 1122 } 1123 if (skb->len <= 76) { 1124 if (tcp_v4_check(skb->h.th, skb->len, skb->nh.iph->saddr, 1125 skb->nh.iph->daddr, 1126 skb_checksum(skb, 0, skb->len, 0))) 1127 return -1; 1128 skb->ip_summed = CHECKSUM_UNNECESSARY; 1129 } else { 1130 skb->csum = ~tcp_v4_check(skb->h.th, skb->len, 1131 skb->nh.iph->saddr, 1132 skb->nh.iph->daddr, 0); 1133 } 1134 return 0; 1135 } 1136 1137 1138 /* The socket must have it's spinlock held when we get 1139 * here. 1140 * 1141 * We have a potential double-lock case here, so even when 1142 * doing backlog processing we use the BH locking scheme. 1143 * This is because we cannot sleep with the original spinlock 1144 * held. 1145 */ 1146 int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb) 1147 { 1148 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */ 1149 TCP_CHECK_TIMER(sk); 1150 if (tcp_rcv_established(sk, skb, skb->h.th, skb->len)) 1151 goto reset; 1152 TCP_CHECK_TIMER(sk); 1153 return 0; 1154 } 1155 1156 if (skb->len < (skb->h.th->doff << 2) || tcp_checksum_complete(skb)) 1157 goto csum_err; 1158 1159 if (sk->sk_state == TCP_LISTEN) { 1160 struct sock *nsk = tcp_v4_hnd_req(sk, skb); 1161 if (!nsk) 1162 goto discard; 1163 1164 if (nsk != sk) { 1165 if (tcp_child_process(sk, nsk, skb)) 1166 goto reset; 1167 return 0; 1168 } 1169 } 1170 1171 TCP_CHECK_TIMER(sk); 1172 if (tcp_rcv_state_process(sk, skb, skb->h.th, skb->len)) 1173 goto reset; 1174 TCP_CHECK_TIMER(sk); 1175 return 0; 1176 1177 reset: 1178 tcp_v4_send_reset(skb); 1179 discard: 1180 kfree_skb(skb); 1181 /* Be careful here. If this function gets more complicated and 1182 * gcc suffers from register pressure on the x86, sk (in %ebx) 1183 * might be destroyed here. This current version compiles correctly, 1184 * but you have been warned. 1185 */ 1186 return 0; 1187 1188 csum_err: 1189 TCP_INC_STATS_BH(TCP_MIB_INERRS); 1190 goto discard; 1191 } 1192 1193 /* 1194 * From tcp_input.c 1195 */ 1196 1197 int tcp_v4_rcv(struct sk_buff *skb) 1198 { 1199 struct tcphdr *th; 1200 struct sock *sk; 1201 int ret; 1202 1203 if (skb->pkt_type != PACKET_HOST) 1204 goto discard_it; 1205 1206 /* Count it even if it's bad */ 1207 TCP_INC_STATS_BH(TCP_MIB_INSEGS); 1208 1209 if (!pskb_may_pull(skb, sizeof(struct tcphdr))) 1210 goto discard_it; 1211 1212 th = skb->h.th; 1213 1214 if (th->doff < sizeof(struct tcphdr) / 4) 1215 goto bad_packet; 1216 if (!pskb_may_pull(skb, th->doff * 4)) 1217 goto discard_it; 1218 1219 /* An explanation is required here, I think. 1220 * Packet length and doff are validated by header prediction, 1221 * provided case of th->doff==0 is elimineted. 1222 * So, we defer the checks. */ 1223 if ((skb->ip_summed != CHECKSUM_UNNECESSARY && 1224 tcp_v4_checksum_init(skb) < 0)) 1225 goto bad_packet; 1226 1227 th = skb->h.th; 1228 TCP_SKB_CB(skb)->seq = ntohl(th->seq); 1229 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin + 1230 skb->len - th->doff * 4); 1231 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq); 1232 TCP_SKB_CB(skb)->when = 0; 1233 TCP_SKB_CB(skb)->flags = skb->nh.iph->tos; 1234 TCP_SKB_CB(skb)->sacked = 0; 1235 1236 sk = __inet_lookup(&tcp_hashinfo, skb->nh.iph->saddr, th->source, 1237 skb->nh.iph->daddr, ntohs(th->dest), 1238 inet_iif(skb)); 1239 1240 if (!sk) 1241 goto no_tcp_socket; 1242 1243 process: 1244 if (sk->sk_state == TCP_TIME_WAIT) 1245 goto do_time_wait; 1246 1247 if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb)) 1248 goto discard_and_relse; 1249 1250 if (sk_filter(sk, skb, 0)) 1251 goto discard_and_relse; 1252 1253 skb->dev = NULL; 1254 1255 bh_lock_sock(sk); 1256 ret = 0; 1257 if (!sock_owned_by_user(sk)) { 1258 if (!tcp_prequeue(sk, skb)) 1259 ret = tcp_v4_do_rcv(sk, skb); 1260 } else 1261 sk_add_backlog(sk, skb); 1262 bh_unlock_sock(sk); 1263 1264 sock_put(sk); 1265 1266 return ret; 1267 1268 no_tcp_socket: 1269 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) 1270 goto discard_it; 1271 1272 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) { 1273 bad_packet: 1274 TCP_INC_STATS_BH(TCP_MIB_INERRS); 1275 } else { 1276 tcp_v4_send_reset(skb); 1277 } 1278 1279 discard_it: 1280 /* Discard frame. */ 1281 kfree_skb(skb); 1282 return 0; 1283 1284 discard_and_relse: 1285 sock_put(sk); 1286 goto discard_it; 1287 1288 do_time_wait: 1289 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) { 1290 inet_twsk_put((struct inet_timewait_sock *) sk); 1291 goto discard_it; 1292 } 1293 1294 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) { 1295 TCP_INC_STATS_BH(TCP_MIB_INERRS); 1296 inet_twsk_put((struct inet_timewait_sock *) sk); 1297 goto discard_it; 1298 } 1299 switch (tcp_timewait_state_process((struct inet_timewait_sock *)sk, 1300 skb, th)) { 1301 case TCP_TW_SYN: { 1302 struct sock *sk2 = inet_lookup_listener(&tcp_hashinfo, 1303 skb->nh.iph->daddr, 1304 ntohs(th->dest), 1305 inet_iif(skb)); 1306 if (sk2) { 1307 inet_twsk_deschedule((struct inet_timewait_sock *)sk, 1308 &tcp_death_row); 1309 inet_twsk_put((struct inet_timewait_sock *)sk); 1310 sk = sk2; 1311 goto process; 1312 } 1313 /* Fall through to ACK */ 1314 } 1315 case TCP_TW_ACK: 1316 tcp_v4_timewait_ack(sk, skb); 1317 break; 1318 case TCP_TW_RST: 1319 goto no_tcp_socket; 1320 case TCP_TW_SUCCESS:; 1321 } 1322 goto discard_it; 1323 } 1324 1325 static void v4_addr2sockaddr(struct sock *sk, struct sockaddr * uaddr) 1326 { 1327 struct sockaddr_in *sin = (struct sockaddr_in *) uaddr; 1328 struct inet_sock *inet = inet_sk(sk); 1329 1330 sin->sin_family = AF_INET; 1331 sin->sin_addr.s_addr = inet->daddr; 1332 sin->sin_port = inet->dport; 1333 } 1334 1335 /* VJ's idea. Save last timestamp seen from this destination 1336 * and hold it at least for normal timewait interval to use for duplicate 1337 * segment detection in subsequent connections, before they enter synchronized 1338 * state. 1339 */ 1340 1341 int tcp_v4_remember_stamp(struct sock *sk) 1342 { 1343 struct inet_sock *inet = inet_sk(sk); 1344 struct tcp_sock *tp = tcp_sk(sk); 1345 struct rtable *rt = (struct rtable *)__sk_dst_get(sk); 1346 struct inet_peer *peer = NULL; 1347 int release_it = 0; 1348 1349 if (!rt || rt->rt_dst != inet->daddr) { 1350 peer = inet_getpeer(inet->daddr, 1); 1351 release_it = 1; 1352 } else { 1353 if (!rt->peer) 1354 rt_bind_peer(rt, 1); 1355 peer = rt->peer; 1356 } 1357 1358 if (peer) { 1359 if ((s32)(peer->tcp_ts - tp->rx_opt.ts_recent) <= 0 || 1360 (peer->tcp_ts_stamp + TCP_PAWS_MSL < xtime.tv_sec && 1361 peer->tcp_ts_stamp <= tp->rx_opt.ts_recent_stamp)) { 1362 peer->tcp_ts_stamp = tp->rx_opt.ts_recent_stamp; 1363 peer->tcp_ts = tp->rx_opt.ts_recent; 1364 } 1365 if (release_it) 1366 inet_putpeer(peer); 1367 return 1; 1368 } 1369 1370 return 0; 1371 } 1372 1373 int tcp_v4_tw_remember_stamp(struct inet_timewait_sock *tw) 1374 { 1375 struct inet_peer *peer = inet_getpeer(tw->tw_daddr, 1); 1376 1377 if (peer) { 1378 const struct tcp_timewait_sock *tcptw = tcp_twsk((struct sock *)tw); 1379 1380 if ((s32)(peer->tcp_ts - tcptw->tw_ts_recent) <= 0 || 1381 (peer->tcp_ts_stamp + TCP_PAWS_MSL < xtime.tv_sec && 1382 peer->tcp_ts_stamp <= tcptw->tw_ts_recent_stamp)) { 1383 peer->tcp_ts_stamp = tcptw->tw_ts_recent_stamp; 1384 peer->tcp_ts = tcptw->tw_ts_recent; 1385 } 1386 inet_putpeer(peer); 1387 return 1; 1388 } 1389 1390 return 0; 1391 } 1392 1393 struct tcp_func ipv4_specific = { 1394 .queue_xmit = ip_queue_xmit, 1395 .send_check = tcp_v4_send_check, 1396 .rebuild_header = inet_sk_rebuild_header, 1397 .conn_request = tcp_v4_conn_request, 1398 .syn_recv_sock = tcp_v4_syn_recv_sock, 1399 .remember_stamp = tcp_v4_remember_stamp, 1400 .net_header_len = sizeof(struct iphdr), 1401 .setsockopt = ip_setsockopt, 1402 .getsockopt = ip_getsockopt, 1403 .addr2sockaddr = v4_addr2sockaddr, 1404 .sockaddr_len = sizeof(struct sockaddr_in), 1405 }; 1406 1407 /* NOTE: A lot of things set to zero explicitly by call to 1408 * sk_alloc() so need not be done here. 1409 */ 1410 static int tcp_v4_init_sock(struct sock *sk) 1411 { 1412 struct inet_connection_sock *icsk = inet_csk(sk); 1413 struct tcp_sock *tp = tcp_sk(sk); 1414 1415 skb_queue_head_init(&tp->out_of_order_queue); 1416 tcp_init_xmit_timers(sk); 1417 tcp_prequeue_init(tp); 1418 1419 icsk->icsk_rto = TCP_TIMEOUT_INIT; 1420 tp->mdev = TCP_TIMEOUT_INIT; 1421 1422 /* So many TCP implementations out there (incorrectly) count the 1423 * initial SYN frame in their delayed-ACK and congestion control 1424 * algorithms that we must have the following bandaid to talk 1425 * efficiently to them. -DaveM 1426 */ 1427 tp->snd_cwnd = 2; 1428 1429 /* See draft-stevens-tcpca-spec-01 for discussion of the 1430 * initialization of these values. 1431 */ 1432 tp->snd_ssthresh = 0x7fffffff; /* Infinity */ 1433 tp->snd_cwnd_clamp = ~0; 1434 tp->mss_cache = 536; 1435 1436 tp->reordering = sysctl_tcp_reordering; 1437 icsk->icsk_ca_ops = &tcp_init_congestion_ops; 1438 1439 sk->sk_state = TCP_CLOSE; 1440 1441 sk->sk_write_space = sk_stream_write_space; 1442 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE); 1443 1444 tp->af_specific = &ipv4_specific; 1445 1446 sk->sk_sndbuf = sysctl_tcp_wmem[1]; 1447 sk->sk_rcvbuf = sysctl_tcp_rmem[1]; 1448 1449 atomic_inc(&tcp_sockets_allocated); 1450 1451 return 0; 1452 } 1453 1454 int tcp_v4_destroy_sock(struct sock *sk) 1455 { 1456 struct tcp_sock *tp = tcp_sk(sk); 1457 1458 tcp_clear_xmit_timers(sk); 1459 1460 tcp_cleanup_congestion_control(sk); 1461 1462 /* Cleanup up the write buffer. */ 1463 sk_stream_writequeue_purge(sk); 1464 1465 /* Cleans up our, hopefully empty, out_of_order_queue. */ 1466 __skb_queue_purge(&tp->out_of_order_queue); 1467 1468 /* Clean prequeue, it must be empty really */ 1469 __skb_queue_purge(&tp->ucopy.prequeue); 1470 1471 /* Clean up a referenced TCP bind bucket. */ 1472 if (inet_csk(sk)->icsk_bind_hash) 1473 inet_put_port(&tcp_hashinfo, sk); 1474 1475 /* 1476 * If sendmsg cached page exists, toss it. 1477 */ 1478 if (sk->sk_sndmsg_page) { 1479 __free_page(sk->sk_sndmsg_page); 1480 sk->sk_sndmsg_page = NULL; 1481 } 1482 1483 atomic_dec(&tcp_sockets_allocated); 1484 1485 return 0; 1486 } 1487 1488 EXPORT_SYMBOL(tcp_v4_destroy_sock); 1489 1490 #ifdef CONFIG_PROC_FS 1491 /* Proc filesystem TCP sock list dumping. */ 1492 1493 static inline struct inet_timewait_sock *tw_head(struct hlist_head *head) 1494 { 1495 return hlist_empty(head) ? NULL : 1496 list_entry(head->first, struct inet_timewait_sock, tw_node); 1497 } 1498 1499 static inline struct inet_timewait_sock *tw_next(struct inet_timewait_sock *tw) 1500 { 1501 return tw->tw_node.next ? 1502 hlist_entry(tw->tw_node.next, typeof(*tw), tw_node) : NULL; 1503 } 1504 1505 static void *listening_get_next(struct seq_file *seq, void *cur) 1506 { 1507 struct inet_connection_sock *icsk; 1508 struct hlist_node *node; 1509 struct sock *sk = cur; 1510 struct tcp_iter_state* st = seq->private; 1511 1512 if (!sk) { 1513 st->bucket = 0; 1514 sk = sk_head(&tcp_hashinfo.listening_hash[0]); 1515 goto get_sk; 1516 } 1517 1518 ++st->num; 1519 1520 if (st->state == TCP_SEQ_STATE_OPENREQ) { 1521 struct request_sock *req = cur; 1522 1523 icsk = inet_csk(st->syn_wait_sk); 1524 req = req->dl_next; 1525 while (1) { 1526 while (req) { 1527 if (req->rsk_ops->family == st->family) { 1528 cur = req; 1529 goto out; 1530 } 1531 req = req->dl_next; 1532 } 1533 if (++st->sbucket >= TCP_SYNQ_HSIZE) 1534 break; 1535 get_req: 1536 req = icsk->icsk_accept_queue.listen_opt->syn_table[st->sbucket]; 1537 } 1538 sk = sk_next(st->syn_wait_sk); 1539 st->state = TCP_SEQ_STATE_LISTENING; 1540 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock); 1541 } else { 1542 icsk = inet_csk(sk); 1543 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock); 1544 if (reqsk_queue_len(&icsk->icsk_accept_queue)) 1545 goto start_req; 1546 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock); 1547 sk = sk_next(sk); 1548 } 1549 get_sk: 1550 sk_for_each_from(sk, node) { 1551 if (sk->sk_family == st->family) { 1552 cur = sk; 1553 goto out; 1554 } 1555 icsk = inet_csk(sk); 1556 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock); 1557 if (reqsk_queue_len(&icsk->icsk_accept_queue)) { 1558 start_req: 1559 st->uid = sock_i_uid(sk); 1560 st->syn_wait_sk = sk; 1561 st->state = TCP_SEQ_STATE_OPENREQ; 1562 st->sbucket = 0; 1563 goto get_req; 1564 } 1565 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock); 1566 } 1567 if (++st->bucket < INET_LHTABLE_SIZE) { 1568 sk = sk_head(&tcp_hashinfo.listening_hash[st->bucket]); 1569 goto get_sk; 1570 } 1571 cur = NULL; 1572 out: 1573 return cur; 1574 } 1575 1576 static void *listening_get_idx(struct seq_file *seq, loff_t *pos) 1577 { 1578 void *rc = listening_get_next(seq, NULL); 1579 1580 while (rc && *pos) { 1581 rc = listening_get_next(seq, rc); 1582 --*pos; 1583 } 1584 return rc; 1585 } 1586 1587 static void *established_get_first(struct seq_file *seq) 1588 { 1589 struct tcp_iter_state* st = seq->private; 1590 void *rc = NULL; 1591 1592 for (st->bucket = 0; st->bucket < tcp_hashinfo.ehash_size; ++st->bucket) { 1593 struct sock *sk; 1594 struct hlist_node *node; 1595 struct inet_timewait_sock *tw; 1596 1597 /* We can reschedule _before_ having picked the target: */ 1598 cond_resched_softirq(); 1599 1600 read_lock(&tcp_hashinfo.ehash[st->bucket].lock); 1601 sk_for_each(sk, node, &tcp_hashinfo.ehash[st->bucket].chain) { 1602 if (sk->sk_family != st->family) { 1603 continue; 1604 } 1605 rc = sk; 1606 goto out; 1607 } 1608 st->state = TCP_SEQ_STATE_TIME_WAIT; 1609 inet_twsk_for_each(tw, node, 1610 &tcp_hashinfo.ehash[st->bucket + tcp_hashinfo.ehash_size].chain) { 1611 if (tw->tw_family != st->family) { 1612 continue; 1613 } 1614 rc = tw; 1615 goto out; 1616 } 1617 read_unlock(&tcp_hashinfo.ehash[st->bucket].lock); 1618 st->state = TCP_SEQ_STATE_ESTABLISHED; 1619 } 1620 out: 1621 return rc; 1622 } 1623 1624 static void *established_get_next(struct seq_file *seq, void *cur) 1625 { 1626 struct sock *sk = cur; 1627 struct inet_timewait_sock *tw; 1628 struct hlist_node *node; 1629 struct tcp_iter_state* st = seq->private; 1630 1631 ++st->num; 1632 1633 if (st->state == TCP_SEQ_STATE_TIME_WAIT) { 1634 tw = cur; 1635 tw = tw_next(tw); 1636 get_tw: 1637 while (tw && tw->tw_family != st->family) { 1638 tw = tw_next(tw); 1639 } 1640 if (tw) { 1641 cur = tw; 1642 goto out; 1643 } 1644 read_unlock(&tcp_hashinfo.ehash[st->bucket].lock); 1645 st->state = TCP_SEQ_STATE_ESTABLISHED; 1646 1647 /* We can reschedule between buckets: */ 1648 cond_resched_softirq(); 1649 1650 if (++st->bucket < tcp_hashinfo.ehash_size) { 1651 read_lock(&tcp_hashinfo.ehash[st->bucket].lock); 1652 sk = sk_head(&tcp_hashinfo.ehash[st->bucket].chain); 1653 } else { 1654 cur = NULL; 1655 goto out; 1656 } 1657 } else 1658 sk = sk_next(sk); 1659 1660 sk_for_each_from(sk, node) { 1661 if (sk->sk_family == st->family) 1662 goto found; 1663 } 1664 1665 st->state = TCP_SEQ_STATE_TIME_WAIT; 1666 tw = tw_head(&tcp_hashinfo.ehash[st->bucket + tcp_hashinfo.ehash_size].chain); 1667 goto get_tw; 1668 found: 1669 cur = sk; 1670 out: 1671 return cur; 1672 } 1673 1674 static void *established_get_idx(struct seq_file *seq, loff_t pos) 1675 { 1676 void *rc = established_get_first(seq); 1677 1678 while (rc && pos) { 1679 rc = established_get_next(seq, rc); 1680 --pos; 1681 } 1682 return rc; 1683 } 1684 1685 static void *tcp_get_idx(struct seq_file *seq, loff_t pos) 1686 { 1687 void *rc; 1688 struct tcp_iter_state* st = seq->private; 1689 1690 inet_listen_lock(&tcp_hashinfo); 1691 st->state = TCP_SEQ_STATE_LISTENING; 1692 rc = listening_get_idx(seq, &pos); 1693 1694 if (!rc) { 1695 inet_listen_unlock(&tcp_hashinfo); 1696 local_bh_disable(); 1697 st->state = TCP_SEQ_STATE_ESTABLISHED; 1698 rc = established_get_idx(seq, pos); 1699 } 1700 1701 return rc; 1702 } 1703 1704 static void *tcp_seq_start(struct seq_file *seq, loff_t *pos) 1705 { 1706 struct tcp_iter_state* st = seq->private; 1707 st->state = TCP_SEQ_STATE_LISTENING; 1708 st->num = 0; 1709 return *pos ? tcp_get_idx(seq, *pos - 1) : SEQ_START_TOKEN; 1710 } 1711 1712 static void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos) 1713 { 1714 void *rc = NULL; 1715 struct tcp_iter_state* st; 1716 1717 if (v == SEQ_START_TOKEN) { 1718 rc = tcp_get_idx(seq, 0); 1719 goto out; 1720 } 1721 st = seq->private; 1722 1723 switch (st->state) { 1724 case TCP_SEQ_STATE_OPENREQ: 1725 case TCP_SEQ_STATE_LISTENING: 1726 rc = listening_get_next(seq, v); 1727 if (!rc) { 1728 inet_listen_unlock(&tcp_hashinfo); 1729 local_bh_disable(); 1730 st->state = TCP_SEQ_STATE_ESTABLISHED; 1731 rc = established_get_first(seq); 1732 } 1733 break; 1734 case TCP_SEQ_STATE_ESTABLISHED: 1735 case TCP_SEQ_STATE_TIME_WAIT: 1736 rc = established_get_next(seq, v); 1737 break; 1738 } 1739 out: 1740 ++*pos; 1741 return rc; 1742 } 1743 1744 static void tcp_seq_stop(struct seq_file *seq, void *v) 1745 { 1746 struct tcp_iter_state* st = seq->private; 1747 1748 switch (st->state) { 1749 case TCP_SEQ_STATE_OPENREQ: 1750 if (v) { 1751 struct inet_connection_sock *icsk = inet_csk(st->syn_wait_sk); 1752 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock); 1753 } 1754 case TCP_SEQ_STATE_LISTENING: 1755 if (v != SEQ_START_TOKEN) 1756 inet_listen_unlock(&tcp_hashinfo); 1757 break; 1758 case TCP_SEQ_STATE_TIME_WAIT: 1759 case TCP_SEQ_STATE_ESTABLISHED: 1760 if (v) 1761 read_unlock(&tcp_hashinfo.ehash[st->bucket].lock); 1762 local_bh_enable(); 1763 break; 1764 } 1765 } 1766 1767 static int tcp_seq_open(struct inode *inode, struct file *file) 1768 { 1769 struct tcp_seq_afinfo *afinfo = PDE(inode)->data; 1770 struct seq_file *seq; 1771 struct tcp_iter_state *s; 1772 int rc; 1773 1774 if (unlikely(afinfo == NULL)) 1775 return -EINVAL; 1776 1777 s = kmalloc(sizeof(*s), GFP_KERNEL); 1778 if (!s) 1779 return -ENOMEM; 1780 memset(s, 0, sizeof(*s)); 1781 s->family = afinfo->family; 1782 s->seq_ops.start = tcp_seq_start; 1783 s->seq_ops.next = tcp_seq_next; 1784 s->seq_ops.show = afinfo->seq_show; 1785 s->seq_ops.stop = tcp_seq_stop; 1786 1787 rc = seq_open(file, &s->seq_ops); 1788 if (rc) 1789 goto out_kfree; 1790 seq = file->private_data; 1791 seq->private = s; 1792 out: 1793 return rc; 1794 out_kfree: 1795 kfree(s); 1796 goto out; 1797 } 1798 1799 int tcp_proc_register(struct tcp_seq_afinfo *afinfo) 1800 { 1801 int rc = 0; 1802 struct proc_dir_entry *p; 1803 1804 if (!afinfo) 1805 return -EINVAL; 1806 afinfo->seq_fops->owner = afinfo->owner; 1807 afinfo->seq_fops->open = tcp_seq_open; 1808 afinfo->seq_fops->read = seq_read; 1809 afinfo->seq_fops->llseek = seq_lseek; 1810 afinfo->seq_fops->release = seq_release_private; 1811 1812 p = proc_net_fops_create(afinfo->name, S_IRUGO, afinfo->seq_fops); 1813 if (p) 1814 p->data = afinfo; 1815 else 1816 rc = -ENOMEM; 1817 return rc; 1818 } 1819 1820 void tcp_proc_unregister(struct tcp_seq_afinfo *afinfo) 1821 { 1822 if (!afinfo) 1823 return; 1824 proc_net_remove(afinfo->name); 1825 memset(afinfo->seq_fops, 0, sizeof(*afinfo->seq_fops)); 1826 } 1827 1828 static void get_openreq4(struct sock *sk, struct request_sock *req, 1829 char *tmpbuf, int i, int uid) 1830 { 1831 const struct inet_request_sock *ireq = inet_rsk(req); 1832 int ttd = req->expires - jiffies; 1833 1834 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X" 1835 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %u %d %p", 1836 i, 1837 ireq->loc_addr, 1838 ntohs(inet_sk(sk)->sport), 1839 ireq->rmt_addr, 1840 ntohs(ireq->rmt_port), 1841 TCP_SYN_RECV, 1842 0, 0, /* could print option size, but that is af dependent. */ 1843 1, /* timers active (only the expire timer) */ 1844 jiffies_to_clock_t(ttd), 1845 req->retrans, 1846 uid, 1847 0, /* non standard timer */ 1848 0, /* open_requests have no inode */ 1849 atomic_read(&sk->sk_refcnt), 1850 req); 1851 } 1852 1853 static void get_tcp4_sock(struct sock *sp, char *tmpbuf, int i) 1854 { 1855 int timer_active; 1856 unsigned long timer_expires; 1857 struct tcp_sock *tp = tcp_sk(sp); 1858 const struct inet_connection_sock *icsk = inet_csk(sp); 1859 struct inet_sock *inet = inet_sk(sp); 1860 unsigned int dest = inet->daddr; 1861 unsigned int src = inet->rcv_saddr; 1862 __u16 destp = ntohs(inet->dport); 1863 __u16 srcp = ntohs(inet->sport); 1864 1865 if (icsk->icsk_pending == ICSK_TIME_RETRANS) { 1866 timer_active = 1; 1867 timer_expires = icsk->icsk_timeout; 1868 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) { 1869 timer_active = 4; 1870 timer_expires = icsk->icsk_timeout; 1871 } else if (timer_pending(&sp->sk_timer)) { 1872 timer_active = 2; 1873 timer_expires = sp->sk_timer.expires; 1874 } else { 1875 timer_active = 0; 1876 timer_expires = jiffies; 1877 } 1878 1879 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX " 1880 "%08X %5d %8d %lu %d %p %u %u %u %u %d", 1881 i, src, srcp, dest, destp, sp->sk_state, 1882 tp->write_seq - tp->snd_una, tp->rcv_nxt - tp->copied_seq, 1883 timer_active, 1884 jiffies_to_clock_t(timer_expires - jiffies), 1885 icsk->icsk_retransmits, 1886 sock_i_uid(sp), 1887 icsk->icsk_probes_out, 1888 sock_i_ino(sp), 1889 atomic_read(&sp->sk_refcnt), sp, 1890 icsk->icsk_rto, 1891 icsk->icsk_ack.ato, 1892 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong, 1893 tp->snd_cwnd, 1894 tp->snd_ssthresh >= 0xFFFF ? -1 : tp->snd_ssthresh); 1895 } 1896 1897 static void get_timewait4_sock(struct inet_timewait_sock *tw, char *tmpbuf, int i) 1898 { 1899 unsigned int dest, src; 1900 __u16 destp, srcp; 1901 int ttd = tw->tw_ttd - jiffies; 1902 1903 if (ttd < 0) 1904 ttd = 0; 1905 1906 dest = tw->tw_daddr; 1907 src = tw->tw_rcv_saddr; 1908 destp = ntohs(tw->tw_dport); 1909 srcp = ntohs(tw->tw_sport); 1910 1911 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X" 1912 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p", 1913 i, src, srcp, dest, destp, tw->tw_substate, 0, 0, 1914 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0, 1915 atomic_read(&tw->tw_refcnt), tw); 1916 } 1917 1918 #define TMPSZ 150 1919 1920 static int tcp4_seq_show(struct seq_file *seq, void *v) 1921 { 1922 struct tcp_iter_state* st; 1923 char tmpbuf[TMPSZ + 1]; 1924 1925 if (v == SEQ_START_TOKEN) { 1926 seq_printf(seq, "%-*s\n", TMPSZ - 1, 1927 " sl local_address rem_address st tx_queue " 1928 "rx_queue tr tm->when retrnsmt uid timeout " 1929 "inode"); 1930 goto out; 1931 } 1932 st = seq->private; 1933 1934 switch (st->state) { 1935 case TCP_SEQ_STATE_LISTENING: 1936 case TCP_SEQ_STATE_ESTABLISHED: 1937 get_tcp4_sock(v, tmpbuf, st->num); 1938 break; 1939 case TCP_SEQ_STATE_OPENREQ: 1940 get_openreq4(st->syn_wait_sk, v, tmpbuf, st->num, st->uid); 1941 break; 1942 case TCP_SEQ_STATE_TIME_WAIT: 1943 get_timewait4_sock(v, tmpbuf, st->num); 1944 break; 1945 } 1946 seq_printf(seq, "%-*s\n", TMPSZ - 1, tmpbuf); 1947 out: 1948 return 0; 1949 } 1950 1951 static struct file_operations tcp4_seq_fops; 1952 static struct tcp_seq_afinfo tcp4_seq_afinfo = { 1953 .owner = THIS_MODULE, 1954 .name = "tcp", 1955 .family = AF_INET, 1956 .seq_show = tcp4_seq_show, 1957 .seq_fops = &tcp4_seq_fops, 1958 }; 1959 1960 int __init tcp4_proc_init(void) 1961 { 1962 return tcp_proc_register(&tcp4_seq_afinfo); 1963 } 1964 1965 void tcp4_proc_exit(void) 1966 { 1967 tcp_proc_unregister(&tcp4_seq_afinfo); 1968 } 1969 #endif /* CONFIG_PROC_FS */ 1970 1971 struct proto tcp_prot = { 1972 .name = "TCP", 1973 .owner = THIS_MODULE, 1974 .close = tcp_close, 1975 .connect = tcp_v4_connect, 1976 .disconnect = tcp_disconnect, 1977 .accept = inet_csk_accept, 1978 .ioctl = tcp_ioctl, 1979 .init = tcp_v4_init_sock, 1980 .destroy = tcp_v4_destroy_sock, 1981 .shutdown = tcp_shutdown, 1982 .setsockopt = tcp_setsockopt, 1983 .getsockopt = tcp_getsockopt, 1984 .sendmsg = tcp_sendmsg, 1985 .recvmsg = tcp_recvmsg, 1986 .backlog_rcv = tcp_v4_do_rcv, 1987 .hash = tcp_v4_hash, 1988 .unhash = tcp_unhash, 1989 .get_port = tcp_v4_get_port, 1990 .enter_memory_pressure = tcp_enter_memory_pressure, 1991 .sockets_allocated = &tcp_sockets_allocated, 1992 .orphan_count = &tcp_orphan_count, 1993 .memory_allocated = &tcp_memory_allocated, 1994 .memory_pressure = &tcp_memory_pressure, 1995 .sysctl_mem = sysctl_tcp_mem, 1996 .sysctl_wmem = sysctl_tcp_wmem, 1997 .sysctl_rmem = sysctl_tcp_rmem, 1998 .max_header = MAX_TCP_HEADER, 1999 .obj_size = sizeof(struct tcp_sock), 2000 .twsk_obj_size = sizeof(struct tcp_timewait_sock), 2001 .rsk_prot = &tcp_request_sock_ops, 2002 }; 2003 2004 2005 2006 void __init tcp_v4_init(struct net_proto_family *ops) 2007 { 2008 int err = sock_create_kern(PF_INET, SOCK_RAW, IPPROTO_TCP, &tcp_socket); 2009 if (err < 0) 2010 panic("Failed to create the TCP control socket.\n"); 2011 tcp_socket->sk->sk_allocation = GFP_ATOMIC; 2012 inet_sk(tcp_socket->sk)->uc_ttl = -1; 2013 2014 /* Unhash it so that IP input processing does not even 2015 * see it, we do not wish this socket to see incoming 2016 * packets. 2017 */ 2018 tcp_socket->sk->sk_prot->unhash(tcp_socket->sk); 2019 } 2020 2021 EXPORT_SYMBOL(ipv4_specific); 2022 EXPORT_SYMBOL(inet_bind_bucket_create); 2023 EXPORT_SYMBOL(tcp_hashinfo); 2024 EXPORT_SYMBOL(tcp_prot); 2025 EXPORT_SYMBOL(tcp_unhash); 2026 EXPORT_SYMBOL(tcp_v4_conn_request); 2027 EXPORT_SYMBOL(tcp_v4_connect); 2028 EXPORT_SYMBOL(tcp_v4_do_rcv); 2029 EXPORT_SYMBOL(tcp_v4_remember_stamp); 2030 EXPORT_SYMBOL(tcp_v4_send_check); 2031 EXPORT_SYMBOL(tcp_v4_syn_recv_sock); 2032 2033 #ifdef CONFIG_PROC_FS 2034 EXPORT_SYMBOL(tcp_proc_register); 2035 EXPORT_SYMBOL(tcp_proc_unregister); 2036 #endif 2037 EXPORT_SYMBOL(sysctl_local_port_range); 2038 EXPORT_SYMBOL(sysctl_tcp_low_latency); 2039 EXPORT_SYMBOL(sysctl_tcp_tw_reuse); 2040 2041