1 /* 2 * UDP over IPv6 3 * Linux INET6 implementation 4 * 5 * Authors: 6 * Pedro Roque <roque@di.fc.ul.pt> 7 * 8 * Based on linux/ipv4/udp.c 9 * 10 * $Id: udp.c,v 1.65 2002/02/01 22:01:04 davem Exp $ 11 * 12 * Fixes: 13 * Hideaki YOSHIFUJI : sin6_scope_id support 14 * YOSHIFUJI Hideaki @USAGI and: Support IPV6_V6ONLY socket option, which 15 * Alexey Kuznetsov allow both IPv4 and IPv6 sockets to bind 16 * a single port at the same time. 17 * Kazunori MIYAZAWA @USAGI: change process style to use ip6_append_data 18 * YOSHIFUJI Hideaki @USAGI: convert /proc/net/udp6 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/errno.h> 27 #include <linux/types.h> 28 #include <linux/socket.h> 29 #include <linux/sockios.h> 30 #include <linux/net.h> 31 #include <linux/in6.h> 32 #include <linux/netdevice.h> 33 #include <linux/if_arp.h> 34 #include <linux/ipv6.h> 35 #include <linux/icmpv6.h> 36 #include <linux/init.h> 37 #include <linux/skbuff.h> 38 #include <asm/uaccess.h> 39 40 #include <net/ndisc.h> 41 #include <net/protocol.h> 42 #include <net/transp_v6.h> 43 #include <net/ip6_route.h> 44 #include <net/raw.h> 45 #include <net/tcp_states.h> 46 #include <net/ip6_checksum.h> 47 #include <net/xfrm.h> 48 49 #include <linux/proc_fs.h> 50 #include <linux/seq_file.h> 51 #include "udp_impl.h" 52 53 DEFINE_SNMP_STAT(struct udp_mib, udp_stats_in6) __read_mostly; 54 55 static int ipv6_rcv_saddr_any(const struct sock *sk) 56 { 57 struct ipv6_pinfo *np = inet6_sk(sk); 58 59 return ipv6_addr_any(&np->rcv_saddr); 60 } 61 62 static unsigned int ipv6_hash_port_and_rcv_saddr(__u16 port, 63 const struct sock *sk) 64 { 65 return port; 66 } 67 68 const struct udp_get_port_ops udp_ipv6_ops = { 69 .saddr_cmp = ipv6_rcv_saddr_equal, 70 .saddr_any = ipv6_rcv_saddr_any, 71 .hash_port_and_rcv_saddr = ipv6_hash_port_and_rcv_saddr, 72 }; 73 74 static inline int udp_v6_get_port(struct sock *sk, unsigned short snum) 75 { 76 return udp_get_port(sk, snum, &udp_ipv6_ops); 77 } 78 79 static struct sock *__udp6_lib_lookup(struct in6_addr *saddr, __be16 sport, 80 struct in6_addr *daddr, __be16 dport, 81 int dif, struct hlist_head udptable[]) 82 { 83 struct sock *sk, *result = NULL; 84 struct hlist_node *node; 85 unsigned short hnum = ntohs(dport); 86 int badness = -1; 87 88 read_lock(&udp_hash_lock); 89 sk_for_each(sk, node, &udptable[hnum & (UDP_HTABLE_SIZE - 1)]) { 90 struct inet_sock *inet = inet_sk(sk); 91 92 if (sk->sk_hash == hnum && sk->sk_family == PF_INET6) { 93 struct ipv6_pinfo *np = inet6_sk(sk); 94 int score = 0; 95 if (inet->dport) { 96 if (inet->dport != sport) 97 continue; 98 score++; 99 } 100 if (!ipv6_addr_any(&np->rcv_saddr)) { 101 if (!ipv6_addr_equal(&np->rcv_saddr, daddr)) 102 continue; 103 score++; 104 } 105 if (!ipv6_addr_any(&np->daddr)) { 106 if (!ipv6_addr_equal(&np->daddr, saddr)) 107 continue; 108 score++; 109 } 110 if (sk->sk_bound_dev_if) { 111 if (sk->sk_bound_dev_if != dif) 112 continue; 113 score++; 114 } 115 if (score == 4) { 116 result = sk; 117 break; 118 } else if (score > badness) { 119 result = sk; 120 badness = score; 121 } 122 } 123 } 124 if (result) 125 sock_hold(result); 126 read_unlock(&udp_hash_lock); 127 return result; 128 } 129 130 /* 131 * This should be easy, if there is something there we 132 * return it, otherwise we block. 133 */ 134 135 int udpv6_recvmsg(struct kiocb *iocb, struct sock *sk, 136 struct msghdr *msg, size_t len, 137 int noblock, int flags, int *addr_len) 138 { 139 struct ipv6_pinfo *np = inet6_sk(sk); 140 struct inet_sock *inet = inet_sk(sk); 141 struct sk_buff *skb; 142 unsigned int ulen, copied; 143 int err; 144 int is_udplite = IS_UDPLITE(sk); 145 146 if (addr_len) 147 *addr_len=sizeof(struct sockaddr_in6); 148 149 if (flags & MSG_ERRQUEUE) 150 return ipv6_recv_error(sk, msg, len); 151 152 try_again: 153 skb = skb_recv_datagram(sk, flags, noblock, &err); 154 if (!skb) 155 goto out; 156 157 ulen = skb->len - sizeof(struct udphdr); 158 copied = len; 159 if (copied > ulen) 160 copied = ulen; 161 else if (copied < ulen) 162 msg->msg_flags |= MSG_TRUNC; 163 164 /* 165 * If checksum is needed at all, try to do it while copying the 166 * data. If the data is truncated, or if we only want a partial 167 * coverage checksum (UDP-Lite), do it before the copy. 168 */ 169 170 if (copied < ulen || UDP_SKB_CB(skb)->partial_cov) { 171 if (udp_lib_checksum_complete(skb)) 172 goto csum_copy_err; 173 } 174 175 if (skb_csum_unnecessary(skb)) 176 err = skb_copy_datagram_iovec(skb, sizeof(struct udphdr), 177 msg->msg_iov, copied ); 178 else { 179 err = skb_copy_and_csum_datagram_iovec(skb, sizeof(struct udphdr), msg->msg_iov); 180 if (err == -EINVAL) 181 goto csum_copy_err; 182 } 183 if (err) 184 goto out_free; 185 186 sock_recv_timestamp(msg, sk, skb); 187 188 /* Copy the address. */ 189 if (msg->msg_name) { 190 struct sockaddr_in6 *sin6; 191 192 sin6 = (struct sockaddr_in6 *) msg->msg_name; 193 sin6->sin6_family = AF_INET6; 194 sin6->sin6_port = udp_hdr(skb)->source; 195 sin6->sin6_flowinfo = 0; 196 sin6->sin6_scope_id = 0; 197 198 if (skb->protocol == htons(ETH_P_IP)) 199 ipv6_addr_set(&sin6->sin6_addr, 0, 0, 200 htonl(0xffff), ip_hdr(skb)->saddr); 201 else { 202 ipv6_addr_copy(&sin6->sin6_addr, 203 &ipv6_hdr(skb)->saddr); 204 if (ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_LINKLOCAL) 205 sin6->sin6_scope_id = IP6CB(skb)->iif; 206 } 207 208 } 209 if (skb->protocol == htons(ETH_P_IP)) { 210 if (inet->cmsg_flags) 211 ip_cmsg_recv(msg, skb); 212 } else { 213 if (np->rxopt.all) 214 datagram_recv_ctl(sk, msg, skb); 215 } 216 217 err = copied; 218 if (flags & MSG_TRUNC) 219 err = ulen; 220 221 out_free: 222 skb_free_datagram(sk, skb); 223 out: 224 return err; 225 226 csum_copy_err: 227 skb_kill_datagram(sk, skb, flags); 228 229 if (flags & MSG_DONTWAIT) { 230 UDP6_INC_STATS_USER(UDP_MIB_INERRORS, is_udplite); 231 return -EAGAIN; 232 } 233 goto try_again; 234 } 235 236 void __udp6_lib_err(struct sk_buff *skb, struct inet6_skb_parm *opt, 237 int type, int code, int offset, __be32 info, 238 struct hlist_head udptable[] ) 239 { 240 struct ipv6_pinfo *np; 241 struct ipv6hdr *hdr = (struct ipv6hdr*)skb->data; 242 struct in6_addr *saddr = &hdr->saddr; 243 struct in6_addr *daddr = &hdr->daddr; 244 struct udphdr *uh = (struct udphdr*)(skb->data+offset); 245 struct sock *sk; 246 int err; 247 248 sk = __udp6_lib_lookup(daddr, uh->dest, 249 saddr, uh->source, inet6_iif(skb), udptable); 250 if (sk == NULL) 251 return; 252 253 np = inet6_sk(sk); 254 255 if (!icmpv6_err_convert(type, code, &err) && !np->recverr) 256 goto out; 257 258 if (sk->sk_state != TCP_ESTABLISHED && !np->recverr) 259 goto out; 260 261 if (np->recverr) 262 ipv6_icmp_error(sk, skb, err, uh->dest, ntohl(info), (u8 *)(uh+1)); 263 264 sk->sk_err = err; 265 sk->sk_error_report(sk); 266 out: 267 sock_put(sk); 268 } 269 270 static __inline__ void udpv6_err(struct sk_buff *skb, 271 struct inet6_skb_parm *opt, int type, 272 int code, int offset, __be32 info ) 273 { 274 return __udp6_lib_err(skb, opt, type, code, offset, info, udp_hash); 275 } 276 277 int udpv6_queue_rcv_skb(struct sock * sk, struct sk_buff *skb) 278 { 279 struct udp_sock *up = udp_sk(sk); 280 int rc; 281 282 if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb)) 283 goto drop; 284 285 /* 286 * UDP-Lite specific tests, ignored on UDP sockets (see net/ipv4/udp.c). 287 */ 288 if ((up->pcflag & UDPLITE_RECV_CC) && UDP_SKB_CB(skb)->partial_cov) { 289 290 if (up->pcrlen == 0) { /* full coverage was set */ 291 LIMIT_NETDEBUG(KERN_WARNING "UDPLITE6: partial coverage" 292 " %d while full coverage %d requested\n", 293 UDP_SKB_CB(skb)->cscov, skb->len); 294 goto drop; 295 } 296 if (UDP_SKB_CB(skb)->cscov < up->pcrlen) { 297 LIMIT_NETDEBUG(KERN_WARNING "UDPLITE6: coverage %d " 298 "too small, need min %d\n", 299 UDP_SKB_CB(skb)->cscov, up->pcrlen); 300 goto drop; 301 } 302 } 303 304 if (sk->sk_filter) { 305 if (udp_lib_checksum_complete(skb)) 306 goto drop; 307 } 308 309 if ((rc = sock_queue_rcv_skb(sk,skb)) < 0) { 310 /* Note that an ENOMEM error is charged twice */ 311 if (rc == -ENOMEM) 312 UDP6_INC_STATS_BH(UDP_MIB_RCVBUFERRORS, up->pcflag); 313 goto drop; 314 } 315 UDP6_INC_STATS_BH(UDP_MIB_INDATAGRAMS, up->pcflag); 316 return 0; 317 drop: 318 UDP6_INC_STATS_BH(UDP_MIB_INERRORS, up->pcflag); 319 kfree_skb(skb); 320 return -1; 321 } 322 323 static struct sock *udp_v6_mcast_next(struct sock *sk, 324 __be16 loc_port, struct in6_addr *loc_addr, 325 __be16 rmt_port, struct in6_addr *rmt_addr, 326 int dif) 327 { 328 struct hlist_node *node; 329 struct sock *s = sk; 330 unsigned short num = ntohs(loc_port); 331 332 sk_for_each_from(s, node) { 333 struct inet_sock *inet = inet_sk(s); 334 335 if (s->sk_hash == num && s->sk_family == PF_INET6) { 336 struct ipv6_pinfo *np = inet6_sk(s); 337 if (inet->dport) { 338 if (inet->dport != rmt_port) 339 continue; 340 } 341 if (!ipv6_addr_any(&np->daddr) && 342 !ipv6_addr_equal(&np->daddr, rmt_addr)) 343 continue; 344 345 if (s->sk_bound_dev_if && s->sk_bound_dev_if != dif) 346 continue; 347 348 if (!ipv6_addr_any(&np->rcv_saddr)) { 349 if (!ipv6_addr_equal(&np->rcv_saddr, loc_addr)) 350 continue; 351 } 352 if (!inet6_mc_check(s, loc_addr, rmt_addr)) 353 continue; 354 return s; 355 } 356 } 357 return NULL; 358 } 359 360 /* 361 * Note: called only from the BH handler context, 362 * so we don't need to lock the hashes. 363 */ 364 static int __udp6_lib_mcast_deliver(struct sk_buff *skb, struct in6_addr *saddr, 365 struct in6_addr *daddr, struct hlist_head udptable[]) 366 { 367 struct sock *sk, *sk2; 368 const struct udphdr *uh = udp_hdr(skb); 369 int dif; 370 371 read_lock(&udp_hash_lock); 372 sk = sk_head(&udptable[ntohs(uh->dest) & (UDP_HTABLE_SIZE - 1)]); 373 dif = inet6_iif(skb); 374 sk = udp_v6_mcast_next(sk, uh->dest, daddr, uh->source, saddr, dif); 375 if (!sk) { 376 kfree_skb(skb); 377 goto out; 378 } 379 380 sk2 = sk; 381 while ((sk2 = udp_v6_mcast_next(sk_next(sk2), uh->dest, daddr, 382 uh->source, saddr, dif))) { 383 struct sk_buff *buff = skb_clone(skb, GFP_ATOMIC); 384 if (buff) 385 udpv6_queue_rcv_skb(sk2, buff); 386 } 387 udpv6_queue_rcv_skb(sk, skb); 388 out: 389 read_unlock(&udp_hash_lock); 390 return 0; 391 } 392 393 static inline int udp6_csum_init(struct sk_buff *skb, struct udphdr *uh, 394 int proto) 395 { 396 int err; 397 398 UDP_SKB_CB(skb)->partial_cov = 0; 399 UDP_SKB_CB(skb)->cscov = skb->len; 400 401 if (proto == IPPROTO_UDPLITE) { 402 err = udplite_checksum_init(skb, uh); 403 if (err) 404 return err; 405 } 406 407 if (uh->check == 0) { 408 /* RFC 2460 section 8.1 says that we SHOULD log 409 this error. Well, it is reasonable. 410 */ 411 LIMIT_NETDEBUG(KERN_INFO "IPv6: udp checksum is 0\n"); 412 return 1; 413 } 414 if (skb->ip_summed == CHECKSUM_COMPLETE && 415 !csum_ipv6_magic(&ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr, 416 skb->len, proto, skb->csum)) 417 skb->ip_summed = CHECKSUM_UNNECESSARY; 418 419 if (!skb_csum_unnecessary(skb)) 420 skb->csum = ~csum_unfold(csum_ipv6_magic(&ipv6_hdr(skb)->saddr, 421 &ipv6_hdr(skb)->daddr, 422 skb->len, proto, 0)); 423 424 return 0; 425 } 426 427 int __udp6_lib_rcv(struct sk_buff **pskb, struct hlist_head udptable[], 428 int proto) 429 { 430 struct sk_buff *skb = *pskb; 431 struct sock *sk; 432 struct udphdr *uh; 433 struct net_device *dev = skb->dev; 434 struct in6_addr *saddr, *daddr; 435 u32 ulen = 0; 436 437 if (!pskb_may_pull(skb, sizeof(struct udphdr))) 438 goto short_packet; 439 440 saddr = &ipv6_hdr(skb)->saddr; 441 daddr = &ipv6_hdr(skb)->daddr; 442 uh = udp_hdr(skb); 443 444 ulen = ntohs(uh->len); 445 if (ulen > skb->len) 446 goto short_packet; 447 448 if (proto == IPPROTO_UDP) { 449 /* UDP validates ulen. */ 450 451 /* Check for jumbo payload */ 452 if (ulen == 0) 453 ulen = skb->len; 454 455 if (ulen < sizeof(*uh)) 456 goto short_packet; 457 458 if (ulen < skb->len) { 459 if (pskb_trim_rcsum(skb, ulen)) 460 goto short_packet; 461 saddr = &ipv6_hdr(skb)->saddr; 462 daddr = &ipv6_hdr(skb)->daddr; 463 uh = udp_hdr(skb); 464 } 465 } 466 467 if (udp6_csum_init(skb, uh, proto)) 468 goto discard; 469 470 /* 471 * Multicast receive code 472 */ 473 if (ipv6_addr_is_multicast(daddr)) 474 return __udp6_lib_mcast_deliver(skb, saddr, daddr, udptable); 475 476 /* Unicast */ 477 478 /* 479 * check socket cache ... must talk to Alan about his plans 480 * for sock caches... i'll skip this for now. 481 */ 482 sk = __udp6_lib_lookup(saddr, uh->source, 483 daddr, uh->dest, inet6_iif(skb), udptable); 484 485 if (sk == NULL) { 486 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) 487 goto discard; 488 489 if (udp_lib_checksum_complete(skb)) 490 goto discard; 491 UDP6_INC_STATS_BH(UDP_MIB_NOPORTS, proto == IPPROTO_UDPLITE); 492 493 icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_PORT_UNREACH, 0, dev); 494 495 kfree_skb(skb); 496 return 0; 497 } 498 499 /* deliver */ 500 501 udpv6_queue_rcv_skb(sk, skb); 502 sock_put(sk); 503 return 0; 504 505 short_packet: 506 LIMIT_NETDEBUG(KERN_DEBUG "UDP%sv6: short packet: %d/%u\n", 507 proto == IPPROTO_UDPLITE ? "-Lite" : "", 508 ulen, skb->len); 509 510 discard: 511 UDP6_INC_STATS_BH(UDP_MIB_INERRORS, proto == IPPROTO_UDPLITE); 512 kfree_skb(skb); 513 return 0; 514 } 515 516 static __inline__ int udpv6_rcv(struct sk_buff **pskb) 517 { 518 return __udp6_lib_rcv(pskb, udp_hash, IPPROTO_UDP); 519 } 520 521 /* 522 * Throw away all pending data and cancel the corking. Socket is locked. 523 */ 524 static void udp_v6_flush_pending_frames(struct sock *sk) 525 { 526 struct udp_sock *up = udp_sk(sk); 527 528 if (up->pending) { 529 up->len = 0; 530 up->pending = 0; 531 ip6_flush_pending_frames(sk); 532 } 533 } 534 535 /* 536 * Sending 537 */ 538 539 static int udp_v6_push_pending_frames(struct sock *sk) 540 { 541 struct sk_buff *skb; 542 struct udphdr *uh; 543 struct udp_sock *up = udp_sk(sk); 544 struct inet_sock *inet = inet_sk(sk); 545 struct flowi *fl = &inet->cork.fl; 546 int err = 0; 547 __wsum csum = 0; 548 549 /* Grab the skbuff where UDP header space exists. */ 550 if ((skb = skb_peek(&sk->sk_write_queue)) == NULL) 551 goto out; 552 553 /* 554 * Create a UDP header 555 */ 556 uh = udp_hdr(skb); 557 uh->source = fl->fl_ip_sport; 558 uh->dest = fl->fl_ip_dport; 559 uh->len = htons(up->len); 560 uh->check = 0; 561 562 if (up->pcflag) 563 csum = udplite_csum_outgoing(sk, skb); 564 else 565 csum = udp_csum_outgoing(sk, skb); 566 567 /* add protocol-dependent pseudo-header */ 568 uh->check = csum_ipv6_magic(&fl->fl6_src, &fl->fl6_dst, 569 up->len, fl->proto, csum ); 570 if (uh->check == 0) 571 uh->check = CSUM_MANGLED_0; 572 573 err = ip6_push_pending_frames(sk); 574 out: 575 up->len = 0; 576 up->pending = 0; 577 return err; 578 } 579 580 int udpv6_sendmsg(struct kiocb *iocb, struct sock *sk, 581 struct msghdr *msg, size_t len) 582 { 583 struct ipv6_txoptions opt_space; 584 struct udp_sock *up = udp_sk(sk); 585 struct inet_sock *inet = inet_sk(sk); 586 struct ipv6_pinfo *np = inet6_sk(sk); 587 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) msg->msg_name; 588 struct in6_addr *daddr, *final_p = NULL, final; 589 struct ipv6_txoptions *opt = NULL; 590 struct ip6_flowlabel *flowlabel = NULL; 591 struct flowi fl; 592 struct dst_entry *dst; 593 int addr_len = msg->msg_namelen; 594 int ulen = len; 595 int hlimit = -1; 596 int tclass = -1; 597 int corkreq = up->corkflag || msg->msg_flags&MSG_MORE; 598 int err; 599 int connected = 0; 600 int is_udplite = up->pcflag; 601 int (*getfrag)(void *, char *, int, int, int, struct sk_buff *); 602 603 /* destination address check */ 604 if (sin6) { 605 if (addr_len < offsetof(struct sockaddr, sa_data)) 606 return -EINVAL; 607 608 switch (sin6->sin6_family) { 609 case AF_INET6: 610 if (addr_len < SIN6_LEN_RFC2133) 611 return -EINVAL; 612 daddr = &sin6->sin6_addr; 613 break; 614 case AF_INET: 615 goto do_udp_sendmsg; 616 case AF_UNSPEC: 617 msg->msg_name = sin6 = NULL; 618 msg->msg_namelen = addr_len = 0; 619 daddr = NULL; 620 break; 621 default: 622 return -EINVAL; 623 } 624 } else if (!up->pending) { 625 if (sk->sk_state != TCP_ESTABLISHED) 626 return -EDESTADDRREQ; 627 daddr = &np->daddr; 628 } else 629 daddr = NULL; 630 631 if (daddr) { 632 if (ipv6_addr_type(daddr) == IPV6_ADDR_MAPPED) { 633 struct sockaddr_in sin; 634 sin.sin_family = AF_INET; 635 sin.sin_port = sin6 ? sin6->sin6_port : inet->dport; 636 sin.sin_addr.s_addr = daddr->s6_addr32[3]; 637 msg->msg_name = &sin; 638 msg->msg_namelen = sizeof(sin); 639 do_udp_sendmsg: 640 if (__ipv6_only_sock(sk)) 641 return -ENETUNREACH; 642 return udp_sendmsg(iocb, sk, msg, len); 643 } 644 } 645 646 if (up->pending == AF_INET) 647 return udp_sendmsg(iocb, sk, msg, len); 648 649 /* Rough check on arithmetic overflow, 650 better check is made in ip6_append_data(). 651 */ 652 if (len > INT_MAX - sizeof(struct udphdr)) 653 return -EMSGSIZE; 654 655 if (up->pending) { 656 /* 657 * There are pending frames. 658 * The socket lock must be held while it's corked. 659 */ 660 lock_sock(sk); 661 if (likely(up->pending)) { 662 if (unlikely(up->pending != AF_INET6)) { 663 release_sock(sk); 664 return -EAFNOSUPPORT; 665 } 666 dst = NULL; 667 goto do_append_data; 668 } 669 release_sock(sk); 670 } 671 ulen += sizeof(struct udphdr); 672 673 memset(&fl, 0, sizeof(fl)); 674 675 if (sin6) { 676 if (sin6->sin6_port == 0) 677 return -EINVAL; 678 679 fl.fl_ip_dport = sin6->sin6_port; 680 daddr = &sin6->sin6_addr; 681 682 if (np->sndflow) { 683 fl.fl6_flowlabel = sin6->sin6_flowinfo&IPV6_FLOWINFO_MASK; 684 if (fl.fl6_flowlabel&IPV6_FLOWLABEL_MASK) { 685 flowlabel = fl6_sock_lookup(sk, fl.fl6_flowlabel); 686 if (flowlabel == NULL) 687 return -EINVAL; 688 daddr = &flowlabel->dst; 689 } 690 } 691 692 /* 693 * Otherwise it will be difficult to maintain 694 * sk->sk_dst_cache. 695 */ 696 if (sk->sk_state == TCP_ESTABLISHED && 697 ipv6_addr_equal(daddr, &np->daddr)) 698 daddr = &np->daddr; 699 700 if (addr_len >= sizeof(struct sockaddr_in6) && 701 sin6->sin6_scope_id && 702 ipv6_addr_type(daddr)&IPV6_ADDR_LINKLOCAL) 703 fl.oif = sin6->sin6_scope_id; 704 } else { 705 if (sk->sk_state != TCP_ESTABLISHED) 706 return -EDESTADDRREQ; 707 708 fl.fl_ip_dport = inet->dport; 709 daddr = &np->daddr; 710 fl.fl6_flowlabel = np->flow_label; 711 connected = 1; 712 } 713 714 if (!fl.oif) 715 fl.oif = sk->sk_bound_dev_if; 716 717 if (msg->msg_controllen) { 718 opt = &opt_space; 719 memset(opt, 0, sizeof(struct ipv6_txoptions)); 720 opt->tot_len = sizeof(*opt); 721 722 err = datagram_send_ctl(msg, &fl, opt, &hlimit, &tclass); 723 if (err < 0) { 724 fl6_sock_release(flowlabel); 725 return err; 726 } 727 if ((fl.fl6_flowlabel&IPV6_FLOWLABEL_MASK) && !flowlabel) { 728 flowlabel = fl6_sock_lookup(sk, fl.fl6_flowlabel); 729 if (flowlabel == NULL) 730 return -EINVAL; 731 } 732 if (!(opt->opt_nflen|opt->opt_flen)) 733 opt = NULL; 734 connected = 0; 735 } 736 if (opt == NULL) 737 opt = np->opt; 738 if (flowlabel) 739 opt = fl6_merge_options(&opt_space, flowlabel, opt); 740 opt = ipv6_fixup_options(&opt_space, opt); 741 742 fl.proto = sk->sk_protocol; 743 ipv6_addr_copy(&fl.fl6_dst, daddr); 744 if (ipv6_addr_any(&fl.fl6_src) && !ipv6_addr_any(&np->saddr)) 745 ipv6_addr_copy(&fl.fl6_src, &np->saddr); 746 fl.fl_ip_sport = inet->sport; 747 748 /* merge ip6_build_xmit from ip6_output */ 749 if (opt && opt->srcrt) { 750 struct rt0_hdr *rt0 = (struct rt0_hdr *) opt->srcrt; 751 ipv6_addr_copy(&final, &fl.fl6_dst); 752 ipv6_addr_copy(&fl.fl6_dst, rt0->addr); 753 final_p = &final; 754 connected = 0; 755 } 756 757 if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst)) { 758 fl.oif = np->mcast_oif; 759 connected = 0; 760 } 761 762 security_sk_classify_flow(sk, &fl); 763 764 err = ip6_sk_dst_lookup(sk, &dst, &fl); 765 if (err) 766 goto out; 767 if (final_p) 768 ipv6_addr_copy(&fl.fl6_dst, final_p); 769 770 if ((err = xfrm_lookup(&dst, &fl, sk, 1)) < 0) 771 goto out; 772 773 if (hlimit < 0) { 774 if (ipv6_addr_is_multicast(&fl.fl6_dst)) 775 hlimit = np->mcast_hops; 776 else 777 hlimit = np->hop_limit; 778 if (hlimit < 0) 779 hlimit = dst_metric(dst, RTAX_HOPLIMIT); 780 if (hlimit < 0) 781 hlimit = ipv6_get_hoplimit(dst->dev); 782 } 783 784 if (tclass < 0) { 785 tclass = np->tclass; 786 if (tclass < 0) 787 tclass = 0; 788 } 789 790 if (msg->msg_flags&MSG_CONFIRM) 791 goto do_confirm; 792 back_from_confirm: 793 794 lock_sock(sk); 795 if (unlikely(up->pending)) { 796 /* The socket is already corked while preparing it. */ 797 /* ... which is an evident application bug. --ANK */ 798 release_sock(sk); 799 800 LIMIT_NETDEBUG(KERN_DEBUG "udp cork app bug 2\n"); 801 err = -EINVAL; 802 goto out; 803 } 804 805 up->pending = AF_INET6; 806 807 do_append_data: 808 up->len += ulen; 809 getfrag = is_udplite ? udplite_getfrag : ip_generic_getfrag; 810 err = ip6_append_data(sk, getfrag, msg->msg_iov, ulen, 811 sizeof(struct udphdr), hlimit, tclass, opt, &fl, 812 (struct rt6_info*)dst, 813 corkreq ? msg->msg_flags|MSG_MORE : msg->msg_flags); 814 if (err) 815 udp_v6_flush_pending_frames(sk); 816 else if (!corkreq) 817 err = udp_v6_push_pending_frames(sk); 818 else if (unlikely(skb_queue_empty(&sk->sk_write_queue))) 819 up->pending = 0; 820 821 if (dst) { 822 if (connected) { 823 ip6_dst_store(sk, dst, 824 ipv6_addr_equal(&fl.fl6_dst, &np->daddr) ? 825 &np->daddr : NULL, 826 #ifdef CONFIG_IPV6_SUBTREES 827 ipv6_addr_equal(&fl.fl6_src, &np->saddr) ? 828 &np->saddr : 829 #endif 830 NULL); 831 } else { 832 dst_release(dst); 833 } 834 } 835 836 if (err > 0) 837 err = np->recverr ? net_xmit_errno(err) : 0; 838 release_sock(sk); 839 out: 840 fl6_sock_release(flowlabel); 841 if (!err) { 842 UDP6_INC_STATS_USER(UDP_MIB_OUTDATAGRAMS, is_udplite); 843 return len; 844 } 845 /* 846 * ENOBUFS = no kernel mem, SOCK_NOSPACE = no sndbuf space. Reporting 847 * ENOBUFS might not be good (it's not tunable per se), but otherwise 848 * we don't have a good statistic (IpOutDiscards but it can be too many 849 * things). We could add another new stat but at least for now that 850 * seems like overkill. 851 */ 852 if (err == -ENOBUFS || test_bit(SOCK_NOSPACE, &sk->sk_socket->flags)) { 853 UDP6_INC_STATS_USER(UDP_MIB_SNDBUFERRORS, is_udplite); 854 } 855 return err; 856 857 do_confirm: 858 dst_confirm(dst); 859 if (!(msg->msg_flags&MSG_PROBE) || len) 860 goto back_from_confirm; 861 err = 0; 862 goto out; 863 } 864 865 int udpv6_destroy_sock(struct sock *sk) 866 { 867 lock_sock(sk); 868 udp_v6_flush_pending_frames(sk); 869 release_sock(sk); 870 871 inet6_destroy_sock(sk); 872 873 return 0; 874 } 875 876 /* 877 * Socket option code for UDP 878 */ 879 int udpv6_setsockopt(struct sock *sk, int level, int optname, 880 char __user *optval, int optlen) 881 { 882 if (level == SOL_UDP || level == SOL_UDPLITE) 883 return udp_lib_setsockopt(sk, level, optname, optval, optlen, 884 udp_v6_push_pending_frames); 885 return ipv6_setsockopt(sk, level, optname, optval, optlen); 886 } 887 888 #ifdef CONFIG_COMPAT 889 int compat_udpv6_setsockopt(struct sock *sk, int level, int optname, 890 char __user *optval, int optlen) 891 { 892 if (level == SOL_UDP || level == SOL_UDPLITE) 893 return udp_lib_setsockopt(sk, level, optname, optval, optlen, 894 udp_v6_push_pending_frames); 895 return compat_ipv6_setsockopt(sk, level, optname, optval, optlen); 896 } 897 #endif 898 899 int udpv6_getsockopt(struct sock *sk, int level, int optname, 900 char __user *optval, int __user *optlen) 901 { 902 if (level == SOL_UDP || level == SOL_UDPLITE) 903 return udp_lib_getsockopt(sk, level, optname, optval, optlen); 904 return ipv6_getsockopt(sk, level, optname, optval, optlen); 905 } 906 907 #ifdef CONFIG_COMPAT 908 int compat_udpv6_getsockopt(struct sock *sk, int level, int optname, 909 char __user *optval, int __user *optlen) 910 { 911 if (level == SOL_UDP || level == SOL_UDPLITE) 912 return udp_lib_getsockopt(sk, level, optname, optval, optlen); 913 return compat_ipv6_getsockopt(sk, level, optname, optval, optlen); 914 } 915 #endif 916 917 static struct inet6_protocol udpv6_protocol = { 918 .handler = udpv6_rcv, 919 .err_handler = udpv6_err, 920 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL, 921 }; 922 923 /* ------------------------------------------------------------------------ */ 924 #ifdef CONFIG_PROC_FS 925 926 static void udp6_sock_seq_show(struct seq_file *seq, struct sock *sp, int bucket) 927 { 928 struct inet_sock *inet = inet_sk(sp); 929 struct ipv6_pinfo *np = inet6_sk(sp); 930 struct in6_addr *dest, *src; 931 __u16 destp, srcp; 932 933 dest = &np->daddr; 934 src = &np->rcv_saddr; 935 destp = ntohs(inet->dport); 936 srcp = ntohs(inet->sport); 937 seq_printf(seq, 938 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X " 939 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %p\n", 940 bucket, 941 src->s6_addr32[0], src->s6_addr32[1], 942 src->s6_addr32[2], src->s6_addr32[3], srcp, 943 dest->s6_addr32[0], dest->s6_addr32[1], 944 dest->s6_addr32[2], dest->s6_addr32[3], destp, 945 sp->sk_state, 946 atomic_read(&sp->sk_wmem_alloc), 947 atomic_read(&sp->sk_rmem_alloc), 948 0, 0L, 0, 949 sock_i_uid(sp), 0, 950 sock_i_ino(sp), 951 atomic_read(&sp->sk_refcnt), sp); 952 } 953 954 int udp6_seq_show(struct seq_file *seq, void *v) 955 { 956 if (v == SEQ_START_TOKEN) 957 seq_printf(seq, 958 " sl " 959 "local_address " 960 "remote_address " 961 "st tx_queue rx_queue tr tm->when retrnsmt" 962 " uid timeout inode\n"); 963 else 964 udp6_sock_seq_show(seq, v, ((struct udp_iter_state *)seq->private)->bucket); 965 return 0; 966 } 967 968 static struct file_operations udp6_seq_fops; 969 static struct udp_seq_afinfo udp6_seq_afinfo = { 970 .owner = THIS_MODULE, 971 .name = "udp6", 972 .family = AF_INET6, 973 .hashtable = udp_hash, 974 .seq_show = udp6_seq_show, 975 .seq_fops = &udp6_seq_fops, 976 }; 977 978 int __init udp6_proc_init(void) 979 { 980 return udp_proc_register(&udp6_seq_afinfo); 981 } 982 983 void udp6_proc_exit(void) { 984 udp_proc_unregister(&udp6_seq_afinfo); 985 } 986 #endif /* CONFIG_PROC_FS */ 987 988 /* ------------------------------------------------------------------------ */ 989 990 struct proto udpv6_prot = { 991 .name = "UDPv6", 992 .owner = THIS_MODULE, 993 .close = udp_lib_close, 994 .connect = ip6_datagram_connect, 995 .disconnect = udp_disconnect, 996 .ioctl = udp_ioctl, 997 .destroy = udpv6_destroy_sock, 998 .setsockopt = udpv6_setsockopt, 999 .getsockopt = udpv6_getsockopt, 1000 .sendmsg = udpv6_sendmsg, 1001 .recvmsg = udpv6_recvmsg, 1002 .backlog_rcv = udpv6_queue_rcv_skb, 1003 .hash = udp_lib_hash, 1004 .unhash = udp_lib_unhash, 1005 .get_port = udp_v6_get_port, 1006 .obj_size = sizeof(struct udp6_sock), 1007 #ifdef CONFIG_COMPAT 1008 .compat_setsockopt = compat_udpv6_setsockopt, 1009 .compat_getsockopt = compat_udpv6_getsockopt, 1010 #endif 1011 }; 1012 1013 static struct inet_protosw udpv6_protosw = { 1014 .type = SOCK_DGRAM, 1015 .protocol = IPPROTO_UDP, 1016 .prot = &udpv6_prot, 1017 .ops = &inet6_dgram_ops, 1018 .capability =-1, 1019 .no_check = UDP_CSUM_DEFAULT, 1020 .flags = INET_PROTOSW_PERMANENT, 1021 }; 1022 1023 1024 void __init udpv6_init(void) 1025 { 1026 if (inet6_add_protocol(&udpv6_protocol, IPPROTO_UDP) < 0) 1027 printk(KERN_ERR "udpv6_init: Could not register protocol\n"); 1028 inet6_register_protosw(&udpv6_protosw); 1029 } 1030