Merge pull request #27 from hanumantmk/GITHUB_26

fix mongoc-stream-tls

Author: chergert

src/mongoc/mongoc-stream-tls.c

@@ -470,22 +470,56 @@ _mongoc_stream_tls_writev (mongoc_stream_t *stream,
    mongoc_stream_tls_t *tls = (mongoc_stream_tls_t *)stream;
    ssize_t ret = 0;
    size_t i;
+   size_t iov_pos = 0;
    int write_ret;
 
+   int64_t now;
+   int64_t expire = 0;
+
    BSON_ASSERT (tls);
    BSON_ASSERT (iov);
    BSON_ASSERT (iovcnt);
 
    tls->timeout = timeout_msec;
 
+   if (timeout_msec >= 0) {
+      expire = bson_get_monotonic_time () + (timeout_msec * 1000UL);
+   }
+
    for (i = 0; i < iovcnt; i++) {
-      write_ret = BIO_write (tls->bio, iov[i].iov_base, (int)iov[i].iov_len);
+      iov_pos = 0;
 
-      if (write_ret != iov[i].iov_len) {
-         return write_ret;
-      }
+      while (iov_pos < iov[i].iov_len) {
+         write_ret = BIO_write (tls->bio, (char *)iov[i].iov_base + iov_pos,
+                              (int)(iov[i].iov_len - iov_pos));
+
+         if (write_ret < 0) {
+            return write_ret;
+         }
+
+         if (expire) {
+            now = bson_get_monotonic_time ();
+
+            if ((expire - now) < 0) {
+               if (write_ret == 0) {
+                  mongoc_counter_streams_timeout_inc();
+#ifdef _WIN32
+                  errno = WSAETIMEDOUT;
+#else
+                  errno = ETIMEDOUT;
+#endif
+                  return -1;
+               }
 
-      ret += write_ret;
+               tls->timeout = 0;
+            } else {
+               tls->timeout = expire - now;
+            }
+         }
+
+         ret += write_ret;
+         iov_pos += write_ret;
+      }
    }
 
    if (ret >= 0) {
@@ -527,48 +561,57 @@ _mongoc_stream_tls_readv (mongoc_stream_t *stream,
    int read_ret;
    size_t iov_pos = 0;
    int64_t now;
-   int64_t expire;
+   int64_t expire = 0;
 
    BSON_ASSERT (tls);
    BSON_ASSERT (iov);
    BSON_ASSERT (iovcnt);
 
    tls->timeout = timeout_msec;
 
-   expire = bson_get_monotonic_time () + (timeout_msec * 1000UL);
+   if (timeout_msec >= 0) {
+      expire = bson_get_monotonic_time () + (timeout_msec * 1000UL);
+   }
 
    for (i = 0; i < iovcnt; i++) {
       iov_pos = 0;
 
-      while (iov_pos < iov[i].iov_len - 1) {
+      while (iov_pos < iov[i].iov_len) {
          read_ret = BIO_read (tls->bio, (char *)iov[i].iov_base + iov_pos,
                               (int)(iov[i].iov_len - iov_pos));
 
-         now = bson_get_monotonic_time ();
+         if (read_ret < 0) {
+            return read_ret;
+         }
+
+         if (expire) {
+            now = bson_get_monotonic_time ();
 
-         if (((expire - now) < 0) && (read_ret == 0)) {
-            mongoc_counter_streams_timeout_inc();
+            if ((expire - now) < 0) {
+               if (read_ret == 0) {
+                  mongoc_counter_streams_timeout_inc();
 #ifdef _WIN32
-            errno = WSAETIMEDOUT;
+                  errno = WSAETIMEDOUT;
 #else
-            errno = ETIMEDOUT;
+                  errno = ETIMEDOUT;
 #endif
-            return -1;
-         }
+                  return -1;
+               }
 
-         if (read_ret == -1) {
-            return read_ret;
+               tls->timeout = 0;
+            } else {
+               tls->timeout = expire - now;
+            }
          }
 
          ret += read_ret;
 
-         if (read_ret != iov[i].iov_len) {
-            if ((size_t)read_ret >= min_bytes) {
-               return read_ret;
-            }
-
-            iov_pos += read_ret;
+         if ((size_t)ret >= min_bytes) {
+            mongoc_counter_streams_ingress_add(ret);
+            return ret;
          }
+
+         iov_pos += read_ret;
       }
    }
 

tests/ssl-test.c

@@ -248,10 +248,17 @@ ssl_test_client (void * ptr)
    r = mongoc_stream_writev(ssl_stream, &wiov, 1, TIMEOUT);
    assert(r == wiov.iov_len);
 
-   r = mongoc_stream_readv(ssl_stream, &riov, 1, 4, TIMEOUT);
-   assert(r > 0);
-   assert(r == wiov.iov_len);
-   assert(strcmp(riov.iov_base, wiov.iov_base) == 0);
+   riov.iov_len = 1;
+
+   r = mongoc_stream_readv(ssl_stream, &riov, 1, 1, TIMEOUT);
+   assert(r == 1);
+   assert(memcmp(riov.iov_base, "f", 1) == 0);
+
+   riov.iov_len = 3;
+
+   r = mongoc_stream_readv(ssl_stream, &riov, 1, 3, TIMEOUT);
+   assert(r == 3);
+   assert(memcmp(riov.iov_base, "oo", 3) == 0);
 
    mongoc_stream_destroy(ssl_stream);