1/* 2 * RAW sockets for IPv6 3 * Linux INET6 implementation 4 * 5 * Authors: 6 * Pedro Roque <roque@di.fc.ul.pt> 7 * 8 * Adapted from linux/net/ipv4/raw.c 9 * 10 * $Id: raw.c,v 1.1.1.1 2007/08/03 18:53:52 Exp $ 11 * 12 * Fixes: 13 * Hideaki YOSHIFUJI : sin6_scope_id support 14 * YOSHIFUJI,H.@USAGI : raw checksum (RFC2292(bis) compliance) 15 * Kazunori MIYAZAWA @USAGI: change process style to use ip6_append_data 16 * 17 * This program is free software; you can redistribute it and/or 18 * modify it under the terms of the GNU General Public License 19 * as published by the Free Software Foundation; either version 20 * 2 of the License, or (at your option) any later version. 21 */ 22 23#include <linux/errno.h> 24#include <linux/types.h> 25#include <linux/socket.h> 26#include <linux/sockios.h> 27#include <linux/net.h> 28#include <linux/in6.h> 29#include <linux/netdevice.h> 30#include <linux/if_arp.h> 31#include <linux/icmpv6.h> 32#include <linux/netfilter.h> 33#include <linux/netfilter_ipv6.h> 34#include <linux/skbuff.h> 35#include <asm/uaccess.h> 36#include <asm/ioctls.h> 37 38#include <net/ip.h> 39#include <net/sock.h> 40#include <net/snmp.h> 41 42#include <net/ipv6.h> 43#include <net/ndisc.h> 44#include <net/protocol.h> 45#include <net/ip6_route.h> 46#include <net/ip6_checksum.h> 47#include <net/addrconf.h> 48#include <net/transp_v6.h> 49#include <net/udp.h> 50#include <net/inet_common.h> 51#include <net/tcp_states.h> 52#ifdef CONFIG_IPV6_MIP6 53#include <net/mip6.h> 54#endif 55 56#include <net/rawv6.h> 57#include <net/xfrm.h> 58 59#include <linux/proc_fs.h> 60#include <linux/seq_file.h> 61 62#ifdef CONFIG_IPV6_MROUTE //foxconn 63#include <linux/mroute6.h> 64#endif 65 66struct hlist_head raw_v6_htable[RAWV6_HTABLE_SIZE]; 67DEFINE_RWLOCK(raw_v6_lock); 68 69static void raw_v6_hash(struct sock *sk) 70{ 71 struct hlist_head *list = &raw_v6_htable[inet_sk(sk)->num & 72 (RAWV6_HTABLE_SIZE - 1)]; 73 74 write_lock_bh(&raw_v6_lock); 75 sk_add_node(sk, list); 76 sock_prot_inc_use(sk->sk_prot); 77 write_unlock_bh(&raw_v6_lock); 78} 79 80static void raw_v6_unhash(struct sock *sk) 81{ 82 write_lock_bh(&raw_v6_lock); 83 if (sk_del_node_init(sk)) 84 sock_prot_dec_use(sk->sk_prot); 85 write_unlock_bh(&raw_v6_lock); 86} 87 88 89/* Grumble... icmp and ip_input want to get at this... */ 90struct sock *__raw_v6_lookup(struct sock *sk, unsigned short num, 91 struct in6_addr *loc_addr, struct in6_addr *rmt_addr, 92 int dif) 93{ 94 struct hlist_node *node; 95 int is_multicast = ipv6_addr_is_multicast(loc_addr); 96 97 sk_for_each_from(sk, node) 98 if (inet_sk(sk)->num == num) { 99 struct ipv6_pinfo *np = inet6_sk(sk); 100 101 if (!ipv6_addr_any(&np->daddr) && 102 !ipv6_addr_equal(&np->daddr, rmt_addr)) 103 continue; 104 105 if (sk->sk_bound_dev_if && sk->sk_bound_dev_if != dif) 106 continue; 107 108 if (!ipv6_addr_any(&np->rcv_saddr)) { 109 if (ipv6_addr_equal(&np->rcv_saddr, loc_addr)) 110 goto found; 111 if (is_multicast && 112 inet6_mc_check(sk, loc_addr, rmt_addr)) 113 goto found; 114 continue; 115 } 116 goto found; 117 } 118 sk = NULL; 119found: 120 return sk; 121} 122 123/* 124 * 0 - deliver 125 * 1 - block 126 */ 127static __inline__ int icmpv6_filter(struct sock *sk, struct sk_buff *skb) 128{ 129 struct icmp6hdr *icmph; 130 struct raw6_sock *rp = raw6_sk(sk); 131 132 if (pskb_may_pull(skb, sizeof(struct icmp6hdr))) { 133 __u32 *data = &rp->filter.data[0]; 134 int bit_nr; 135 136 icmph = (struct icmp6hdr *) skb->data; 137 bit_nr = icmph->icmp6_type; 138 139 return (data[bit_nr >> 5] & (1 << (bit_nr & 31))) != 0; 140 } 141 return 0; 142} 143 144/* 145 * demultiplex raw sockets. 146 * (should consider queueing the skb in the sock receive_queue 147 * without calling rawv6.c) 148 * 149 * Caller owns SKB so we must make clones. 150 */ 151int ipv6_raw_deliver(struct sk_buff *skb, int nexthdr) 152{ 153 struct in6_addr *saddr; 154 struct in6_addr *daddr; 155 struct sock *sk; 156 int delivered = 0; 157 __u8 hash; 158 159 saddr = &ipv6_hdr(skb)->saddr; 160 daddr = saddr + 1; 161 162 hash = nexthdr & (MAX_INET_PROTOS - 1); 163 164 read_lock(&raw_v6_lock); 165 sk = sk_head(&raw_v6_htable[hash]); 166 167 /* 168 * The first socket found will be delivered after 169 * delivery to transport protocols. 170 */ 171 172 if (sk == NULL) 173 goto out; 174 175 sk = __raw_v6_lookup(sk, nexthdr, daddr, saddr, IP6CB(skb)->iif); 176 177 while (sk) { 178 int filtered; 179 180 delivered = 1; 181 switch (nexthdr) { 182 case IPPROTO_ICMPV6: 183 filtered = icmpv6_filter(sk, skb); 184 break; 185#ifdef CONFIG_IPV6_MIP6 186 case IPPROTO_MH: 187 filtered = mip6_mh_filter(sk, skb); 188 break; 189#endif 190 default: 191 filtered = 0; 192 break; 193 } 194 195 if (filtered < 0) 196 break; 197 if (filtered == 0) { 198 struct sk_buff *clone = skb_clone(skb, GFP_ATOMIC); 199 200 /* Not releasing hash table! */ 201 if (clone) { 202 nf_reset(clone); 203 rawv6_rcv(sk, clone); 204 } 205 } 206 sk = __raw_v6_lookup(sk_next(sk), nexthdr, daddr, saddr, 207 IP6CB(skb)->iif); 208 } 209out: 210 read_unlock(&raw_v6_lock); 211 return delivered; 212} 213 214/* This cleans up af_inet6 a bit. -DaveM */ 215static int rawv6_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len) 216{ 217 struct inet_sock *inet = inet_sk(sk); 218 struct ipv6_pinfo *np = inet6_sk(sk); 219 struct sockaddr_in6 *addr = (struct sockaddr_in6 *) uaddr; 220 __be32 v4addr = 0; 221 int addr_type; 222 int err; 223 224 if (addr_len < SIN6_LEN_RFC2133) 225 return -EINVAL; 226 addr_type = ipv6_addr_type(&addr->sin6_addr); 227 228 /* Raw sockets are IPv6 only */ 229 if (addr_type == IPV6_ADDR_MAPPED) 230 return(-EADDRNOTAVAIL); 231 232 lock_sock(sk); 233 234 err = -EINVAL; 235 if (sk->sk_state != TCP_CLOSE) 236 goto out; 237 238 /* Check if the address belongs to the host. */ 239 if (addr_type != IPV6_ADDR_ANY) { 240 struct net_device *dev = NULL; 241 242 if (addr_type & IPV6_ADDR_LINKLOCAL) { 243 if (addr_len >= sizeof(struct sockaddr_in6) && 244 addr->sin6_scope_id) { 245 /* Override any existing binding, if another 246 * one is supplied by user. 247 */ 248 sk->sk_bound_dev_if = addr->sin6_scope_id; 249 } 250 251 /* Binding to link-local address requires an interface */ 252 if (!sk->sk_bound_dev_if) 253 goto out; 254 255 dev = dev_get_by_index(sk->sk_bound_dev_if); 256 if (!dev) { 257 err = -ENODEV; 258 goto out; 259 } 260 } 261 262 /* ipv4 addr of the socket is invalid. Only the 263 * unspecified and mapped address have a v4 equivalent. 264 */ 265 v4addr = LOOPBACK4_IPV6; 266 if (!(addr_type & IPV6_ADDR_MULTICAST)) { 267 err = -EADDRNOTAVAIL; 268 if (!ipv6_chk_addr(&addr->sin6_addr, dev, 0)) { 269 if (dev) 270 dev_put(dev); 271 goto out; 272 } 273 } 274 if (dev) 275 dev_put(dev); 276 } 277 278 inet->rcv_saddr = inet->saddr = v4addr; 279 ipv6_addr_copy(&np->rcv_saddr, &addr->sin6_addr); 280 if (!(addr_type & IPV6_ADDR_MULTICAST)) 281 ipv6_addr_copy(&np->saddr, &addr->sin6_addr); 282 err = 0; 283out: 284 release_sock(sk); 285 return err; 286} 287 288void rawv6_err(struct sock *sk, struct sk_buff *skb, 289 struct inet6_skb_parm *opt, 290 int type, int code, int offset, __be32 info) 291{ 292 struct inet_sock *inet = inet_sk(sk); 293 struct ipv6_pinfo *np = inet6_sk(sk); 294 int err; 295 int harderr; 296 297 /* Report error on raw socket, if: 298 1. User requested recverr. 299 2. Socket is connected (otherwise the error indication 300 is useless without recverr and error is hard. 301 */ 302 if (!np->recverr && sk->sk_state != TCP_ESTABLISHED) 303 return; 304 305 harderr = icmpv6_err_convert(type, code, &err); 306 if (type == ICMPV6_PKT_TOOBIG) 307 harderr = (np->pmtudisc == IPV6_PMTUDISC_DO); 308 309 if (np->recverr) { 310 u8 *payload = skb->data; 311 if (!inet->hdrincl) 312 payload += offset; 313 ipv6_icmp_error(sk, skb, err, 0, ntohl(info), payload); 314 } 315 316 if (np->recverr || harderr) { 317 sk->sk_err = err; 318 sk->sk_error_report(sk); 319 } 320} 321 322static inline int rawv6_rcv_skb(struct sock * sk, struct sk_buff * skb) 323{ 324 if ((raw6_sk(sk)->checksum || sk->sk_filter) && 325 skb_checksum_complete(skb)) { 326 kfree_skb(skb); 327 return 0; 328 } 329 330 /* Charge it to the socket. */ 331 if (sock_queue_rcv_skb(sk,skb)<0) { 332 kfree_skb(skb); 333 return 0; 334 } 335 336 return 0; 337} 338 339/* 340 * This is next to useless... 341 * if we demultiplex in network layer we don't need the extra call 342 * just to queue the skb... 343 * maybe we could have the network decide upon a hint if it 344 * should call raw_rcv for demultiplexing 345 */ 346int rawv6_rcv(struct sock *sk, struct sk_buff *skb) 347{ 348 struct inet_sock *inet = inet_sk(sk); 349 struct raw6_sock *rp = raw6_sk(sk); 350 351 if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb)) { 352 kfree_skb(skb); 353 return NET_RX_DROP; 354 } 355 356 if (!rp->checksum) 357 skb->ip_summed = CHECKSUM_UNNECESSARY; 358 359 if (skb->ip_summed == CHECKSUM_COMPLETE) { 360 skb_postpull_rcsum(skb, skb_network_header(skb), 361 skb_network_header_len(skb)); 362 if (!csum_ipv6_magic(&ipv6_hdr(skb)->saddr, 363 &ipv6_hdr(skb)->daddr, 364 skb->len, inet->num, skb->csum)) 365 skb->ip_summed = CHECKSUM_UNNECESSARY; 366 } 367 if (!skb_csum_unnecessary(skb)) 368 skb->csum = ~csum_unfold(csum_ipv6_magic(&ipv6_hdr(skb)->saddr, 369 &ipv6_hdr(skb)->daddr, 370 skb->len, 371 inet->num, 0)); 372 373 if (inet->hdrincl) { 374 if (skb_checksum_complete(skb)) { 375 kfree_skb(skb); 376 return 0; 377 } 378 } 379 380 rawv6_rcv_skb(sk, skb); 381 return 0; 382} 383 384 385/* 386 * This should be easy, if there is something there 387 * we return it, otherwise we block. 388 */ 389 390static int rawv6_recvmsg(struct kiocb *iocb, struct sock *sk, 391 struct msghdr *msg, size_t len, 392 int noblock, int flags, int *addr_len) 393{ 394 struct ipv6_pinfo *np = inet6_sk(sk); 395 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)msg->msg_name; 396 struct sk_buff *skb; 397 size_t copied; 398 int err; 399 400 if (flags & MSG_OOB) 401 return -EOPNOTSUPP; 402 403 if (addr_len) 404 *addr_len=sizeof(*sin6); 405 406 if (flags & MSG_ERRQUEUE) 407 return ipv6_recv_error(sk, msg, len); 408 409 skb = skb_recv_datagram(sk, flags, noblock, &err); 410 if (!skb) 411 goto out; 412 413 copied = skb->len; 414 if (copied > len) { 415 copied = len; 416 msg->msg_flags |= MSG_TRUNC; 417 } 418 419 if (skb_csum_unnecessary(skb)) { 420 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied); 421 } else if (msg->msg_flags&MSG_TRUNC) { 422 if (__skb_checksum_complete(skb)) 423 goto csum_copy_err; 424 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied); 425 } else { 426 err = skb_copy_and_csum_datagram_iovec(skb, 0, msg->msg_iov); 427 if (err == -EINVAL) 428 goto csum_copy_err; 429 } 430 if (err) 431 goto out_free; 432 433 /* Copy the address. */ 434 if (sin6) { 435 sin6->sin6_family = AF_INET6; 436 sin6->sin6_port = 0; 437 ipv6_addr_copy(&sin6->sin6_addr, &ipv6_hdr(skb)->saddr); 438 sin6->sin6_flowinfo = 0; 439 sin6->sin6_scope_id = 0; 440 if (ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_LINKLOCAL) 441 sin6->sin6_scope_id = IP6CB(skb)->iif; 442 } 443 444 sock_recv_timestamp(msg, sk, skb); 445 446 if (np->rxopt.all) 447 datagram_recv_ctl(sk, msg, skb); 448 449 err = copied; 450 if (flags & MSG_TRUNC) 451 err = skb->len; 452 453out_free: 454 skb_free_datagram(sk, skb); 455out: 456 return err; 457 458csum_copy_err: 459 skb_kill_datagram(sk, skb, flags); 460 461 /* Error for blocking case is chosen to masquerade 462 as some normal condition. 463 */ 464 err = (flags&MSG_DONTWAIT) ? -EAGAIN : -EHOSTUNREACH; 465 goto out; 466} 467 468static int rawv6_push_pending_frames(struct sock *sk, struct flowi *fl, 469 struct raw6_sock *rp) 470{ 471 struct sk_buff *skb; 472 int err = 0; 473 int offset; 474 int len; 475 int total_len; 476 __wsum tmp_csum; 477 __sum16 csum; 478 479 if (!rp->checksum) 480 goto send; 481 482 if ((skb = skb_peek(&sk->sk_write_queue)) == NULL) 483 goto out; 484 485 offset = rp->offset; 486 total_len = inet_sk(sk)->cork.length - (skb_network_header(skb) - 487 skb->data); 488 if (offset >= total_len - 1) { 489 err = -EINVAL; 490 ip6_flush_pending_frames(sk); 491 goto out; 492 } 493 494 /* should be check HW csum miyazawa */ 495 if (skb_queue_len(&sk->sk_write_queue) == 1) { 496 /* 497 * Only one fragment on the socket. 498 */ 499 tmp_csum = skb->csum; 500 } else { 501 struct sk_buff *csum_skb = NULL; 502 tmp_csum = 0; 503 504 skb_queue_walk(&sk->sk_write_queue, skb) { 505 tmp_csum = csum_add(tmp_csum, skb->csum); 506 507 if (csum_skb) 508 continue; 509 510 len = skb->len - skb_transport_offset(skb); 511 if (offset >= len) { 512 offset -= len; 513 continue; 514 } 515 516 csum_skb = skb; 517 } 518 519 skb = csum_skb; 520 } 521 522 offset += skb_transport_offset(skb); 523 if (skb_copy_bits(skb, offset, &csum, 2)) 524 BUG(); 525 526 /* in case cksum was not initialized */ 527 if (unlikely(csum)) 528 tmp_csum = csum_sub(tmp_csum, csum_unfold(csum)); 529 530 csum = csum_ipv6_magic(&fl->fl6_src, 531 &fl->fl6_dst, 532 total_len, fl->proto, tmp_csum); 533 534 if (csum == 0 && fl->proto == IPPROTO_UDP) 535 csum = CSUM_MANGLED_0; 536 537 if (skb_store_bits(skb, offset, &csum, 2)) 538 BUG(); 539 540send: 541 err = ip6_push_pending_frames(sk); 542out: 543 return err; 544} 545 546static int rawv6_send_hdrinc(struct sock *sk, void *from, int length, 547 struct flowi *fl, struct rt6_info *rt, 548 unsigned int flags) 549{ 550 struct ipv6_pinfo *np = inet6_sk(sk); 551 struct ipv6hdr *iph; 552 struct sk_buff *skb; 553 unsigned int hh_len; 554 int err; 555 556 if (length > rt->u.dst.dev->mtu) { 557 ipv6_local_error(sk, EMSGSIZE, fl, rt->u.dst.dev->mtu); 558 return -EMSGSIZE; 559 } 560 if (flags&MSG_PROBE) 561 goto out; 562 563 hh_len = LL_RESERVED_SPACE(rt->u.dst.dev); 564 565 skb = sock_alloc_send_skb(sk, length+hh_len+15, 566 flags&MSG_DONTWAIT, &err); 567 if (skb == NULL) 568 goto error; 569 skb_reserve(skb, hh_len); 570 571 skb->priority = sk->sk_priority; 572 skb->dst = dst_clone(&rt->u.dst); 573 574 skb_put(skb, length); 575 skb_reset_network_header(skb); 576 iph = ipv6_hdr(skb); 577 578 skb->ip_summed = CHECKSUM_NONE; 579 580 skb->transport_header = skb->network_header; 581 err = memcpy_fromiovecend((void *)iph, from, 0, length); 582 if (err) 583 goto error_fault; 584 585 IP6_INC_STATS(rt->rt6i_idev, IPSTATS_MIB_OUTREQUESTS); 586 err = NF_HOOK(PF_INET6, NF_IP6_LOCAL_OUT, skb, NULL, rt->u.dst.dev, 587 dst_output); 588 if (err > 0) 589 err = np->recverr ? net_xmit_errno(err) : 0; 590 if (err) 591 goto error; 592out: 593 return 0; 594 595error_fault: 596 err = -EFAULT; 597 kfree_skb(skb); 598error: 599 IP6_INC_STATS(rt->rt6i_idev, IPSTATS_MIB_OUTDISCARDS); 600 return err; 601} 602 603static int rawv6_probe_proto_opt(struct flowi *fl, struct msghdr *msg) 604{ 605 struct iovec *iov; 606 u8 __user *type = NULL; 607 u8 __user *code = NULL; 608#ifdef CONFIG_IPV6_MIP6 609 u8 len = 0; 610#endif 611 int probed = 0; 612 int i; 613 614 if (!msg->msg_iov) 615 return 0; 616 617 for (i = 0; i < msg->msg_iovlen; i++) { 618 iov = &msg->msg_iov[i]; 619 if (!iov) 620 continue; 621 622 switch (fl->proto) { 623 case IPPROTO_ICMPV6: 624 /* check if one-byte field is readable or not. */ 625 if (iov->iov_base && iov->iov_len < 1) 626 break; 627 628 if (!type) { 629 type = iov->iov_base; 630 /* check if code field is readable or not. */ 631 if (iov->iov_len > 1) 632 code = type + 1; 633 } else if (!code) 634 code = iov->iov_base; 635 636 if (type && code) { 637 if (get_user(fl->fl_icmp_type, type) || 638 get_user(fl->fl_icmp_code, code)) 639 return -EFAULT; 640 probed = 1; 641 } 642 break; 643#ifdef CONFIG_IPV6_MIP6 644 case IPPROTO_MH: 645 if (iov->iov_base && iov->iov_len < 1) 646 break; 647 /* check if type field is readable or not. */ 648 if (iov->iov_len > 2 - len) { 649 u8 __user *p = iov->iov_base; 650 if (get_user(fl->fl_mh_type, &p[2 - len])) 651 return -EFAULT; 652 probed = 1; 653 } else 654 len += iov->iov_len; 655 656 break; 657#endif 658 default: 659 probed = 1; 660 break; 661 } 662 if (probed) 663 break; 664 } 665 return 0; 666} 667 668static int rawv6_sendmsg(struct kiocb *iocb, struct sock *sk, 669 struct msghdr *msg, size_t len) 670{ 671 struct ipv6_txoptions opt_space; 672 struct sockaddr_in6 * sin6 = (struct sockaddr_in6 *) msg->msg_name; 673 struct in6_addr *daddr, *final_p = NULL, final; 674 struct inet_sock *inet = inet_sk(sk); 675 struct ipv6_pinfo *np = inet6_sk(sk); 676 struct raw6_sock *rp = raw6_sk(sk); 677 struct ipv6_txoptions *opt = NULL; 678 struct ip6_flowlabel *flowlabel = NULL; 679 struct dst_entry *dst = NULL; 680 struct flowi fl; 681 int addr_len = msg->msg_namelen; 682 int hlimit = -1; 683 int tclass = -1; 684 u16 proto; 685 int err; 686 687 /* Rough check on arithmetic overflow, 688 better check is made in ip6_append_data(). 689 */ 690 if (len > INT_MAX) 691 return -EMSGSIZE; 692 693 /* Mirror BSD error message compatibility */ 694 if (msg->msg_flags & MSG_OOB) 695 return -EOPNOTSUPP; 696 697 /* 698 * Get and verify the address. 699 */ 700 memset(&fl, 0, sizeof(fl)); 701 702 if (sin6) { 703 if (addr_len < SIN6_LEN_RFC2133) 704 return -EINVAL; 705 706 if (sin6->sin6_family && sin6->sin6_family != AF_INET6) 707 return(-EAFNOSUPPORT); 708 709 /* port is the proto value [0..255] carried in nexthdr */ 710 proto = ntohs(sin6->sin6_port); 711 712 if (!proto) 713 proto = inet->num; 714 else if (proto != inet->num) 715 return(-EINVAL); 716 717 if (proto > 255) 718 return(-EINVAL); 719 720 daddr = &sin6->sin6_addr; 721 if (np->sndflow) { 722 fl.fl6_flowlabel = sin6->sin6_flowinfo&IPV6_FLOWINFO_MASK; 723 if (fl.fl6_flowlabel&IPV6_FLOWLABEL_MASK) { 724 flowlabel = fl6_sock_lookup(sk, fl.fl6_flowlabel); 725 if (flowlabel == NULL) 726 return -EINVAL; 727 daddr = &flowlabel->dst; 728 } 729 } 730 731 /* 732 * Otherwise it will be difficult to maintain 733 * sk->sk_dst_cache. 734 */ 735 if (sk->sk_state == TCP_ESTABLISHED && 736 ipv6_addr_equal(daddr, &np->daddr)) 737 daddr = &np->daddr; 738 739 if (addr_len >= sizeof(struct sockaddr_in6) && 740 sin6->sin6_scope_id) 741 //&& ipv6_addr_type(daddr)&IPV6_ADDR_LINKLOCAL) //Bob removed for ipv6ready conformance test 742 fl.oif = sin6->sin6_scope_id; 743 } else { 744 if (sk->sk_state != TCP_ESTABLISHED) 745 return -EDESTADDRREQ; 746 747 proto = inet->num; 748 daddr = &np->daddr; 749 fl.fl6_flowlabel = np->flow_label; 750 } 751 752 if (ipv6_addr_any(daddr)) { 753 /* 754 * unspecified destination address 755 * treated as error... is this correct ? 756 */ 757 fl6_sock_release(flowlabel); 758 return(-EINVAL); 759 } 760 761 if (fl.oif == 0) 762 fl.oif = sk->sk_bound_dev_if; 763 764 if (msg->msg_controllen) { 765 opt = &opt_space; 766 memset(opt, 0, sizeof(struct ipv6_txoptions)); 767 opt->tot_len = sizeof(struct ipv6_txoptions); 768 769 err = datagram_send_ctl(msg, &fl, opt, &hlimit, &tclass); 770 if (err < 0) { 771 fl6_sock_release(flowlabel); 772 return err; 773 } 774 if ((fl.fl6_flowlabel&IPV6_FLOWLABEL_MASK) && !flowlabel) { 775 flowlabel = fl6_sock_lookup(sk, fl.fl6_flowlabel); 776 if (flowlabel == NULL) 777 return -EINVAL; 778 } 779 if (!(opt->opt_nflen|opt->opt_flen)) 780 opt = NULL; 781 } 782 if (opt == NULL) 783 opt = np->opt; 784 if (flowlabel) 785 opt = fl6_merge_options(&opt_space, flowlabel, opt); 786 opt = ipv6_fixup_options(&opt_space, opt); 787 788 fl.proto = proto; 789 err = rawv6_probe_proto_opt(&fl, msg); 790 if (err) 791 goto out; 792 793 ipv6_addr_copy(&fl.fl6_dst, daddr); 794 if (ipv6_addr_any(&fl.fl6_src) && !ipv6_addr_any(&np->saddr)) 795 ipv6_addr_copy(&fl.fl6_src, &np->saddr); 796 797 /* merge ip6_build_xmit from ip6_output */ 798 if (opt && opt->srcrt) { 799 struct rt0_hdr *rt0 = (struct rt0_hdr *) opt->srcrt; 800 ipv6_addr_copy(&final, &fl.fl6_dst); 801 ipv6_addr_copy(&fl.fl6_dst, rt0->addr); 802 final_p = &final; 803 } 804 805 if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst)) 806 fl.oif = np->mcast_oif; 807 security_sk_classify_flow(sk, &fl); 808 809 err = ip6_dst_lookup(sk, &dst, &fl); 810 if (err) 811 goto out; 812 if (final_p) 813 ipv6_addr_copy(&fl.fl6_dst, final_p); 814 815 if ((err = __xfrm_lookup(&dst, &fl, sk, 1)) < 0) { 816 if (err == -EREMOTE) 817 err = ip6_dst_blackhole(sk, &dst, &fl); 818 if (err < 0) 819 goto out; 820 } 821 822 if (hlimit < 0) { 823 if (ipv6_addr_is_multicast(&fl.fl6_dst)) 824 hlimit = np->mcast_hops; 825 else 826 hlimit = np->hop_limit; 827 if (hlimit < 0) 828 hlimit = dst_metric(dst, RTAX_HOPLIMIT); 829 if (hlimit < 0) 830 hlimit = ipv6_get_hoplimit(dst->dev); 831 } 832 833 if (tclass < 0) { 834 tclass = np->tclass; 835 if (tclass < 0) 836 tclass = 0; 837 } 838 839 if (msg->msg_flags&MSG_CONFIRM) 840 goto do_confirm; 841 842back_from_confirm: 843 if (inet->hdrincl) { 844 err = rawv6_send_hdrinc(sk, msg->msg_iov, len, &fl, (struct rt6_info*)dst, msg->msg_flags); 845 } else { 846 lock_sock(sk); 847 err = ip6_append_data(sk, ip_generic_getfrag, msg->msg_iov, 848 len, 0, hlimit, tclass, opt, &fl, (struct rt6_info*)dst, 849 msg->msg_flags); 850 851 if (err) 852 ip6_flush_pending_frames(sk); 853 else if (!(msg->msg_flags & MSG_MORE)) 854 err = rawv6_push_pending_frames(sk, &fl, rp); 855 } 856done: 857 dst_release(dst); 858 if (!inet->hdrincl) 859 release_sock(sk); 860out: 861 fl6_sock_release(flowlabel); 862 return err<0?err:len; 863do_confirm: 864 dst_confirm(dst); 865 if (!(msg->msg_flags & MSG_PROBE) || len) 866 goto back_from_confirm; 867 err = 0; 868 goto done; 869} 870 871static int rawv6_seticmpfilter(struct sock *sk, int level, int optname, 872 char __user *optval, int optlen) 873{ 874 switch (optname) { 875 case ICMPV6_FILTER: 876 if (optlen > sizeof(struct icmp6_filter)) 877 optlen = sizeof(struct icmp6_filter); 878 if (copy_from_user(&raw6_sk(sk)->filter, optval, optlen)) 879 return -EFAULT; 880 return 0; 881 default: 882 return -ENOPROTOOPT; 883 } 884 885 return 0; 886} 887 888static int rawv6_geticmpfilter(struct sock *sk, int level, int optname, 889 char __user *optval, int __user *optlen) 890{ 891 int len; 892 893 switch (optname) { 894 case ICMPV6_FILTER: 895 if (get_user(len, optlen)) 896 return -EFAULT; 897 if (len < 0) 898 return -EINVAL; 899 if (len > sizeof(struct icmp6_filter)) 900 len = sizeof(struct icmp6_filter); 901 if (put_user(len, optlen)) 902 return -EFAULT; 903 if (copy_to_user(optval, &raw6_sk(sk)->filter, len)) 904 return -EFAULT; 905 return 0; 906 default: 907 return -ENOPROTOOPT; 908 } 909 910 return 0; 911} 912 913 914static int do_rawv6_setsockopt(struct sock *sk, int level, int optname, 915 char __user *optval, int optlen) 916{ 917 struct raw6_sock *rp = raw6_sk(sk); 918 int val; 919 920 if (get_user(val, (int __user *)optval)) 921 return -EFAULT; 922 923 switch (optname) { 924 case IPV6_CHECKSUM: 925 /* You may get strange result with a positive odd offset; 926 RFC2292bis agrees with me. */ 927 if (val > 0 && (val&1)) 928 return(-EINVAL); 929 if (val < 0) { 930 rp->checksum = 0; 931 } else { 932 rp->checksum = 1; 933 rp->offset = val; 934 } 935 936 return 0; 937 break; 938 939 default: 940 return(-ENOPROTOOPT); 941 } 942} 943 944static int rawv6_setsockopt(struct sock *sk, int level, int optname, 945 char __user *optval, int optlen) 946{ 947 switch(level) { 948 case SOL_RAW: 949 break; 950 951 case SOL_ICMPV6: 952 if (inet_sk(sk)->num != IPPROTO_ICMPV6) 953 return -EOPNOTSUPP; 954 return rawv6_seticmpfilter(sk, level, optname, optval, 955 optlen); 956 case SOL_IPV6: 957 if (optname == IPV6_CHECKSUM) 958 break; 959 default: 960 return ipv6_setsockopt(sk, level, optname, optval, 961 optlen); 962 } 963 964 return do_rawv6_setsockopt(sk, level, optname, optval, optlen); 965} 966 967#ifdef CONFIG_COMPAT 968static int compat_rawv6_setsockopt(struct sock *sk, int level, int optname, 969 char __user *optval, int optlen) 970{ 971 switch (level) { 972 case SOL_RAW: 973 break; 974 case SOL_ICMPV6: 975 if (inet_sk(sk)->num != IPPROTO_ICMPV6) 976 return -EOPNOTSUPP; 977 return rawv6_seticmpfilter(sk, level, optname, optval, optlen); 978 case SOL_IPV6: 979 if (optname == IPV6_CHECKSUM) 980 break; 981 default: 982 return compat_ipv6_setsockopt(sk, level, optname, 983 optval, optlen); 984 } 985 return do_rawv6_setsockopt(sk, level, optname, optval, optlen); 986} 987#endif 988 989static int do_rawv6_getsockopt(struct sock *sk, int level, int optname, 990 char __user *optval, int __user *optlen) 991{ 992 struct raw6_sock *rp = raw6_sk(sk); 993 int val, len; 994 995 if (get_user(len,optlen)) 996 return -EFAULT; 997 998 switch (optname) { 999 case IPV6_CHECKSUM: 1000 if (rp->checksum == 0) 1001 val = -1; 1002 else 1003 val = rp->offset; 1004 break; 1005 1006 default: 1007 return -ENOPROTOOPT; 1008 } 1009 1010 len = min_t(unsigned int, sizeof(int), len); 1011 1012 if (put_user(len, optlen)) 1013 return -EFAULT; 1014 if (copy_to_user(optval,&val,len)) 1015 return -EFAULT; 1016 return 0; 1017} 1018 1019static int rawv6_getsockopt(struct sock *sk, int level, int optname, 1020 char __user *optval, int __user *optlen) 1021{ 1022 switch(level) { 1023 case SOL_RAW: 1024 break; 1025 1026 case SOL_ICMPV6: 1027 if (inet_sk(sk)->num != IPPROTO_ICMPV6) 1028 return -EOPNOTSUPP; 1029 return rawv6_geticmpfilter(sk, level, optname, optval, 1030 optlen); 1031 case SOL_IPV6: 1032 if (optname == IPV6_CHECKSUM) 1033 break; 1034 default: 1035 return ipv6_getsockopt(sk, level, optname, optval, 1036 optlen); 1037 } 1038 1039 return do_rawv6_getsockopt(sk, level, optname, optval, optlen); 1040} 1041 1042#ifdef CONFIG_COMPAT 1043static int compat_rawv6_getsockopt(struct sock *sk, int level, int optname, 1044 char __user *optval, int __user *optlen) 1045{ 1046 switch (level) { 1047 case SOL_RAW: 1048 break; 1049 case SOL_ICMPV6: 1050 if (inet_sk(sk)->num != IPPROTO_ICMPV6) 1051 return -EOPNOTSUPP; 1052 return rawv6_geticmpfilter(sk, level, optname, optval, optlen); 1053 case SOL_IPV6: 1054 if (optname == IPV6_CHECKSUM) 1055 break; 1056 default: 1057 return compat_ipv6_getsockopt(sk, level, optname, 1058 optval, optlen); 1059 } 1060 return do_rawv6_getsockopt(sk, level, optname, optval, optlen); 1061} 1062#endif 1063 1064static int rawv6_ioctl(struct sock *sk, int cmd, unsigned long arg) 1065{ 1066 switch(cmd) { 1067 case SIOCOUTQ: 1068 { 1069 int amount = atomic_read(&sk->sk_wmem_alloc); 1070 return put_user(amount, (int __user *)arg); 1071 } 1072 case SIOCINQ: 1073 { 1074 struct sk_buff *skb; 1075 int amount = 0; 1076 1077 spin_lock_bh(&sk->sk_receive_queue.lock); 1078 skb = skb_peek(&sk->sk_receive_queue); 1079 if (skb != NULL) 1080 amount = skb->tail - skb->transport_header; 1081 spin_unlock_bh(&sk->sk_receive_queue.lock); 1082 return put_user(amount, (int __user *)arg); 1083 } 1084 1085 default: 1086#ifdef CONFIG_IPV6_MROUTE //foxconn 1087 return ip6mr_ioctl(sk,cmd,(void __user *)arg); 1088#endif 1089 return -ENOIOCTLCMD; 1090 } 1091} 1092 1093static void rawv6_close(struct sock *sk, long timeout) 1094{ 1095 if (inet_sk(sk)->num == IPPROTO_RAW) 1096 ip6_ra_control(sk, -1, NULL); 1097#ifdef CONFIG_IPV6_MROUTE //foxconn 1098 if (sk == mroute6_socket) { 1099 printk(KERN_DEBUG "closing mroute6 socket.\n"); 1100 ip6_ra_control(sk,-1,NULL); 1101 } 1102#endif 1103 sk_common_release(sk); 1104} 1105 1106static int rawv6_init_sk(struct sock *sk) 1107{ 1108 struct raw6_sock *rp = raw6_sk(sk); 1109 1110 switch (inet_sk(sk)->num) { 1111 case IPPROTO_ICMPV6: 1112 rp->checksum = 1; 1113 rp->offset = 2; 1114 break; 1115 case IPPROTO_MH: 1116 rp->checksum = 1; 1117 rp->offset = 4; 1118 break; 1119 default: 1120 break; 1121 } 1122 return(0); 1123} 1124 1125struct proto rawv6_prot = { 1126 .name = "RAWv6", 1127 .owner = THIS_MODULE, 1128 .close = rawv6_close, 1129 .connect = ip6_datagram_connect, 1130 .disconnect = udp_disconnect, 1131 .ioctl = rawv6_ioctl, 1132 .init = rawv6_init_sk, 1133 .destroy = inet6_destroy_sock, 1134 .setsockopt = rawv6_setsockopt, 1135 .getsockopt = rawv6_getsockopt, 1136 .sendmsg = rawv6_sendmsg, 1137 .recvmsg = rawv6_recvmsg, 1138 .bind = rawv6_bind, 1139 .backlog_rcv = rawv6_rcv_skb, 1140 .hash = raw_v6_hash, 1141 .unhash = raw_v6_unhash, 1142 .obj_size = sizeof(struct raw6_sock), 1143#ifdef CONFIG_COMPAT 1144 .compat_setsockopt = compat_rawv6_setsockopt, 1145 .compat_getsockopt = compat_rawv6_getsockopt, 1146#endif 1147}; 1148 1149#ifdef CONFIG_PROC_FS 1150struct raw6_iter_state { 1151 int bucket; 1152}; 1153 1154#define raw6_seq_private(seq) ((struct raw6_iter_state *)(seq)->private) 1155 1156static struct sock *raw6_get_first(struct seq_file *seq) 1157{ 1158 struct sock *sk; 1159 struct hlist_node *node; 1160 struct raw6_iter_state* state = raw6_seq_private(seq); 1161 1162 for (state->bucket = 0; state->bucket < RAWV6_HTABLE_SIZE; ++state->bucket) 1163 sk_for_each(sk, node, &raw_v6_htable[state->bucket]) 1164 if (sk->sk_family == PF_INET6) 1165 goto out; 1166 sk = NULL; 1167out: 1168 return sk; 1169} 1170 1171static struct sock *raw6_get_next(struct seq_file *seq, struct sock *sk) 1172{ 1173 struct raw6_iter_state* state = raw6_seq_private(seq); 1174 1175 do { 1176 sk = sk_next(sk); 1177try_again: 1178 ; 1179 } while (sk && sk->sk_family != PF_INET6); 1180 1181 if (!sk && ++state->bucket < RAWV6_HTABLE_SIZE) { 1182 sk = sk_head(&raw_v6_htable[state->bucket]); 1183 goto try_again; 1184 } 1185 return sk; 1186} 1187 1188static struct sock *raw6_get_idx(struct seq_file *seq, loff_t pos) 1189{ 1190 struct sock *sk = raw6_get_first(seq); 1191 if (sk) 1192 while (pos && (sk = raw6_get_next(seq, sk)) != NULL) 1193 --pos; 1194 return pos ? NULL : sk; 1195} 1196 1197static void *raw6_seq_start(struct seq_file *seq, loff_t *pos) 1198{ 1199 read_lock(&raw_v6_lock); 1200 return *pos ? raw6_get_idx(seq, *pos - 1) : SEQ_START_TOKEN; 1201} 1202 1203static void *raw6_seq_next(struct seq_file *seq, void *v, loff_t *pos) 1204{ 1205 struct sock *sk; 1206 1207 if (v == SEQ_START_TOKEN) 1208 sk = raw6_get_first(seq); 1209 else 1210 sk = raw6_get_next(seq, v); 1211 ++*pos; 1212 return sk; 1213} 1214 1215static void raw6_seq_stop(struct seq_file *seq, void *v) 1216{ 1217 read_unlock(&raw_v6_lock); 1218} 1219 1220static void raw6_sock_seq_show(struct seq_file *seq, struct sock *sp, int i) 1221{ 1222 struct ipv6_pinfo *np = inet6_sk(sp); 1223 struct in6_addr *dest, *src; 1224 __u16 destp, srcp; 1225 1226 dest = &np->daddr; 1227 src = &np->rcv_saddr; 1228 destp = 0; 1229 srcp = inet_sk(sp)->num; 1230 seq_printf(seq, 1231 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X " 1232 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %p\n", 1233 i, 1234 src->s6_addr32[0], src->s6_addr32[1], 1235 src->s6_addr32[2], src->s6_addr32[3], srcp, 1236 dest->s6_addr32[0], dest->s6_addr32[1], 1237 dest->s6_addr32[2], dest->s6_addr32[3], destp, 1238 sp->sk_state, 1239 atomic_read(&sp->sk_wmem_alloc), 1240 atomic_read(&sp->sk_rmem_alloc), 1241 0, 0L, 0, 1242 sock_i_uid(sp), 0, 1243 sock_i_ino(sp), 1244 atomic_read(&sp->sk_refcnt), sp); 1245} 1246 1247static int raw6_seq_show(struct seq_file *seq, void *v) 1248{ 1249 if (v == SEQ_START_TOKEN) 1250 seq_printf(seq, 1251 " sl " 1252 "local_address " 1253 "remote_address " 1254 "st tx_queue rx_queue tr tm->when retrnsmt" 1255 " uid timeout inode\n"); 1256 else 1257 raw6_sock_seq_show(seq, v, raw6_seq_private(seq)->bucket); 1258 return 0; 1259} 1260 1261static struct seq_operations raw6_seq_ops = { 1262 .start = raw6_seq_start, 1263 .next = raw6_seq_next, 1264 .stop = raw6_seq_stop, 1265 .show = raw6_seq_show, 1266}; 1267 1268static int raw6_seq_open(struct inode *inode, struct file *file) 1269{ 1270 struct seq_file *seq; 1271 int rc = -ENOMEM; 1272 struct raw6_iter_state *s = kzalloc(sizeof(*s), GFP_KERNEL); 1273 if (!s) 1274 goto out; 1275 rc = seq_open(file, &raw6_seq_ops); 1276 if (rc) 1277 goto out_kfree; 1278 seq = file->private_data; 1279 seq->private = s; 1280out: 1281 return rc; 1282out_kfree: 1283 kfree(s); 1284 goto out; 1285} 1286 1287static const struct file_operations raw6_seq_fops = { 1288 .owner = THIS_MODULE, 1289 .open = raw6_seq_open, 1290 .read = seq_read, 1291 .llseek = seq_lseek, 1292 .release = seq_release_private, 1293}; 1294 1295int __init raw6_proc_init(void) 1296{ 1297 if (!proc_net_fops_create("raw6", S_IRUGO, &raw6_seq_fops)) 1298 return -ENOMEM; 1299 return 0; 1300} 1301 1302void raw6_proc_exit(void) 1303{ 1304 proc_net_remove("raw6"); 1305} 1306#endif /* CONFIG_PROC_FS */ 1307