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