Landing Recent QUIC changes until 4AM, Aug 7, 2016 UTC-4

net/tools/quic/quic_socket_utils.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/tools/quic/quic_socket_utils.h"
 
 #include <errno.h>
 #include <linux/net_tstamp.h>
 #include <netinet/in.h>
 #include <string.h>
 #include <sys/socket.h>
 #include <sys/uio.h>
 #include <string>
 
 #include "base/logging.h"
 #include "net/quic/core/quic_bug_tracker.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_protocol.h"
 
 #ifndef SO_RXQ_OVFL
 #define SO_RXQ_OVFL 40
 #endif
 
 namespace net {
 
 // static
 void QuicSocketUtils::GetAddressAndTimestampFromMsghdr(
     struct msghdr* hdr,
     IPAddress* address,
-    QuicTime* timestamp,
-    QuicWallTime* walltimestamp,
-    bool latched_walltimestamps) {
+    QuicWallTime* walltimestamp) {
   if (hdr->msg_controllen > 0) {
     for (cmsghdr* cmsg = CMSG_FIRSTHDR(hdr); cmsg != nullptr;
          cmsg = CMSG_NXTHDR(hdr, cmsg)) {
       const uint8_t* addr_data = nullptr;
       int len = 0;
       if (cmsg->cmsg_type == IPV6_PKTINFO) {
         in6_pktinfo* info = reinterpret_cast<in6_pktinfo*>(CMSG_DATA(cmsg));
         addr_data = reinterpret_cast<const uint8_t*>(&info->ipi6_addr);
         len = sizeof(in6_addr);
         *address = IPAddress(addr_data, len);
       } else if (cmsg->cmsg_type == IP_PKTINFO) {
         in_pktinfo* info = reinterpret_cast<in_pktinfo*>(CMSG_DATA(cmsg));
         addr_data = reinterpret_cast<const uint8_t*>(&info->ipi_addr);
         len = sizeof(in_addr);
         *address = IPAddress(addr_data, len);
       } else if (cmsg->cmsg_level == SOL_SOCKET &&
                  cmsg->cmsg_type == SO_TIMESTAMPING) {
         LinuxTimestamping* lts =
             reinterpret_cast<LinuxTimestamping*>(CMSG_DATA(cmsg));
         timespec* ts = &lts->systime;
         int64_t usec = (static_cast<int64_t>(ts->tv_sec) * 1000 * 1000) +
                        (static_cast<int64_t>(ts->tv_nsec) / 1000);
-        if (latched_walltimestamps) {
-          *walltimestamp = QuicWallTime::FromUNIXMicroseconds(usec);
-        } else {
-          *timestamp =
-              QuicTime::Zero() + QuicTime::Delta::FromMicroseconds(usec);
-        }
+        *walltimestamp = QuicWallTime::FromUNIXMicroseconds(usec);
       }
     }
   }
 }
 
 // static
 bool QuicSocketUtils::GetOverflowFromMsghdr(struct msghdr* hdr,
                                             QuicPacketCount* dropped_packets) {
   if (hdr->msg_controllen > 0) {
     struct cmsghdr* cmsg;
     for (cmsg = CMSG_FIRSTHDR(hdr); cmsg != nullptr;
          cmsg = CMSG_NXTHDR(hdr, cmsg)) {
       if (cmsg->cmsg_type == SO_RXQ_OVFL) {
         *dropped_packets = *(reinterpret_cast<uint32_t*> CMSG_DATA(cmsg));
         return true;
       }
     }
   }
   return false;
 }
 
 // static
+bool QuicSocketUtils::GetTtlFromMsghdr(struct msghdr* hdr, int* ttl) {
+  if (hdr->msg_controllen > 0) {
+    struct cmsghdr* cmsg;
+    for (cmsg = CMSG_FIRSTHDR(hdr); cmsg != nullptr;
+         cmsg = CMSG_NXTHDR(hdr, cmsg)) {
+      if ((cmsg->cmsg_level == IPPROTO_IP && cmsg->cmsg_type == IP_TTL) ||
+          (cmsg->cmsg_level == IPPROTO_IPV6 &&
+           cmsg->cmsg_type == IPV6_HOPLIMIT)) {
+        *ttl = *(reinterpret_cast<int*>(CMSG_DATA(cmsg)));
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+// static
 int QuicSocketUtils::SetGetAddressInfo(int fd, int address_family) {
   int get_local_ip = 1;
   int rc = setsockopt(fd, IPPROTO_IP, IP_PKTINFO, &get_local_ip,
                       sizeof(get_local_ip));
   if (rc == 0 && address_family == AF_INET6) {
     rc = setsockopt(fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &get_local_ip,
                     sizeof(get_local_ip));
   }
   return rc;
 }
@@ skipping 22 matching lines @@
   }
   return true;
 }
 
 // static
 int QuicSocketUtils::ReadPacket(int fd,
                                 char* buffer,
                                 size_t buf_len,
                                 QuicPacketCount* dropped_packets,
                                 IPAddress* self_address,
-                                QuicTime* timestamp,
                                 QuicWallTime* walltimestamp,
-                                bool latched_walltimestamps,
                                 IPEndPoint* peer_address) {
   DCHECK(peer_address != nullptr);
   char cbuf[kSpaceForCmsg];
   memset(cbuf, 0, arraysize(cbuf));
 
   iovec iov = {buffer, buf_len};
   struct sockaddr_storage raw_address;
   msghdr hdr;
 
   hdr.msg_name = &raw_address;
@@ skipping 31 matching lines @@
   IPAddress stack_address;
   if (self_address == nullptr) {
     self_address = &stack_address;
   }
 
   QuicWallTime stack_walltimestamp = QuicWallTime::FromUNIXMicroseconds(0);
   if (walltimestamp == nullptr) {
     walltimestamp = &stack_walltimestamp;
   }
 
-  QuicTime stack_timestamp = QuicTime::Zero();
-  if (timestamp == nullptr) {
-    timestamp = &stack_timestamp;
-  }
-
-  GetAddressAndTimestampFromMsghdr(&hdr, self_address, timestamp, walltimestamp,
-                                   latched_walltimestamps);
+  GetAddressAndTimestampFromMsghdr(&hdr, self_address, walltimestamp);
 
   if (raw_address.ss_family == AF_INET) {
     CHECK(peer_address->FromSockAddr(
         reinterpret_cast<const sockaddr*>(&raw_address),
         sizeof(struct sockaddr_in)));
   } else if (raw_address.ss_family == AF_INET6) {
     CHECK(peer_address->FromSockAddr(
         reinterpret_cast<const sockaddr*>(&raw_address),
         sizeof(struct sockaddr_in6)));
   }
@@ skipping 113 matching lines @@
   rc = SetGetSoftwareReceiveTimestamp(fd);
   if (rc < 0) {
     LOG(WARNING) << "SO_TIMESTAMPING not supported; using fallback: "
                  << strerror(errno);
   }
 
   return fd;
 }
 
 }  // namespace net