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.1.1.1 2005/04/11 02:51:13 jack 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->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                         if (!ipv6_addr_any(&src_info->ipi6_addr)) {
 289                                 if (!ipv6_chk_addr(&src_info->ipi6_addr, NULL)) {
 290                                         err = -EINVAL;
 291                                         goto exit_f;
 292                                 }
 293
 294                                 fl->fl6_src = &src_info->ipi6_addr;
 295                         }
 296
 297                         break;
 298
 299                 case IPV6_FLOWINFO:
 300                         if (cmsg->cmsg_len < CMSG_LEN(4)) {
 301                                 err = -EINVAL;
 302                                 goto exit_f;
 303                         }
 304
 305                         if (fl->fl6_flowlabel&IPV6_FLOWINFO_MASK) {
 306                                 if ((fl->fl6_flowlabel^*(u32 *)CMSG_DATA(cmsg))&~IPV6_FLOWINFO_MASK) {
 307                                         err = -EINVAL;
 308                                         goto exit_f;
 309                                 }
 310                         }
 311                         fl->fl6_flowlabel = IPV6_FLOWINFO_MASK & *(u32 *)CMSG_DATA(cmsg);
 312                         break;
 313
 314                 case IPV6_HOPOPTS:
 315                         if (opt->hopopt || cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_opt_hdr))) {
 316                                 err = -EINVAL;
 317                                 goto exit_f;
 318                         }
 319
 320                         hdr = (struct ipv6_opt_hdr *)CMSG_DATA(cmsg);
 321                         len = ((hdr->hdrlen + 1) << 3);
 322                         if (cmsg->cmsg_len < CMSG_LEN(len)) {
 323                                 err = -EINVAL;
 324                                 goto exit_f;
 325                         }
 326                         if (!capable(CAP_NET_RAW)) {
 327                                 err = -EPERM;
 328                                 goto exit_f;
 329                         }
 330                         opt->opt_nflen += len;
 331                         opt->hopopt = hdr;
 332                         break;
 333
 334                 case IPV6_DSTOPTS:
 335                         if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_opt_hdr))) {
 336                                 err = -EINVAL;
 337                                 goto exit_f;
 338                         }
 339
 340                         hdr = (struct ipv6_opt_hdr *)CMSG_DATA(cmsg);
 341                         len = ((hdr->hdrlen + 1) << 3);
 342                         if (cmsg->cmsg_len < CMSG_LEN(len)) {
 343                                 err = -EINVAL;
 344                                 goto exit_f;
 345                         }
 346                         if (!capable(CAP_NET_RAW)) {
 347                                 err = -EPERM;
 348                                 goto exit_f;
 349                         }
 350                         if (opt->dst1opt) {
 351                                 err = -EINVAL;
 352                                 goto exit_f;
 353                         }
 354                         opt->opt_flen += len;
 355                         opt->dst1opt = hdr;
 356                         break;
 357
 358                 case IPV6_AUTHHDR:
 359                         if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_opt_hdr))) {
 360                                 err = -EINVAL;
 361                                 goto exit_f;
 362                         }
 363
 364                         hdr = (struct ipv6_opt_hdr *)CMSG_DATA(cmsg);
 365                         len = ((hdr->hdrlen + 2) << 2);
 366                         if (cmsg->cmsg_len < CMSG_LEN(len)) {
 367                                 err = -EINVAL;
 368                                 goto exit_f;
 369                         }
 370                         if (len & ~7) {
 371                                 err = -EINVAL;
 372                                 goto exit_f;
 373                         }
 374                         opt->opt_flen += len;
 375                         opt->auth = hdr;
 376                         break;
 377
 378                 case IPV6_RTHDR:
 379                         if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_rt_hdr))) {
 380                                 err = -EINVAL;
 381                                 goto exit_f;
 382                         }
 383
 384                         rthdr = (struct ipv6_rt_hdr *)CMSG_DATA(cmsg);
 385
 386                         /*
 387                          *      TYPE 0
 388                          */
 389                         if (rthdr->type) {
 390                                 err = -EINVAL;
 391                                 goto exit_f;
 392                         }
 393
 394                         len = ((rthdr->hdrlen + 1) << 3);
 395
 396                         if (cmsg->cmsg_len < CMSG_LEN(len)) {
 397                                 err = -EINVAL;
 398                                 goto exit_f;
 399                         }
 400
 401                         /* segments left must also match */
 402                         if ((rthdr->hdrlen >> 1) != rthdr->segments_left) {
 403                                 err = -EINVAL;
 404                                 goto exit_f;
 405                         }
 406
 407                         opt->opt_nflen += len;
 408                         opt->srcrt = rthdr;
 409
 410                         if (opt->dst1opt) {
 411                                 int dsthdrlen = ((opt->dst1opt->hdrlen+1)<<3);
 412
 413                                 opt->opt_nflen += dsthdrlen;
 414                                 opt->dst0opt = opt->dst1opt;
 415                                 opt->dst1opt = NULL;
 416                                 opt->opt_flen -= dsthdrlen;
 417                         }
 418
 419                         break;
 420
 421                 case IPV6_HOPLIMIT:
 422                         if (cmsg->cmsg_len != CMSG_LEN(sizeof(int))) {
 423                                 err = -EINVAL;
 424                                 goto exit_f;
 425                         }
 426
 427                         *hlimit = *(int *)CMSG_DATA(cmsg);
 428                         break;
 429
 430                 default:
 431                         if (net_ratelimit())
 432                                 printk(KERN_DEBUG "invalid cmsg type: %d\n", cmsg->cmsg_type);
 433                         err = -EINVAL;
 434                         break;
 435                 };
 436         }
 437
 438 exit_f:
 439         return err;
 440 }