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.21 2000/11/28 13:42:08 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 = memcpy_toiovec(msg->msg_iov, skb->data, 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                                       __constant_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                 if (serr->ee.ee_origin == SO_EE_ORIGIN_ICMP6) {
 162                         memcpy(&sin->sin6_addr, &skb->nh.ipv6h->saddr, 16);
 163                         if (sk->net_pinfo.af_inet6.rxopt.all)
 164                                 datagram_recv_ctl(sk, msg, skb);
 165                         if (ipv6_addr_type(&sin->sin6_addr) & IPV6_ADDR_LINKLOCAL) {
 166                                 struct inet6_skb_parm *opt = (struct inet6_skb_parm *) skb->cb;
 167                                 sin->sin6_scope_id = opt->iif;
 168                         }
 169                 } else {
 170                         ipv6_addr_set(&sin->sin6_addr, 0, 0,
 171                                       __constant_htonl(0xffff),
 172                                       skb->nh.iph->saddr);
 173                         if (sk->protinfo.af_inet.cmsg_flags)
 174                                 ip_cmsg_recv(msg, skb);
 175                 }
 176         }
 177
 178         put_cmsg(msg, SOL_IPV6, IPV6_RECVERR, sizeof(errhdr), &errhdr);
 179
 180         /* Now we could try to dump offended packet options */
 181
 182         msg->msg_flags |= MSG_ERRQUEUE;
 183         err = copied;
 184
 185         /* Reset and regenerate socket error */
 186         spin_lock_irq(&sk->error_queue.lock);
 187         sk->err = 0;
 188         if ((skb2 = skb_peek(&sk->error_queue)) != NULL) {
 189                 sk->err = SKB_EXT_ERR(skb2)->ee.ee_errno;
 190                 spin_unlock_irq(&sk->error_queue.lock);
 191                 sk->error_report(sk);
 192         } else {
 193                 spin_unlock_irq(&sk->error_queue.lock);
 194         }
 195
 196 out_free_skb:
 197         kfree_skb(skb);
 198 out:
 199         return err;
 200 }
 201
 202
 203
 204 int datagram_recv_ctl(struct sock *sk, struct msghdr *msg, struct sk_buff *skb)
 205 {
 206         struct ipv6_pinfo *np = &sk->net_pinfo.af_inet6;
 207         struct inet6_skb_parm *opt = (struct inet6_skb_parm *) skb->cb;
 208
 209         if (np->rxopt.bits.rxinfo) {
 210                 struct in6_pktinfo src_info;
 211
 212                 src_info.ipi6_ifindex = opt->iif;
 213                 ipv6_addr_copy(&src_info.ipi6_addr, &skb->nh.ipv6h->daddr);
 214                 put_cmsg(msg, SOL_IPV6, IPV6_PKTINFO, sizeof(src_info), &src_info);
 215         }
 216
 217         if (np->rxopt.bits.rxhlim) {
 218                 int hlim = skb->nh.ipv6h->hop_limit;
 219                 put_cmsg(msg, SOL_IPV6, IPV6_HOPLIMIT, sizeof(hlim), &hlim);
 220         }
 221
 222         if (np->rxopt.bits.rxflow && (*(u32*)skb->nh.raw & IPV6_FLOWINFO_MASK)) {
 223                 u32 flowinfo = *(u32*)skb->nh.raw & IPV6_FLOWINFO_MASK;
 224                 put_cmsg(msg, SOL_IPV6, IPV6_FLOWINFO, sizeof(flowinfo), &flowinfo);
 225         }
 226         if (np->rxopt.bits.hopopts && opt->hop) {
 227                 u8 *ptr = skb->nh.raw + opt->hop;
 228                 put_cmsg(msg, SOL_IPV6, IPV6_HOPOPTS, (ptr[1]+1)<<3, ptr);
 229         }
 230         if (np->rxopt.bits.dstopts && opt->dst0) {
 231                 u8 *ptr = skb->nh.raw + opt->dst0;
 232                 put_cmsg(msg, SOL_IPV6, IPV6_DSTOPTS, (ptr[1]+1)<<3, ptr);
 233         }
 234         if (np->rxopt.bits.srcrt && opt->srcrt) {
 235                 struct ipv6_rt_hdr *rthdr = (struct ipv6_rt_hdr *)(skb->nh.raw + opt->srcrt);
 236                 put_cmsg(msg, SOL_IPV6, IPV6_RTHDR, (rthdr->hdrlen+1) << 3, rthdr);
 237         }
 238         if (np->rxopt.bits.authhdr && opt->auth) {
 239                 u8 *ptr = skb->nh.raw + opt->auth;
 240                 put_cmsg(msg, SOL_IPV6, IPV6_AUTHHDR, (ptr[1]+1)<<2, ptr);
 241         }
 242         if (np->rxopt.bits.dstopts && opt->dst1) {
 243                 u8 *ptr = skb->nh.raw + opt->dst1;
 244                 put_cmsg(msg, SOL_IPV6, IPV6_DSTOPTS, (ptr[1]+1)<<3, ptr);
 245         }
 246         return 0;
 247 }
 248
 249 int datagram_send_ctl(struct msghdr *msg, struct flowi *fl,
 250                       struct ipv6_txoptions *opt,
 251                       int *hlimit)
 252 {
 253         struct in6_pktinfo *src_info;
 254         struct cmsghdr *cmsg;
 255         struct ipv6_rt_hdr *rthdr;
 256         struct ipv6_opt_hdr *hdr;
 257         int len;
 258         int err = 0;
 259
 260         for (cmsg = CMSG_FIRSTHDR(msg); cmsg; cmsg = CMSG_NXTHDR(msg, cmsg)) {
 261
 262                 if (cmsg->cmsg_len < sizeof(struct cmsghdr) ||
 263                     (unsigned long)(((char*)cmsg - (char*)msg->msg_control)
 264                                     + cmsg->cmsg_len) > msg->msg_controllen) {
 265                         err = -EINVAL;
 266                         goto exit_f;
 267                 }
 268
 269                 if (cmsg->cmsg_level != SOL_IPV6)
 270                         continue;
 271
 272                 switch (cmsg->cmsg_type) {
 273                 case IPV6_PKTINFO:
 274                         if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct in6_pktinfo))) {
 275                                 err = -EINVAL;
 276                                 goto exit_f;
 277                         }
 278
 279                         src_info = (struct in6_pktinfo *)CMSG_DATA(cmsg);
 280
 281                         if (src_info->ipi6_ifindex) {
 282                                 if (fl->oif && src_info->ipi6_ifindex != fl->oif)
 283                                         return -EINVAL;
 284                                 fl->oif = src_info->ipi6_ifindex;
 285                         }
 286
 287                         if (!ipv6_addr_any(&src_info->ipi6_addr)) {
 288                                 if (!ipv6_chk_addr(&src_info->ipi6_addr, NULL)) {
 289                                         err = -EINVAL;
 290                                         goto exit_f;
 291                                 }
 292
 293                                 fl->fl6_src = &src_info->ipi6_addr;
 294                         }
 295
 296                         break;
 297
 298                 case IPV6_FLOWINFO:
 299                         if (cmsg->cmsg_len < CMSG_LEN(4)) {
 300                                 err = -EINVAL;
 301                                 goto exit_f;
 302                         }
 303
 304                         if (fl->fl6_flowlabel&IPV6_FLOWINFO_MASK) {
 305                                 if ((fl->fl6_flowlabel^*(u32 *)CMSG_DATA(cmsg))&~IPV6_FLOWINFO_MASK) {
 306                                         err = -EINVAL;
 307                                         goto exit_f;
 308                                 }
 309                         }
 310                         fl->fl6_flowlabel = IPV6_FLOWINFO_MASK & *(u32 *)CMSG_DATA(cmsg);
 311                         break;
 312
 313                 case IPV6_HOPOPTS:
 314                         if (opt->hopopt || cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_opt_hdr))) {
 315                                 err = -EINVAL;
 316                                 goto exit_f;
 317                         }
 318
 319                         hdr = (struct ipv6_opt_hdr *)CMSG_DATA(cmsg);
 320                         len = ((hdr->hdrlen + 1) << 3);
 321                         if (cmsg->cmsg_len < CMSG_LEN(len)) {
 322                                 err = -EINVAL;
 323                                 goto exit_f;
 324                         }
 325                         if (!capable(CAP_NET_RAW)) {
 326                                 err = -EPERM;
 327                                 goto exit_f;
 328                         }
 329                         opt->opt_nflen += len;
 330                         opt->hopopt = hdr;
 331                         break;
 332
 333                 case IPV6_DSTOPTS:
 334                         if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_opt_hdr))) {
 335                                 err = -EINVAL;
 336                                 goto exit_f;
 337                         }
 338
 339                         hdr = (struct ipv6_opt_hdr *)CMSG_DATA(cmsg);
 340                         len = ((hdr->hdrlen + 1) << 3);
 341                         if (cmsg->cmsg_len < CMSG_LEN(len)) {
 342                                 err = -EINVAL;
 343                                 goto exit_f;
 344                         }
 345                         if (!capable(CAP_NET_RAW)) {
 346                                 err = -EPERM;
 347                                 goto exit_f;
 348                         }
 349                         if (opt->dst1opt) {
 350                                 err = -EINVAL;
 351                                 goto exit_f;
 352                         }
 353                         opt->opt_flen += len;
 354                         opt->dst1opt = hdr;
 355                         break;
 356
 357                 case IPV6_AUTHHDR:
 358                         if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_opt_hdr))) {
 359                                 err = -EINVAL;
 360                                 goto exit_f;
 361                         }
 362
 363                         hdr = (struct ipv6_opt_hdr *)CMSG_DATA(cmsg);
 364                         len = ((hdr->hdrlen + 2) << 2);
 365                         if (cmsg->cmsg_len < CMSG_LEN(len)) {
 366                                 err = -EINVAL;
 367                                 goto exit_f;
 368                         }
 369                         if (len & ~7) {
 370                                 err = -EINVAL;
 371                                 goto exit_f;
 372                         }
 373                         opt->opt_flen += len;
 374                         opt->auth = hdr;
 375                         break;
 376
 377                 case IPV6_RTHDR:
 378                         if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_rt_hdr))) {
 379                                 err = -EINVAL;
 380                                 goto exit_f;
 381                         }
 382
 383                         rthdr = (struct ipv6_rt_hdr *)CMSG_DATA(cmsg);
 384
 385                         /*
 386                          *      TYPE 0
 387                          */
 388                         if (rthdr->type) {
 389                                 err = -EINVAL;
 390                                 goto exit_f;
 391                         }
 392
 393                         len = ((rthdr->hdrlen + 1) << 3);
 394
 395                         if (cmsg->cmsg_len < CMSG_LEN(len)) {
 396                                 err = -EINVAL;
 397                                 goto exit_f;
 398                         }
 399
 400                         /* segments left must also match */
 401                         if ((rthdr->hdrlen >> 1) != rthdr->segments_left) {
 402                                 err = -EINVAL;
 403                                 goto exit_f;
 404                         }
 405
 406                         opt->opt_nflen += len;
 407                         opt->srcrt = rthdr;
 408
 409                         if (opt->dst1opt) {
 410                                 int dsthdrlen = ((opt->dst1opt->hdrlen+1)<<3);
 411
 412                                 opt->opt_nflen += dsthdrlen;
 413                                 opt->dst0opt = opt->dst1opt;
 414                                 opt->dst1opt = NULL;
 415                                 opt->opt_flen -= dsthdrlen;
 416                         }
 417
 418                         break;
 419
 420                 case IPV6_HOPLIMIT:
 421                         if (cmsg->cmsg_len != CMSG_LEN(sizeof(int))) {
 422                                 err = -EINVAL;
 423                                 goto exit_f;
 424                         }
 425
 426                         *hlimit = *(int *)CMSG_DATA(cmsg);
 427                         break;
 428
 429                 default:
 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 }