1 /* 2 * TCP over IPv6 3 * Linux INET6 implementation 4 * 5 * Authors: 6 * Pedro Roque <roque@di.fc.ul.pt> 7 * 8 * Based on: 9 * linux/net/ipv4/tcp.c 10 * linux/net/ipv4/tcp_input.c 11 * linux/net/ipv4/tcp_output.c 12 * 13 * Fixes: 14 * Hideaki YOSHIFUJI : sin6_scope_id support 15 * YOSHIFUJI Hideaki @USAGI and: Support IPV6_V6ONLY socket option, which 16 * Alexey Kuznetsov allow both IPv4 and IPv6 sockets to bind 17 * a single port at the same time. 18 * YOSHIFUJI Hideaki @USAGI: convert /proc/net/tcp6 to seq_file. 19 * 20 * This program is free software; you can redistribute it and/or 21 * modify it under the terms of the GNU General Public License 22 * as published by the Free Software Foundation; either version 23 * 2 of the License, or (at your option) any later version. 24 */ 25 26 #include <linux/bottom_half.h> 27 #include <linux/module.h> 28 #include <linux/errno.h> 29 #include <linux/types.h> 30 #include <linux/socket.h> 31 #include <linux/sockios.h> 32 #include <linux/net.h> 33 #include <linux/jiffies.h> 34 #include <linux/in.h> 35 #include <linux/in6.h> 36 #include <linux/netdevice.h> 37 #include <linux/init.h> 38 #include <linux/jhash.h> 39 #include <linux/ipsec.h> 40 #include <linux/times.h> 41 #include <linux/slab.h> 42 #include <linux/uaccess.h> 43 #include <linux/ipv6.h> 44 #include <linux/icmpv6.h> 45 #include <linux/random.h> 46 47 #include <net/tcp.h> 48 #include <net/ndisc.h> 49 #include <net/inet6_hashtables.h> 50 #include <net/inet6_connection_sock.h> 51 #include <net/ipv6.h> 52 #include <net/transp_v6.h> 53 #include <net/addrconf.h> 54 #include <net/ip6_route.h> 55 #include <net/ip6_checksum.h> 56 #include <net/inet_ecn.h> 57 #include <net/protocol.h> 58 #include <net/xfrm.h> 59 #include <net/snmp.h> 60 #include <net/dsfield.h> 61 #include <net/timewait_sock.h> 62 #include <net/inet_common.h> 63 #include <net/secure_seq.h> 64 #include <net/busy_poll.h> 65 66 #include <linux/proc_fs.h> 67 #include <linux/seq_file.h> 68 69 #include <crypto/hash.h> 70 #include <linux/scatterlist.h> 71 72 static void tcp_v6_send_reset(const struct sock *sk, struct sk_buff *skb); 73 static void tcp_v6_reqsk_send_ack(const struct sock *sk, struct sk_buff *skb, 74 struct request_sock *req); 75 76 static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb); 77 78 static const struct inet_connection_sock_af_ops ipv6_mapped; 79 static const struct inet_connection_sock_af_ops ipv6_specific; 80 #ifdef CONFIG_TCP_MD5SIG 81 static const struct tcp_sock_af_ops tcp_sock_ipv6_specific; 82 static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific; 83 #else 84 static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(const struct sock *sk, 85 const struct in6_addr *addr) 86 { 87 return NULL; 88 } 89 #endif 90 91 static void inet6_sk_rx_dst_set(struct sock *sk, const struct sk_buff *skb) 92 { 93 struct dst_entry *dst = skb_dst(skb); 94 95 if (dst && dst_hold_safe(dst)) { 96 const struct rt6_info *rt = (const struct rt6_info *)dst; 97 98 sk->sk_rx_dst = dst; 99 inet_sk(sk)->rx_dst_ifindex = skb->skb_iif; 100 inet6_sk(sk)->rx_dst_cookie = rt6_get_cookie(rt); 101 } 102 } 103 104 static __u32 tcp_v6_init_sequence(const struct sk_buff *skb) 105 { 106 return secure_tcpv6_sequence_number(ipv6_hdr(skb)->daddr.s6_addr32, 107 ipv6_hdr(skb)->saddr.s6_addr32, 108 tcp_hdr(skb)->dest, 109 tcp_hdr(skb)->source); 110 } 111 112 static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr, 113 int addr_len) 114 { 115 struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr; 116 struct inet_sock *inet = inet_sk(sk); 117 struct inet_connection_sock *icsk = inet_csk(sk); 118 struct ipv6_pinfo *np = inet6_sk(sk); 119 struct tcp_sock *tp = tcp_sk(sk); 120 struct in6_addr *saddr = NULL, *final_p, final; 121 struct ipv6_txoptions *opt; 122 struct flowi6 fl6; 123 struct dst_entry *dst; 124 int addr_type; 125 int err; 126 127 if (addr_len < SIN6_LEN_RFC2133) 128 return -EINVAL; 129 130 if (usin->sin6_family != AF_INET6) 131 return -EAFNOSUPPORT; 132 133 memset(&fl6, 0, sizeof(fl6)); 134 135 if (np->sndflow) { 136 fl6.flowlabel = usin->sin6_flowinfo&IPV6_FLOWINFO_MASK; 137 IP6_ECN_flow_init(fl6.flowlabel); 138 if (fl6.flowlabel&IPV6_FLOWLABEL_MASK) { 139 struct ip6_flowlabel *flowlabel; 140 flowlabel = fl6_sock_lookup(sk, fl6.flowlabel); 141 if (!flowlabel) 142 return -EINVAL; 143 fl6_sock_release(flowlabel); 144 } 145 } 146 147 /* 148 * connect() to INADDR_ANY means loopback (BSD'ism). 149 */ 150 151 if (ipv6_addr_any(&usin->sin6_addr)) 152 usin->sin6_addr.s6_addr[15] = 0x1; 153 154 addr_type = ipv6_addr_type(&usin->sin6_addr); 155 156 if (addr_type & IPV6_ADDR_MULTICAST) 157 return -ENETUNREACH; 158 159 if (addr_type&IPV6_ADDR_LINKLOCAL) { 160 if (addr_len >= sizeof(struct sockaddr_in6) && 161 usin->sin6_scope_id) { 162 /* If interface is set while binding, indices 163 * must coincide. 164 */ 165 if (sk->sk_bound_dev_if && 166 sk->sk_bound_dev_if != usin->sin6_scope_id) 167 return -EINVAL; 168 169 sk->sk_bound_dev_if = usin->sin6_scope_id; 170 } 171 172 /* Connect to link-local address requires an interface */ 173 if (!sk->sk_bound_dev_if) 174 return -EINVAL; 175 } 176 177 if (tp->rx_opt.ts_recent_stamp && 178 !ipv6_addr_equal(&sk->sk_v6_daddr, &usin->sin6_addr)) { 179 tp->rx_opt.ts_recent = 0; 180 tp->rx_opt.ts_recent_stamp = 0; 181 tp->write_seq = 0; 182 } 183 184 sk->sk_v6_daddr = usin->sin6_addr; 185 np->flow_label = fl6.flowlabel; 186 187 /* 188 * TCP over IPv4 189 */ 190 191 if (addr_type == IPV6_ADDR_MAPPED) { 192 u32 exthdrlen = icsk->icsk_ext_hdr_len; 193 struct sockaddr_in sin; 194 195 SOCK_DEBUG(sk, "connect: ipv4 mapped\n"); 196 197 if (__ipv6_only_sock(sk)) 198 return -ENETUNREACH; 199 200 sin.sin_family = AF_INET; 201 sin.sin_port = usin->sin6_port; 202 sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3]; 203 204 icsk->icsk_af_ops = &ipv6_mapped; 205 sk->sk_backlog_rcv = tcp_v4_do_rcv; 206 #ifdef CONFIG_TCP_MD5SIG 207 tp->af_specific = &tcp_sock_ipv6_mapped_specific; 208 #endif 209 210 err = tcp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin)); 211 212 if (err) { 213 icsk->icsk_ext_hdr_len = exthdrlen; 214 icsk->icsk_af_ops = &ipv6_specific; 215 sk->sk_backlog_rcv = tcp_v6_do_rcv; 216 #ifdef CONFIG_TCP_MD5SIG 217 tp->af_specific = &tcp_sock_ipv6_specific; 218 #endif 219 goto failure; 220 } 221 np->saddr = sk->sk_v6_rcv_saddr; 222 223 return err; 224 } 225 226 if (!ipv6_addr_any(&sk->sk_v6_rcv_saddr)) 227 saddr = &sk->sk_v6_rcv_saddr; 228 229 fl6.flowi6_proto = IPPROTO_TCP; 230 fl6.daddr = sk->sk_v6_daddr; 231 fl6.saddr = saddr ? *saddr : np->saddr; 232 fl6.flowi6_oif = sk->sk_bound_dev_if; 233 fl6.flowi6_mark = sk->sk_mark; 234 fl6.fl6_dport = usin->sin6_port; 235 fl6.fl6_sport = inet->inet_sport; 236 237 opt = rcu_dereference_protected(np->opt, lockdep_sock_is_held(sk)); 238 final_p = fl6_update_dst(&fl6, opt, &final); 239 240 security_sk_classify_flow(sk, flowi6_to_flowi(&fl6)); 241 242 dst = ip6_dst_lookup_flow(sk, &fl6, final_p); 243 if (IS_ERR(dst)) { 244 err = PTR_ERR(dst); 245 goto failure; 246 } 247 248 if (!saddr) { 249 saddr = &fl6.saddr; 250 sk->sk_v6_rcv_saddr = *saddr; 251 } 252 253 /* set the source address */ 254 np->saddr = *saddr; 255 inet->inet_rcv_saddr = LOOPBACK4_IPV6; 256 257 sk->sk_gso_type = SKB_GSO_TCPV6; 258 ip6_dst_store(sk, dst, NULL, NULL); 259 260 if (tcp_death_row.sysctl_tw_recycle && 261 !tp->rx_opt.ts_recent_stamp && 262 ipv6_addr_equal(&fl6.daddr, &sk->sk_v6_daddr)) 263 tcp_fetch_timewait_stamp(sk, dst); 264 265 icsk->icsk_ext_hdr_len = 0; 266 if (opt) 267 icsk->icsk_ext_hdr_len = opt->opt_flen + 268 opt->opt_nflen; 269 270 tp->rx_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr); 271 272 inet->inet_dport = usin->sin6_port; 273 274 tcp_set_state(sk, TCP_SYN_SENT); 275 err = inet6_hash_connect(&tcp_death_row, sk); 276 if (err) 277 goto late_failure; 278 279 sk_set_txhash(sk); 280 281 if (!tp->write_seq && likely(!tp->repair)) 282 tp->write_seq = secure_tcpv6_sequence_number(np->saddr.s6_addr32, 283 sk->sk_v6_daddr.s6_addr32, 284 inet->inet_sport, 285 inet->inet_dport); 286 287 err = tcp_connect(sk); 288 if (err) 289 goto late_failure; 290 291 return 0; 292 293 late_failure: 294 tcp_set_state(sk, TCP_CLOSE); 295 __sk_dst_reset(sk); 296 failure: 297 inet->inet_dport = 0; 298 sk->sk_route_caps = 0; 299 return err; 300 } 301 302 static void tcp_v6_mtu_reduced(struct sock *sk) 303 { 304 struct dst_entry *dst; 305 306 if ((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE)) 307 return; 308 309 dst = inet6_csk_update_pmtu(sk, tcp_sk(sk)->mtu_info); 310 if (!dst) 311 return; 312 313 if (inet_csk(sk)->icsk_pmtu_cookie > dst_mtu(dst)) { 314 tcp_sync_mss(sk, dst_mtu(dst)); 315 tcp_simple_retransmit(sk); 316 } 317 } 318 319 static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt, 320 u8 type, u8 code, int offset, __be32 info) 321 { 322 const struct ipv6hdr *hdr = (const struct ipv6hdr *)skb->data; 323 const struct tcphdr *th = (struct tcphdr *)(skb->data+offset); 324 struct net *net = dev_net(skb->dev); 325 struct request_sock *fastopen; 326 struct ipv6_pinfo *np; 327 struct tcp_sock *tp; 328 __u32 seq, snd_una; 329 struct sock *sk; 330 bool fatal; 331 int err; 332 333 sk = __inet6_lookup_established(net, &tcp_hashinfo, 334 &hdr->daddr, th->dest, 335 &hdr->saddr, ntohs(th->source), 336 skb->dev->ifindex); 337 338 if (!sk) { 339 __ICMP6_INC_STATS(net, __in6_dev_get(skb->dev), 340 ICMP6_MIB_INERRORS); 341 return; 342 } 343 344 if (sk->sk_state == TCP_TIME_WAIT) { 345 inet_twsk_put(inet_twsk(sk)); 346 return; 347 } 348 seq = ntohl(th->seq); 349 fatal = icmpv6_err_convert(type, code, &err); 350 if (sk->sk_state == TCP_NEW_SYN_RECV) 351 return tcp_req_err(sk, seq, fatal); 352 353 bh_lock_sock(sk); 354 if (sock_owned_by_user(sk) && type != ICMPV6_PKT_TOOBIG) 355 __NET_INC_STATS(net, LINUX_MIB_LOCKDROPPEDICMPS); 356 357 if (sk->sk_state == TCP_CLOSE) 358 goto out; 359 360 if (ipv6_hdr(skb)->hop_limit < inet6_sk(sk)->min_hopcount) { 361 __NET_INC_STATS(net, LINUX_MIB_TCPMINTTLDROP); 362 goto out; 363 } 364 365 tp = tcp_sk(sk); 366 /* XXX (TFO) - tp->snd_una should be ISN (tcp_create_openreq_child() */ 367 fastopen = tp->fastopen_rsk; 368 snd_una = fastopen ? tcp_rsk(fastopen)->snt_isn : tp->snd_una; 369 if (sk->sk_state != TCP_LISTEN && 370 !between(seq, snd_una, tp->snd_nxt)) { 371 __NET_INC_STATS(net, LINUX_MIB_OUTOFWINDOWICMPS); 372 goto out; 373 } 374 375 np = inet6_sk(sk); 376 377 if (type == NDISC_REDIRECT) { 378 struct dst_entry *dst = __sk_dst_check(sk, np->dst_cookie); 379 380 if (dst) 381 dst->ops->redirect(dst, sk, skb); 382 goto out; 383 } 384 385 if (type == ICMPV6_PKT_TOOBIG) { 386 /* We are not interested in TCP_LISTEN and open_requests 387 * (SYN-ACKs send out by Linux are always <576bytes so 388 * they should go through unfragmented). 389 */ 390 if (sk->sk_state == TCP_LISTEN) 391 goto out; 392 393 if (!ip6_sk_accept_pmtu(sk)) 394 goto out; 395 396 tp->mtu_info = ntohl(info); 397 if (!sock_owned_by_user(sk)) 398 tcp_v6_mtu_reduced(sk); 399 else if (!test_and_set_bit(TCP_MTU_REDUCED_DEFERRED, 400 &tp->tsq_flags)) 401 sock_hold(sk); 402 goto out; 403 } 404 405 406 /* Might be for an request_sock */ 407 switch (sk->sk_state) { 408 case TCP_SYN_SENT: 409 case TCP_SYN_RECV: 410 /* Only in fast or simultaneous open. If a fast open socket is 411 * is already accepted it is treated as a connected one below. 412 */ 413 if (fastopen && !fastopen->sk) 414 break; 415 416 if (!sock_owned_by_user(sk)) { 417 sk->sk_err = err; 418 sk->sk_error_report(sk); /* Wake people up to see the error (see connect in sock.c) */ 419 420 tcp_done(sk); 421 } else 422 sk->sk_err_soft = err; 423 goto out; 424 } 425 426 if (!sock_owned_by_user(sk) && np->recverr) { 427 sk->sk_err = err; 428 sk->sk_error_report(sk); 429 } else 430 sk->sk_err_soft = err; 431 432 out: 433 bh_unlock_sock(sk); 434 sock_put(sk); 435 } 436 437 438 static int tcp_v6_send_synack(const struct sock *sk, struct dst_entry *dst, 439 struct flowi *fl, 440 struct request_sock *req, 441 struct tcp_fastopen_cookie *foc, 442 enum tcp_synack_type synack_type) 443 { 444 struct inet_request_sock *ireq = inet_rsk(req); 445 struct ipv6_pinfo *np = inet6_sk(sk); 446 struct ipv6_txoptions *opt; 447 struct flowi6 *fl6 = &fl->u.ip6; 448 struct sk_buff *skb; 449 int err = -ENOMEM; 450 451 /* First, grab a route. */ 452 if (!dst && (dst = inet6_csk_route_req(sk, fl6, req, 453 IPPROTO_TCP)) == NULL) 454 goto done; 455 456 skb = tcp_make_synack(sk, dst, req, foc, synack_type); 457 458 if (skb) { 459 __tcp_v6_send_check(skb, &ireq->ir_v6_loc_addr, 460 &ireq->ir_v6_rmt_addr); 461 462 fl6->daddr = ireq->ir_v6_rmt_addr; 463 if (np->repflow && ireq->pktopts) 464 fl6->flowlabel = ip6_flowlabel(ipv6_hdr(ireq->pktopts)); 465 466 rcu_read_lock(); 467 opt = ireq->ipv6_opt; 468 if (!opt) 469 opt = rcu_dereference(np->opt); 470 err = ip6_xmit(sk, skb, fl6, opt, np->tclass); 471 rcu_read_unlock(); 472 err = net_xmit_eval(err); 473 } 474 475 done: 476 return err; 477 } 478 479 480 static void tcp_v6_reqsk_destructor(struct request_sock *req) 481 { 482 kfree(inet_rsk(req)->ipv6_opt); 483 kfree_skb(inet_rsk(req)->pktopts); 484 } 485 486 #ifdef CONFIG_TCP_MD5SIG 487 static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(const struct sock *sk, 488 const struct in6_addr *addr) 489 { 490 return tcp_md5_do_lookup(sk, (union tcp_md5_addr *)addr, AF_INET6); 491 } 492 493 static struct tcp_md5sig_key *tcp_v6_md5_lookup(const struct sock *sk, 494 const struct sock *addr_sk) 495 { 496 return tcp_v6_md5_do_lookup(sk, &addr_sk->sk_v6_daddr); 497 } 498 499 static int tcp_v6_parse_md5_keys(struct sock *sk, char __user *optval, 500 int optlen) 501 { 502 struct tcp_md5sig cmd; 503 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&cmd.tcpm_addr; 504 505 if (optlen < sizeof(cmd)) 506 return -EINVAL; 507 508 if (copy_from_user(&cmd, optval, sizeof(cmd))) 509 return -EFAULT; 510 511 if (sin6->sin6_family != AF_INET6) 512 return -EINVAL; 513 514 if (!cmd.tcpm_keylen) { 515 if (ipv6_addr_v4mapped(&sin6->sin6_addr)) 516 return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3], 517 AF_INET); 518 return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin6->sin6_addr, 519 AF_INET6); 520 } 521 522 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN) 523 return -EINVAL; 524 525 if (ipv6_addr_v4mapped(&sin6->sin6_addr)) 526 return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3], 527 AF_INET, cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL); 528 529 return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr, 530 AF_INET6, cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL); 531 } 532 533 static int tcp_v6_md5_hash_headers(struct tcp_md5sig_pool *hp, 534 const struct in6_addr *daddr, 535 const struct in6_addr *saddr, 536 const struct tcphdr *th, int nbytes) 537 { 538 struct tcp6_pseudohdr *bp; 539 struct scatterlist sg; 540 struct tcphdr *_th; 541 542 bp = hp->scratch; 543 /* 1. TCP pseudo-header (RFC2460) */ 544 bp->saddr = *saddr; 545 bp->daddr = *daddr; 546 bp->protocol = cpu_to_be32(IPPROTO_TCP); 547 bp->len = cpu_to_be32(nbytes); 548 549 _th = (struct tcphdr *)(bp + 1); 550 memcpy(_th, th, sizeof(*th)); 551 _th->check = 0; 552 553 sg_init_one(&sg, bp, sizeof(*bp) + sizeof(*th)); 554 ahash_request_set_crypt(hp->md5_req, &sg, NULL, 555 sizeof(*bp) + sizeof(*th)); 556 return crypto_ahash_update(hp->md5_req); 557 } 558 559 static int tcp_v6_md5_hash_hdr(char *md5_hash, const struct tcp_md5sig_key *key, 560 const struct in6_addr *daddr, struct in6_addr *saddr, 561 const struct tcphdr *th) 562 { 563 struct tcp_md5sig_pool *hp; 564 struct ahash_request *req; 565 566 hp = tcp_get_md5sig_pool(); 567 if (!hp) 568 goto clear_hash_noput; 569 req = hp->md5_req; 570 571 if (crypto_ahash_init(req)) 572 goto clear_hash; 573 if (tcp_v6_md5_hash_headers(hp, daddr, saddr, th, th->doff << 2)) 574 goto clear_hash; 575 if (tcp_md5_hash_key(hp, key)) 576 goto clear_hash; 577 ahash_request_set_crypt(req, NULL, md5_hash, 0); 578 if (crypto_ahash_final(req)) 579 goto clear_hash; 580 581 tcp_put_md5sig_pool(); 582 return 0; 583 584 clear_hash: 585 tcp_put_md5sig_pool(); 586 clear_hash_noput: 587 memset(md5_hash, 0, 16); 588 return 1; 589 } 590 591 static int tcp_v6_md5_hash_skb(char *md5_hash, 592 const struct tcp_md5sig_key *key, 593 const struct sock *sk, 594 const struct sk_buff *skb) 595 { 596 const struct in6_addr *saddr, *daddr; 597 struct tcp_md5sig_pool *hp; 598 struct ahash_request *req; 599 const struct tcphdr *th = tcp_hdr(skb); 600 601 if (sk) { /* valid for establish/request sockets */ 602 saddr = &sk->sk_v6_rcv_saddr; 603 daddr = &sk->sk_v6_daddr; 604 } else { 605 const struct ipv6hdr *ip6h = ipv6_hdr(skb); 606 saddr = &ip6h->saddr; 607 daddr = &ip6h->daddr; 608 } 609 610 hp = tcp_get_md5sig_pool(); 611 if (!hp) 612 goto clear_hash_noput; 613 req = hp->md5_req; 614 615 if (crypto_ahash_init(req)) 616 goto clear_hash; 617 618 if (tcp_v6_md5_hash_headers(hp, daddr, saddr, th, skb->len)) 619 goto clear_hash; 620 if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2)) 621 goto clear_hash; 622 if (tcp_md5_hash_key(hp, key)) 623 goto clear_hash; 624 ahash_request_set_crypt(req, NULL, md5_hash, 0); 625 if (crypto_ahash_final(req)) 626 goto clear_hash; 627 628 tcp_put_md5sig_pool(); 629 return 0; 630 631 clear_hash: 632 tcp_put_md5sig_pool(); 633 clear_hash_noput: 634 memset(md5_hash, 0, 16); 635 return 1; 636 } 637 638 #endif 639 640 static bool tcp_v6_inbound_md5_hash(const struct sock *sk, 641 const struct sk_buff *skb) 642 { 643 #ifdef CONFIG_TCP_MD5SIG 644 const __u8 *hash_location = NULL; 645 struct tcp_md5sig_key *hash_expected; 646 const struct ipv6hdr *ip6h = ipv6_hdr(skb); 647 const struct tcphdr *th = tcp_hdr(skb); 648 int genhash; 649 u8 newhash[16]; 650 651 hash_expected = tcp_v6_md5_do_lookup(sk, &ip6h->saddr); 652 hash_location = tcp_parse_md5sig_option(th); 653 654 /* We've parsed the options - do we have a hash? */ 655 if (!hash_expected && !hash_location) 656 return false; 657 658 if (hash_expected && !hash_location) { 659 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND); 660 return true; 661 } 662 663 if (!hash_expected && hash_location) { 664 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED); 665 return true; 666 } 667 668 /* check the signature */ 669 genhash = tcp_v6_md5_hash_skb(newhash, 670 hash_expected, 671 NULL, skb); 672 673 if (genhash || memcmp(hash_location, newhash, 16) != 0) { 674 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMD5FAILURE); 675 net_info_ratelimited("MD5 Hash %s for [%pI6c]:%u->[%pI6c]:%u\n", 676 genhash ? "failed" : "mismatch", 677 &ip6h->saddr, ntohs(th->source), 678 &ip6h->daddr, ntohs(th->dest)); 679 return true; 680 } 681 #endif 682 return false; 683 } 684 685 static void tcp_v6_init_req(struct request_sock *req, 686 const struct sock *sk_listener, 687 struct sk_buff *skb) 688 { 689 struct inet_request_sock *ireq = inet_rsk(req); 690 const struct ipv6_pinfo *np = inet6_sk(sk_listener); 691 692 ireq->ir_v6_rmt_addr = ipv6_hdr(skb)->saddr; 693 ireq->ir_v6_loc_addr = ipv6_hdr(skb)->daddr; 694 695 /* So that link locals have meaning */ 696 if (!sk_listener->sk_bound_dev_if && 697 ipv6_addr_type(&ireq->ir_v6_rmt_addr) & IPV6_ADDR_LINKLOCAL) 698 ireq->ir_iif = tcp_v6_iif(skb); 699 700 if (!TCP_SKB_CB(skb)->tcp_tw_isn && 701 (ipv6_opt_accepted(sk_listener, skb, &TCP_SKB_CB(skb)->header.h6) || 702 np->rxopt.bits.rxinfo || 703 np->rxopt.bits.rxoinfo || np->rxopt.bits.rxhlim || 704 np->rxopt.bits.rxohlim || np->repflow)) { 705 atomic_inc(&skb->users); 706 ireq->pktopts = skb; 707 } 708 } 709 710 static struct dst_entry *tcp_v6_route_req(const struct sock *sk, 711 struct flowi *fl, 712 const struct request_sock *req, 713 bool *strict) 714 { 715 if (strict) 716 *strict = true; 717 return inet6_csk_route_req(sk, &fl->u.ip6, req, IPPROTO_TCP); 718 } 719 720 struct request_sock_ops tcp6_request_sock_ops __read_mostly = { 721 .family = AF_INET6, 722 .obj_size = sizeof(struct tcp6_request_sock), 723 .rtx_syn_ack = tcp_rtx_synack, 724 .send_ack = tcp_v6_reqsk_send_ack, 725 .destructor = tcp_v6_reqsk_destructor, 726 .send_reset = tcp_v6_send_reset, 727 .syn_ack_timeout = tcp_syn_ack_timeout, 728 }; 729 730 static const struct tcp_request_sock_ops tcp_request_sock_ipv6_ops = { 731 .mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - 732 sizeof(struct ipv6hdr), 733 #ifdef CONFIG_TCP_MD5SIG 734 .req_md5_lookup = tcp_v6_md5_lookup, 735 .calc_md5_hash = tcp_v6_md5_hash_skb, 736 #endif 737 .init_req = tcp_v6_init_req, 738 #ifdef CONFIG_SYN_COOKIES 739 .cookie_init_seq = cookie_v6_init_sequence, 740 #endif 741 .route_req = tcp_v6_route_req, 742 .init_seq = tcp_v6_init_sequence, 743 .send_synack = tcp_v6_send_synack, 744 }; 745 746 static void tcp_v6_send_response(const struct sock *sk, struct sk_buff *skb, u32 seq, 747 u32 ack, u32 win, u32 tsval, u32 tsecr, 748 int oif, struct tcp_md5sig_key *key, int rst, 749 u8 tclass, __be32 label) 750 { 751 const struct tcphdr *th = tcp_hdr(skb); 752 struct tcphdr *t1; 753 struct sk_buff *buff; 754 struct flowi6 fl6; 755 struct net *net = sk ? sock_net(sk) : dev_net(skb_dst(skb)->dev); 756 struct sock *ctl_sk = net->ipv6.tcp_sk; 757 unsigned int tot_len = sizeof(struct tcphdr); 758 struct dst_entry *dst; 759 __be32 *topt; 760 761 if (tsecr) 762 tot_len += TCPOLEN_TSTAMP_ALIGNED; 763 #ifdef CONFIG_TCP_MD5SIG 764 if (key) 765 tot_len += TCPOLEN_MD5SIG_ALIGNED; 766 #endif 767 768 buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len, 769 GFP_ATOMIC); 770 if (!buff) 771 return; 772 773 skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + tot_len); 774 775 t1 = (struct tcphdr *) skb_push(buff, tot_len); 776 skb_reset_transport_header(buff); 777 778 /* Swap the send and the receive. */ 779 memset(t1, 0, sizeof(*t1)); 780 t1->dest = th->source; 781 t1->source = th->dest; 782 t1->doff = tot_len / 4; 783 t1->seq = htonl(seq); 784 t1->ack_seq = htonl(ack); 785 t1->ack = !rst || !th->ack; 786 t1->rst = rst; 787 t1->window = htons(win); 788 789 topt = (__be32 *)(t1 + 1); 790 791 if (tsecr) { 792 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) | 793 (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP); 794 *topt++ = htonl(tsval); 795 *topt++ = htonl(tsecr); 796 } 797 798 #ifdef CONFIG_TCP_MD5SIG 799 if (key) { 800 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) | 801 (TCPOPT_MD5SIG << 8) | TCPOLEN_MD5SIG); 802 tcp_v6_md5_hash_hdr((__u8 *)topt, key, 803 &ipv6_hdr(skb)->saddr, 804 &ipv6_hdr(skb)->daddr, t1); 805 } 806 #endif 807 808 memset(&fl6, 0, sizeof(fl6)); 809 fl6.daddr = ipv6_hdr(skb)->saddr; 810 fl6.saddr = ipv6_hdr(skb)->daddr; 811 fl6.flowlabel = label; 812 813 buff->ip_summed = CHECKSUM_PARTIAL; 814 buff->csum = 0; 815 816 __tcp_v6_send_check(buff, &fl6.saddr, &fl6.daddr); 817 818 fl6.flowi6_proto = IPPROTO_TCP; 819 if (rt6_need_strict(&fl6.daddr) && !oif) 820 fl6.flowi6_oif = tcp_v6_iif(skb); 821 else { 822 if (!oif && netif_index_is_l3_master(net, skb->skb_iif)) 823 oif = skb->skb_iif; 824 825 fl6.flowi6_oif = oif; 826 } 827 828 fl6.flowi6_mark = IP6_REPLY_MARK(net, skb->mark); 829 fl6.fl6_dport = t1->dest; 830 fl6.fl6_sport = t1->source; 831 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6)); 832 833 /* Pass a socket to ip6_dst_lookup either it is for RST 834 * Underlying function will use this to retrieve the network 835 * namespace 836 */ 837 dst = ip6_dst_lookup_flow(ctl_sk, &fl6, NULL); 838 if (!IS_ERR(dst)) { 839 skb_dst_set(buff, dst); 840 ip6_xmit(ctl_sk, buff, &fl6, NULL, tclass); 841 TCP_INC_STATS(net, TCP_MIB_OUTSEGS); 842 if (rst) 843 TCP_INC_STATS(net, TCP_MIB_OUTRSTS); 844 return; 845 } 846 847 kfree_skb(buff); 848 } 849 850 static void tcp_v6_send_reset(const struct sock *sk, struct sk_buff *skb) 851 { 852 const struct tcphdr *th = tcp_hdr(skb); 853 u32 seq = 0, ack_seq = 0; 854 struct tcp_md5sig_key *key = NULL; 855 #ifdef CONFIG_TCP_MD5SIG 856 const __u8 *hash_location = NULL; 857 struct ipv6hdr *ipv6h = ipv6_hdr(skb); 858 unsigned char newhash[16]; 859 int genhash; 860 struct sock *sk1 = NULL; 861 #endif 862 int oif; 863 864 if (th->rst) 865 return; 866 867 /* If sk not NULL, it means we did a successful lookup and incoming 868 * route had to be correct. prequeue might have dropped our dst. 869 */ 870 if (!sk && !ipv6_unicast_destination(skb)) 871 return; 872 873 #ifdef CONFIG_TCP_MD5SIG 874 rcu_read_lock(); 875 hash_location = tcp_parse_md5sig_option(th); 876 if (sk && sk_fullsock(sk)) { 877 key = tcp_v6_md5_do_lookup(sk, &ipv6h->saddr); 878 } else if (hash_location) { 879 /* 880 * active side is lost. Try to find listening socket through 881 * source port, and then find md5 key through listening socket. 882 * we are not loose security here: 883 * Incoming packet is checked with md5 hash with finding key, 884 * no RST generated if md5 hash doesn't match. 885 */ 886 sk1 = inet6_lookup_listener(dev_net(skb_dst(skb)->dev), 887 &tcp_hashinfo, NULL, 0, 888 &ipv6h->saddr, 889 th->source, &ipv6h->daddr, 890 ntohs(th->source), tcp_v6_iif(skb)); 891 if (!sk1) 892 goto out; 893 894 key = tcp_v6_md5_do_lookup(sk1, &ipv6h->saddr); 895 if (!key) 896 goto out; 897 898 genhash = tcp_v6_md5_hash_skb(newhash, key, NULL, skb); 899 if (genhash || memcmp(hash_location, newhash, 16) != 0) 900 goto out; 901 } 902 #endif 903 904 if (th->ack) 905 seq = ntohl(th->ack_seq); 906 else 907 ack_seq = ntohl(th->seq) + th->syn + th->fin + skb->len - 908 (th->doff << 2); 909 910 oif = sk ? sk->sk_bound_dev_if : 0; 911 tcp_v6_send_response(sk, skb, seq, ack_seq, 0, 0, 0, oif, key, 1, 0, 0); 912 913 #ifdef CONFIG_TCP_MD5SIG 914 out: 915 rcu_read_unlock(); 916 #endif 917 } 918 919 static void tcp_v6_send_ack(const struct sock *sk, struct sk_buff *skb, u32 seq, 920 u32 ack, u32 win, u32 tsval, u32 tsecr, int oif, 921 struct tcp_md5sig_key *key, u8 tclass, 922 __be32 label) 923 { 924 tcp_v6_send_response(sk, skb, seq, ack, win, tsval, tsecr, oif, key, 0, 925 tclass, label); 926 } 927 928 static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb) 929 { 930 struct inet_timewait_sock *tw = inet_twsk(sk); 931 struct tcp_timewait_sock *tcptw = tcp_twsk(sk); 932 933 tcp_v6_send_ack(sk, skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt, 934 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale, 935 tcp_time_stamp + tcptw->tw_ts_offset, 936 tcptw->tw_ts_recent, tw->tw_bound_dev_if, tcp_twsk_md5_key(tcptw), 937 tw->tw_tclass, cpu_to_be32(tw->tw_flowlabel)); 938 939 inet_twsk_put(tw); 940 } 941 942 static void tcp_v6_reqsk_send_ack(const struct sock *sk, struct sk_buff *skb, 943 struct request_sock *req) 944 { 945 /* sk->sk_state == TCP_LISTEN -> for regular TCP_SYN_RECV 946 * sk->sk_state == TCP_SYN_RECV -> for Fast Open. 947 */ 948 /* RFC 7323 2.3 949 * The window field (SEG.WND) of every outgoing segment, with the 950 * exception of <SYN> segments, MUST be right-shifted by 951 * Rcv.Wind.Shift bits: 952 */ 953 tcp_v6_send_ack(sk, skb, (sk->sk_state == TCP_LISTEN) ? 954 tcp_rsk(req)->snt_isn + 1 : tcp_sk(sk)->snd_nxt, 955 tcp_rsk(req)->rcv_nxt, 956 req->rsk_rcv_wnd >> inet_rsk(req)->rcv_wscale, 957 tcp_time_stamp, req->ts_recent, sk->sk_bound_dev_if, 958 tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->daddr), 959 0, 0); 960 } 961 962 963 static struct sock *tcp_v6_cookie_check(struct sock *sk, struct sk_buff *skb) 964 { 965 #ifdef CONFIG_SYN_COOKIES 966 const struct tcphdr *th = tcp_hdr(skb); 967 968 if (!th->syn) 969 sk = cookie_v6_check(sk, skb); 970 #endif 971 return sk; 972 } 973 974 static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb) 975 { 976 if (skb->protocol == htons(ETH_P_IP)) 977 return tcp_v4_conn_request(sk, skb); 978 979 if (!ipv6_unicast_destination(skb)) 980 goto drop; 981 982 return tcp_conn_request(&tcp6_request_sock_ops, 983 &tcp_request_sock_ipv6_ops, sk, skb); 984 985 drop: 986 tcp_listendrop(sk); 987 return 0; /* don't send reset */ 988 } 989 990 static struct sock *tcp_v6_syn_recv_sock(const struct sock *sk, struct sk_buff *skb, 991 struct request_sock *req, 992 struct dst_entry *dst, 993 struct request_sock *req_unhash, 994 bool *own_req) 995 { 996 struct inet_request_sock *ireq; 997 struct ipv6_pinfo *newnp; 998 const struct ipv6_pinfo *np = inet6_sk(sk); 999 struct ipv6_txoptions *opt; 1000 struct tcp6_sock *newtcp6sk; 1001 struct inet_sock *newinet; 1002 struct tcp_sock *newtp; 1003 struct sock *newsk; 1004 #ifdef CONFIG_TCP_MD5SIG 1005 struct tcp_md5sig_key *key; 1006 #endif 1007 struct flowi6 fl6; 1008 1009 if (skb->protocol == htons(ETH_P_IP)) { 1010 /* 1011 * v6 mapped 1012 */ 1013 1014 newsk = tcp_v4_syn_recv_sock(sk, skb, req, dst, 1015 req_unhash, own_req); 1016 1017 if (!newsk) 1018 return NULL; 1019 1020 newtcp6sk = (struct tcp6_sock *)newsk; 1021 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6; 1022 1023 newinet = inet_sk(newsk); 1024 newnp = inet6_sk(newsk); 1025 newtp = tcp_sk(newsk); 1026 1027 memcpy(newnp, np, sizeof(struct ipv6_pinfo)); 1028 1029 newnp->saddr = newsk->sk_v6_rcv_saddr; 1030 1031 inet_csk(newsk)->icsk_af_ops = &ipv6_mapped; 1032 newsk->sk_backlog_rcv = tcp_v4_do_rcv; 1033 #ifdef CONFIG_TCP_MD5SIG 1034 newtp->af_specific = &tcp_sock_ipv6_mapped_specific; 1035 #endif 1036 1037 newnp->ipv6_ac_list = NULL; 1038 newnp->ipv6_fl_list = NULL; 1039 newnp->pktoptions = NULL; 1040 newnp->opt = NULL; 1041 newnp->mcast_oif = tcp_v6_iif(skb); 1042 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit; 1043 newnp->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(skb)); 1044 if (np->repflow) 1045 newnp->flow_label = ip6_flowlabel(ipv6_hdr(skb)); 1046 1047 /* 1048 * No need to charge this sock to the relevant IPv6 refcnt debug socks count 1049 * here, tcp_create_openreq_child now does this for us, see the comment in 1050 * that function for the gory details. -acme 1051 */ 1052 1053 /* It is tricky place. Until this moment IPv4 tcp 1054 worked with IPv6 icsk.icsk_af_ops. 1055 Sync it now. 1056 */ 1057 tcp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie); 1058 1059 return newsk; 1060 } 1061 1062 ireq = inet_rsk(req); 1063 1064 if (sk_acceptq_is_full(sk)) 1065 goto out_overflow; 1066 1067 if (!dst) { 1068 dst = inet6_csk_route_req(sk, &fl6, req, IPPROTO_TCP); 1069 if (!dst) 1070 goto out; 1071 } 1072 1073 newsk = tcp_create_openreq_child(sk, req, skb); 1074 if (!newsk) 1075 goto out_nonewsk; 1076 1077 /* 1078 * No need to charge this sock to the relevant IPv6 refcnt debug socks 1079 * count here, tcp_create_openreq_child now does this for us, see the 1080 * comment in that function for the gory details. -acme 1081 */ 1082 1083 newsk->sk_gso_type = SKB_GSO_TCPV6; 1084 ip6_dst_store(newsk, dst, NULL, NULL); 1085 inet6_sk_rx_dst_set(newsk, skb); 1086 1087 newtcp6sk = (struct tcp6_sock *)newsk; 1088 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6; 1089 1090 newtp = tcp_sk(newsk); 1091 newinet = inet_sk(newsk); 1092 newnp = inet6_sk(newsk); 1093 1094 memcpy(newnp, np, sizeof(struct ipv6_pinfo)); 1095 1096 newsk->sk_v6_daddr = ireq->ir_v6_rmt_addr; 1097 newnp->saddr = ireq->ir_v6_loc_addr; 1098 newsk->sk_v6_rcv_saddr = ireq->ir_v6_loc_addr; 1099 newsk->sk_bound_dev_if = ireq->ir_iif; 1100 1101 /* Now IPv6 options... 1102 1103 First: no IPv4 options. 1104 */ 1105 newinet->inet_opt = NULL; 1106 newnp->ipv6_ac_list = NULL; 1107 newnp->ipv6_fl_list = NULL; 1108 1109 /* Clone RX bits */ 1110 newnp->rxopt.all = np->rxopt.all; 1111 1112 newnp->pktoptions = NULL; 1113 newnp->opt = NULL; 1114 newnp->mcast_oif = tcp_v6_iif(skb); 1115 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit; 1116 newnp->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(skb)); 1117 if (np->repflow) 1118 newnp->flow_label = ip6_flowlabel(ipv6_hdr(skb)); 1119 1120 /* Clone native IPv6 options from listening socket (if any) 1121 1122 Yes, keeping reference count would be much more clever, 1123 but we make one more one thing there: reattach optmem 1124 to newsk. 1125 */ 1126 opt = ireq->ipv6_opt; 1127 if (!opt) 1128 opt = rcu_dereference(np->opt); 1129 if (opt) { 1130 opt = ipv6_dup_options(newsk, opt); 1131 RCU_INIT_POINTER(newnp->opt, opt); 1132 } 1133 inet_csk(newsk)->icsk_ext_hdr_len = 0; 1134 if (opt) 1135 inet_csk(newsk)->icsk_ext_hdr_len = opt->opt_nflen + 1136 opt->opt_flen; 1137 1138 tcp_ca_openreq_child(newsk, dst); 1139 1140 tcp_sync_mss(newsk, dst_mtu(dst)); 1141 newtp->advmss = dst_metric_advmss(dst); 1142 if (tcp_sk(sk)->rx_opt.user_mss && 1143 tcp_sk(sk)->rx_opt.user_mss < newtp->advmss) 1144 newtp->advmss = tcp_sk(sk)->rx_opt.user_mss; 1145 1146 tcp_initialize_rcv_mss(newsk); 1147 1148 newinet->inet_daddr = newinet->inet_saddr = LOOPBACK4_IPV6; 1149 newinet->inet_rcv_saddr = LOOPBACK4_IPV6; 1150 1151 #ifdef CONFIG_TCP_MD5SIG 1152 /* Copy over the MD5 key from the original socket */ 1153 key = tcp_v6_md5_do_lookup(sk, &newsk->sk_v6_daddr); 1154 if (key) { 1155 /* We're using one, so create a matching key 1156 * on the newsk structure. If we fail to get 1157 * memory, then we end up not copying the key 1158 * across. Shucks. 1159 */ 1160 tcp_md5_do_add(newsk, (union tcp_md5_addr *)&newsk->sk_v6_daddr, 1161 AF_INET6, key->key, key->keylen, 1162 sk_gfp_mask(sk, GFP_ATOMIC)); 1163 } 1164 #endif 1165 1166 if (__inet_inherit_port(sk, newsk) < 0) { 1167 inet_csk_prepare_forced_close(newsk); 1168 tcp_done(newsk); 1169 goto out; 1170 } 1171 *own_req = inet_ehash_nolisten(newsk, req_to_sk(req_unhash)); 1172 if (*own_req) { 1173 tcp_move_syn(newtp, req); 1174 1175 /* Clone pktoptions received with SYN, if we own the req */ 1176 if (ireq->pktopts) { 1177 newnp->pktoptions = skb_clone(ireq->pktopts, 1178 sk_gfp_mask(sk, GFP_ATOMIC)); 1179 consume_skb(ireq->pktopts); 1180 ireq->pktopts = NULL; 1181 if (newnp->pktoptions) 1182 skb_set_owner_r(newnp->pktoptions, newsk); 1183 } 1184 } 1185 1186 return newsk; 1187 1188 out_overflow: 1189 __NET_INC_STATS(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS); 1190 out_nonewsk: 1191 dst_release(dst); 1192 out: 1193 tcp_listendrop(sk); 1194 return NULL; 1195 } 1196 1197 /* The socket must have it's spinlock held when we get 1198 * here, unless it is a TCP_LISTEN socket. 1199 * 1200 * We have a potential double-lock case here, so even when 1201 * doing backlog processing we use the BH locking scheme. 1202 * This is because we cannot sleep with the original spinlock 1203 * held. 1204 */ 1205 static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb) 1206 { 1207 struct ipv6_pinfo *np = inet6_sk(sk); 1208 struct tcp_sock *tp; 1209 struct sk_buff *opt_skb = NULL; 1210 1211 /* Imagine: socket is IPv6. IPv4 packet arrives, 1212 goes to IPv4 receive handler and backlogged. 1213 From backlog it always goes here. Kerboom... 1214 Fortunately, tcp_rcv_established and rcv_established 1215 handle them correctly, but it is not case with 1216 tcp_v6_hnd_req and tcp_v6_send_reset(). --ANK 1217 */ 1218 1219 if (skb->protocol == htons(ETH_P_IP)) 1220 return tcp_v4_do_rcv(sk, skb); 1221 1222 if (sk_filter(sk, skb)) 1223 goto discard; 1224 1225 /* 1226 * socket locking is here for SMP purposes as backlog rcv 1227 * is currently called with bh processing disabled. 1228 */ 1229 1230 /* Do Stevens' IPV6_PKTOPTIONS. 1231 1232 Yes, guys, it is the only place in our code, where we 1233 may make it not affecting IPv4. 1234 The rest of code is protocol independent, 1235 and I do not like idea to uglify IPv4. 1236 1237 Actually, all the idea behind IPV6_PKTOPTIONS 1238 looks not very well thought. For now we latch 1239 options, received in the last packet, enqueued 1240 by tcp. Feel free to propose better solution. 1241 --ANK (980728) 1242 */ 1243 if (np->rxopt.all) 1244 opt_skb = skb_clone(skb, sk_gfp_mask(sk, GFP_ATOMIC)); 1245 1246 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */ 1247 struct dst_entry *dst = sk->sk_rx_dst; 1248 1249 sock_rps_save_rxhash(sk, skb); 1250 sk_mark_napi_id(sk, skb); 1251 if (dst) { 1252 if (inet_sk(sk)->rx_dst_ifindex != skb->skb_iif || 1253 dst->ops->check(dst, np->rx_dst_cookie) == NULL) { 1254 dst_release(dst); 1255 sk->sk_rx_dst = NULL; 1256 } 1257 } 1258 1259 tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len); 1260 if (opt_skb) 1261 goto ipv6_pktoptions; 1262 return 0; 1263 } 1264 1265 if (tcp_checksum_complete(skb)) 1266 goto csum_err; 1267 1268 if (sk->sk_state == TCP_LISTEN) { 1269 struct sock *nsk = tcp_v6_cookie_check(sk, skb); 1270 1271 if (!nsk) 1272 goto discard; 1273 1274 if (nsk != sk) { 1275 sock_rps_save_rxhash(nsk, skb); 1276 sk_mark_napi_id(nsk, skb); 1277 if (tcp_child_process(sk, nsk, skb)) 1278 goto reset; 1279 if (opt_skb) 1280 __kfree_skb(opt_skb); 1281 return 0; 1282 } 1283 } else 1284 sock_rps_save_rxhash(sk, skb); 1285 1286 if (tcp_rcv_state_process(sk, skb)) 1287 goto reset; 1288 if (opt_skb) 1289 goto ipv6_pktoptions; 1290 return 0; 1291 1292 reset: 1293 tcp_v6_send_reset(sk, skb); 1294 discard: 1295 if (opt_skb) 1296 __kfree_skb(opt_skb); 1297 kfree_skb(skb); 1298 return 0; 1299 csum_err: 1300 TCP_INC_STATS(sock_net(sk), TCP_MIB_CSUMERRORS); 1301 TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS); 1302 goto discard; 1303 1304 1305 ipv6_pktoptions: 1306 /* Do you ask, what is it? 1307 1308 1. skb was enqueued by tcp. 1309 2. skb is added to tail of read queue, rather than out of order. 1310 3. socket is not in passive state. 1311 4. Finally, it really contains options, which user wants to receive. 1312 */ 1313 tp = tcp_sk(sk); 1314 if (TCP_SKB_CB(opt_skb)->end_seq == tp->rcv_nxt && 1315 !((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))) { 1316 if (np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo) 1317 np->mcast_oif = tcp_v6_iif(opt_skb); 1318 if (np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim) 1319 np->mcast_hops = ipv6_hdr(opt_skb)->hop_limit; 1320 if (np->rxopt.bits.rxflow || np->rxopt.bits.rxtclass) 1321 np->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(opt_skb)); 1322 if (np->repflow) 1323 np->flow_label = ip6_flowlabel(ipv6_hdr(opt_skb)); 1324 if (ipv6_opt_accepted(sk, opt_skb, &TCP_SKB_CB(opt_skb)->header.h6)) { 1325 skb_set_owner_r(opt_skb, sk); 1326 opt_skb = xchg(&np->pktoptions, opt_skb); 1327 } else { 1328 __kfree_skb(opt_skb); 1329 opt_skb = xchg(&np->pktoptions, NULL); 1330 } 1331 } 1332 1333 kfree_skb(opt_skb); 1334 return 0; 1335 } 1336 1337 static void tcp_v6_fill_cb(struct sk_buff *skb, const struct ipv6hdr *hdr, 1338 const struct tcphdr *th) 1339 { 1340 /* This is tricky: we move IP6CB at its correct location into 1341 * TCP_SKB_CB(). It must be done after xfrm6_policy_check(), because 1342 * _decode_session6() uses IP6CB(). 1343 * barrier() makes sure compiler won't play aliasing games. 1344 */ 1345 memmove(&TCP_SKB_CB(skb)->header.h6, IP6CB(skb), 1346 sizeof(struct inet6_skb_parm)); 1347 barrier(); 1348 1349 TCP_SKB_CB(skb)->seq = ntohl(th->seq); 1350 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin + 1351 skb->len - th->doff*4); 1352 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq); 1353 TCP_SKB_CB(skb)->tcp_flags = tcp_flag_byte(th); 1354 TCP_SKB_CB(skb)->tcp_tw_isn = 0; 1355 TCP_SKB_CB(skb)->ip_dsfield = ipv6_get_dsfield(hdr); 1356 TCP_SKB_CB(skb)->sacked = 0; 1357 } 1358 1359 static void tcp_v6_restore_cb(struct sk_buff *skb) 1360 { 1361 /* We need to move header back to the beginning if xfrm6_policy_check() 1362 * and tcp_v6_fill_cb() are going to be called again. 1363 */ 1364 memmove(IP6CB(skb), &TCP_SKB_CB(skb)->header.h6, 1365 sizeof(struct inet6_skb_parm)); 1366 } 1367 1368 static int tcp_v6_rcv(struct sk_buff *skb) 1369 { 1370 const struct tcphdr *th; 1371 const struct ipv6hdr *hdr; 1372 bool refcounted; 1373 struct sock *sk; 1374 int ret; 1375 struct net *net = dev_net(skb->dev); 1376 1377 if (skb->pkt_type != PACKET_HOST) 1378 goto discard_it; 1379 1380 /* 1381 * Count it even if it's bad. 1382 */ 1383 __TCP_INC_STATS(net, TCP_MIB_INSEGS); 1384 1385 if (!pskb_may_pull(skb, sizeof(struct tcphdr))) 1386 goto discard_it; 1387 1388 th = (const struct tcphdr *)skb->data; 1389 1390 if (unlikely(th->doff < sizeof(struct tcphdr)/4)) 1391 goto bad_packet; 1392 if (!pskb_may_pull(skb, th->doff*4)) 1393 goto discard_it; 1394 1395 if (skb_checksum_init(skb, IPPROTO_TCP, ip6_compute_pseudo)) 1396 goto csum_error; 1397 1398 th = (const struct tcphdr *)skb->data; 1399 hdr = ipv6_hdr(skb); 1400 1401 lookup: 1402 sk = __inet6_lookup_skb(&tcp_hashinfo, skb, __tcp_hdrlen(th), 1403 th->source, th->dest, inet6_iif(skb), 1404 &refcounted); 1405 if (!sk) 1406 goto no_tcp_socket; 1407 1408 process: 1409 if (sk->sk_state == TCP_TIME_WAIT) 1410 goto do_time_wait; 1411 1412 if (sk->sk_state == TCP_NEW_SYN_RECV) { 1413 struct request_sock *req = inet_reqsk(sk); 1414 struct sock *nsk; 1415 1416 sk = req->rsk_listener; 1417 tcp_v6_fill_cb(skb, hdr, th); 1418 if (tcp_v6_inbound_md5_hash(sk, skb)) { 1419 sk_drops_add(sk, skb); 1420 reqsk_put(req); 1421 goto discard_it; 1422 } 1423 if (unlikely(sk->sk_state != TCP_LISTEN)) { 1424 inet_csk_reqsk_queue_drop_and_put(sk, req); 1425 goto lookup; 1426 } 1427 sock_hold(sk); 1428 refcounted = true; 1429 nsk = tcp_check_req(sk, skb, req, false); 1430 if (!nsk) { 1431 reqsk_put(req); 1432 goto discard_and_relse; 1433 } 1434 if (nsk == sk) { 1435 reqsk_put(req); 1436 tcp_v6_restore_cb(skb); 1437 } else if (tcp_child_process(sk, nsk, skb)) { 1438 tcp_v6_send_reset(nsk, skb); 1439 goto discard_and_relse; 1440 } else { 1441 sock_put(sk); 1442 return 0; 1443 } 1444 } 1445 if (hdr->hop_limit < inet6_sk(sk)->min_hopcount) { 1446 __NET_INC_STATS(net, LINUX_MIB_TCPMINTTLDROP); 1447 goto discard_and_relse; 1448 } 1449 1450 if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb)) 1451 goto discard_and_relse; 1452 1453 tcp_v6_fill_cb(skb, hdr, th); 1454 1455 if (tcp_v6_inbound_md5_hash(sk, skb)) 1456 goto discard_and_relse; 1457 1458 if (sk_filter(sk, skb)) 1459 goto discard_and_relse; 1460 1461 skb->dev = NULL; 1462 1463 if (sk->sk_state == TCP_LISTEN) { 1464 ret = tcp_v6_do_rcv(sk, skb); 1465 goto put_and_return; 1466 } 1467 1468 sk_incoming_cpu_update(sk); 1469 1470 bh_lock_sock_nested(sk); 1471 tcp_segs_in(tcp_sk(sk), skb); 1472 ret = 0; 1473 if (!sock_owned_by_user(sk)) { 1474 if (!tcp_prequeue(sk, skb)) 1475 ret = tcp_v6_do_rcv(sk, skb); 1476 } else if (tcp_add_backlog(sk, skb)) { 1477 goto discard_and_relse; 1478 } 1479 bh_unlock_sock(sk); 1480 1481 put_and_return: 1482 if (refcounted) 1483 sock_put(sk); 1484 return ret ? -1 : 0; 1485 1486 no_tcp_socket: 1487 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) 1488 goto discard_it; 1489 1490 tcp_v6_fill_cb(skb, hdr, th); 1491 1492 if (tcp_checksum_complete(skb)) { 1493 csum_error: 1494 __TCP_INC_STATS(net, TCP_MIB_CSUMERRORS); 1495 bad_packet: 1496 __TCP_INC_STATS(net, TCP_MIB_INERRS); 1497 } else { 1498 tcp_v6_send_reset(NULL, skb); 1499 } 1500 1501 discard_it: 1502 kfree_skb(skb); 1503 return 0; 1504 1505 discard_and_relse: 1506 sk_drops_add(sk, skb); 1507 if (refcounted) 1508 sock_put(sk); 1509 goto discard_it; 1510 1511 do_time_wait: 1512 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) { 1513 inet_twsk_put(inet_twsk(sk)); 1514 goto discard_it; 1515 } 1516 1517 tcp_v6_fill_cb(skb, hdr, th); 1518 1519 if (tcp_checksum_complete(skb)) { 1520 inet_twsk_put(inet_twsk(sk)); 1521 goto csum_error; 1522 } 1523 1524 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) { 1525 case TCP_TW_SYN: 1526 { 1527 struct sock *sk2; 1528 1529 sk2 = inet6_lookup_listener(dev_net(skb->dev), &tcp_hashinfo, 1530 skb, __tcp_hdrlen(th), 1531 &ipv6_hdr(skb)->saddr, th->source, 1532 &ipv6_hdr(skb)->daddr, 1533 ntohs(th->dest), tcp_v6_iif(skb)); 1534 if (sk2) { 1535 struct inet_timewait_sock *tw = inet_twsk(sk); 1536 inet_twsk_deschedule_put(tw); 1537 sk = sk2; 1538 tcp_v6_restore_cb(skb); 1539 refcounted = false; 1540 goto process; 1541 } 1542 /* Fall through to ACK */ 1543 } 1544 case TCP_TW_ACK: 1545 tcp_v6_timewait_ack(sk, skb); 1546 break; 1547 case TCP_TW_RST: 1548 tcp_v6_restore_cb(skb); 1549 tcp_v6_send_reset(sk, skb); 1550 inet_twsk_deschedule_put(inet_twsk(sk)); 1551 goto discard_it; 1552 case TCP_TW_SUCCESS: 1553 ; 1554 } 1555 goto discard_it; 1556 } 1557 1558 static void tcp_v6_early_demux(struct sk_buff *skb) 1559 { 1560 const struct ipv6hdr *hdr; 1561 const struct tcphdr *th; 1562 struct sock *sk; 1563 1564 if (skb->pkt_type != PACKET_HOST) 1565 return; 1566 1567 if (!pskb_may_pull(skb, skb_transport_offset(skb) + sizeof(struct tcphdr))) 1568 return; 1569 1570 hdr = ipv6_hdr(skb); 1571 th = tcp_hdr(skb); 1572 1573 if (th->doff < sizeof(struct tcphdr) / 4) 1574 return; 1575 1576 /* Note : We use inet6_iif() here, not tcp_v6_iif() */ 1577 sk = __inet6_lookup_established(dev_net(skb->dev), &tcp_hashinfo, 1578 &hdr->saddr, th->source, 1579 &hdr->daddr, ntohs(th->dest), 1580 inet6_iif(skb)); 1581 if (sk) { 1582 skb->sk = sk; 1583 skb->destructor = sock_edemux; 1584 if (sk_fullsock(sk)) { 1585 struct dst_entry *dst = READ_ONCE(sk->sk_rx_dst); 1586 1587 if (dst) 1588 dst = dst_check(dst, inet6_sk(sk)->rx_dst_cookie); 1589 if (dst && 1590 inet_sk(sk)->rx_dst_ifindex == skb->skb_iif) 1591 skb_dst_set_noref(skb, dst); 1592 } 1593 } 1594 } 1595 1596 static struct timewait_sock_ops tcp6_timewait_sock_ops = { 1597 .twsk_obj_size = sizeof(struct tcp6_timewait_sock), 1598 .twsk_unique = tcp_twsk_unique, 1599 .twsk_destructor = tcp_twsk_destructor, 1600 }; 1601 1602 static const struct inet_connection_sock_af_ops ipv6_specific = { 1603 .queue_xmit = inet6_csk_xmit, 1604 .send_check = tcp_v6_send_check, 1605 .rebuild_header = inet6_sk_rebuild_header, 1606 .sk_rx_dst_set = inet6_sk_rx_dst_set, 1607 .conn_request = tcp_v6_conn_request, 1608 .syn_recv_sock = tcp_v6_syn_recv_sock, 1609 .net_header_len = sizeof(struct ipv6hdr), 1610 .net_frag_header_len = sizeof(struct frag_hdr), 1611 .setsockopt = ipv6_setsockopt, 1612 .getsockopt = ipv6_getsockopt, 1613 .addr2sockaddr = inet6_csk_addr2sockaddr, 1614 .sockaddr_len = sizeof(struct sockaddr_in6), 1615 .bind_conflict = inet6_csk_bind_conflict, 1616 #ifdef CONFIG_COMPAT 1617 .compat_setsockopt = compat_ipv6_setsockopt, 1618 .compat_getsockopt = compat_ipv6_getsockopt, 1619 #endif 1620 .mtu_reduced = tcp_v6_mtu_reduced, 1621 }; 1622 1623 #ifdef CONFIG_TCP_MD5SIG 1624 static const struct tcp_sock_af_ops tcp_sock_ipv6_specific = { 1625 .md5_lookup = tcp_v6_md5_lookup, 1626 .calc_md5_hash = tcp_v6_md5_hash_skb, 1627 .md5_parse = tcp_v6_parse_md5_keys, 1628 }; 1629 #endif 1630 1631 /* 1632 * TCP over IPv4 via INET6 API 1633 */ 1634 static const struct inet_connection_sock_af_ops ipv6_mapped = { 1635 .queue_xmit = ip_queue_xmit, 1636 .send_check = tcp_v4_send_check, 1637 .rebuild_header = inet_sk_rebuild_header, 1638 .sk_rx_dst_set = inet_sk_rx_dst_set, 1639 .conn_request = tcp_v6_conn_request, 1640 .syn_recv_sock = tcp_v6_syn_recv_sock, 1641 .net_header_len = sizeof(struct iphdr), 1642 .setsockopt = ipv6_setsockopt, 1643 .getsockopt = ipv6_getsockopt, 1644 .addr2sockaddr = inet6_csk_addr2sockaddr, 1645 .sockaddr_len = sizeof(struct sockaddr_in6), 1646 .bind_conflict = inet6_csk_bind_conflict, 1647 #ifdef CONFIG_COMPAT 1648 .compat_setsockopt = compat_ipv6_setsockopt, 1649 .compat_getsockopt = compat_ipv6_getsockopt, 1650 #endif 1651 .mtu_reduced = tcp_v4_mtu_reduced, 1652 }; 1653 1654 #ifdef CONFIG_TCP_MD5SIG 1655 static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific = { 1656 .md5_lookup = tcp_v4_md5_lookup, 1657 .calc_md5_hash = tcp_v4_md5_hash_skb, 1658 .md5_parse = tcp_v6_parse_md5_keys, 1659 }; 1660 #endif 1661 1662 /* NOTE: A lot of things set to zero explicitly by call to 1663 * sk_alloc() so need not be done here. 1664 */ 1665 static int tcp_v6_init_sock(struct sock *sk) 1666 { 1667 struct inet_connection_sock *icsk = inet_csk(sk); 1668 1669 tcp_init_sock(sk); 1670 1671 icsk->icsk_af_ops = &ipv6_specific; 1672 1673 #ifdef CONFIG_TCP_MD5SIG 1674 tcp_sk(sk)->af_specific = &tcp_sock_ipv6_specific; 1675 #endif 1676 1677 return 0; 1678 } 1679 1680 static void tcp_v6_destroy_sock(struct sock *sk) 1681 { 1682 tcp_v4_destroy_sock(sk); 1683 inet6_destroy_sock(sk); 1684 } 1685 1686 #ifdef CONFIG_PROC_FS 1687 /* Proc filesystem TCPv6 sock list dumping. */ 1688 static void get_openreq6(struct seq_file *seq, 1689 const struct request_sock *req, int i) 1690 { 1691 long ttd = req->rsk_timer.expires - jiffies; 1692 const struct in6_addr *src = &inet_rsk(req)->ir_v6_loc_addr; 1693 const struct in6_addr *dest = &inet_rsk(req)->ir_v6_rmt_addr; 1694 1695 if (ttd < 0) 1696 ttd = 0; 1697 1698 seq_printf(seq, 1699 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X " 1700 "%02X %08X:%08X %02X:%08lX %08X %5u %8d %d %d %pK\n", 1701 i, 1702 src->s6_addr32[0], src->s6_addr32[1], 1703 src->s6_addr32[2], src->s6_addr32[3], 1704 inet_rsk(req)->ir_num, 1705 dest->s6_addr32[0], dest->s6_addr32[1], 1706 dest->s6_addr32[2], dest->s6_addr32[3], 1707 ntohs(inet_rsk(req)->ir_rmt_port), 1708 TCP_SYN_RECV, 1709 0, 0, /* could print option size, but that is af dependent. */ 1710 1, /* timers active (only the expire timer) */ 1711 jiffies_to_clock_t(ttd), 1712 req->num_timeout, 1713 from_kuid_munged(seq_user_ns(seq), 1714 sock_i_uid(req->rsk_listener)), 1715 0, /* non standard timer */ 1716 0, /* open_requests have no inode */ 1717 0, req); 1718 } 1719 1720 static void get_tcp6_sock(struct seq_file *seq, struct sock *sp, int i) 1721 { 1722 const struct in6_addr *dest, *src; 1723 __u16 destp, srcp; 1724 int timer_active; 1725 unsigned long timer_expires; 1726 const struct inet_sock *inet = inet_sk(sp); 1727 const struct tcp_sock *tp = tcp_sk(sp); 1728 const struct inet_connection_sock *icsk = inet_csk(sp); 1729 const struct fastopen_queue *fastopenq = &icsk->icsk_accept_queue.fastopenq; 1730 int rx_queue; 1731 int state; 1732 1733 dest = &sp->sk_v6_daddr; 1734 src = &sp->sk_v6_rcv_saddr; 1735 destp = ntohs(inet->inet_dport); 1736 srcp = ntohs(inet->inet_sport); 1737 1738 if (icsk->icsk_pending == ICSK_TIME_RETRANS || 1739 icsk->icsk_pending == ICSK_TIME_EARLY_RETRANS || 1740 icsk->icsk_pending == ICSK_TIME_LOSS_PROBE) { 1741 timer_active = 1; 1742 timer_expires = icsk->icsk_timeout; 1743 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) { 1744 timer_active = 4; 1745 timer_expires = icsk->icsk_timeout; 1746 } else if (timer_pending(&sp->sk_timer)) { 1747 timer_active = 2; 1748 timer_expires = sp->sk_timer.expires; 1749 } else { 1750 timer_active = 0; 1751 timer_expires = jiffies; 1752 } 1753 1754 state = sk_state_load(sp); 1755 if (state == TCP_LISTEN) 1756 rx_queue = sp->sk_ack_backlog; 1757 else 1758 /* Because we don't lock the socket, 1759 * we might find a transient negative value. 1760 */ 1761 rx_queue = max_t(int, tp->rcv_nxt - tp->copied_seq, 0); 1762 1763 seq_printf(seq, 1764 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X " 1765 "%02X %08X:%08X %02X:%08lX %08X %5u %8d %lu %d %pK %lu %lu %u %u %d\n", 1766 i, 1767 src->s6_addr32[0], src->s6_addr32[1], 1768 src->s6_addr32[2], src->s6_addr32[3], srcp, 1769 dest->s6_addr32[0], dest->s6_addr32[1], 1770 dest->s6_addr32[2], dest->s6_addr32[3], destp, 1771 state, 1772 tp->write_seq - tp->snd_una, 1773 rx_queue, 1774 timer_active, 1775 jiffies_delta_to_clock_t(timer_expires - jiffies), 1776 icsk->icsk_retransmits, 1777 from_kuid_munged(seq_user_ns(seq), sock_i_uid(sp)), 1778 icsk->icsk_probes_out, 1779 sock_i_ino(sp), 1780 atomic_read(&sp->sk_refcnt), sp, 1781 jiffies_to_clock_t(icsk->icsk_rto), 1782 jiffies_to_clock_t(icsk->icsk_ack.ato), 1783 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong, 1784 tp->snd_cwnd, 1785 state == TCP_LISTEN ? 1786 fastopenq->max_qlen : 1787 (tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh) 1788 ); 1789 } 1790 1791 static void get_timewait6_sock(struct seq_file *seq, 1792 struct inet_timewait_sock *tw, int i) 1793 { 1794 long delta = tw->tw_timer.expires - jiffies; 1795 const struct in6_addr *dest, *src; 1796 __u16 destp, srcp; 1797 1798 dest = &tw->tw_v6_daddr; 1799 src = &tw->tw_v6_rcv_saddr; 1800 destp = ntohs(tw->tw_dport); 1801 srcp = ntohs(tw->tw_sport); 1802 1803 seq_printf(seq, 1804 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X " 1805 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK\n", 1806 i, 1807 src->s6_addr32[0], src->s6_addr32[1], 1808 src->s6_addr32[2], src->s6_addr32[3], srcp, 1809 dest->s6_addr32[0], dest->s6_addr32[1], 1810 dest->s6_addr32[2], dest->s6_addr32[3], destp, 1811 tw->tw_substate, 0, 0, 1812 3, jiffies_delta_to_clock_t(delta), 0, 0, 0, 0, 1813 atomic_read(&tw->tw_refcnt), tw); 1814 } 1815 1816 static int tcp6_seq_show(struct seq_file *seq, void *v) 1817 { 1818 struct tcp_iter_state *st; 1819 struct sock *sk = v; 1820 1821 if (v == SEQ_START_TOKEN) { 1822 seq_puts(seq, 1823 " sl " 1824 "local_address " 1825 "remote_address " 1826 "st tx_queue rx_queue tr tm->when retrnsmt" 1827 " uid timeout inode\n"); 1828 goto out; 1829 } 1830 st = seq->private; 1831 1832 if (sk->sk_state == TCP_TIME_WAIT) 1833 get_timewait6_sock(seq, v, st->num); 1834 else if (sk->sk_state == TCP_NEW_SYN_RECV) 1835 get_openreq6(seq, v, st->num); 1836 else 1837 get_tcp6_sock(seq, v, st->num); 1838 out: 1839 return 0; 1840 } 1841 1842 static const struct file_operations tcp6_afinfo_seq_fops = { 1843 .owner = THIS_MODULE, 1844 .open = tcp_seq_open, 1845 .read = seq_read, 1846 .llseek = seq_lseek, 1847 .release = seq_release_net 1848 }; 1849 1850 static struct tcp_seq_afinfo tcp6_seq_afinfo = { 1851 .name = "tcp6", 1852 .family = AF_INET6, 1853 .seq_fops = &tcp6_afinfo_seq_fops, 1854 .seq_ops = { 1855 .show = tcp6_seq_show, 1856 }, 1857 }; 1858 1859 int __net_init tcp6_proc_init(struct net *net) 1860 { 1861 return tcp_proc_register(net, &tcp6_seq_afinfo); 1862 } 1863 1864 void tcp6_proc_exit(struct net *net) 1865 { 1866 tcp_proc_unregister(net, &tcp6_seq_afinfo); 1867 } 1868 #endif 1869 1870 struct proto tcpv6_prot = { 1871 .name = "TCPv6", 1872 .owner = THIS_MODULE, 1873 .close = tcp_close, 1874 .connect = tcp_v6_connect, 1875 .disconnect = tcp_disconnect, 1876 .accept = inet_csk_accept, 1877 .ioctl = tcp_ioctl, 1878 .init = tcp_v6_init_sock, 1879 .destroy = tcp_v6_destroy_sock, 1880 .shutdown = tcp_shutdown, 1881 .setsockopt = tcp_setsockopt, 1882 .getsockopt = tcp_getsockopt, 1883 .recvmsg = tcp_recvmsg, 1884 .sendmsg = tcp_sendmsg, 1885 .sendpage = tcp_sendpage, 1886 .backlog_rcv = tcp_v6_do_rcv, 1887 .release_cb = tcp_release_cb, 1888 .hash = inet6_hash, 1889 .unhash = inet_unhash, 1890 .get_port = inet_csk_get_port, 1891 .enter_memory_pressure = tcp_enter_memory_pressure, 1892 .stream_memory_free = tcp_stream_memory_free, 1893 .sockets_allocated = &tcp_sockets_allocated, 1894 .memory_allocated = &tcp_memory_allocated, 1895 .memory_pressure = &tcp_memory_pressure, 1896 .orphan_count = &tcp_orphan_count, 1897 .sysctl_mem = sysctl_tcp_mem, 1898 .sysctl_wmem = sysctl_tcp_wmem, 1899 .sysctl_rmem = sysctl_tcp_rmem, 1900 .max_header = MAX_TCP_HEADER, 1901 .obj_size = sizeof(struct tcp6_sock), 1902 .slab_flags = SLAB_DESTROY_BY_RCU, 1903 .twsk_prot = &tcp6_timewait_sock_ops, 1904 .rsk_prot = &tcp6_request_sock_ops, 1905 .h.hashinfo = &tcp_hashinfo, 1906 .no_autobind = true, 1907 #ifdef CONFIG_COMPAT 1908 .compat_setsockopt = compat_tcp_setsockopt, 1909 .compat_getsockopt = compat_tcp_getsockopt, 1910 #endif 1911 .diag_destroy = tcp_abort, 1912 }; 1913 1914 static const struct inet6_protocol tcpv6_protocol = { 1915 .early_demux = tcp_v6_early_demux, 1916 .handler = tcp_v6_rcv, 1917 .err_handler = tcp_v6_err, 1918 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL, 1919 }; 1920 1921 static struct inet_protosw tcpv6_protosw = { 1922 .type = SOCK_STREAM, 1923 .protocol = IPPROTO_TCP, 1924 .prot = &tcpv6_prot, 1925 .ops = &inet6_stream_ops, 1926 .flags = INET_PROTOSW_PERMANENT | 1927 INET_PROTOSW_ICSK, 1928 }; 1929 1930 static int __net_init tcpv6_net_init(struct net *net) 1931 { 1932 return inet_ctl_sock_create(&net->ipv6.tcp_sk, PF_INET6, 1933 SOCK_RAW, IPPROTO_TCP, net); 1934 } 1935 1936 static void __net_exit tcpv6_net_exit(struct net *net) 1937 { 1938 inet_ctl_sock_destroy(net->ipv6.tcp_sk); 1939 } 1940 1941 static void __net_exit tcpv6_net_exit_batch(struct list_head *net_exit_list) 1942 { 1943 inet_twsk_purge(&tcp_hashinfo, &tcp_death_row, AF_INET6); 1944 } 1945 1946 static struct pernet_operations tcpv6_net_ops = { 1947 .init = tcpv6_net_init, 1948 .exit = tcpv6_net_exit, 1949 .exit_batch = tcpv6_net_exit_batch, 1950 }; 1951 1952 int __init tcpv6_init(void) 1953 { 1954 int ret; 1955 1956 ret = inet6_add_protocol(&tcpv6_protocol, IPPROTO_TCP); 1957 if (ret) 1958 goto out; 1959 1960 /* register inet6 protocol */ 1961 ret = inet6_register_protosw(&tcpv6_protosw); 1962 if (ret) 1963 goto out_tcpv6_protocol; 1964 1965 ret = register_pernet_subsys(&tcpv6_net_ops); 1966 if (ret) 1967 goto out_tcpv6_protosw; 1968 out: 1969 return ret; 1970 1971 out_tcpv6_protosw: 1972 inet6_unregister_protosw(&tcpv6_protosw); 1973 out_tcpv6_protocol: 1974 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP); 1975 goto out; 1976 } 1977 1978 void tcpv6_exit(void) 1979 { 1980 unregister_pernet_subsys(&tcpv6_net_ops); 1981 inet6_unregister_protosw(&tcpv6_protosw); 1982 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP); 1983 } 1984