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