net/ipv6/datagram.c

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