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 * IPv4 specific functions 9 * 10 * 11 * code split from: 12 * linux/ipv4/tcp.c 13 * linux/ipv4/tcp_input.c 14 * linux/ipv4/tcp_output.c 15 * 16 * See tcp.c for author information 17 * 18 * This program is free software; you can redistribute it and/or 19 * modify it under the terms of the GNU General Public License 20 * as published by the Free Software Foundation; either version 21 * 2 of the License, or (at your option) any later version. 22 */ 23 24 /* 25 * Changes: 26 * David S. Miller : New socket lookup architecture. 27 * This code is dedicated to John Dyson. 28 * David S. Miller : Change semantics of established hash, 29 * half is devoted to TIME_WAIT sockets 30 * and the rest go in the other half. 31 * Andi Kleen : Add support for syncookies and fixed 32 * some bugs: ip options weren't passed to 33 * the TCP layer, missed a check for an 34 * ACK bit. 35 * Andi Kleen : Implemented fast path mtu discovery. 36 * Fixed many serious bugs in the 37 * request_sock handling and moved 38 * most of it into the af independent code. 39 * Added tail drop and some other bugfixes. 40 * Added new listen semantics. 41 * Mike McLagan : Routing by source 42 * Juan Jose Ciarlante: ip_dynaddr bits 43 * Andi Kleen: various fixes. 44 * Vitaly E. Lavrov : Transparent proxy revived after year 45 * coma. 46 * Andi Kleen : Fix new listen. 47 * Andi Kleen : Fix accept error reporting. 48 * YOSHIFUJI Hideaki @USAGI and: Support IPV6_V6ONLY socket option, which 49 * Alexey Kuznetsov allow both IPv4 and IPv6 sockets to bind 50 * a single port at the same time. 51 */ 52 53 54 #include <linux/bottom_half.h> 55 #include <linux/types.h> 56 #include <linux/fcntl.h> 57 #include <linux/module.h> 58 #include <linux/random.h> 59 #include <linux/cache.h> 60 #include <linux/jhash.h> 61 #include <linux/init.h> 62 #include <linux/times.h> 63 #include <linux/slab.h> 64 65 #include <net/net_namespace.h> 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 #include <net/secure_seq.h> 76 77 #include <linux/inet.h> 78 #include <linux/ipv6.h> 79 #include <linux/stddef.h> 80 #include <linux/proc_fs.h> 81 #include <linux/seq_file.h> 82 83 #include <linux/crypto.h> 84 #include <linux/scatterlist.h> 85 86 int sysctl_tcp_tw_reuse __read_mostly; 87 int sysctl_tcp_low_latency __read_mostly; 88 EXPORT_SYMBOL(sysctl_tcp_low_latency); 89 90 91 #ifdef CONFIG_TCP_MD5SIG 92 static struct tcp_md5sig_key *tcp_v4_md5_do_lookup(struct sock *sk, 93 __be32 addr); 94 static int tcp_v4_md5_hash_hdr(char *md5_hash, struct tcp_md5sig_key *key, 95 __be32 daddr, __be32 saddr, struct tcphdr *th); 96 #else 97 static inline 98 struct tcp_md5sig_key *tcp_v4_md5_do_lookup(struct sock *sk, __be32 addr) 99 { 100 return NULL; 101 } 102 #endif 103 104 struct inet_hashinfo tcp_hashinfo; 105 EXPORT_SYMBOL(tcp_hashinfo); 106 107 static inline __u32 tcp_v4_init_sequence(struct sk_buff *skb) 108 { 109 return secure_tcp_sequence_number(ip_hdr(skb)->daddr, 110 ip_hdr(skb)->saddr, 111 tcp_hdr(skb)->dest, 112 tcp_hdr(skb)->source); 113 } 114 115 int tcp_twsk_unique(struct sock *sk, struct sock *sktw, void *twp) 116 { 117 const struct tcp_timewait_sock *tcptw = tcp_twsk(sktw); 118 struct tcp_sock *tp = tcp_sk(sk); 119 120 /* With PAWS, it is safe from the viewpoint 121 of data integrity. Even without PAWS it is safe provided sequence 122 spaces do not overlap i.e. at data rates <= 80Mbit/sec. 123 124 Actually, the idea is close to VJ's one, only timestamp cache is 125 held not per host, but per port pair and TW bucket is used as state 126 holder. 127 128 If TW bucket has been already destroyed we fall back to VJ's scheme 129 and use initial timestamp retrieved from peer table. 130 */ 131 if (tcptw->tw_ts_recent_stamp && 132 (twp == NULL || (sysctl_tcp_tw_reuse && 133 get_seconds() - tcptw->tw_ts_recent_stamp > 1))) { 134 tp->write_seq = tcptw->tw_snd_nxt + 65535 + 2; 135 if (tp->write_seq == 0) 136 tp->write_seq = 1; 137 tp->rx_opt.ts_recent = tcptw->tw_ts_recent; 138 tp->rx_opt.ts_recent_stamp = tcptw->tw_ts_recent_stamp; 139 sock_hold(sktw); 140 return 1; 141 } 142 143 return 0; 144 } 145 EXPORT_SYMBOL_GPL(tcp_twsk_unique); 146 147 /* This will initiate an outgoing connection. */ 148 int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len) 149 { 150 struct sockaddr_in *usin = (struct sockaddr_in *)uaddr; 151 struct inet_sock *inet = inet_sk(sk); 152 struct tcp_sock *tp = tcp_sk(sk); 153 __be16 orig_sport, orig_dport; 154 __be32 daddr, nexthop; 155 struct flowi4 *fl4; 156 struct rtable *rt; 157 int err; 158 struct ip_options_rcu *inet_opt; 159 160 if (addr_len < sizeof(struct sockaddr_in)) 161 return -EINVAL; 162 163 if (usin->sin_family != AF_INET) 164 return -EAFNOSUPPORT; 165 166 nexthop = daddr = usin->sin_addr.s_addr; 167 inet_opt = rcu_dereference_protected(inet->inet_opt, 168 sock_owned_by_user(sk)); 169 if (inet_opt && inet_opt->opt.srr) { 170 if (!daddr) 171 return -EINVAL; 172 nexthop = inet_opt->opt.faddr; 173 } 174 175 orig_sport = inet->inet_sport; 176 orig_dport = usin->sin_port; 177 fl4 = &inet->cork.fl.u.ip4; 178 rt = ip_route_connect(fl4, nexthop, inet->inet_saddr, 179 RT_CONN_FLAGS(sk), sk->sk_bound_dev_if, 180 IPPROTO_TCP, 181 orig_sport, orig_dport, sk, true); 182 if (IS_ERR(rt)) { 183 err = PTR_ERR(rt); 184 if (err == -ENETUNREACH) 185 IP_INC_STATS_BH(sock_net(sk), IPSTATS_MIB_OUTNOROUTES); 186 return err; 187 } 188 189 if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) { 190 ip_rt_put(rt); 191 return -ENETUNREACH; 192 } 193 194 if (!inet_opt || !inet_opt->opt.srr) 195 daddr = fl4->daddr; 196 197 if (!inet->inet_saddr) 198 inet->inet_saddr = fl4->saddr; 199 inet->inet_rcv_saddr = inet->inet_saddr; 200 201 if (tp->rx_opt.ts_recent_stamp && inet->inet_daddr != daddr) { 202 /* Reset inherited state */ 203 tp->rx_opt.ts_recent = 0; 204 tp->rx_opt.ts_recent_stamp = 0; 205 tp->write_seq = 0; 206 } 207 208 if (tcp_death_row.sysctl_tw_recycle && 209 !tp->rx_opt.ts_recent_stamp && fl4->daddr == daddr) { 210 struct inet_peer *peer = rt_get_peer(rt, fl4->daddr); 211 /* 212 * VJ's idea. We save last timestamp seen from 213 * the destination in peer table, when entering state 214 * TIME-WAIT * and initialize rx_opt.ts_recent from it, 215 * when trying new connection. 216 */ 217 if (peer) { 218 inet_peer_refcheck(peer); 219 if ((u32)get_seconds() - peer->tcp_ts_stamp <= TCP_PAWS_MSL) { 220 tp->rx_opt.ts_recent_stamp = peer->tcp_ts_stamp; 221 tp->rx_opt.ts_recent = peer->tcp_ts; 222 } 223 } 224 } 225 226 inet->inet_dport = usin->sin_port; 227 inet->inet_daddr = daddr; 228 229 inet_csk(sk)->icsk_ext_hdr_len = 0; 230 if (inet_opt) 231 inet_csk(sk)->icsk_ext_hdr_len = inet_opt->opt.optlen; 232 233 tp->rx_opt.mss_clamp = TCP_MSS_DEFAULT; 234 235 /* Socket identity is still unknown (sport may be zero). 236 * However we set state to SYN-SENT and not releasing socket 237 * lock select source port, enter ourselves into the hash tables and 238 * complete initialization after this. 239 */ 240 tcp_set_state(sk, TCP_SYN_SENT); 241 err = inet_hash_connect(&tcp_death_row, sk); 242 if (err) 243 goto failure; 244 245 rt = ip_route_newports(fl4, rt, orig_sport, orig_dport, 246 inet->inet_sport, inet->inet_dport, sk); 247 if (IS_ERR(rt)) { 248 err = PTR_ERR(rt); 249 rt = NULL; 250 goto failure; 251 } 252 /* OK, now commit destination to socket. */ 253 sk->sk_gso_type = SKB_GSO_TCPV4; 254 sk_setup_caps(sk, &rt->dst); 255 256 if (!tp->write_seq) 257 tp->write_seq = secure_tcp_sequence_number(inet->inet_saddr, 258 inet->inet_daddr, 259 inet->inet_sport, 260 usin->sin_port); 261 262 inet->inet_id = tp->write_seq ^ jiffies; 263 264 err = tcp_connect(sk); 265 rt = NULL; 266 if (err) 267 goto failure; 268 269 return 0; 270 271 failure: 272 /* 273 * This unhashes the socket and releases the local port, 274 * if necessary. 275 */ 276 tcp_set_state(sk, TCP_CLOSE); 277 ip_rt_put(rt); 278 sk->sk_route_caps = 0; 279 inet->inet_dport = 0; 280 return err; 281 } 282 EXPORT_SYMBOL(tcp_v4_connect); 283 284 /* 285 * This routine does path mtu discovery as defined in RFC1191. 286 */ 287 static void do_pmtu_discovery(struct sock *sk, const struct iphdr *iph, u32 mtu) 288 { 289 struct dst_entry *dst; 290 struct inet_sock *inet = inet_sk(sk); 291 292 /* We are not interested in TCP_LISTEN and open_requests (SYN-ACKs 293 * send out by Linux are always <576bytes so they should go through 294 * unfragmented). 295 */ 296 if (sk->sk_state == TCP_LISTEN) 297 return; 298 299 /* We don't check in the destentry if pmtu discovery is forbidden 300 * on this route. We just assume that no packet_to_big packets 301 * are send back when pmtu discovery is not active. 302 * There is a small race when the user changes this flag in the 303 * route, but I think that's acceptable. 304 */ 305 if ((dst = __sk_dst_check(sk, 0)) == NULL) 306 return; 307 308 dst->ops->update_pmtu(dst, mtu); 309 310 /* Something is about to be wrong... Remember soft error 311 * for the case, if this connection will not able to recover. 312 */ 313 if (mtu < dst_mtu(dst) && ip_dont_fragment(sk, dst)) 314 sk->sk_err_soft = EMSGSIZE; 315 316 mtu = dst_mtu(dst); 317 318 if (inet->pmtudisc != IP_PMTUDISC_DONT && 319 inet_csk(sk)->icsk_pmtu_cookie > mtu) { 320 tcp_sync_mss(sk, mtu); 321 322 /* Resend the TCP packet because it's 323 * clear that the old packet has been 324 * dropped. This is the new "fast" path mtu 325 * discovery. 326 */ 327 tcp_simple_retransmit(sk); 328 } /* else let the usual retransmit timer handle it */ 329 } 330 331 /* 332 * This routine is called by the ICMP module when it gets some 333 * sort of error condition. If err < 0 then the socket should 334 * be closed and the error returned to the user. If err > 0 335 * it's just the icmp type << 8 | icmp code. After adjustment 336 * header points to the first 8 bytes of the tcp header. We need 337 * to find the appropriate port. 338 * 339 * The locking strategy used here is very "optimistic". When 340 * someone else accesses the socket the ICMP is just dropped 341 * and for some paths there is no check at all. 342 * A more general error queue to queue errors for later handling 343 * is probably better. 344 * 345 */ 346 347 void tcp_v4_err(struct sk_buff *icmp_skb, u32 info) 348 { 349 const struct iphdr *iph = (const struct iphdr *)icmp_skb->data; 350 struct tcphdr *th = (struct tcphdr *)(icmp_skb->data + (iph->ihl << 2)); 351 struct inet_connection_sock *icsk; 352 struct tcp_sock *tp; 353 struct inet_sock *inet; 354 const int type = icmp_hdr(icmp_skb)->type; 355 const int code = icmp_hdr(icmp_skb)->code; 356 struct sock *sk; 357 struct sk_buff *skb; 358 __u32 seq; 359 __u32 remaining; 360 int err; 361 struct net *net = dev_net(icmp_skb->dev); 362 363 if (icmp_skb->len < (iph->ihl << 2) + 8) { 364 ICMP_INC_STATS_BH(net, ICMP_MIB_INERRORS); 365 return; 366 } 367 368 sk = inet_lookup(net, &tcp_hashinfo, iph->daddr, th->dest, 369 iph->saddr, th->source, inet_iif(icmp_skb)); 370 if (!sk) { 371 ICMP_INC_STATS_BH(net, ICMP_MIB_INERRORS); 372 return; 373 } 374 if (sk->sk_state == TCP_TIME_WAIT) { 375 inet_twsk_put(inet_twsk(sk)); 376 return; 377 } 378 379 bh_lock_sock(sk); 380 /* If too many ICMPs get dropped on busy 381 * servers this needs to be solved differently. 382 */ 383 if (sock_owned_by_user(sk)) 384 NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS); 385 386 if (sk->sk_state == TCP_CLOSE) 387 goto out; 388 389 if (unlikely(iph->ttl < inet_sk(sk)->min_ttl)) { 390 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP); 391 goto out; 392 } 393 394 icsk = inet_csk(sk); 395 tp = tcp_sk(sk); 396 seq = ntohl(th->seq); 397 if (sk->sk_state != TCP_LISTEN && 398 !between(seq, tp->snd_una, tp->snd_nxt)) { 399 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS); 400 goto out; 401 } 402 403 switch (type) { 404 case ICMP_SOURCE_QUENCH: 405 /* Just silently ignore these. */ 406 goto out; 407 case ICMP_PARAMETERPROB: 408 err = EPROTO; 409 break; 410 case ICMP_DEST_UNREACH: 411 if (code > NR_ICMP_UNREACH) 412 goto out; 413 414 if (code == ICMP_FRAG_NEEDED) { /* PMTU discovery (RFC1191) */ 415 if (!sock_owned_by_user(sk)) 416 do_pmtu_discovery(sk, iph, info); 417 goto out; 418 } 419 420 err = icmp_err_convert[code].errno; 421 /* check if icmp_skb allows revert of backoff 422 * (see draft-zimmermann-tcp-lcd) */ 423 if (code != ICMP_NET_UNREACH && code != ICMP_HOST_UNREACH) 424 break; 425 if (seq != tp->snd_una || !icsk->icsk_retransmits || 426 !icsk->icsk_backoff) 427 break; 428 429 if (sock_owned_by_user(sk)) 430 break; 431 432 icsk->icsk_backoff--; 433 inet_csk(sk)->icsk_rto = (tp->srtt ? __tcp_set_rto(tp) : 434 TCP_TIMEOUT_INIT) << icsk->icsk_backoff; 435 tcp_bound_rto(sk); 436 437 skb = tcp_write_queue_head(sk); 438 BUG_ON(!skb); 439 440 remaining = icsk->icsk_rto - min(icsk->icsk_rto, 441 tcp_time_stamp - TCP_SKB_CB(skb)->when); 442 443 if (remaining) { 444 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS, 445 remaining, TCP_RTO_MAX); 446 } else { 447 /* RTO revert clocked out retransmission. 448 * Will retransmit now */ 449 tcp_retransmit_timer(sk); 450 } 451 452 break; 453 case ICMP_TIME_EXCEEDED: 454 err = EHOSTUNREACH; 455 break; 456 default: 457 goto out; 458 } 459 460 switch (sk->sk_state) { 461 struct request_sock *req, **prev; 462 case TCP_LISTEN: 463 if (sock_owned_by_user(sk)) 464 goto out; 465 466 req = inet_csk_search_req(sk, &prev, th->dest, 467 iph->daddr, iph->saddr); 468 if (!req) 469 goto out; 470 471 /* ICMPs are not backlogged, hence we cannot get 472 an established socket here. 473 */ 474 WARN_ON(req->sk); 475 476 if (seq != tcp_rsk(req)->snt_isn) { 477 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS); 478 goto out; 479 } 480 481 /* 482 * Still in SYN_RECV, just remove it silently. 483 * There is no good way to pass the error to the newly 484 * created socket, and POSIX does not want network 485 * errors returned from accept(). 486 */ 487 inet_csk_reqsk_queue_drop(sk, req, prev); 488 goto out; 489 490 case TCP_SYN_SENT: 491 case TCP_SYN_RECV: /* Cannot happen. 492 It can f.e. if SYNs crossed. 493 */ 494 if (!sock_owned_by_user(sk)) { 495 sk->sk_err = err; 496 497 sk->sk_error_report(sk); 498 499 tcp_done(sk); 500 } else { 501 sk->sk_err_soft = err; 502 } 503 goto out; 504 } 505 506 /* If we've already connected we will keep trying 507 * until we time out, or the user gives up. 508 * 509 * rfc1122 4.2.3.9 allows to consider as hard errors 510 * only PROTO_UNREACH and PORT_UNREACH (well, FRAG_FAILED too, 511 * but it is obsoleted by pmtu discovery). 512 * 513 * Note, that in modern internet, where routing is unreliable 514 * and in each dark corner broken firewalls sit, sending random 515 * errors ordered by their masters even this two messages finally lose 516 * their original sense (even Linux sends invalid PORT_UNREACHs) 517 * 518 * Now we are in compliance with RFCs. 519 * --ANK (980905) 520 */ 521 522 inet = inet_sk(sk); 523 if (!sock_owned_by_user(sk) && inet->recverr) { 524 sk->sk_err = err; 525 sk->sk_error_report(sk); 526 } else { /* Only an error on timeout */ 527 sk->sk_err_soft = err; 528 } 529 530 out: 531 bh_unlock_sock(sk); 532 sock_put(sk); 533 } 534 535 static void __tcp_v4_send_check(struct sk_buff *skb, 536 __be32 saddr, __be32 daddr) 537 { 538 struct tcphdr *th = tcp_hdr(skb); 539 540 if (skb->ip_summed == CHECKSUM_PARTIAL) { 541 th->check = ~tcp_v4_check(skb->len, saddr, daddr, 0); 542 skb->csum_start = skb_transport_header(skb) - skb->head; 543 skb->csum_offset = offsetof(struct tcphdr, check); 544 } else { 545 th->check = tcp_v4_check(skb->len, saddr, daddr, 546 csum_partial(th, 547 th->doff << 2, 548 skb->csum)); 549 } 550 } 551 552 /* This routine computes an IPv4 TCP checksum. */ 553 void tcp_v4_send_check(struct sock *sk, struct sk_buff *skb) 554 { 555 struct inet_sock *inet = inet_sk(sk); 556 557 __tcp_v4_send_check(skb, inet->inet_saddr, inet->inet_daddr); 558 } 559 EXPORT_SYMBOL(tcp_v4_send_check); 560 561 int tcp_v4_gso_send_check(struct sk_buff *skb) 562 { 563 const struct iphdr *iph; 564 struct tcphdr *th; 565 566 if (!pskb_may_pull(skb, sizeof(*th))) 567 return -EINVAL; 568 569 iph = ip_hdr(skb); 570 th = tcp_hdr(skb); 571 572 th->check = 0; 573 skb->ip_summed = CHECKSUM_PARTIAL; 574 __tcp_v4_send_check(skb, iph->saddr, iph->daddr); 575 return 0; 576 } 577 578 /* 579 * This routine will send an RST to the other tcp. 580 * 581 * Someone asks: why I NEVER use socket parameters (TOS, TTL etc.) 582 * for reset. 583 * Answer: if a packet caused RST, it is not for a socket 584 * existing in our system, if it is matched to a socket, 585 * it is just duplicate segment or bug in other side's TCP. 586 * So that we build reply only basing on parameters 587 * arrived with segment. 588 * Exception: precedence violation. We do not implement it in any case. 589 */ 590 591 static void tcp_v4_send_reset(struct sock *sk, struct sk_buff *skb) 592 { 593 struct tcphdr *th = tcp_hdr(skb); 594 struct { 595 struct tcphdr th; 596 #ifdef CONFIG_TCP_MD5SIG 597 __be32 opt[(TCPOLEN_MD5SIG_ALIGNED >> 2)]; 598 #endif 599 } rep; 600 struct ip_reply_arg arg; 601 #ifdef CONFIG_TCP_MD5SIG 602 struct tcp_md5sig_key *key; 603 #endif 604 struct net *net; 605 606 /* Never send a reset in response to a reset. */ 607 if (th->rst) 608 return; 609 610 if (skb_rtable(skb)->rt_type != RTN_LOCAL) 611 return; 612 613 /* Swap the send and the receive. */ 614 memset(&rep, 0, sizeof(rep)); 615 rep.th.dest = th->source; 616 rep.th.source = th->dest; 617 rep.th.doff = sizeof(struct tcphdr) / 4; 618 rep.th.rst = 1; 619 620 if (th->ack) { 621 rep.th.seq = th->ack_seq; 622 } else { 623 rep.th.ack = 1; 624 rep.th.ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin + 625 skb->len - (th->doff << 2)); 626 } 627 628 memset(&arg, 0, sizeof(arg)); 629 arg.iov[0].iov_base = (unsigned char *)&rep; 630 arg.iov[0].iov_len = sizeof(rep.th); 631 632 #ifdef CONFIG_TCP_MD5SIG 633 key = sk ? tcp_v4_md5_do_lookup(sk, ip_hdr(skb)->daddr) : NULL; 634 if (key) { 635 rep.opt[0] = htonl((TCPOPT_NOP << 24) | 636 (TCPOPT_NOP << 16) | 637 (TCPOPT_MD5SIG << 8) | 638 TCPOLEN_MD5SIG); 639 /* Update length and the length the header thinks exists */ 640 arg.iov[0].iov_len += TCPOLEN_MD5SIG_ALIGNED; 641 rep.th.doff = arg.iov[0].iov_len / 4; 642 643 tcp_v4_md5_hash_hdr((__u8 *) &rep.opt[1], 644 key, ip_hdr(skb)->saddr, 645 ip_hdr(skb)->daddr, &rep.th); 646 } 647 #endif 648 arg.csum = csum_tcpudp_nofold(ip_hdr(skb)->daddr, 649 ip_hdr(skb)->saddr, /* XXX */ 650 arg.iov[0].iov_len, IPPROTO_TCP, 0); 651 arg.csumoffset = offsetof(struct tcphdr, check) / 2; 652 arg.flags = (sk && inet_sk(sk)->transparent) ? IP_REPLY_ARG_NOSRCCHECK : 0; 653 654 net = dev_net(skb_dst(skb)->dev); 655 ip_send_reply(net->ipv4.tcp_sock, skb, ip_hdr(skb)->saddr, 656 &arg, arg.iov[0].iov_len); 657 658 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS); 659 TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS); 660 } 661 662 /* The code following below sending ACKs in SYN-RECV and TIME-WAIT states 663 outside socket context is ugly, certainly. What can I do? 664 */ 665 666 static void tcp_v4_send_ack(struct sk_buff *skb, u32 seq, u32 ack, 667 u32 win, u32 ts, int oif, 668 struct tcp_md5sig_key *key, 669 int reply_flags) 670 { 671 struct tcphdr *th = tcp_hdr(skb); 672 struct { 673 struct tcphdr th; 674 __be32 opt[(TCPOLEN_TSTAMP_ALIGNED >> 2) 675 #ifdef CONFIG_TCP_MD5SIG 676 + (TCPOLEN_MD5SIG_ALIGNED >> 2) 677 #endif 678 ]; 679 } rep; 680 struct ip_reply_arg arg; 681 struct net *net = dev_net(skb_dst(skb)->dev); 682 683 memset(&rep.th, 0, sizeof(struct tcphdr)); 684 memset(&arg, 0, sizeof(arg)); 685 686 arg.iov[0].iov_base = (unsigned char *)&rep; 687 arg.iov[0].iov_len = sizeof(rep.th); 688 if (ts) { 689 rep.opt[0] = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) | 690 (TCPOPT_TIMESTAMP << 8) | 691 TCPOLEN_TIMESTAMP); 692 rep.opt[1] = htonl(tcp_time_stamp); 693 rep.opt[2] = htonl(ts); 694 arg.iov[0].iov_len += TCPOLEN_TSTAMP_ALIGNED; 695 } 696 697 /* Swap the send and the receive. */ 698 rep.th.dest = th->source; 699 rep.th.source = th->dest; 700 rep.th.doff = arg.iov[0].iov_len / 4; 701 rep.th.seq = htonl(seq); 702 rep.th.ack_seq = htonl(ack); 703 rep.th.ack = 1; 704 rep.th.window = htons(win); 705 706 #ifdef CONFIG_TCP_MD5SIG 707 if (key) { 708 int offset = (ts) ? 3 : 0; 709 710 rep.opt[offset++] = htonl((TCPOPT_NOP << 24) | 711 (TCPOPT_NOP << 16) | 712 (TCPOPT_MD5SIG << 8) | 713 TCPOLEN_MD5SIG); 714 arg.iov[0].iov_len += TCPOLEN_MD5SIG_ALIGNED; 715 rep.th.doff = arg.iov[0].iov_len/4; 716 717 tcp_v4_md5_hash_hdr((__u8 *) &rep.opt[offset], 718 key, ip_hdr(skb)->saddr, 719 ip_hdr(skb)->daddr, &rep.th); 720 } 721 #endif 722 arg.flags = reply_flags; 723 arg.csum = csum_tcpudp_nofold(ip_hdr(skb)->daddr, 724 ip_hdr(skb)->saddr, /* XXX */ 725 arg.iov[0].iov_len, IPPROTO_TCP, 0); 726 arg.csumoffset = offsetof(struct tcphdr, check) / 2; 727 if (oif) 728 arg.bound_dev_if = oif; 729 730 ip_send_reply(net->ipv4.tcp_sock, skb, ip_hdr(skb)->saddr, 731 &arg, arg.iov[0].iov_len); 732 733 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS); 734 } 735 736 static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb) 737 { 738 struct inet_timewait_sock *tw = inet_twsk(sk); 739 struct tcp_timewait_sock *tcptw = tcp_twsk(sk); 740 741 tcp_v4_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt, 742 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale, 743 tcptw->tw_ts_recent, 744 tw->tw_bound_dev_if, 745 tcp_twsk_md5_key(tcptw), 746 tw->tw_transparent ? IP_REPLY_ARG_NOSRCCHECK : 0 747 ); 748 749 inet_twsk_put(tw); 750 } 751 752 static void tcp_v4_reqsk_send_ack(struct sock *sk, struct sk_buff *skb, 753 struct request_sock *req) 754 { 755 tcp_v4_send_ack(skb, tcp_rsk(req)->snt_isn + 1, 756 tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd, 757 req->ts_recent, 758 0, 759 tcp_v4_md5_do_lookup(sk, ip_hdr(skb)->daddr), 760 inet_rsk(req)->no_srccheck ? IP_REPLY_ARG_NOSRCCHECK : 0); 761 } 762 763 /* 764 * Send a SYN-ACK after having received a SYN. 765 * This still operates on a request_sock only, not on a big 766 * socket. 767 */ 768 static int tcp_v4_send_synack(struct sock *sk, struct dst_entry *dst, 769 struct request_sock *req, 770 struct request_values *rvp) 771 { 772 const struct inet_request_sock *ireq = inet_rsk(req); 773 struct flowi4 fl4; 774 int err = -1; 775 struct sk_buff * skb; 776 777 /* First, grab a route. */ 778 if (!dst && (dst = inet_csk_route_req(sk, &fl4, req)) == NULL) 779 return -1; 780 781 skb = tcp_make_synack(sk, dst, req, rvp); 782 783 if (skb) { 784 __tcp_v4_send_check(skb, ireq->loc_addr, ireq->rmt_addr); 785 786 err = ip_build_and_send_pkt(skb, sk, ireq->loc_addr, 787 ireq->rmt_addr, 788 ireq->opt); 789 err = net_xmit_eval(err); 790 } 791 792 dst_release(dst); 793 return err; 794 } 795 796 static int tcp_v4_rtx_synack(struct sock *sk, struct request_sock *req, 797 struct request_values *rvp) 798 { 799 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_RETRANSSEGS); 800 return tcp_v4_send_synack(sk, NULL, req, rvp); 801 } 802 803 /* 804 * IPv4 request_sock destructor. 805 */ 806 static void tcp_v4_reqsk_destructor(struct request_sock *req) 807 { 808 kfree(inet_rsk(req)->opt); 809 } 810 811 static void syn_flood_warning(const struct sk_buff *skb) 812 { 813 const char *msg; 814 815 #ifdef CONFIG_SYN_COOKIES 816 if (sysctl_tcp_syncookies) 817 msg = "Sending cookies"; 818 else 819 #endif 820 msg = "Dropping request"; 821 822 pr_info("TCP: Possible SYN flooding on port %d. %s.\n", 823 ntohs(tcp_hdr(skb)->dest), msg); 824 } 825 826 /* 827 * Save and compile IPv4 options into the request_sock if needed. 828 */ 829 static struct ip_options_rcu *tcp_v4_save_options(struct sock *sk, 830 struct sk_buff *skb) 831 { 832 const struct ip_options *opt = &(IPCB(skb)->opt); 833 struct ip_options_rcu *dopt = NULL; 834 835 if (opt && opt->optlen) { 836 int opt_size = sizeof(*dopt) + opt->optlen; 837 838 dopt = kmalloc(opt_size, GFP_ATOMIC); 839 if (dopt) { 840 if (ip_options_echo(&dopt->opt, skb)) { 841 kfree(dopt); 842 dopt = NULL; 843 } 844 } 845 } 846 return dopt; 847 } 848 849 #ifdef CONFIG_TCP_MD5SIG 850 /* 851 * RFC2385 MD5 checksumming requires a mapping of 852 * IP address->MD5 Key. 853 * We need to maintain these in the sk structure. 854 */ 855 856 /* Find the Key structure for an address. */ 857 static struct tcp_md5sig_key * 858 tcp_v4_md5_do_lookup(struct sock *sk, __be32 addr) 859 { 860 struct tcp_sock *tp = tcp_sk(sk); 861 int i; 862 863 if (!tp->md5sig_info || !tp->md5sig_info->entries4) 864 return NULL; 865 for (i = 0; i < tp->md5sig_info->entries4; i++) { 866 if (tp->md5sig_info->keys4[i].addr == addr) 867 return &tp->md5sig_info->keys4[i].base; 868 } 869 return NULL; 870 } 871 872 struct tcp_md5sig_key *tcp_v4_md5_lookup(struct sock *sk, 873 struct sock *addr_sk) 874 { 875 return tcp_v4_md5_do_lookup(sk, inet_sk(addr_sk)->inet_daddr); 876 } 877 EXPORT_SYMBOL(tcp_v4_md5_lookup); 878 879 static struct tcp_md5sig_key *tcp_v4_reqsk_md5_lookup(struct sock *sk, 880 struct request_sock *req) 881 { 882 return tcp_v4_md5_do_lookup(sk, inet_rsk(req)->rmt_addr); 883 } 884 885 /* This can be called on a newly created socket, from other files */ 886 int tcp_v4_md5_do_add(struct sock *sk, __be32 addr, 887 u8 *newkey, u8 newkeylen) 888 { 889 /* Add Key to the list */ 890 struct tcp_md5sig_key *key; 891 struct tcp_sock *tp = tcp_sk(sk); 892 struct tcp4_md5sig_key *keys; 893 894 key = tcp_v4_md5_do_lookup(sk, addr); 895 if (key) { 896 /* Pre-existing entry - just update that one. */ 897 kfree(key->key); 898 key->key = newkey; 899 key->keylen = newkeylen; 900 } else { 901 struct tcp_md5sig_info *md5sig; 902 903 if (!tp->md5sig_info) { 904 tp->md5sig_info = kzalloc(sizeof(*tp->md5sig_info), 905 GFP_ATOMIC); 906 if (!tp->md5sig_info) { 907 kfree(newkey); 908 return -ENOMEM; 909 } 910 sk_nocaps_add(sk, NETIF_F_GSO_MASK); 911 } 912 if (tcp_alloc_md5sig_pool(sk) == NULL) { 913 kfree(newkey); 914 return -ENOMEM; 915 } 916 md5sig = tp->md5sig_info; 917 918 if (md5sig->alloced4 == md5sig->entries4) { 919 keys = kmalloc((sizeof(*keys) * 920 (md5sig->entries4 + 1)), GFP_ATOMIC); 921 if (!keys) { 922 kfree(newkey); 923 tcp_free_md5sig_pool(); 924 return -ENOMEM; 925 } 926 927 if (md5sig->entries4) 928 memcpy(keys, md5sig->keys4, 929 sizeof(*keys) * md5sig->entries4); 930 931 /* Free old key list, and reference new one */ 932 kfree(md5sig->keys4); 933 md5sig->keys4 = keys; 934 md5sig->alloced4++; 935 } 936 md5sig->entries4++; 937 md5sig->keys4[md5sig->entries4 - 1].addr = addr; 938 md5sig->keys4[md5sig->entries4 - 1].base.key = newkey; 939 md5sig->keys4[md5sig->entries4 - 1].base.keylen = newkeylen; 940 } 941 return 0; 942 } 943 EXPORT_SYMBOL(tcp_v4_md5_do_add); 944 945 static int tcp_v4_md5_add_func(struct sock *sk, struct sock *addr_sk, 946 u8 *newkey, u8 newkeylen) 947 { 948 return tcp_v4_md5_do_add(sk, inet_sk(addr_sk)->inet_daddr, 949 newkey, newkeylen); 950 } 951 952 int tcp_v4_md5_do_del(struct sock *sk, __be32 addr) 953 { 954 struct tcp_sock *tp = tcp_sk(sk); 955 int i; 956 957 for (i = 0; i < tp->md5sig_info->entries4; i++) { 958 if (tp->md5sig_info->keys4[i].addr == addr) { 959 /* Free the key */ 960 kfree(tp->md5sig_info->keys4[i].base.key); 961 tp->md5sig_info->entries4--; 962 963 if (tp->md5sig_info->entries4 == 0) { 964 kfree(tp->md5sig_info->keys4); 965 tp->md5sig_info->keys4 = NULL; 966 tp->md5sig_info->alloced4 = 0; 967 } else if (tp->md5sig_info->entries4 != i) { 968 /* Need to do some manipulation */ 969 memmove(&tp->md5sig_info->keys4[i], 970 &tp->md5sig_info->keys4[i+1], 971 (tp->md5sig_info->entries4 - i) * 972 sizeof(struct tcp4_md5sig_key)); 973 } 974 tcp_free_md5sig_pool(); 975 return 0; 976 } 977 } 978 return -ENOENT; 979 } 980 EXPORT_SYMBOL(tcp_v4_md5_do_del); 981 982 static void tcp_v4_clear_md5_list(struct sock *sk) 983 { 984 struct tcp_sock *tp = tcp_sk(sk); 985 986 /* Free each key, then the set of key keys, 987 * the crypto element, and then decrement our 988 * hold on the last resort crypto. 989 */ 990 if (tp->md5sig_info->entries4) { 991 int i; 992 for (i = 0; i < tp->md5sig_info->entries4; i++) 993 kfree(tp->md5sig_info->keys4[i].base.key); 994 tp->md5sig_info->entries4 = 0; 995 tcp_free_md5sig_pool(); 996 } 997 if (tp->md5sig_info->keys4) { 998 kfree(tp->md5sig_info->keys4); 999 tp->md5sig_info->keys4 = NULL; 1000 tp->md5sig_info->alloced4 = 0; 1001 } 1002 } 1003 1004 static int tcp_v4_parse_md5_keys(struct sock *sk, char __user *optval, 1005 int optlen) 1006 { 1007 struct tcp_md5sig cmd; 1008 struct sockaddr_in *sin = (struct sockaddr_in *)&cmd.tcpm_addr; 1009 u8 *newkey; 1010 1011 if (optlen < sizeof(cmd)) 1012 return -EINVAL; 1013 1014 if (copy_from_user(&cmd, optval, sizeof(cmd))) 1015 return -EFAULT; 1016 1017 if (sin->sin_family != AF_INET) 1018 return -EINVAL; 1019 1020 if (!cmd.tcpm_key || !cmd.tcpm_keylen) { 1021 if (!tcp_sk(sk)->md5sig_info) 1022 return -ENOENT; 1023 return tcp_v4_md5_do_del(sk, sin->sin_addr.s_addr); 1024 } 1025 1026 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN) 1027 return -EINVAL; 1028 1029 if (!tcp_sk(sk)->md5sig_info) { 1030 struct tcp_sock *tp = tcp_sk(sk); 1031 struct tcp_md5sig_info *p; 1032 1033 p = kzalloc(sizeof(*p), sk->sk_allocation); 1034 if (!p) 1035 return -EINVAL; 1036 1037 tp->md5sig_info = p; 1038 sk_nocaps_add(sk, NETIF_F_GSO_MASK); 1039 } 1040 1041 newkey = kmemdup(cmd.tcpm_key, cmd.tcpm_keylen, sk->sk_allocation); 1042 if (!newkey) 1043 return -ENOMEM; 1044 return tcp_v4_md5_do_add(sk, sin->sin_addr.s_addr, 1045 newkey, cmd.tcpm_keylen); 1046 } 1047 1048 static int tcp_v4_md5_hash_pseudoheader(struct tcp_md5sig_pool *hp, 1049 __be32 daddr, __be32 saddr, int nbytes) 1050 { 1051 struct tcp4_pseudohdr *bp; 1052 struct scatterlist sg; 1053 1054 bp = &hp->md5_blk.ip4; 1055 1056 /* 1057 * 1. the TCP pseudo-header (in the order: source IP address, 1058 * destination IP address, zero-padded protocol number, and 1059 * segment length) 1060 */ 1061 bp->saddr = saddr; 1062 bp->daddr = daddr; 1063 bp->pad = 0; 1064 bp->protocol = IPPROTO_TCP; 1065 bp->len = cpu_to_be16(nbytes); 1066 1067 sg_init_one(&sg, bp, sizeof(*bp)); 1068 return crypto_hash_update(&hp->md5_desc, &sg, sizeof(*bp)); 1069 } 1070 1071 static int tcp_v4_md5_hash_hdr(char *md5_hash, struct tcp_md5sig_key *key, 1072 __be32 daddr, __be32 saddr, struct tcphdr *th) 1073 { 1074 struct tcp_md5sig_pool *hp; 1075 struct hash_desc *desc; 1076 1077 hp = tcp_get_md5sig_pool(); 1078 if (!hp) 1079 goto clear_hash_noput; 1080 desc = &hp->md5_desc; 1081 1082 if (crypto_hash_init(desc)) 1083 goto clear_hash; 1084 if (tcp_v4_md5_hash_pseudoheader(hp, daddr, saddr, th->doff << 2)) 1085 goto clear_hash; 1086 if (tcp_md5_hash_header(hp, th)) 1087 goto clear_hash; 1088 if (tcp_md5_hash_key(hp, key)) 1089 goto clear_hash; 1090 if (crypto_hash_final(desc, md5_hash)) 1091 goto clear_hash; 1092 1093 tcp_put_md5sig_pool(); 1094 return 0; 1095 1096 clear_hash: 1097 tcp_put_md5sig_pool(); 1098 clear_hash_noput: 1099 memset(md5_hash, 0, 16); 1100 return 1; 1101 } 1102 1103 int tcp_v4_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key, 1104 struct sock *sk, struct request_sock *req, 1105 struct sk_buff *skb) 1106 { 1107 struct tcp_md5sig_pool *hp; 1108 struct hash_desc *desc; 1109 struct tcphdr *th = tcp_hdr(skb); 1110 __be32 saddr, daddr; 1111 1112 if (sk) { 1113 saddr = inet_sk(sk)->inet_saddr; 1114 daddr = inet_sk(sk)->inet_daddr; 1115 } else if (req) { 1116 saddr = inet_rsk(req)->loc_addr; 1117 daddr = inet_rsk(req)->rmt_addr; 1118 } else { 1119 const struct iphdr *iph = ip_hdr(skb); 1120 saddr = iph->saddr; 1121 daddr = iph->daddr; 1122 } 1123 1124 hp = tcp_get_md5sig_pool(); 1125 if (!hp) 1126 goto clear_hash_noput; 1127 desc = &hp->md5_desc; 1128 1129 if (crypto_hash_init(desc)) 1130 goto clear_hash; 1131 1132 if (tcp_v4_md5_hash_pseudoheader(hp, daddr, saddr, skb->len)) 1133 goto clear_hash; 1134 if (tcp_md5_hash_header(hp, th)) 1135 goto clear_hash; 1136 if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2)) 1137 goto clear_hash; 1138 if (tcp_md5_hash_key(hp, key)) 1139 goto clear_hash; 1140 if (crypto_hash_final(desc, md5_hash)) 1141 goto clear_hash; 1142 1143 tcp_put_md5sig_pool(); 1144 return 0; 1145 1146 clear_hash: 1147 tcp_put_md5sig_pool(); 1148 clear_hash_noput: 1149 memset(md5_hash, 0, 16); 1150 return 1; 1151 } 1152 EXPORT_SYMBOL(tcp_v4_md5_hash_skb); 1153 1154 static int tcp_v4_inbound_md5_hash(struct sock *sk, struct sk_buff *skb) 1155 { 1156 /* 1157 * This gets called for each TCP segment that arrives 1158 * so we want to be efficient. 1159 * We have 3 drop cases: 1160 * o No MD5 hash and one expected. 1161 * o MD5 hash and we're not expecting one. 1162 * o MD5 hash and its wrong. 1163 */ 1164 __u8 *hash_location = NULL; 1165 struct tcp_md5sig_key *hash_expected; 1166 const struct iphdr *iph = ip_hdr(skb); 1167 struct tcphdr *th = tcp_hdr(skb); 1168 int genhash; 1169 unsigned char newhash[16]; 1170 1171 hash_expected = tcp_v4_md5_do_lookup(sk, iph->saddr); 1172 hash_location = tcp_parse_md5sig_option(th); 1173 1174 /* We've parsed the options - do we have a hash? */ 1175 if (!hash_expected && !hash_location) 1176 return 0; 1177 1178 if (hash_expected && !hash_location) { 1179 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND); 1180 return 1; 1181 } 1182 1183 if (!hash_expected && hash_location) { 1184 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED); 1185 return 1; 1186 } 1187 1188 /* Okay, so this is hash_expected and hash_location - 1189 * so we need to calculate the checksum. 1190 */ 1191 genhash = tcp_v4_md5_hash_skb(newhash, 1192 hash_expected, 1193 NULL, NULL, skb); 1194 1195 if (genhash || memcmp(hash_location, newhash, 16) != 0) { 1196 if (net_ratelimit()) { 1197 printk(KERN_INFO "MD5 Hash failed for (%pI4, %d)->(%pI4, %d)%s\n", 1198 &iph->saddr, ntohs(th->source), 1199 &iph->daddr, ntohs(th->dest), 1200 genhash ? " tcp_v4_calc_md5_hash failed" : ""); 1201 } 1202 return 1; 1203 } 1204 return 0; 1205 } 1206 1207 #endif 1208 1209 struct request_sock_ops tcp_request_sock_ops __read_mostly = { 1210 .family = PF_INET, 1211 .obj_size = sizeof(struct tcp_request_sock), 1212 .rtx_syn_ack = tcp_v4_rtx_synack, 1213 .send_ack = tcp_v4_reqsk_send_ack, 1214 .destructor = tcp_v4_reqsk_destructor, 1215 .send_reset = tcp_v4_send_reset, 1216 .syn_ack_timeout = tcp_syn_ack_timeout, 1217 }; 1218 1219 #ifdef CONFIG_TCP_MD5SIG 1220 static const struct tcp_request_sock_ops tcp_request_sock_ipv4_ops = { 1221 .md5_lookup = tcp_v4_reqsk_md5_lookup, 1222 .calc_md5_hash = tcp_v4_md5_hash_skb, 1223 }; 1224 #endif 1225 1226 int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb) 1227 { 1228 struct tcp_extend_values tmp_ext; 1229 struct tcp_options_received tmp_opt; 1230 u8 *hash_location; 1231 struct request_sock *req; 1232 struct inet_request_sock *ireq; 1233 struct tcp_sock *tp = tcp_sk(sk); 1234 struct dst_entry *dst = NULL; 1235 __be32 saddr = ip_hdr(skb)->saddr; 1236 __be32 daddr = ip_hdr(skb)->daddr; 1237 __u32 isn = TCP_SKB_CB(skb)->when; 1238 #ifdef CONFIG_SYN_COOKIES 1239 int want_cookie = 0; 1240 #else 1241 #define want_cookie 0 /* Argh, why doesn't gcc optimize this :( */ 1242 #endif 1243 1244 /* Never answer to SYNs send to broadcast or multicast */ 1245 if (skb_rtable(skb)->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST)) 1246 goto drop; 1247 1248 /* TW buckets are converted to open requests without 1249 * limitations, they conserve resources and peer is 1250 * evidently real one. 1251 */ 1252 if (inet_csk_reqsk_queue_is_full(sk) && !isn) { 1253 if (net_ratelimit()) 1254 syn_flood_warning(skb); 1255 #ifdef CONFIG_SYN_COOKIES 1256 if (sysctl_tcp_syncookies) { 1257 want_cookie = 1; 1258 } else 1259 #endif 1260 goto drop; 1261 } 1262 1263 /* Accept backlog is full. If we have already queued enough 1264 * of warm entries in syn queue, drop request. It is better than 1265 * clogging syn queue with openreqs with exponentially increasing 1266 * timeout. 1267 */ 1268 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1) 1269 goto drop; 1270 1271 req = inet_reqsk_alloc(&tcp_request_sock_ops); 1272 if (!req) 1273 goto drop; 1274 1275 #ifdef CONFIG_TCP_MD5SIG 1276 tcp_rsk(req)->af_specific = &tcp_request_sock_ipv4_ops; 1277 #endif 1278 1279 tcp_clear_options(&tmp_opt); 1280 tmp_opt.mss_clamp = TCP_MSS_DEFAULT; 1281 tmp_opt.user_mss = tp->rx_opt.user_mss; 1282 tcp_parse_options(skb, &tmp_opt, &hash_location, 0); 1283 1284 if (tmp_opt.cookie_plus > 0 && 1285 tmp_opt.saw_tstamp && 1286 !tp->rx_opt.cookie_out_never && 1287 (sysctl_tcp_cookie_size > 0 || 1288 (tp->cookie_values != NULL && 1289 tp->cookie_values->cookie_desired > 0))) { 1290 u8 *c; 1291 u32 *mess = &tmp_ext.cookie_bakery[COOKIE_DIGEST_WORDS]; 1292 int l = tmp_opt.cookie_plus - TCPOLEN_COOKIE_BASE; 1293 1294 if (tcp_cookie_generator(&tmp_ext.cookie_bakery[0]) != 0) 1295 goto drop_and_release; 1296 1297 /* Secret recipe starts with IP addresses */ 1298 *mess++ ^= (__force u32)daddr; 1299 *mess++ ^= (__force u32)saddr; 1300 1301 /* plus variable length Initiator Cookie */ 1302 c = (u8 *)mess; 1303 while (l-- > 0) 1304 *c++ ^= *hash_location++; 1305 1306 #ifdef CONFIG_SYN_COOKIES 1307 want_cookie = 0; /* not our kind of cookie */ 1308 #endif 1309 tmp_ext.cookie_out_never = 0; /* false */ 1310 tmp_ext.cookie_plus = tmp_opt.cookie_plus; 1311 } else if (!tp->rx_opt.cookie_in_always) { 1312 /* redundant indications, but ensure initialization. */ 1313 tmp_ext.cookie_out_never = 1; /* true */ 1314 tmp_ext.cookie_plus = 0; 1315 } else { 1316 goto drop_and_release; 1317 } 1318 tmp_ext.cookie_in_always = tp->rx_opt.cookie_in_always; 1319 1320 if (want_cookie && !tmp_opt.saw_tstamp) 1321 tcp_clear_options(&tmp_opt); 1322 1323 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp; 1324 tcp_openreq_init(req, &tmp_opt, skb); 1325 1326 ireq = inet_rsk(req); 1327 ireq->loc_addr = daddr; 1328 ireq->rmt_addr = saddr; 1329 ireq->no_srccheck = inet_sk(sk)->transparent; 1330 ireq->opt = tcp_v4_save_options(sk, skb); 1331 1332 if (security_inet_conn_request(sk, skb, req)) 1333 goto drop_and_free; 1334 1335 if (!want_cookie || tmp_opt.tstamp_ok) 1336 TCP_ECN_create_request(req, tcp_hdr(skb)); 1337 1338 if (want_cookie) { 1339 isn = cookie_v4_init_sequence(sk, skb, &req->mss); 1340 req->cookie_ts = tmp_opt.tstamp_ok; 1341 } else if (!isn) { 1342 struct inet_peer *peer = NULL; 1343 struct flowi4 fl4; 1344 1345 /* VJ's idea. We save last timestamp seen 1346 * from the destination in peer table, when entering 1347 * state TIME-WAIT, and check against it before 1348 * accepting new connection request. 1349 * 1350 * If "isn" is not zero, this request hit alive 1351 * timewait bucket, so that all the necessary checks 1352 * are made in the function processing timewait state. 1353 */ 1354 if (tmp_opt.saw_tstamp && 1355 tcp_death_row.sysctl_tw_recycle && 1356 (dst = inet_csk_route_req(sk, &fl4, req)) != NULL && 1357 fl4.daddr == saddr && 1358 (peer = rt_get_peer((struct rtable *)dst, fl4.daddr)) != NULL) { 1359 inet_peer_refcheck(peer); 1360 if ((u32)get_seconds() - peer->tcp_ts_stamp < TCP_PAWS_MSL && 1361 (s32)(peer->tcp_ts - req->ts_recent) > 1362 TCP_PAWS_WINDOW) { 1363 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PAWSPASSIVEREJECTED); 1364 goto drop_and_release; 1365 } 1366 } 1367 /* Kill the following clause, if you dislike this way. */ 1368 else if (!sysctl_tcp_syncookies && 1369 (sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) < 1370 (sysctl_max_syn_backlog >> 2)) && 1371 (!peer || !peer->tcp_ts_stamp) && 1372 (!dst || !dst_metric(dst, RTAX_RTT))) { 1373 /* Without syncookies last quarter of 1374 * backlog is filled with destinations, 1375 * proven to be alive. 1376 * It means that we continue to communicate 1377 * to destinations, already remembered 1378 * to the moment of synflood. 1379 */ 1380 LIMIT_NETDEBUG(KERN_DEBUG "TCP: drop open request from %pI4/%u\n", 1381 &saddr, ntohs(tcp_hdr(skb)->source)); 1382 goto drop_and_release; 1383 } 1384 1385 isn = tcp_v4_init_sequence(skb); 1386 } 1387 tcp_rsk(req)->snt_isn = isn; 1388 tcp_rsk(req)->snt_synack = tcp_time_stamp; 1389 1390 if (tcp_v4_send_synack(sk, dst, req, 1391 (struct request_values *)&tmp_ext) || 1392 want_cookie) 1393 goto drop_and_free; 1394 1395 inet_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT); 1396 return 0; 1397 1398 drop_and_release: 1399 dst_release(dst); 1400 drop_and_free: 1401 reqsk_free(req); 1402 drop: 1403 return 0; 1404 } 1405 EXPORT_SYMBOL(tcp_v4_conn_request); 1406 1407 1408 /* 1409 * The three way handshake has completed - we got a valid synack - 1410 * now create the new socket. 1411 */ 1412 struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb, 1413 struct request_sock *req, 1414 struct dst_entry *dst) 1415 { 1416 struct inet_request_sock *ireq; 1417 struct inet_sock *newinet; 1418 struct tcp_sock *newtp; 1419 struct sock *newsk; 1420 #ifdef CONFIG_TCP_MD5SIG 1421 struct tcp_md5sig_key *key; 1422 #endif 1423 struct ip_options_rcu *inet_opt; 1424 1425 if (sk_acceptq_is_full(sk)) 1426 goto exit_overflow; 1427 1428 newsk = tcp_create_openreq_child(sk, req, skb); 1429 if (!newsk) 1430 goto exit_nonewsk; 1431 1432 newsk->sk_gso_type = SKB_GSO_TCPV4; 1433 1434 newtp = tcp_sk(newsk); 1435 newinet = inet_sk(newsk); 1436 ireq = inet_rsk(req); 1437 newinet->inet_daddr = ireq->rmt_addr; 1438 newinet->inet_rcv_saddr = ireq->loc_addr; 1439 newinet->inet_saddr = ireq->loc_addr; 1440 inet_opt = ireq->opt; 1441 rcu_assign_pointer(newinet->inet_opt, inet_opt); 1442 ireq->opt = NULL; 1443 newinet->mc_index = inet_iif(skb); 1444 newinet->mc_ttl = ip_hdr(skb)->ttl; 1445 inet_csk(newsk)->icsk_ext_hdr_len = 0; 1446 if (inet_opt) 1447 inet_csk(newsk)->icsk_ext_hdr_len = inet_opt->opt.optlen; 1448 newinet->inet_id = newtp->write_seq ^ jiffies; 1449 1450 if (!dst && (dst = inet_csk_route_child_sock(sk, newsk, req)) == NULL) 1451 goto put_and_exit; 1452 1453 sk_setup_caps(newsk, dst); 1454 1455 tcp_mtup_init(newsk); 1456 tcp_sync_mss(newsk, dst_mtu(dst)); 1457 newtp->advmss = dst_metric_advmss(dst); 1458 if (tcp_sk(sk)->rx_opt.user_mss && 1459 tcp_sk(sk)->rx_opt.user_mss < newtp->advmss) 1460 newtp->advmss = tcp_sk(sk)->rx_opt.user_mss; 1461 1462 tcp_initialize_rcv_mss(newsk); 1463 if (tcp_rsk(req)->snt_synack) 1464 tcp_valid_rtt_meas(newsk, 1465 tcp_time_stamp - tcp_rsk(req)->snt_synack); 1466 newtp->total_retrans = req->retrans; 1467 1468 #ifdef CONFIG_TCP_MD5SIG 1469 /* Copy over the MD5 key from the original socket */ 1470 key = tcp_v4_md5_do_lookup(sk, newinet->inet_daddr); 1471 if (key != NULL) { 1472 /* 1473 * We're using one, so create a matching key 1474 * on the newsk structure. If we fail to get 1475 * memory, then we end up not copying the key 1476 * across. Shucks. 1477 */ 1478 char *newkey = kmemdup(key->key, key->keylen, GFP_ATOMIC); 1479 if (newkey != NULL) 1480 tcp_v4_md5_do_add(newsk, newinet->inet_daddr, 1481 newkey, key->keylen); 1482 sk_nocaps_add(newsk, NETIF_F_GSO_MASK); 1483 } 1484 #endif 1485 1486 if (__inet_inherit_port(sk, newsk) < 0) 1487 goto put_and_exit; 1488 __inet_hash_nolisten(newsk, NULL); 1489 1490 return newsk; 1491 1492 exit_overflow: 1493 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS); 1494 exit_nonewsk: 1495 dst_release(dst); 1496 exit: 1497 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS); 1498 return NULL; 1499 put_and_exit: 1500 sock_put(newsk); 1501 goto exit; 1502 } 1503 EXPORT_SYMBOL(tcp_v4_syn_recv_sock); 1504 1505 static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb) 1506 { 1507 struct tcphdr *th = tcp_hdr(skb); 1508 const struct iphdr *iph = ip_hdr(skb); 1509 struct sock *nsk; 1510 struct request_sock **prev; 1511 /* Find possible connection requests. */ 1512 struct request_sock *req = inet_csk_search_req(sk, &prev, th->source, 1513 iph->saddr, iph->daddr); 1514 if (req) 1515 return tcp_check_req(sk, skb, req, prev); 1516 1517 nsk = inet_lookup_established(sock_net(sk), &tcp_hashinfo, iph->saddr, 1518 th->source, iph->daddr, th->dest, inet_iif(skb)); 1519 1520 if (nsk) { 1521 if (nsk->sk_state != TCP_TIME_WAIT) { 1522 bh_lock_sock(nsk); 1523 return nsk; 1524 } 1525 inet_twsk_put(inet_twsk(nsk)); 1526 return NULL; 1527 } 1528 1529 #ifdef CONFIG_SYN_COOKIES 1530 if (!th->syn) 1531 sk = cookie_v4_check(sk, skb, &(IPCB(skb)->opt)); 1532 #endif 1533 return sk; 1534 } 1535 1536 static __sum16 tcp_v4_checksum_init(struct sk_buff *skb) 1537 { 1538 const struct iphdr *iph = ip_hdr(skb); 1539 1540 if (skb->ip_summed == CHECKSUM_COMPLETE) { 1541 if (!tcp_v4_check(skb->len, iph->saddr, 1542 iph->daddr, skb->csum)) { 1543 skb->ip_summed = CHECKSUM_UNNECESSARY; 1544 return 0; 1545 } 1546 } 1547 1548 skb->csum = csum_tcpudp_nofold(iph->saddr, iph->daddr, 1549 skb->len, IPPROTO_TCP, 0); 1550 1551 if (skb->len <= 76) { 1552 return __skb_checksum_complete(skb); 1553 } 1554 return 0; 1555 } 1556 1557 1558 /* The socket must have it's spinlock held when we get 1559 * here. 1560 * 1561 * We have a potential double-lock case here, so even when 1562 * doing backlog processing we use the BH locking scheme. 1563 * This is because we cannot sleep with the original spinlock 1564 * held. 1565 */ 1566 int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb) 1567 { 1568 struct sock *rsk; 1569 #ifdef CONFIG_TCP_MD5SIG 1570 /* 1571 * We really want to reject the packet as early as possible 1572 * if: 1573 * o We're expecting an MD5'd packet and this is no MD5 tcp option 1574 * o There is an MD5 option and we're not expecting one 1575 */ 1576 if (tcp_v4_inbound_md5_hash(sk, skb)) 1577 goto discard; 1578 #endif 1579 1580 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */ 1581 sock_rps_save_rxhash(sk, skb->rxhash); 1582 if (tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len)) { 1583 rsk = sk; 1584 goto reset; 1585 } 1586 return 0; 1587 } 1588 1589 if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb)) 1590 goto csum_err; 1591 1592 if (sk->sk_state == TCP_LISTEN) { 1593 struct sock *nsk = tcp_v4_hnd_req(sk, skb); 1594 if (!nsk) 1595 goto discard; 1596 1597 if (nsk != sk) { 1598 sock_rps_save_rxhash(nsk, skb->rxhash); 1599 if (tcp_child_process(sk, nsk, skb)) { 1600 rsk = nsk; 1601 goto reset; 1602 } 1603 return 0; 1604 } 1605 } else 1606 sock_rps_save_rxhash(sk, skb->rxhash); 1607 1608 if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len)) { 1609 rsk = sk; 1610 goto reset; 1611 } 1612 return 0; 1613 1614 reset: 1615 tcp_v4_send_reset(rsk, skb); 1616 discard: 1617 kfree_skb(skb); 1618 /* Be careful here. If this function gets more complicated and 1619 * gcc suffers from register pressure on the x86, sk (in %ebx) 1620 * might be destroyed here. This current version compiles correctly, 1621 * but you have been warned. 1622 */ 1623 return 0; 1624 1625 csum_err: 1626 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS); 1627 goto discard; 1628 } 1629 EXPORT_SYMBOL(tcp_v4_do_rcv); 1630 1631 /* 1632 * From tcp_input.c 1633 */ 1634 1635 int tcp_v4_rcv(struct sk_buff *skb) 1636 { 1637 const struct iphdr *iph; 1638 struct tcphdr *th; 1639 struct sock *sk; 1640 int ret; 1641 struct net *net = dev_net(skb->dev); 1642 1643 if (skb->pkt_type != PACKET_HOST) 1644 goto discard_it; 1645 1646 /* Count it even if it's bad */ 1647 TCP_INC_STATS_BH(net, TCP_MIB_INSEGS); 1648 1649 if (!pskb_may_pull(skb, sizeof(struct tcphdr))) 1650 goto discard_it; 1651 1652 th = tcp_hdr(skb); 1653 1654 if (th->doff < sizeof(struct tcphdr) / 4) 1655 goto bad_packet; 1656 if (!pskb_may_pull(skb, th->doff * 4)) 1657 goto discard_it; 1658 1659 /* An explanation is required here, I think. 1660 * Packet length and doff are validated by header prediction, 1661 * provided case of th->doff==0 is eliminated. 1662 * So, we defer the checks. */ 1663 if (!skb_csum_unnecessary(skb) && tcp_v4_checksum_init(skb)) 1664 goto bad_packet; 1665 1666 th = tcp_hdr(skb); 1667 iph = ip_hdr(skb); 1668 TCP_SKB_CB(skb)->seq = ntohl(th->seq); 1669 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin + 1670 skb->len - th->doff * 4); 1671 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq); 1672 TCP_SKB_CB(skb)->when = 0; 1673 TCP_SKB_CB(skb)->flags = iph->tos; 1674 TCP_SKB_CB(skb)->sacked = 0; 1675 1676 sk = __inet_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest); 1677 if (!sk) 1678 goto no_tcp_socket; 1679 1680 process: 1681 if (sk->sk_state == TCP_TIME_WAIT) 1682 goto do_time_wait; 1683 1684 if (unlikely(iph->ttl < inet_sk(sk)->min_ttl)) { 1685 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP); 1686 goto discard_and_relse; 1687 } 1688 1689 if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb)) 1690 goto discard_and_relse; 1691 nf_reset(skb); 1692 1693 if (sk_filter(sk, skb)) 1694 goto discard_and_relse; 1695 1696 skb->dev = NULL; 1697 1698 bh_lock_sock_nested(sk); 1699 ret = 0; 1700 if (!sock_owned_by_user(sk)) { 1701 #ifdef CONFIG_NET_DMA 1702 struct tcp_sock *tp = tcp_sk(sk); 1703 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list) 1704 tp->ucopy.dma_chan = dma_find_channel(DMA_MEMCPY); 1705 if (tp->ucopy.dma_chan) 1706 ret = tcp_v4_do_rcv(sk, skb); 1707 else 1708 #endif 1709 { 1710 if (!tcp_prequeue(sk, skb)) 1711 ret = tcp_v4_do_rcv(sk, skb); 1712 } 1713 } else if (unlikely(sk_add_backlog(sk, skb))) { 1714 bh_unlock_sock(sk); 1715 NET_INC_STATS_BH(net, LINUX_MIB_TCPBACKLOGDROP); 1716 goto discard_and_relse; 1717 } 1718 bh_unlock_sock(sk); 1719 1720 sock_put(sk); 1721 1722 return ret; 1723 1724 no_tcp_socket: 1725 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) 1726 goto discard_it; 1727 1728 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) { 1729 bad_packet: 1730 TCP_INC_STATS_BH(net, TCP_MIB_INERRS); 1731 } else { 1732 tcp_v4_send_reset(NULL, skb); 1733 } 1734 1735 discard_it: 1736 /* Discard frame. */ 1737 kfree_skb(skb); 1738 return 0; 1739 1740 discard_and_relse: 1741 sock_put(sk); 1742 goto discard_it; 1743 1744 do_time_wait: 1745 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) { 1746 inet_twsk_put(inet_twsk(sk)); 1747 goto discard_it; 1748 } 1749 1750 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) { 1751 TCP_INC_STATS_BH(net, TCP_MIB_INERRS); 1752 inet_twsk_put(inet_twsk(sk)); 1753 goto discard_it; 1754 } 1755 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) { 1756 case TCP_TW_SYN: { 1757 struct sock *sk2 = inet_lookup_listener(dev_net(skb->dev), 1758 &tcp_hashinfo, 1759 iph->daddr, th->dest, 1760 inet_iif(skb)); 1761 if (sk2) { 1762 inet_twsk_deschedule(inet_twsk(sk), &tcp_death_row); 1763 inet_twsk_put(inet_twsk(sk)); 1764 sk = sk2; 1765 goto process; 1766 } 1767 /* Fall through to ACK */ 1768 } 1769 case TCP_TW_ACK: 1770 tcp_v4_timewait_ack(sk, skb); 1771 break; 1772 case TCP_TW_RST: 1773 goto no_tcp_socket; 1774 case TCP_TW_SUCCESS:; 1775 } 1776 goto discard_it; 1777 } 1778 1779 struct inet_peer *tcp_v4_get_peer(struct sock *sk, bool *release_it) 1780 { 1781 struct rtable *rt = (struct rtable *) __sk_dst_get(sk); 1782 struct inet_sock *inet = inet_sk(sk); 1783 struct inet_peer *peer; 1784 1785 if (!rt || 1786 inet->cork.fl.u.ip4.daddr != inet->inet_daddr) { 1787 peer = inet_getpeer_v4(inet->inet_daddr, 1); 1788 *release_it = true; 1789 } else { 1790 if (!rt->peer) 1791 rt_bind_peer(rt, inet->inet_daddr, 1); 1792 peer = rt->peer; 1793 *release_it = false; 1794 } 1795 1796 return peer; 1797 } 1798 EXPORT_SYMBOL(tcp_v4_get_peer); 1799 1800 void *tcp_v4_tw_get_peer(struct sock *sk) 1801 { 1802 struct inet_timewait_sock *tw = inet_twsk(sk); 1803 1804 return inet_getpeer_v4(tw->tw_daddr, 1); 1805 } 1806 EXPORT_SYMBOL(tcp_v4_tw_get_peer); 1807 1808 static struct timewait_sock_ops tcp_timewait_sock_ops = { 1809 .twsk_obj_size = sizeof(struct tcp_timewait_sock), 1810 .twsk_unique = tcp_twsk_unique, 1811 .twsk_destructor= tcp_twsk_destructor, 1812 .twsk_getpeer = tcp_v4_tw_get_peer, 1813 }; 1814 1815 const struct inet_connection_sock_af_ops ipv4_specific = { 1816 .queue_xmit = ip_queue_xmit, 1817 .send_check = tcp_v4_send_check, 1818 .rebuild_header = inet_sk_rebuild_header, 1819 .conn_request = tcp_v4_conn_request, 1820 .syn_recv_sock = tcp_v4_syn_recv_sock, 1821 .get_peer = tcp_v4_get_peer, 1822 .net_header_len = sizeof(struct iphdr), 1823 .setsockopt = ip_setsockopt, 1824 .getsockopt = ip_getsockopt, 1825 .addr2sockaddr = inet_csk_addr2sockaddr, 1826 .sockaddr_len = sizeof(struct sockaddr_in), 1827 .bind_conflict = inet_csk_bind_conflict, 1828 #ifdef CONFIG_COMPAT 1829 .compat_setsockopt = compat_ip_setsockopt, 1830 .compat_getsockopt = compat_ip_getsockopt, 1831 #endif 1832 }; 1833 EXPORT_SYMBOL(ipv4_specific); 1834 1835 #ifdef CONFIG_TCP_MD5SIG 1836 static const struct tcp_sock_af_ops tcp_sock_ipv4_specific = { 1837 .md5_lookup = tcp_v4_md5_lookup, 1838 .calc_md5_hash = tcp_v4_md5_hash_skb, 1839 .md5_add = tcp_v4_md5_add_func, 1840 .md5_parse = tcp_v4_parse_md5_keys, 1841 }; 1842 #endif 1843 1844 /* NOTE: A lot of things set to zero explicitly by call to 1845 * sk_alloc() so need not be done here. 1846 */ 1847 static int tcp_v4_init_sock(struct sock *sk) 1848 { 1849 struct inet_connection_sock *icsk = inet_csk(sk); 1850 struct tcp_sock *tp = tcp_sk(sk); 1851 1852 skb_queue_head_init(&tp->out_of_order_queue); 1853 tcp_init_xmit_timers(sk); 1854 tcp_prequeue_init(tp); 1855 1856 icsk->icsk_rto = TCP_TIMEOUT_INIT; 1857 tp->mdev = TCP_TIMEOUT_INIT; 1858 1859 /* So many TCP implementations out there (incorrectly) count the 1860 * initial SYN frame in their delayed-ACK and congestion control 1861 * algorithms that we must have the following bandaid to talk 1862 * efficiently to them. -DaveM 1863 */ 1864 tp->snd_cwnd = TCP_INIT_CWND; 1865 1866 /* See draft-stevens-tcpca-spec-01 for discussion of the 1867 * initialization of these values. 1868 */ 1869 tp->snd_ssthresh = TCP_INFINITE_SSTHRESH; 1870 tp->snd_cwnd_clamp = ~0; 1871 tp->mss_cache = TCP_MSS_DEFAULT; 1872 1873 tp->reordering = sysctl_tcp_reordering; 1874 icsk->icsk_ca_ops = &tcp_init_congestion_ops; 1875 1876 sk->sk_state = TCP_CLOSE; 1877 1878 sk->sk_write_space = sk_stream_write_space; 1879 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE); 1880 1881 icsk->icsk_af_ops = &ipv4_specific; 1882 icsk->icsk_sync_mss = tcp_sync_mss; 1883 #ifdef CONFIG_TCP_MD5SIG 1884 tp->af_specific = &tcp_sock_ipv4_specific; 1885 #endif 1886 1887 /* TCP Cookie Transactions */ 1888 if (sysctl_tcp_cookie_size > 0) { 1889 /* Default, cookies without s_data_payload. */ 1890 tp->cookie_values = 1891 kzalloc(sizeof(*tp->cookie_values), 1892 sk->sk_allocation); 1893 if (tp->cookie_values != NULL) 1894 kref_init(&tp->cookie_values->kref); 1895 } 1896 /* Presumed zeroed, in order of appearance: 1897 * cookie_in_always, cookie_out_never, 1898 * s_data_constant, s_data_in, s_data_out 1899 */ 1900 sk->sk_sndbuf = sysctl_tcp_wmem[1]; 1901 sk->sk_rcvbuf = sysctl_tcp_rmem[1]; 1902 1903 local_bh_disable(); 1904 percpu_counter_inc(&tcp_sockets_allocated); 1905 local_bh_enable(); 1906 1907 return 0; 1908 } 1909 1910 void tcp_v4_destroy_sock(struct sock *sk) 1911 { 1912 struct tcp_sock *tp = tcp_sk(sk); 1913 1914 tcp_clear_xmit_timers(sk); 1915 1916 tcp_cleanup_congestion_control(sk); 1917 1918 /* Cleanup up the write buffer. */ 1919 tcp_write_queue_purge(sk); 1920 1921 /* Cleans up our, hopefully empty, out_of_order_queue. */ 1922 __skb_queue_purge(&tp->out_of_order_queue); 1923 1924 #ifdef CONFIG_TCP_MD5SIG 1925 /* Clean up the MD5 key list, if any */ 1926 if (tp->md5sig_info) { 1927 tcp_v4_clear_md5_list(sk); 1928 kfree(tp->md5sig_info); 1929 tp->md5sig_info = NULL; 1930 } 1931 #endif 1932 1933 #ifdef CONFIG_NET_DMA 1934 /* Cleans up our sk_async_wait_queue */ 1935 __skb_queue_purge(&sk->sk_async_wait_queue); 1936 #endif 1937 1938 /* Clean prequeue, it must be empty really */ 1939 __skb_queue_purge(&tp->ucopy.prequeue); 1940 1941 /* Clean up a referenced TCP bind bucket. */ 1942 if (inet_csk(sk)->icsk_bind_hash) 1943 inet_put_port(sk); 1944 1945 /* 1946 * If sendmsg cached page exists, toss it. 1947 */ 1948 if (sk->sk_sndmsg_page) { 1949 __free_page(sk->sk_sndmsg_page); 1950 sk->sk_sndmsg_page = NULL; 1951 } 1952 1953 /* TCP Cookie Transactions */ 1954 if (tp->cookie_values != NULL) { 1955 kref_put(&tp->cookie_values->kref, 1956 tcp_cookie_values_release); 1957 tp->cookie_values = NULL; 1958 } 1959 1960 percpu_counter_dec(&tcp_sockets_allocated); 1961 } 1962 EXPORT_SYMBOL(tcp_v4_destroy_sock); 1963 1964 #ifdef CONFIG_PROC_FS 1965 /* Proc filesystem TCP sock list dumping. */ 1966 1967 static inline struct inet_timewait_sock *tw_head(struct hlist_nulls_head *head) 1968 { 1969 return hlist_nulls_empty(head) ? NULL : 1970 list_entry(head->first, struct inet_timewait_sock, tw_node); 1971 } 1972 1973 static inline struct inet_timewait_sock *tw_next(struct inet_timewait_sock *tw) 1974 { 1975 return !is_a_nulls(tw->tw_node.next) ? 1976 hlist_nulls_entry(tw->tw_node.next, typeof(*tw), tw_node) : NULL; 1977 } 1978 1979 /* 1980 * Get next listener socket follow cur. If cur is NULL, get first socket 1981 * starting from bucket given in st->bucket; when st->bucket is zero the 1982 * very first socket in the hash table is returned. 1983 */ 1984 static void *listening_get_next(struct seq_file *seq, void *cur) 1985 { 1986 struct inet_connection_sock *icsk; 1987 struct hlist_nulls_node *node; 1988 struct sock *sk = cur; 1989 struct inet_listen_hashbucket *ilb; 1990 struct tcp_iter_state *st = seq->private; 1991 struct net *net = seq_file_net(seq); 1992 1993 if (!sk) { 1994 ilb = &tcp_hashinfo.listening_hash[st->bucket]; 1995 spin_lock_bh(&ilb->lock); 1996 sk = sk_nulls_head(&ilb->head); 1997 st->offset = 0; 1998 goto get_sk; 1999 } 2000 ilb = &tcp_hashinfo.listening_hash[st->bucket]; 2001 ++st->num; 2002 ++st->offset; 2003 2004 if (st->state == TCP_SEQ_STATE_OPENREQ) { 2005 struct request_sock *req = cur; 2006 2007 icsk = inet_csk(st->syn_wait_sk); 2008 req = req->dl_next; 2009 while (1) { 2010 while (req) { 2011 if (req->rsk_ops->family == st->family) { 2012 cur = req; 2013 goto out; 2014 } 2015 req = req->dl_next; 2016 } 2017 if (++st->sbucket >= icsk->icsk_accept_queue.listen_opt->nr_table_entries) 2018 break; 2019 get_req: 2020 req = icsk->icsk_accept_queue.listen_opt->syn_table[st->sbucket]; 2021 } 2022 sk = sk_nulls_next(st->syn_wait_sk); 2023 st->state = TCP_SEQ_STATE_LISTENING; 2024 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock); 2025 } else { 2026 icsk = inet_csk(sk); 2027 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock); 2028 if (reqsk_queue_len(&icsk->icsk_accept_queue)) 2029 goto start_req; 2030 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock); 2031 sk = sk_nulls_next(sk); 2032 } 2033 get_sk: 2034 sk_nulls_for_each_from(sk, node) { 2035 if (!net_eq(sock_net(sk), net)) 2036 continue; 2037 if (sk->sk_family == st->family) { 2038 cur = sk; 2039 goto out; 2040 } 2041 icsk = inet_csk(sk); 2042 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock); 2043 if (reqsk_queue_len(&icsk->icsk_accept_queue)) { 2044 start_req: 2045 st->uid = sock_i_uid(sk); 2046 st->syn_wait_sk = sk; 2047 st->state = TCP_SEQ_STATE_OPENREQ; 2048 st->sbucket = 0; 2049 goto get_req; 2050 } 2051 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock); 2052 } 2053 spin_unlock_bh(&ilb->lock); 2054 st->offset = 0; 2055 if (++st->bucket < INET_LHTABLE_SIZE) { 2056 ilb = &tcp_hashinfo.listening_hash[st->bucket]; 2057 spin_lock_bh(&ilb->lock); 2058 sk = sk_nulls_head(&ilb->head); 2059 goto get_sk; 2060 } 2061 cur = NULL; 2062 out: 2063 return cur; 2064 } 2065 2066 static void *listening_get_idx(struct seq_file *seq, loff_t *pos) 2067 { 2068 struct tcp_iter_state *st = seq->private; 2069 void *rc; 2070 2071 st->bucket = 0; 2072 st->offset = 0; 2073 rc = listening_get_next(seq, NULL); 2074 2075 while (rc && *pos) { 2076 rc = listening_get_next(seq, rc); 2077 --*pos; 2078 } 2079 return rc; 2080 } 2081 2082 static inline int empty_bucket(struct tcp_iter_state *st) 2083 { 2084 return hlist_nulls_empty(&tcp_hashinfo.ehash[st->bucket].chain) && 2085 hlist_nulls_empty(&tcp_hashinfo.ehash[st->bucket].twchain); 2086 } 2087 2088 /* 2089 * Get first established socket starting from bucket given in st->bucket. 2090 * If st->bucket is zero, the very first socket in the hash is returned. 2091 */ 2092 static void *established_get_first(struct seq_file *seq) 2093 { 2094 struct tcp_iter_state *st = seq->private; 2095 struct net *net = seq_file_net(seq); 2096 void *rc = NULL; 2097 2098 st->offset = 0; 2099 for (; st->bucket <= tcp_hashinfo.ehash_mask; ++st->bucket) { 2100 struct sock *sk; 2101 struct hlist_nulls_node *node; 2102 struct inet_timewait_sock *tw; 2103 spinlock_t *lock = inet_ehash_lockp(&tcp_hashinfo, st->bucket); 2104 2105 /* Lockless fast path for the common case of empty buckets */ 2106 if (empty_bucket(st)) 2107 continue; 2108 2109 spin_lock_bh(lock); 2110 sk_nulls_for_each(sk, node, &tcp_hashinfo.ehash[st->bucket].chain) { 2111 if (sk->sk_family != st->family || 2112 !net_eq(sock_net(sk), net)) { 2113 continue; 2114 } 2115 rc = sk; 2116 goto out; 2117 } 2118 st->state = TCP_SEQ_STATE_TIME_WAIT; 2119 inet_twsk_for_each(tw, node, 2120 &tcp_hashinfo.ehash[st->bucket].twchain) { 2121 if (tw->tw_family != st->family || 2122 !net_eq(twsk_net(tw), net)) { 2123 continue; 2124 } 2125 rc = tw; 2126 goto out; 2127 } 2128 spin_unlock_bh(lock); 2129 st->state = TCP_SEQ_STATE_ESTABLISHED; 2130 } 2131 out: 2132 return rc; 2133 } 2134 2135 static void *established_get_next(struct seq_file *seq, void *cur) 2136 { 2137 struct sock *sk = cur; 2138 struct inet_timewait_sock *tw; 2139 struct hlist_nulls_node *node; 2140 struct tcp_iter_state *st = seq->private; 2141 struct net *net = seq_file_net(seq); 2142 2143 ++st->num; 2144 ++st->offset; 2145 2146 if (st->state == TCP_SEQ_STATE_TIME_WAIT) { 2147 tw = cur; 2148 tw = tw_next(tw); 2149 get_tw: 2150 while (tw && (tw->tw_family != st->family || !net_eq(twsk_net(tw), net))) { 2151 tw = tw_next(tw); 2152 } 2153 if (tw) { 2154 cur = tw; 2155 goto out; 2156 } 2157 spin_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket)); 2158 st->state = TCP_SEQ_STATE_ESTABLISHED; 2159 2160 /* Look for next non empty bucket */ 2161 st->offset = 0; 2162 while (++st->bucket <= tcp_hashinfo.ehash_mask && 2163 empty_bucket(st)) 2164 ; 2165 if (st->bucket > tcp_hashinfo.ehash_mask) 2166 return NULL; 2167 2168 spin_lock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket)); 2169 sk = sk_nulls_head(&tcp_hashinfo.ehash[st->bucket].chain); 2170 } else 2171 sk = sk_nulls_next(sk); 2172 2173 sk_nulls_for_each_from(sk, node) { 2174 if (sk->sk_family == st->family && net_eq(sock_net(sk), net)) 2175 goto found; 2176 } 2177 2178 st->state = TCP_SEQ_STATE_TIME_WAIT; 2179 tw = tw_head(&tcp_hashinfo.ehash[st->bucket].twchain); 2180 goto get_tw; 2181 found: 2182 cur = sk; 2183 out: 2184 return cur; 2185 } 2186 2187 static void *established_get_idx(struct seq_file *seq, loff_t pos) 2188 { 2189 struct tcp_iter_state *st = seq->private; 2190 void *rc; 2191 2192 st->bucket = 0; 2193 rc = established_get_first(seq); 2194 2195 while (rc && pos) { 2196 rc = established_get_next(seq, rc); 2197 --pos; 2198 } 2199 return rc; 2200 } 2201 2202 static void *tcp_get_idx(struct seq_file *seq, loff_t pos) 2203 { 2204 void *rc; 2205 struct tcp_iter_state *st = seq->private; 2206 2207 st->state = TCP_SEQ_STATE_LISTENING; 2208 rc = listening_get_idx(seq, &pos); 2209 2210 if (!rc) { 2211 st->state = TCP_SEQ_STATE_ESTABLISHED; 2212 rc = established_get_idx(seq, pos); 2213 } 2214 2215 return rc; 2216 } 2217 2218 static void *tcp_seek_last_pos(struct seq_file *seq) 2219 { 2220 struct tcp_iter_state *st = seq->private; 2221 int offset = st->offset; 2222 int orig_num = st->num; 2223 void *rc = NULL; 2224 2225 switch (st->state) { 2226 case TCP_SEQ_STATE_OPENREQ: 2227 case TCP_SEQ_STATE_LISTENING: 2228 if (st->bucket >= INET_LHTABLE_SIZE) 2229 break; 2230 st->state = TCP_SEQ_STATE_LISTENING; 2231 rc = listening_get_next(seq, NULL); 2232 while (offset-- && rc) 2233 rc = listening_get_next(seq, rc); 2234 if (rc) 2235 break; 2236 st->bucket = 0; 2237 /* Fallthrough */ 2238 case TCP_SEQ_STATE_ESTABLISHED: 2239 case TCP_SEQ_STATE_TIME_WAIT: 2240 st->state = TCP_SEQ_STATE_ESTABLISHED; 2241 if (st->bucket > tcp_hashinfo.ehash_mask) 2242 break; 2243 rc = established_get_first(seq); 2244 while (offset-- && rc) 2245 rc = established_get_next(seq, rc); 2246 } 2247 2248 st->num = orig_num; 2249 2250 return rc; 2251 } 2252 2253 static void *tcp_seq_start(struct seq_file *seq, loff_t *pos) 2254 { 2255 struct tcp_iter_state *st = seq->private; 2256 void *rc; 2257 2258 if (*pos && *pos == st->last_pos) { 2259 rc = tcp_seek_last_pos(seq); 2260 if (rc) 2261 goto out; 2262 } 2263 2264 st->state = TCP_SEQ_STATE_LISTENING; 2265 st->num = 0; 2266 st->bucket = 0; 2267 st->offset = 0; 2268 rc = *pos ? tcp_get_idx(seq, *pos - 1) : SEQ_START_TOKEN; 2269 2270 out: 2271 st->last_pos = *pos; 2272 return rc; 2273 } 2274 2275 static void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos) 2276 { 2277 struct tcp_iter_state *st = seq->private; 2278 void *rc = NULL; 2279 2280 if (v == SEQ_START_TOKEN) { 2281 rc = tcp_get_idx(seq, 0); 2282 goto out; 2283 } 2284 2285 switch (st->state) { 2286 case TCP_SEQ_STATE_OPENREQ: 2287 case TCP_SEQ_STATE_LISTENING: 2288 rc = listening_get_next(seq, v); 2289 if (!rc) { 2290 st->state = TCP_SEQ_STATE_ESTABLISHED; 2291 st->bucket = 0; 2292 st->offset = 0; 2293 rc = established_get_first(seq); 2294 } 2295 break; 2296 case TCP_SEQ_STATE_ESTABLISHED: 2297 case TCP_SEQ_STATE_TIME_WAIT: 2298 rc = established_get_next(seq, v); 2299 break; 2300 } 2301 out: 2302 ++*pos; 2303 st->last_pos = *pos; 2304 return rc; 2305 } 2306 2307 static void tcp_seq_stop(struct seq_file *seq, void *v) 2308 { 2309 struct tcp_iter_state *st = seq->private; 2310 2311 switch (st->state) { 2312 case TCP_SEQ_STATE_OPENREQ: 2313 if (v) { 2314 struct inet_connection_sock *icsk = inet_csk(st->syn_wait_sk); 2315 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock); 2316 } 2317 case TCP_SEQ_STATE_LISTENING: 2318 if (v != SEQ_START_TOKEN) 2319 spin_unlock_bh(&tcp_hashinfo.listening_hash[st->bucket].lock); 2320 break; 2321 case TCP_SEQ_STATE_TIME_WAIT: 2322 case TCP_SEQ_STATE_ESTABLISHED: 2323 if (v) 2324 spin_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket)); 2325 break; 2326 } 2327 } 2328 2329 static int tcp_seq_open(struct inode *inode, struct file *file) 2330 { 2331 struct tcp_seq_afinfo *afinfo = PDE(inode)->data; 2332 struct tcp_iter_state *s; 2333 int err; 2334 2335 err = seq_open_net(inode, file, &afinfo->seq_ops, 2336 sizeof(struct tcp_iter_state)); 2337 if (err < 0) 2338 return err; 2339 2340 s = ((struct seq_file *)file->private_data)->private; 2341 s->family = afinfo->family; 2342 s->last_pos = 0; 2343 return 0; 2344 } 2345 2346 int tcp_proc_register(struct net *net, struct tcp_seq_afinfo *afinfo) 2347 { 2348 int rc = 0; 2349 struct proc_dir_entry *p; 2350 2351 afinfo->seq_fops.open = tcp_seq_open; 2352 afinfo->seq_fops.read = seq_read; 2353 afinfo->seq_fops.llseek = seq_lseek; 2354 afinfo->seq_fops.release = seq_release_net; 2355 2356 afinfo->seq_ops.start = tcp_seq_start; 2357 afinfo->seq_ops.next = tcp_seq_next; 2358 afinfo->seq_ops.stop = tcp_seq_stop; 2359 2360 p = proc_create_data(afinfo->name, S_IRUGO, net->proc_net, 2361 &afinfo->seq_fops, afinfo); 2362 if (!p) 2363 rc = -ENOMEM; 2364 return rc; 2365 } 2366 EXPORT_SYMBOL(tcp_proc_register); 2367 2368 void tcp_proc_unregister(struct net *net, struct tcp_seq_afinfo *afinfo) 2369 { 2370 proc_net_remove(net, afinfo->name); 2371 } 2372 EXPORT_SYMBOL(tcp_proc_unregister); 2373 2374 static void get_openreq4(struct sock *sk, struct request_sock *req, 2375 struct seq_file *f, int i, int uid, int *len) 2376 { 2377 const struct inet_request_sock *ireq = inet_rsk(req); 2378 int ttd = req->expires - jiffies; 2379 2380 seq_printf(f, "%4d: %08X:%04X %08X:%04X" 2381 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %u %d %pK%n", 2382 i, 2383 ireq->loc_addr, 2384 ntohs(inet_sk(sk)->inet_sport), 2385 ireq->rmt_addr, 2386 ntohs(ireq->rmt_port), 2387 TCP_SYN_RECV, 2388 0, 0, /* could print option size, but that is af dependent. */ 2389 1, /* timers active (only the expire timer) */ 2390 jiffies_to_clock_t(ttd), 2391 req->retrans, 2392 uid, 2393 0, /* non standard timer */ 2394 0, /* open_requests have no inode */ 2395 atomic_read(&sk->sk_refcnt), 2396 req, 2397 len); 2398 } 2399 2400 static void get_tcp4_sock(struct sock *sk, struct seq_file *f, int i, int *len) 2401 { 2402 int timer_active; 2403 unsigned long timer_expires; 2404 struct tcp_sock *tp = tcp_sk(sk); 2405 const struct inet_connection_sock *icsk = inet_csk(sk); 2406 struct inet_sock *inet = inet_sk(sk); 2407 __be32 dest = inet->inet_daddr; 2408 __be32 src = inet->inet_rcv_saddr; 2409 __u16 destp = ntohs(inet->inet_dport); 2410 __u16 srcp = ntohs(inet->inet_sport); 2411 int rx_queue; 2412 2413 if (icsk->icsk_pending == ICSK_TIME_RETRANS) { 2414 timer_active = 1; 2415 timer_expires = icsk->icsk_timeout; 2416 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) { 2417 timer_active = 4; 2418 timer_expires = icsk->icsk_timeout; 2419 } else if (timer_pending(&sk->sk_timer)) { 2420 timer_active = 2; 2421 timer_expires = sk->sk_timer.expires; 2422 } else { 2423 timer_active = 0; 2424 timer_expires = jiffies; 2425 } 2426 2427 if (sk->sk_state == TCP_LISTEN) 2428 rx_queue = sk->sk_ack_backlog; 2429 else 2430 /* 2431 * because we dont lock socket, we might find a transient negative value 2432 */ 2433 rx_queue = max_t(int, tp->rcv_nxt - tp->copied_seq, 0); 2434 2435 seq_printf(f, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX " 2436 "%08X %5d %8d %lu %d %pK %lu %lu %u %u %d%n", 2437 i, src, srcp, dest, destp, sk->sk_state, 2438 tp->write_seq - tp->snd_una, 2439 rx_queue, 2440 timer_active, 2441 jiffies_to_clock_t(timer_expires - jiffies), 2442 icsk->icsk_retransmits, 2443 sock_i_uid(sk), 2444 icsk->icsk_probes_out, 2445 sock_i_ino(sk), 2446 atomic_read(&sk->sk_refcnt), sk, 2447 jiffies_to_clock_t(icsk->icsk_rto), 2448 jiffies_to_clock_t(icsk->icsk_ack.ato), 2449 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong, 2450 tp->snd_cwnd, 2451 tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh, 2452 len); 2453 } 2454 2455 static void get_timewait4_sock(struct inet_timewait_sock *tw, 2456 struct seq_file *f, int i, int *len) 2457 { 2458 __be32 dest, src; 2459 __u16 destp, srcp; 2460 int ttd = tw->tw_ttd - jiffies; 2461 2462 if (ttd < 0) 2463 ttd = 0; 2464 2465 dest = tw->tw_daddr; 2466 src = tw->tw_rcv_saddr; 2467 destp = ntohs(tw->tw_dport); 2468 srcp = ntohs(tw->tw_sport); 2469 2470 seq_printf(f, "%4d: %08X:%04X %08X:%04X" 2471 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK%n", 2472 i, src, srcp, dest, destp, tw->tw_substate, 0, 0, 2473 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0, 2474 atomic_read(&tw->tw_refcnt), tw, len); 2475 } 2476 2477 #define TMPSZ 150 2478 2479 static int tcp4_seq_show(struct seq_file *seq, void *v) 2480 { 2481 struct tcp_iter_state *st; 2482 int len; 2483 2484 if (v == SEQ_START_TOKEN) { 2485 seq_printf(seq, "%-*s\n", TMPSZ - 1, 2486 " sl local_address rem_address st tx_queue " 2487 "rx_queue tr tm->when retrnsmt uid timeout " 2488 "inode"); 2489 goto out; 2490 } 2491 st = seq->private; 2492 2493 switch (st->state) { 2494 case TCP_SEQ_STATE_LISTENING: 2495 case TCP_SEQ_STATE_ESTABLISHED: 2496 get_tcp4_sock(v, seq, st->num, &len); 2497 break; 2498 case TCP_SEQ_STATE_OPENREQ: 2499 get_openreq4(st->syn_wait_sk, v, seq, st->num, st->uid, &len); 2500 break; 2501 case TCP_SEQ_STATE_TIME_WAIT: 2502 get_timewait4_sock(v, seq, st->num, &len); 2503 break; 2504 } 2505 seq_printf(seq, "%*s\n", TMPSZ - 1 - len, ""); 2506 out: 2507 return 0; 2508 } 2509 2510 static struct tcp_seq_afinfo tcp4_seq_afinfo = { 2511 .name = "tcp", 2512 .family = AF_INET, 2513 .seq_fops = { 2514 .owner = THIS_MODULE, 2515 }, 2516 .seq_ops = { 2517 .show = tcp4_seq_show, 2518 }, 2519 }; 2520 2521 static int __net_init tcp4_proc_init_net(struct net *net) 2522 { 2523 return tcp_proc_register(net, &tcp4_seq_afinfo); 2524 } 2525 2526 static void __net_exit tcp4_proc_exit_net(struct net *net) 2527 { 2528 tcp_proc_unregister(net, &tcp4_seq_afinfo); 2529 } 2530 2531 static struct pernet_operations tcp4_net_ops = { 2532 .init = tcp4_proc_init_net, 2533 .exit = tcp4_proc_exit_net, 2534 }; 2535 2536 int __init tcp4_proc_init(void) 2537 { 2538 return register_pernet_subsys(&tcp4_net_ops); 2539 } 2540 2541 void tcp4_proc_exit(void) 2542 { 2543 unregister_pernet_subsys(&tcp4_net_ops); 2544 } 2545 #endif /* CONFIG_PROC_FS */ 2546 2547 struct sk_buff **tcp4_gro_receive(struct sk_buff **head, struct sk_buff *skb) 2548 { 2549 const struct iphdr *iph = skb_gro_network_header(skb); 2550 2551 switch (skb->ip_summed) { 2552 case CHECKSUM_COMPLETE: 2553 if (!tcp_v4_check(skb_gro_len(skb), iph->saddr, iph->daddr, 2554 skb->csum)) { 2555 skb->ip_summed = CHECKSUM_UNNECESSARY; 2556 break; 2557 } 2558 2559 /* fall through */ 2560 case CHECKSUM_NONE: 2561 NAPI_GRO_CB(skb)->flush = 1; 2562 return NULL; 2563 } 2564 2565 return tcp_gro_receive(head, skb); 2566 } 2567 2568 int tcp4_gro_complete(struct sk_buff *skb) 2569 { 2570 const struct iphdr *iph = ip_hdr(skb); 2571 struct tcphdr *th = tcp_hdr(skb); 2572 2573 th->check = ~tcp_v4_check(skb->len - skb_transport_offset(skb), 2574 iph->saddr, iph->daddr, 0); 2575 skb_shinfo(skb)->gso_type = SKB_GSO_TCPV4; 2576 2577 return tcp_gro_complete(skb); 2578 } 2579 2580 struct proto tcp_prot = { 2581 .name = "TCP", 2582 .owner = THIS_MODULE, 2583 .close = tcp_close, 2584 .connect = tcp_v4_connect, 2585 .disconnect = tcp_disconnect, 2586 .accept = inet_csk_accept, 2587 .ioctl = tcp_ioctl, 2588 .init = tcp_v4_init_sock, 2589 .destroy = tcp_v4_destroy_sock, 2590 .shutdown = tcp_shutdown, 2591 .setsockopt = tcp_setsockopt, 2592 .getsockopt = tcp_getsockopt, 2593 .recvmsg = tcp_recvmsg, 2594 .sendmsg = tcp_sendmsg, 2595 .sendpage = tcp_sendpage, 2596 .backlog_rcv = tcp_v4_do_rcv, 2597 .hash = inet_hash, 2598 .unhash = inet_unhash, 2599 .get_port = inet_csk_get_port, 2600 .enter_memory_pressure = tcp_enter_memory_pressure, 2601 .sockets_allocated = &tcp_sockets_allocated, 2602 .orphan_count = &tcp_orphan_count, 2603 .memory_allocated = &tcp_memory_allocated, 2604 .memory_pressure = &tcp_memory_pressure, 2605 .sysctl_mem = sysctl_tcp_mem, 2606 .sysctl_wmem = sysctl_tcp_wmem, 2607 .sysctl_rmem = sysctl_tcp_rmem, 2608 .max_header = MAX_TCP_HEADER, 2609 .obj_size = sizeof(struct tcp_sock), 2610 .slab_flags = SLAB_DESTROY_BY_RCU, 2611 .twsk_prot = &tcp_timewait_sock_ops, 2612 .rsk_prot = &tcp_request_sock_ops, 2613 .h.hashinfo = &tcp_hashinfo, 2614 .no_autobind = true, 2615 #ifdef CONFIG_COMPAT 2616 .compat_setsockopt = compat_tcp_setsockopt, 2617 .compat_getsockopt = compat_tcp_getsockopt, 2618 #endif 2619 }; 2620 EXPORT_SYMBOL(tcp_prot); 2621 2622 2623 static int __net_init tcp_sk_init(struct net *net) 2624 { 2625 return inet_ctl_sock_create(&net->ipv4.tcp_sock, 2626 PF_INET, SOCK_RAW, IPPROTO_TCP, net); 2627 } 2628 2629 static void __net_exit tcp_sk_exit(struct net *net) 2630 { 2631 inet_ctl_sock_destroy(net->ipv4.tcp_sock); 2632 } 2633 2634 static void __net_exit tcp_sk_exit_batch(struct list_head *net_exit_list) 2635 { 2636 inet_twsk_purge(&tcp_hashinfo, &tcp_death_row, AF_INET); 2637 } 2638 2639 static struct pernet_operations __net_initdata tcp_sk_ops = { 2640 .init = tcp_sk_init, 2641 .exit = tcp_sk_exit, 2642 .exit_batch = tcp_sk_exit_batch, 2643 }; 2644 2645 void __init tcp_v4_init(void) 2646 { 2647 inet_hashinfo_init(&tcp_hashinfo); 2648 if (register_pernet_subsys(&tcp_sk_ops)) 2649 panic("Failed to create the TCP control socket.\n"); 2650 } 2651