Read recv timestamps from socket (posix only).

webrtc/base/physicalsocketserver.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 #include "webrtc/base/physicalsocketserver.h"
 
 #if defined(_MSC_VER) && _MSC_VER < 1300
 #pragma warning(disable:4786)
 #endif
 
 #include <assert.h>
 
 #ifdef MEMORY_SANITIZER
 #include <sanitizer/msan_interface.h>
 #endif
 
 #if defined(WEBRTC_POSIX)
 #include <string.h>
 #include <errno.h>
 #include <fcntl.h>
+#include <sys/ioctl.h>
 #include <sys/time.h>
 #include <sys/select.h>
 #include <unistd.h>
 #include <signal.h>
 #endif
 
 #if defined(WEBRTC_WIN)
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 #include <winsock2.h>
@@ skipping 12 matching lines @@
 #include "webrtc/base/networkmonitor.h"
 #include "webrtc/base/nullsocketserver.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/base/winping.h"
 #include "webrtc/base/win32socketinit.h"
 
 #if defined(WEBRTC_POSIX)
 #include <netinet/tcp.h>  // for TCP_NODELAY
 #define IP_MTU 14 // Until this is integrated from linux/in.h to netinet/in.h
 typedef void* SockOptArg;
+
 #endif  // WEBRTC_POSIX
 
+#if defined(WEBRTC_POSIX) && !defined(WEBRTC_MAC)
+int64_t GetSocketRecvTimestamp(int socket) {
+  struct timeval tv_ioctl;
+  int ret = ioctl(socket, SIOCGSTAMP, &tv_ioctl);

[juberti2, 2016/05/11 05:03:34]

Do you need to set a socket option for this to work?

[stefan-webrtc, 2016/05/11 08:41:14]

No. There are two ways of getting the timestamp from the socket
1) this way which doesn't require a socket option
2) reading the timestamp with recvmsg(), which requires setting the
SO_TIMESTAMPING socket option. Doing that also disables the first way of reading
recv timestamps.

#1 is a lot simpler, so I suggest going with that for now at least.

+  if (ret != 0)
+    return -1;
+  int64_t timestamp =
+      rtc::kNumMicrosecsPerSec * static_cast<int64_t>(tv_ioctl.tv_sec) +
+      static_cast<int64_t>(tv_ioctl.tv_usec);
+  return timestamp;
+}
+
+#else
+
+int64_t GetSocketRecvTimestamp(int socket) {
+  return -1;
+}
+#endif
+
 #if defined(WEBRTC_WIN)
 typedef char* SockOptArg;
 #endif
 
 namespace rtc {
 
 std::unique_ptr<SocketServer> SocketServer::CreateDefault() {
 #if defined(__native_client__)
   return std::unique_ptr<SocketServer>(new rtc::NullSocketServer);
 #else
@@ skipping 247 matching lines @@
   MaybeRemapSendError();
   // We have seen minidumps where this may be false.
   ASSERT(sent <= static_cast<int>(length));
   if ((sent > 0 && sent < static_cast<int>(length)) ||
       (sent < 0 && IsBlockingError(GetError()))) {
     enabled_events_ |= DE_WRITE;
   }
   return sent;
 }
 
-int PhysicalSocket::Recv(void* buffer, size_t length) {
+int PhysicalSocket::Recv(void* buffer, size_t length, int64_t* timestamp) {
   int received = ::recv(s_, static_cast<char*>(buffer),
                         static_cast<int>(length), 0);
   if ((received == 0) && (length != 0)) {
     // Note: on graceful shutdown, recv can return 0.  In this case, we
     // pretend it is blocking, and then signal close, so that simplifying
     // assumptions can be made about Recv.
     LOG(LS_WARNING) << "EOF from socket; deferring close event";
     // Must turn this back on so that the select() loop will notice the close
     // event.
     enabled_events_ |= DE_READ;
     SetError(EWOULDBLOCK);
     return SOCKET_ERROR;
   }
+  *timestamp = GetSocketRecvTimestamp(s_);

[juberti2, 2016/05/11 05:03:34]

Allow NULL to be passed so that clients who don't care about timestamps don't
have to write more complex code.

[stefan-webrtc, 2016/05/11 08:41:14]

Done.

   UpdateLastError();
   int error = GetError();
   bool success = (received >= 0) || IsBlockingError(error);
   if (udp_ || success) {
     enabled_events_ |= DE_READ;
   }
   if (!success) {
     LOG_F(LS_VERBOSE) << "Error = " << error;
   }
   return received;
 }
 
 int PhysicalSocket::RecvFrom(void* buffer,
                              size_t length,
-                             SocketAddress* out_addr) {
+                             SocketAddress* out_addr,
+                             int64_t* timestamp) {
   sockaddr_storage addr_storage;
   socklen_t addr_len = sizeof(addr_storage);
   sockaddr* addr = reinterpret_cast<sockaddr*>(&addr_storage);
   int received = ::recvfrom(s_, static_cast<char*>(buffer),
                             static_cast<int>(length), 0, addr, &addr_len);
+  *timestamp = GetSocketRecvTimestamp(s_);
   UpdateLastError();
   if ((received >= 0) && (out_addr != nullptr))
     SocketAddressFromSockAddrStorage(addr_storage, out_addr);
   int error = GetError();
   bool success = (received >= 0) || IsBlockingError(error);
   if (udp_ || success) {
     enabled_events_ |= DE_READ;
   }
   if (!success) {
     LOG_F(LS_VERBOSE) << "Error = " << error;
@@ skipping 1256 matching lines @@
        break;
     }
   }
 
   // Done
   return true;
 }
 #endif  // WEBRTC_WIN
 
 }  // namespace rtc