net/tools/quic/quic_socket_utils.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/tools/quic/quic_socket_utils.h"
   6
   7 #include <errno.h>
   8 #include <netinet/in.h>
   9 #include <string.h>
  10 #include <sys/socket.h>
  11 #include <sys/uio.h>
  12 #include <string>
  13
  14 #include "base/logging.h"
  15
  16 #ifndef SO_RXQ_OVFL
  17 #define SO_RXQ_OVFL 40
  18 #endif
  19
  20 namespace net {
  21 namespace tools {
  22
  23 // static
  24 IPAddressNumber QuicSocketUtils::GetAddressFromMsghdr(struct msghdr *hdr) {
  25   IPAddressNumber ret;
  26   if (hdr->msg_controllen > 0) {
  27     for (cmsghdr* cmsg = CMSG_FIRSTHDR(hdr);
  28          cmsg != NULL;
  29          cmsg = CMSG_NXTHDR(hdr, cmsg)) {
  30       const uint8* addr_data = reinterpret_cast<const uint8*>CMSG_DATA(cmsg);
  31       int len = 0;
  32       if (cmsg->cmsg_type == IPV6_PKTINFO) {
  33         len = sizeof(in6_pktinfo);
  34       } else if (cmsg->cmsg_type == IP_PKTINFO) {
  35         len = sizeof(in_pktinfo);
  36       }
  37       ret.assign(addr_data, addr_data + len);
  38       break;
  39     }
  40   }
  41   return ret;
  42 }
  43
  44 // static
  45 bool QuicSocketUtils::GetOverflowFromMsghdr(struct msghdr *hdr,
  46                                       int *dropped_packets) {
  47   if (hdr->msg_controllen > 0) {
  48     struct cmsghdr *cmsg;
  49     for (cmsg = CMSG_FIRSTHDR(hdr);
  50          cmsg != NULL;
  51          cmsg = CMSG_NXTHDR(hdr, cmsg)) {
  52       if (cmsg->cmsg_type == SO_RXQ_OVFL) {
  53         *dropped_packets = *(reinterpret_cast<int*>CMSG_DATA(cmsg));
  54         return true;
  55       }
  56     }
  57   }
  58   return false;
  59 }
  60
  61 // static
  62 int QuicSocketUtils::SetGetAddressInfo(int fd, int address_family) {
  63   int get_local_ip = 1;
  64   if (address_family == AF_INET) {
  65     return setsockopt(fd, IPPROTO_IP, IP_PKTINFO,
  66                       &get_local_ip, sizeof(get_local_ip));
  67   } else {
  68     return setsockopt(fd, IPPROTO_IPV6, IPV6_RECVPKTINFO,
  69                       &get_local_ip, sizeof(get_local_ip));
  70   }
  71 }
  72
  73 // static
  74 int QuicSocketUtils::ReadPacket(int fd, char* buffer, size_t buf_len,
  75                           int* dropped_packets,
  76                           IPAddressNumber* self_address,
  77                           IPEndPoint* peer_address) {
  78   CHECK(peer_address != NULL);
  79   const int kSpaceForOverflowAndIp =
  80       CMSG_SPACE(sizeof(int)) + CMSG_SPACE(sizeof(in6_pktinfo));
  81   char cbuf[kSpaceForOverflowAndIp];
  82   memset(cbuf, 0, arraysize(cbuf));
  83
  84   iovec iov = {buffer, buf_len};
  85   struct sockaddr_storage raw_address;
  86   msghdr hdr;
  87
  88   hdr.msg_name = &raw_address;
  89   hdr.msg_namelen = sizeof(sockaddr_storage);
  90   hdr.msg_iov = &iov;
  91   hdr.msg_iovlen = 1;
  92   hdr.msg_flags = 0;
  93
  94   struct cmsghdr *cmsg = (struct cmsghdr *) cbuf;
  95   cmsg->cmsg_len = arraysize(cbuf);
  96   hdr.msg_control = cmsg;
  97   hdr.msg_controllen = arraysize(cbuf);
  98
  99   int bytes_read = recvmsg(fd, &hdr, 0);
 100
 101   // Return before setting dropped packets: if we get EAGAIN, it will
 102   // be 0.
 103   if (bytes_read < 0 && errno != 0) {
 104     if (errno != EAGAIN) {
 105       LOG(ERROR) << "Error reading " << strerror(errno);
 106     }
 107     return -1;
 108   }
 109
 110   if (dropped_packets != NULL) {
 111     GetOverflowFromMsghdr(&hdr, dropped_packets);
 112   }
 113   if (self_address != NULL) {
 114     *self_address = QuicSocketUtils::GetAddressFromMsghdr(&hdr);
 115   }
 116
 117   if (raw_address.ss_family == AF_INET) {
 118     CHECK(peer_address->FromSockAddr(
 119         reinterpret_cast<const sockaddr*>(&raw_address),
 120         sizeof(struct sockaddr_in)));
 121   } else if (raw_address.ss_family == AF_INET6) {
 122     CHECK(peer_address->FromSockAddr(
 123         reinterpret_cast<const sockaddr*>(&raw_address),
 124         sizeof(struct sockaddr_in6)));
 125   }
 126
 127   return bytes_read;
 128 }
 129
 130 // static
 131 int QuicSocketUtils::WritePacket(int fd, const char* buffer, size_t buf_len,
 132                                  const IPAddressNumber& self_address,
 133                                  const IPEndPoint& peer_address,
 134                                  int* error) {
 135   sockaddr_storage raw_address;
 136   socklen_t address_len = sizeof(raw_address);
 137   CHECK(peer_address.ToSockAddr(
 138       reinterpret_cast<struct sockaddr*>(&raw_address),
 139       &address_len));
 140   iovec iov = {const_cast<char*>(buffer), buf_len};
 141
 142   msghdr hdr;
 143   hdr.msg_name = &raw_address;
 144   hdr.msg_namelen = address_len;
 145   hdr.msg_iov = &iov;
 146   hdr.msg_iovlen = 1;
 147   hdr.msg_flags = 0;
 148
 149   const int kSpaceForIpv4 = CMSG_SPACE(sizeof(in_pktinfo));
 150   const int kSpaceForIpv6 = CMSG_SPACE(sizeof(in6_pktinfo));
 151   // kSpaceForIp should be big enough to hold both IPv4 and IPv6 packet info.
 152   const int kSpaceForIp =
 153       (kSpaceForIpv4 < kSpaceForIpv6) ? kSpaceForIpv6 : kSpaceForIpv4;
 154   char cbuf[kSpaceForIp];
 155   if (self_address.empty()) {
 156     hdr.msg_control = 0;
 157     hdr.msg_controllen = 0;
 158   } else if (GetAddressFamily(self_address) == ADDRESS_FAMILY_IPV4) {
 159     hdr.msg_control = cbuf;
 160     hdr.msg_controllen = kSpaceForIp;
 161     cmsghdr* cmsg = CMSG_FIRSTHDR(&hdr);
 162
 163     cmsg->cmsg_len = CMSG_LEN(sizeof(in_pktinfo));
 164     cmsg->cmsg_level = IPPROTO_IP;
 165     cmsg->cmsg_type = IP_PKTINFO;
 166     in_pktinfo* pktinfo = reinterpret_cast<in_pktinfo*>(CMSG_DATA(cmsg));
 167     memset(pktinfo, 0, sizeof(in_pktinfo));
 168     pktinfo->ipi_ifindex = 0;
 169     memcpy(&pktinfo->ipi_spec_dst, &self_address[0], self_address.size());
 170     hdr.msg_controllen = cmsg->cmsg_len;
 171   } else {
 172     hdr.msg_control = cbuf;
 173     hdr.msg_controllen = kSpaceForIp;
 174     cmsghdr* cmsg = CMSG_FIRSTHDR(&hdr);
 175
 176     cmsg->cmsg_len = CMSG_LEN(sizeof(in6_pktinfo));
 177     cmsg->cmsg_level = IPPROTO_IPV6;
 178     cmsg->cmsg_type = IPV6_PKTINFO;
 179     in6_pktinfo* pktinfo = reinterpret_cast<in6_pktinfo*>(CMSG_DATA(cmsg));
 180     memset(pktinfo, 0, sizeof(in6_pktinfo));
 181     memcpy(&pktinfo->ipi6_addr, &self_address[0], self_address.size());
 182     hdr.msg_controllen = cmsg->cmsg_len;
 183   }
 184
 185   int rc = sendmsg(fd, &hdr, 0);
 186   *error = (rc >= 0) ? 0 : errno;
 187   return rc;
 188 }
 189
 190 }  // namespace tools
 191 }  // namespace net