CDRIVER-2237 distinguish network timeout and error

Author: ajdavis

NEWS

@@ -8,6 +8,7 @@ mongo-c-driver 1.8.0
   * mongoc_collection_create_index and mongoc_collection_create_index_with_opts
     are both now deprecated. Use mongoc_database_write_command_with_opts
     instead; a guide to creating an index using that function has been added.
+  * New stream method mongoc_stream_timed_out.
 
 Thanks to everyone who contributed to the development of this release.
 

doc/mongoc_stream_t.rst

@@ -37,6 +37,7 @@ There are a number of built in stream types that come with mongoc. The default c
     mongoc_stream_read
     mongoc_stream_readv
     mongoc_stream_setsockopt
+    mongoc_stream_timed_out
     mongoc_stream_uncork
     mongoc_stream_write
     mongoc_stream_writev

doc/mongoc_stream_timed_out.rst

@@ -0,0 +1,22 @@
+:man_page: mongoc_stream_timed_out
+
+mongoc_stream_timed_out()
+=========================
+
+Synopsis
+--------
+
+.. code-block:: c
+
+  bool
+  mongoc_stream_timed_out (mongoc_stream_t *stream);
+
+Parameters
+----------
+
+* ``stream``: A :symbol:`mongoc_stream_t`.
+
+Returns
+-------
+
+True if there has been a network timeout error on this stream.

src/mongoc/mongoc-errno-private.h

@@ -35,15 +35,18 @@ BSON_BEGIN_DECLS
 #if defined(_WIN32)
 #define MONGOC_ERRNO_IS_AGAIN(errno) \
    ((errno == EAGAIN) || (errno == WSAEWOULDBLOCK) || (errno == WSAEINPROGRESS))
+#define MONGOC_ERRNO_IS_TIMEDOUT(errno) (errno == WSAETIMEDOUT)
 #elif defined(__sun)
 /* for some reason, accept() returns -1 and errno of 0 */
 #define MONGOC_ERRNO_IS_AGAIN(errno)                                   \
    ((errno == EINTR) || (errno == EAGAIN) || (errno == EWOULDBLOCK) || \
     (errno == EINPROGRESS) || (errno == 0))
+#define MONGOC_ERRNO_IS_TIMEDOUT(errno) (errno == ETIMEDOUT)
 #else
 #define MONGOC_ERRNO_IS_AGAIN(errno)                                   \
    ((errno == EINTR) || (errno == EAGAIN) || (errno == EWOULDBLOCK) || \
     (errno == EINPROGRESS))
+#define MONGOC_ERRNO_IS_TIMEDOUT(errno) (errno == ETIMEDOUT)
 #endif
 
 

src/mongoc/mongoc-socket.c

@@ -39,6 +39,35 @@
 /* either struct sockaddr or void, depending on platform */
 typedef MONGOC_SOCKET_ARG2 mongoc_sockaddr_t;
 
+
+/*
+ *--------------------------------------------------------------------------
+ *
+ * _mongoc_socket_capture_errno --
+ *
+ *       Save the errno state for contextual use.
+ *
+ * Returns:
+ *       None.
+ *
+ * Side effects:
+ *       None.
+ *
+ *--------------------------------------------------------------------------
+ */
+
+static void
+_mongoc_socket_capture_errno (mongoc_socket_t *sock) /* IN */
+{
+#ifdef _WIN32
+   errno = sock->errno_ = WSAGetLastError ();
+#else
+   sock->errno_ = errno;
+#endif
+   TRACE ("setting errno: %d %s", sock->errno_, strerror (sock->errno_));
+}
+
+
 /*
  *--------------------------------------------------------------------------
  *
@@ -99,13 +128,9 @@ _mongoc_socket_setnonblock (int sd)
  */
 
 static bool
-#ifdef _WIN32
-_mongoc_socket_wait (SOCKET sd, /* IN */
-#else
-_mongoc_socket_wait (int sd, /* IN */
-#endif
-                     int events,        /* IN */
-                     int64_t expire_at) /* IN */
+_mongoc_socket_wait (mongoc_socket_t *sock, /* IN */
+                     int events,            /* IN */
+                     int64_t expire_at)     /* IN */
 {
 #ifdef _WIN32
    fd_set read_fds;
@@ -121,6 +146,7 @@ _mongoc_socket_wait (int sd, /* IN */
 
    ENTRY;
 
+   BSON_ASSERT (sock);
    BSON_ASSERT (events);
 
 #ifdef _WIN32
@@ -129,16 +155,16 @@ _mongoc_socket_wait (int sd, /* IN */
    FD_ZERO (&error_fds);
 
    if (events & POLLIN) {
-      FD_SET (sd, &read_fds);
+      FD_SET (sock->sd, &read_fds);
    }
 
    if (events & POLLOUT) {
-      FD_SET (sd, &write_fds);
+      FD_SET (sock->sd, &write_fds);
    }
 
-   FD_SET (sd, &error_fds);
+   FD_SET (sock->sd, &error_fds);
 #else
-   pfd.fd = sd;
+   pfd.fd = sock->sd;
    pfd.events = events | POLLERR | POLLHUP;
    pfd.revents = 0;
 #endif
@@ -167,9 +193,9 @@ _mongoc_socket_wait (int sd, /* IN */
             0 /*unused*/, &read_fds, &write_fds, &error_fds, &timeout_tv);
       }
       if (ret == SOCKET_ERROR) {
-         errno = WSAGetLastError ();
+         _mongoc_socket_capture_errno (sock);
          ret = -1;
-      } else if (FD_ISSET (sd, &error_fds)) {
+      } else if (FD_ISSET (sock->sd, &error_fds)) {
          errno = WSAECONNRESET;
          ret = -1;
       }
@@ -180,7 +206,8 @@ _mongoc_socket_wait (int sd, /* IN */
       if (ret > 0) {
 /* Something happened, so return that */
 #ifdef _WIN32
-         return (FD_ISSET (sd, &read_fds) || FD_ISSET (sd, &write_fds));
+         return (FD_ISSET (sock->sd, &read_fds)
+                 || FD_ISSET (sock->sd, &write_fds));
 #else
          RETURN (0 != (pfd.revents & events));
 #endif
@@ -192,16 +219,23 @@ _mongoc_socket_wait (int sd, /* IN */
             now = bson_get_monotonic_time ();
 
             if (expire_at < now) {
+               _mongoc_socket_capture_errno (sock);
                RETURN (false);
             } else {
                continue;
             }
          } else {
             /* poll failed for some non-transient reason */
+            _mongoc_socket_capture_errno (sock);
             RETURN (false);
          }
       } else {
-         /* ret == 0, poll timed out */
+/* ret == 0, poll timed out */
+#ifdef _WIN32
+         sock->errno_ = timeout ? WSAETIMEDOUT : EAGAIN;
+#else
+         sock->errno_ = timeout ? ETIMEDOUT : EAGAIN;
+#endif
          RETURN (false);
       }
    }
@@ -560,34 +594,6 @@ mongoc_socket_errno (mongoc_socket_t *sock) /* IN */
 }
 
 
-/*
- *--------------------------------------------------------------------------
- *
- * _mongoc_socket_capture_errno --
- *
- *       Save the errno state for contextual use.
- *
- * Returns:
- *       None.
- *
- * Side effects:
- *       None.
- *
- *--------------------------------------------------------------------------
- */
-
-static void
-_mongoc_socket_capture_errno (mongoc_socket_t *sock) /* IN */
-{
-#ifdef _WIN32
-   errno = sock->errno_ = WSAGetLastError ();
-#else
-   sock->errno_ = errno;
-#endif
-   TRACE ("setting errno: %d %s", sock->errno_, strerror (sock->errno_));
-}
-
-
 /*
  *--------------------------------------------------------------------------
  *
@@ -689,7 +695,7 @@ mongoc_socket_accept_ex (mongoc_socket_t *sock, /* IN */
    try_again = (failed && _mongoc_socket_errno_is_again (sock));
 
    if (failed && try_again) {
-      if (_mongoc_socket_wait (sock->sd, POLLIN, expire_at)) {
+      if (_mongoc_socket_wait (sock, POLLIN, expire_at)) {
          GOTO (again);
       }
       RETURN (NULL);
@@ -849,7 +855,7 @@ mongoc_socket_connect (mongoc_socket_t *sock,       /* IN */
    }
 
    if (failed && try_again) {
-      if (_mongoc_socket_wait (sock->sd, POLLOUT, expire_at)) {
+      if (_mongoc_socket_wait (sock, POLLOUT, expire_at)) {
          optval = -1;
          ret = getsockopt (
             sock->sd, SOL_SOCKET, SO_ERROR, (char *) &optval, &optlen);
@@ -1058,7 +1064,7 @@ mongoc_socket_recv (mongoc_socket_t *sock, /* IN */
    if (failed) {
       _mongoc_socket_capture_errno (sock);
       if (_mongoc_socket_errno_is_again (sock) &&
-          _mongoc_socket_wait (sock->sd, POLLIN, expire_at)) {
+          _mongoc_socket_wait (sock, POLLIN, expire_at)) {
          GOTO (again);
       }
    }
@@ -1408,7 +1414,7 @@ mongoc_socket_sendv (mongoc_socket_t *sock,  /* IN */
       /*
        * Block on poll() until our desired condition is met.
        */
-      if (!_mongoc_socket_wait (sock->sd, POLLOUT, expire_at)) {
+      if (!_mongoc_socket_wait (sock, POLLOUT, expire_at)) {
          GOTO (CLEANUP);
       }
    }
@@ -1469,7 +1475,7 @@ mongoc_socket_check_closed (mongoc_socket_t *sock) /* IN */
    char buf[1];
    ssize_t r;
 
-   if (_mongoc_socket_wait (sock->sd, POLLIN, 0)) {
+   if (_mongoc_socket_wait (sock, POLLIN, 0)) {
       sock->errno_ = 0;
 
       r = recv (sock->sd, buf, 1, MSG_PEEK);

src/mongoc/mongoc-stream-buffered.c

@@ -275,6 +275,15 @@ _mongoc_stream_buffered_check_closed (mongoc_stream_t *stream) /* IN */
 }
 
 
+static bool
+_mongoc_stream_buffered_timed_out (mongoc_stream_t *stream) /* IN */
+{
+   mongoc_stream_buffered_t *buffered = (mongoc_stream_buffered_t *) stream;
+   BSON_ASSERT (stream);
+   return mongoc_stream_timed_out (buffered->base_stream);
+}
+
+
 /*
  *--------------------------------------------------------------------------
  *
@@ -316,6 +325,7 @@ mongoc_stream_buffered_new (mongoc_stream_t *base_stream, /* IN */
    stream->stream.readv = mongoc_stream_buffered_readv;
    stream->stream.get_base_stream = _mongoc_stream_buffered_get_base_stream;
    stream->stream.check_closed = _mongoc_stream_buffered_check_closed;
+   stream->stream.timed_out = _mongoc_stream_buffered_timed_out;
 
    stream->base_stream = base_stream;
 

src/mongoc/mongoc-stream-socket.c

@@ -18,7 +18,8 @@
 #include "mongoc-stream-private.h"
 #include "mongoc-stream-socket.h"
 #include "mongoc-trace-private.h"
-
+#include "mongoc-socket-private.h"
+#include "mongoc-errno-private.h"
 
 #undef MONGOC_LOG_DOMAIN
 #define MONGOC_LOG_DOMAIN "stream"
@@ -275,6 +276,20 @@ _mongoc_stream_socket_check_closed (mongoc_stream_t *stream) /* IN */
 }
 
 
+static bool
+_mongoc_stream_socket_timed_out (mongoc_stream_t *stream) /* IN */
+{
+   mongoc_stream_socket_t *ss = (mongoc_stream_socket_t *) stream;
+
+   ENTRY;
+
+   BSON_ASSERT (ss);
+   BSON_ASSERT (ss->sock);
+
+   RETURN (MONGOC_ERRNO_IS_TIMEDOUT (ss->sock->errno_));
+}
+
+
 /*
  *--------------------------------------------------------------------------
  *
@@ -309,6 +324,7 @@ mongoc_stream_socket_new (mongoc_socket_t *sock) /* IN */
    stream->vtable.writev = _mongoc_stream_socket_writev;
    stream->vtable.setsockopt = _mongoc_stream_socket_setsockopt;
    stream->vtable.check_closed = _mongoc_stream_socket_check_closed;
+   stream->vtable.timed_out = _mongoc_stream_socket_timed_out;
    stream->vtable.poll = _mongoc_stream_socket_poll;
    stream->sock = sock;
 

src/mongoc/mongoc-stream-tls-libressl.c

@@ -441,6 +441,16 @@ mongoc_stream_tls_libressl_handshake (mongoc_stream_t *stream,
    RETURN (false);
 }
 
+static bool
+_mongoc_stream_tls_libressl_timed_out (mongoc_stream_t *stream)
+{
+   mongoc_stream_tls_t *tls = (mongoc_stream_tls_t *) stream;
+
+   ENTRY;
+
+   RETURN (mongoc_stream_timed_out (tls->base_stream));
+}
+
 mongoc_stream_t *
 mongoc_stream_tls_libressl_new (mongoc_stream_t *base_stream,
                                 const char *host,
@@ -474,6 +484,7 @@ mongoc_stream_tls_libressl_new (mongoc_stream_t *base_stream,
    tls->parent.setsockopt = _mongoc_stream_tls_libressl_setsockopt;
    tls->parent.get_base_stream = _mongoc_stream_tls_libressl_get_base_stream;
    tls->parent.check_closed = _mongoc_stream_tls_libressl_check_closed;
+   tls->parent.timed_out = _mongoc_stream_tls_libressl_timed_out;
    memcpy (&tls->ssl_opts, opt, sizeof tls->ssl_opts);
    tls->handshake = mongoc_stream_tls_libressl_handshake;
    tls->ctx = (void *) libressl;

src/mongoc/mongoc-stream-tls-openssl.c

@@ -616,6 +616,16 @@ _mongoc_stream_tls_openssl_sni (SSL *ssl, int *ad, void *arg)
    return SSL_TLSEXT_ERR_OK;
 }
 
+static bool
+_mongoc_stream_tls_openssl_timed_out (mongoc_stream_t *stream)
+{
+   mongoc_stream_tls_t *tls = (mongoc_stream_tls_t *) stream;
+
+   ENTRY;
+
+   RETURN (mongoc_stream_timed_out (tls->base_stream));
+}
+
 /*
  *--------------------------------------------------------------------------
  *
@@ -735,6 +745,7 @@ mongoc_stream_tls_openssl_new (mongoc_stream_t *base_stream,
    tls->parent.setsockopt = _mongoc_stream_tls_openssl_setsockopt;
    tls->parent.get_base_stream = _mongoc_stream_tls_openssl_get_base_stream;
    tls->parent.check_closed = _mongoc_stream_tls_openssl_check_closed;
+   tls->parent.timed_out = _mongoc_stream_tls_openssl_timed_out;
    memcpy (&tls->ssl_opts, opt, sizeof tls->ssl_opts);
    tls->handshake = mongoc_stream_tls_openssl_handshake;
    tls->ctx = (void *) openssl;