net/ipv6/datagram.c

   1 /*
   2  *      common UDP/RAW code
   3  *      Linux INET6 implementation
   4  *
   5  *      Authors:
   6  *      Pedro Roque             <roque@di.fc.ul.pt>
   7  *
   8  *      $Id: datagram.c,v 1.24 2002/02/01 22:01:04 davem Exp $
   9  *
  10  *      This program is free software; you can redistribute it and/or
  11  *      modify it under the terms of the GNU General Public License
  12  *      as published by the Free Software Foundation; either version
  13  *      2 of the License, or (at your option) any later version.
  14  */
  15
  16 #include <linux/errno.h>
  17 #include <linux/types.h>
  18 #include <linux/kernel.h>
  19 #include <linux/sched.h>
  20 #include <linux/interrupt.h>
  21 #include <linux/socket.h>
  22 #include <linux/sockios.h>
  23 #include <linux/in6.h>
  24 #include <linux/ipv6.h>
  25 #include <linux/route.h>
  26
  27 #include <net/ipv6.h>
  28 #include <net/ndisc.h>
  29 #include <net/addrconf.h>
  30 #include <net/transp_v6.h>
  31
  32 #include <linux/errqueue.h>
  33 #include <asm/uaccess.h>
  34
  35 void ipv6_icmp_error(struct sock *sk, struct sk_buff *skb, int err,
  36                      u16 port, u32 info, u8 *payload)
  37 {
  38         struct ipv6_pinfo *np  = inet6_sk(sk);
  39         struct icmp6hdr *icmph = (struct icmp6hdr *)skb->h.raw;
  40         struct sock_exterr_skb *serr;
  41
  42         if (!np->recverr)
  43                 return;
  44
  45         skb = skb_clone(skb, GFP_ATOMIC);
  46         if (!skb)
  47                 return;
  48
  49         serr = SKB_EXT_ERR(skb);
  50         serr->ee.ee_errno = err;
  51         serr->ee.ee_origin = SO_EE_ORIGIN_ICMP6;
  52         serr->ee.ee_type = icmph->icmp6_type;
  53         serr->ee.ee_code = icmph->icmp6_code;
  54         serr->ee.ee_pad = 0;
  55         serr->ee.ee_info = info;
  56         serr->ee.ee_data = 0;
  57         serr->addr_offset = (u8*)&(((struct ipv6hdr*)(icmph+1))->daddr) - skb->nh.raw;
  58         serr->port = port;
  59
  60         skb->h.raw = payload;
  61         __skb_pull(skb, payload - skb->data);
  62
  63         if (sock_queue_err_skb(sk, skb))
  64                 kfree_skb(skb);
  65 }
  66
  67 void ipv6_local_error(struct sock *sk, int err, struct flowi *fl, u32 info)
  68 {
  69         struct ipv6_pinfo *np = inet6_sk(sk);
  70         struct sock_exterr_skb *serr;
  71         struct ipv6hdr *iph;
  72         struct sk_buff *skb;
  73
  74         if (!np->recverr)
  75                 return;
  76
  77         skb = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
  78         if (!skb)
  79                 return;
  80
  81         iph = (struct ipv6hdr*)skb_put(skb, sizeof(struct ipv6hdr));
  82         skb->nh.ipv6h = iph;
  83         ipv6_addr_copy(&iph->daddr, &fl->fl6_dst);
  84
  85         serr = SKB_EXT_ERR(skb);
  86         serr->ee.ee_errno = err;
  87         serr->ee.ee_origin = SO_EE_ORIGIN_LOCAL;
  88         serr->ee.ee_type = 0;
  89         serr->ee.ee_code = 0;
  90         serr->ee.ee_pad = 0;
  91         serr->ee.ee_info = info;
  92         serr->ee.ee_data = 0;
  93         serr->addr_offset = (u8*)&iph->daddr - skb->nh.raw;
  94         serr->port = fl->fl_ip_dport;
  95
  96         skb->h.raw = skb->tail;
  97         __skb_pull(skb, skb->tail - skb->data);
  98
  99         if (sock_queue_err_skb(sk, skb))
 100                 kfree_skb(skb);
 101 }
 102
 103 /*
 104  *      Handle MSG_ERRQUEUE
 105  */
 106 int ipv6_recv_error(struct sock *sk, struct msghdr *msg, int len)
 107 {
 108         struct ipv6_pinfo *np = inet6_sk(sk);
 109         struct sock_exterr_skb *serr;
 110         struct sk_buff *skb, *skb2;
 111         struct sockaddr_in6 *sin;
 112         struct {
 113                 struct sock_extended_err ee;
 114                 struct sockaddr_in6      offender;
 115         } errhdr;
 116         int err;
 117         int copied;
 118
 119         err = -EAGAIN;
 120         skb = skb_dequeue(&sk->sk_error_queue);
 121         if (skb == NULL)
 122                 goto out;
 123
 124         copied = skb->len;
 125         if (copied > len) {
 126                 msg->msg_flags |= MSG_TRUNC;
 127                 copied = len;
 128         }
 129         err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
 130         if (err)
 131                 goto out_free_skb;
 132
 133         sock_recv_timestamp(msg, sk, skb);
 134
 135         serr = SKB_EXT_ERR(skb);
 136
 137         sin = (struct sockaddr_in6 *)msg->msg_name;
 138         if (sin) {
 139                 sin->sin6_family = AF_INET6;
 140                 sin->sin6_flowinfo = 0;
 141                 sin->sin6_port = serr->port;
 142                 sin->sin6_scope_id = 0;
 143                 if (serr->ee.ee_origin == SO_EE_ORIGIN_ICMP6) {
 144                         ipv6_addr_copy(&sin->sin6_addr,
 145                           (struct in6_addr *)(skb->nh.raw + serr->addr_offset));
 146                         if (np->sndflow)
 147                                 sin->sin6_flowinfo = *(u32*)(skb->nh.raw + serr->addr_offset - 24) & IPV6_FLOWINFO_MASK;
 148                         if (ipv6_addr_type(&sin->sin6_addr) & IPV6_ADDR_LINKLOCAL)
 149                                 sin->sin6_scope_id = IP6CB(skb)->iif;
 150                 } else {
 151                         ipv6_addr_set(&sin->sin6_addr, 0, 0,
 152                                       htonl(0xffff),
 153                                       *(u32*)(skb->nh.raw + serr->addr_offset));
 154                 }
 155         }
 156
 157         memcpy(&errhdr.ee, &serr->ee, sizeof(struct sock_extended_err));
 158         sin = &errhdr.offender;
 159         sin->sin6_family = AF_UNSPEC;
 160         if (serr->ee.ee_origin != SO_EE_ORIGIN_LOCAL) {
 161                 sin->sin6_family = AF_INET6;
 162                 sin->sin6_flowinfo = 0;
 163                 sin->sin6_scope_id = 0;
 164                 if (serr->ee.ee_origin == SO_EE_ORIGIN_ICMP6) {
 165                         ipv6_addr_copy(&sin->sin6_addr, &skb->nh.ipv6h->saddr);
 166                         if (np->rxopt.all)
 167                                 datagram_recv_ctl(sk, msg, skb);
 168                         if (ipv6_addr_type(&sin->sin6_addr) & IPV6_ADDR_LINKLOCAL)
 169                                 sin->sin6_scope_id = IP6CB(skb)->iif;
 170                 } else {
 171                         struct inet_opt *inet = inet_sk(sk);
 172
 173                         ipv6_addr_set(&sin->sin6_addr, 0, 0,
 174                                       htonl(0xffff),
 175                                       skb->nh.iph->saddr);
 176                         if (inet->cmsg_flags)
 177                                 ip_cmsg_recv(msg, skb);
 178                 }
 179         }
 180
 181         put_cmsg(msg, SOL_IPV6, IPV6_RECVERR, sizeof(errhdr), &errhdr);
 182
 183         /* Now we could try to dump offended packet options */
 184
 185         msg->msg_flags |= MSG_ERRQUEUE;
 186         err = copied;
 187
 188         /* Reset and regenerate socket error */
 189         spin_lock_irq(&sk->sk_error_queue.lock);
 190         sk->sk_err = 0;
 191         if ((skb2 = skb_peek(&sk->sk_error_queue)) != NULL) {
 192                 sk->sk_err = SKB_EXT_ERR(skb2)->ee.ee_errno;
 193                 spin_unlock_irq(&sk->sk_error_queue.lock);
 194                 sk->sk_error_report(sk);
 195         } else {
 196                 spin_unlock_irq(&sk->sk_error_queue.lock);
 197         }
 198
 199 out_free_skb:
 200         kfree_skb(skb);
 201 out:
 202         return err;
 203 }
 204
 205
 206
 207 int datagram_recv_ctl(struct sock *sk, struct msghdr *msg, struct sk_buff *skb)
 208 {
 209         struct ipv6_pinfo *np = inet6_sk(sk);
 210         struct inet6_skb_parm *opt = IP6CB(skb);
 211
 212         if (np->rxopt.bits.rxinfo) {
 213                 struct in6_pktinfo src_info;
 214
 215                 src_info.ipi6_ifindex = opt->iif;
 216                 ipv6_addr_copy(&src_info.ipi6_addr, &skb->nh.ipv6h->daddr);
 217                 put_cmsg(msg, SOL_IPV6, IPV6_PKTINFO, sizeof(src_info), &src_info);
 218         }
 219
 220         if (np->rxopt.bits.rxhlim) {
 221                 int hlim = skb->nh.ipv6h->hop_limit;
 222                 put_cmsg(msg, SOL_IPV6, IPV6_HOPLIMIT, sizeof(hlim), &hlim);
 223         }
 224
 225         if (np->rxopt.bits.rxflow && (*(u32*)skb->nh.raw & IPV6_FLOWINFO_MASK)) {
 226                 u32 flowinfo = *(u32*)skb->nh.raw & IPV6_FLOWINFO_MASK;
 227                 put_cmsg(msg, SOL_IPV6, IPV6_FLOWINFO, sizeof(flowinfo), &flowinfo);
 228         }
 229         if (np->rxopt.bits.hopopts && opt->hop) {
 230                 u8 *ptr = skb->nh.raw + opt->hop;
 231                 put_cmsg(msg, SOL_IPV6, IPV6_HOPOPTS, (ptr[1]+1)<<3, ptr);
 232         }
 233         if (np->rxopt.bits.dstopts && opt->dst0) {
 234                 u8 *ptr = skb->nh.raw + opt->dst0;
 235                 put_cmsg(msg, SOL_IPV6, IPV6_DSTOPTS, (ptr[1]+1)<<3, ptr);
 236         }
 237         if (np->rxopt.bits.srcrt && opt->srcrt) {
 238                 struct ipv6_rt_hdr *rthdr = (struct ipv6_rt_hdr *)(skb->nh.raw + opt->srcrt);
 239                 put_cmsg(msg, SOL_IPV6, IPV6_RTHDR, (rthdr->hdrlen+1) << 3, rthdr);
 240         }
 241         if (np->rxopt.bits.dstopts && opt->dst1) {
 242                 u8 *ptr = skb->nh.raw + opt->dst1;
 243                 put_cmsg(msg, SOL_IPV6, IPV6_DSTOPTS, (ptr[1]+1)<<3, ptr);
 244         }
 245         return 0;
 246 }
 247
 248 int datagram_send_ctl(struct msghdr *msg, struct flowi *fl,
 249                       struct ipv6_txoptions *opt,
 250                       int *hlimit)
 251 {
 252         struct in6_pktinfo *src_info;
 253         struct cmsghdr *cmsg;
 254         struct ipv6_rt_hdr *rthdr;
 255         struct ipv6_opt_hdr *hdr;
 256         int len;
 257         int err = 0;
 258
 259         for (cmsg = CMSG_FIRSTHDR(msg); cmsg; cmsg = CMSG_NXTHDR(msg, cmsg)) {
 260                 int addr_type;
 261                 struct net_device *dev = NULL;
 262
 263                 if (cmsg->cmsg_len < sizeof(struct cmsghdr) ||
 264                     (unsigned long)(((char*)cmsg - (char*)msg->msg_control)
 265                                     + cmsg->cmsg_len) > msg->msg_controllen) {
 266                         err = -EINVAL;
 267                         goto exit_f;
 268                 }
 269
 270                 if (cmsg->cmsg_level != SOL_IPV6)
 271                         continue;
 272
 273                 switch (cmsg->cmsg_type) {
 274                 case IPV6_PKTINFO:
 275                         if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct in6_pktinfo))) {
 276                                 err = -EINVAL;
 277                                 goto exit_f;
 278                         }
 279
 280                         src_info = (struct in6_pktinfo *)CMSG_DATA(cmsg);
 281
 282                         if (src_info->ipi6_ifindex) {
 283                                 if (fl->oif && src_info->ipi6_ifindex != fl->oif)
 284                                         return -EINVAL;
 285                                 fl->oif = src_info->ipi6_ifindex;
 286                         }
 287
 288                         addr_type = ipv6_addr_type(&src_info->ipi6_addr);
 289
 290                         if (addr_type == IPV6_ADDR_ANY)
 291                                 break;
 292
 293                         if (addr_type & IPV6_ADDR_LINKLOCAL) {
 294                                 if (!src_info->ipi6_ifindex)
 295                                         return -EINVAL;
 296                                 else {
 297                                         dev = dev_get_by_index(src_info->ipi6_ifindex);
 298                                         if (!dev)
 299                                                 return -ENODEV;
 300                                 }
 301                         }
 302                         if (!ipv6_chk_addr(&src_info->ipi6_addr, dev, 0)) {
 303                                 if (dev)
 304                                         dev_put(dev);
 305                                 err = -EINVAL;
 306                                 goto exit_f;
 307                         }
 308                         if (dev)
 309                                 dev_put(dev);
 310
 311                         ipv6_addr_copy(&fl->fl6_src, &src_info->ipi6_addr);
 312                         break;
 313
 314                 case IPV6_FLOWINFO:
 315                         if (cmsg->cmsg_len < CMSG_LEN(4)) {
 316                                 err = -EINVAL;
 317                                 goto exit_f;
 318                         }
 319
 320                         if (fl->fl6_flowlabel&IPV6_FLOWINFO_MASK) {
 321                                 if ((fl->fl6_flowlabel^*(u32 *)CMSG_DATA(cmsg))&~IPV6_FLOWINFO_MASK) {
 322                                         err = -EINVAL;
 323                                         goto exit_f;
 324                                 }
 325                         }
 326                         fl->fl6_flowlabel = IPV6_FLOWINFO_MASK & *(u32 *)CMSG_DATA(cmsg);
 327                         break;
 328
 329                 case IPV6_HOPOPTS:
 330                         if (opt->hopopt || cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_opt_hdr))) {
 331                                 err = -EINVAL;
 332                                 goto exit_f;
 333                         }
 334
 335                         hdr = (struct ipv6_opt_hdr *)CMSG_DATA(cmsg);
 336                         len = ((hdr->hdrlen + 1) << 3);
 337                         if (cmsg->cmsg_len < CMSG_LEN(len)) {
 338                                 err = -EINVAL;
 339                                 goto exit_f;
 340                         }
 341                         if (!capable(CAP_NET_RAW)) {
 342                                 err = -EPERM;
 343                                 goto exit_f;
 344                         }
 345                         opt->opt_nflen += len;
 346                         opt->hopopt = hdr;
 347                         break;
 348
 349                 case IPV6_DSTOPTS:
 350                         if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_opt_hdr))) {
 351                                 err = -EINVAL;
 352                                 goto exit_f;
 353                         }
 354
 355                         hdr = (struct ipv6_opt_hdr *)CMSG_DATA(cmsg);
 356                         len = ((hdr->hdrlen + 1) << 3);
 357                         if (cmsg->cmsg_len < CMSG_LEN(len)) {
 358                                 err = -EINVAL;
 359                                 goto exit_f;
 360                         }
 361                         if (!capable(CAP_NET_RAW)) {
 362                                 err = -EPERM;
 363                                 goto exit_f;
 364                         }
 365                         if (opt->dst1opt) {
 366                                 err = -EINVAL;
 367                                 goto exit_f;
 368                         }
 369                         opt->opt_flen += len;
 370                         opt->dst1opt = hdr;
 371                         break;
 372
 373                 case IPV6_RTHDR:
 374                         if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_rt_hdr))) {
 375                                 err = -EINVAL;
 376                                 goto exit_f;
 377                         }
 378
 379                         rthdr = (struct ipv6_rt_hdr *)CMSG_DATA(cmsg);
 380
 381                         /*
 382                          *      TYPE 0
 383                          */
 384                         if (rthdr->type) {
 385                                 err = -EINVAL;
 386                                 goto exit_f;
 387                         }
 388
 389                         len = ((rthdr->hdrlen + 1) << 3);
 390
 391                         if (cmsg->cmsg_len < CMSG_LEN(len)) {
 392                                 err = -EINVAL;
 393                                 goto exit_f;
 394                         }
 395
 396                         /* segments left must also match */
 397                         if ((rthdr->hdrlen >> 1) != rthdr->segments_left) {
 398                                 err = -EINVAL;
 399                                 goto exit_f;
 400                         }
 401
 402                         opt->opt_nflen += len;
 403                         opt->srcrt = rthdr;
 404
 405                         if (opt->dst1opt) {
 406                                 int dsthdrlen = ((opt->dst1opt->hdrlen+1)<<3);
 407
 408                                 opt->opt_nflen += dsthdrlen;
 409                                 opt->dst0opt = opt->dst1opt;
 410                                 opt->dst1opt = NULL;
 411                                 opt->opt_flen -= dsthdrlen;
 412                         }
 413
 414                         break;
 415
 416                 case IPV6_HOPLIMIT:
 417                         if (cmsg->cmsg_len != CMSG_LEN(sizeof(int))) {
 418                                 err = -EINVAL;
 419                                 goto exit_f;
 420                         }
 421
 422                         *hlimit = *(int *)CMSG_DATA(cmsg);
 423                         break;
 424
 425                 default:
 426                         LIMIT_NETDEBUG(
 427                                 printk(KERN_DEBUG "invalid cmsg type: %d\n", cmsg->cmsg_type));
 428                         err = -EINVAL;
 429                         break;
 430                 };
 431         }
 432
 433 exit_f:
 434         return err;
 435 }