static ssize_t
_mongoc_stream_gridfs_readv (mongoc_stream_t *stream,
mongoc_iovec_t *iov,
size_t iovcnt,
size_t min_bytes,
int32_t timeout_msec)
{
mongoc_stream_gridfs_t *file = (mongoc_stream_gridfs_t *) stream;
ssize_t ret = 0;
ENTRY;
BSON_ASSERT (stream);
BSON_ASSERT (iov);
BSON_ASSERT (iovcnt);
/* timeout_msec is unused by mongoc_gridfs_file_readv */
ret = mongoc_gridfs_file_readv (file->file, iov, iovcnt, min_bytes, 0);
mongoc_counter_streams_ingress_add (ret);
RETURN (ret);
}
static ssize_t
_mongoc_stream_gridfs_readv (mongoc_stream_t *stream,
struct iovec *iov,
size_t iovcnt,
size_t min_bytes,
bson_int32_t timeout_msec)
{
mongoc_stream_gridfs_t *file = (mongoc_stream_gridfs_t *)stream;
ssize_t ret = 0;
ENTRY;
BSON_ASSERT (stream);
BSON_ASSERT (iov);
BSON_ASSERT (iovcnt);
BSON_ASSERT (timeout_msec <= INT_MAX);
ret = mongoc_gridfs_file_readv (file->file, iov, iovcnt, min_bytes,
timeout_msec);
mongoc_counter_streams_ingress_add (ret);
RETURN (ret);
}
static ssize_t
_mongoc_stream_tls_readv (mongoc_stream_t *stream,
mongoc_iovec_t *iov,
size_t iovcnt,
size_t min_bytes,
int32_t timeout_msec)
{
mongoc_stream_tls_t *tls = (mongoc_stream_tls_t *)stream;
ssize_t ret = 0;
size_t i;
int read_ret;
size_t iov_pos = 0;
int64_t now;
int64_t expire = 0;
BSON_ASSERT (tls);
BSON_ASSERT (iov);
BSON_ASSERT (iovcnt);
tls->timeout_msec = timeout_msec;
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) {
read_ret = BIO_read (tls->bio, (char *)iov[i].iov_base + iov_pos,
(int)(iov[i].iov_len - iov_pos));
if (read_ret < 0) {
return read_ret;
}
if (expire) {
now = bson_get_monotonic_time ();
if ((expire - now) < 0) {
if (read_ret == 0) {
mongoc_counter_streams_timeout_inc();
#ifdef _WIN32
errno = WSAETIMEDOUT;
#else
errno = ETIMEDOUT;
#endif
return -1;
}
tls->timeout_msec = 0;
} else {
tls->timeout_msec = (expire - now) / 1000L;
}
}
ret += read_ret;
if ((size_t)ret >= min_bytes) {
mongoc_counter_streams_ingress_add(ret);
return ret;
}
iov_pos += read_ret;
}
}
if (ret >= 0) {
mongoc_counter_streams_ingress_add(ret);
}
return ret;
}
mongoc_socket_t *
mongoc_socket_new (int domain, /* IN */
int type, /* IN */
int protocol) /* IN */
{
mongoc_socket_t *sock;
#ifdef _WIN32
SOCKET sd;
#else
int sd;
#endif
ENTRY;
sd = socket (domain, type, protocol);
#ifdef _WIN32
if (sd == INVALID_SOCKET) {
#else
if (sd == -1) {
#endif
RETURN (NULL);
}
if (!_mongoc_socket_setnonblock (sd)) {
GOTO (fail);
}
if (domain != AF_UNIX) {
if (!_mongoc_socket_setnodelay (sd)) {
MONGOC_WARNING ("Failed to enable TCP_NODELAY.");
}
_mongoc_socket_setkeepalive (sd);
}
sock = (mongoc_socket_t *) bson_malloc0 (sizeof *sock);
sock->sd = sd;
sock->domain = domain;
#ifdef _WIN32
sock->pid = (int) _getpid ();
#else
sock->pid = (int) getpid ();
#endif
RETURN (sock);
fail:
#ifdef _WIN32
closesocket (sd);
#else
close (sd);
#endif
RETURN (NULL);
}
/*
*--------------------------------------------------------------------------
*
* mongoc_socket_recv --
*
* A portable wrapper around recv() that also respects an absolute
* timeout.
*
* @expire_at is 0 for no blocking, -1 for infinite blocking,
* or a time using the monotonic clock to expire. Calculate this
* using bson_get_monotonic_time() + N_MICROSECONDS.
*
* Returns:
* The number of bytes received on success.
* 0 on end of stream.
* -1 on failure.
*
* Side effects:
* @buf will be read into.
*
*--------------------------------------------------------------------------
*/
ssize_t
mongoc_socket_recv (mongoc_socket_t *sock, /* IN */
void *buf, /* OUT */
size_t buflen, /* IN */
int flags, /* IN */
int64_t expire_at) /* IN */
{
ssize_t ret = 0;
bool failed = false;
ENTRY;
BSON_ASSERT (sock);
BSON_ASSERT (buf);
BSON_ASSERT (buflen);
again:
sock->errno_ = 0;
#ifdef _WIN32
ret = recv (sock->sd, (char *) buf, (int) buflen, flags);
failed = (ret == SOCKET_ERROR);
#else
ret = recv (sock->sd, buf, buflen, flags);
failed = (ret == -1);
#endif
if (failed) {
_mongoc_socket_capture_errno (sock);
if (_mongoc_socket_errno_is_again (sock) &&
_mongoc_socket_wait (sock, POLLIN, expire_at)) {
GOTO (again);
}
}
if (failed) {
RETURN (-1);
}
mongoc_counter_streams_ingress_add (ret);
RETURN (ret);
}
/* This function is copypasta of _mongoc_stream_tls_openssl_readv */
static ssize_t
_mongoc_stream_tls_secure_transport_readv (mongoc_stream_t *stream,
mongoc_iovec_t *iov,
size_t iovcnt,
size_t min_bytes,
int32_t timeout_msec)
{
mongoc_stream_tls_t *tls = (mongoc_stream_tls_t *) stream;
mongoc_stream_tls_secure_transport_t *secure_transport =
(mongoc_stream_tls_secure_transport_t *) tls->ctx;
ssize_t ret = 0;
size_t i;
size_t read_ret;
size_t iov_pos = 0;
int64_t now;
int64_t expire = 0;
BSON_ASSERT (iov);
BSON_ASSERT (iovcnt);
BSON_ASSERT (secure_transport);
ENTRY;
tls->timeout_msec = timeout_msec;
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) {
OSStatus status = SSLRead (secure_transport->ssl_ctx_ref,
(char *) iov[i].iov_base + iov_pos,
(int) (iov[i].iov_len - iov_pos),
&read_ret);
if (status != noErr) {
RETURN (-1);
}
if (expire) {
now = bson_get_monotonic_time ();
if ((expire - now) < 0) {
if (read_ret == 0) {
mongoc_counter_streams_timeout_inc ();
errno = ETIMEDOUT;
RETURN (-1);
}
tls->timeout_msec = 0;
} else {
tls->timeout_msec = (expire - now) / 1000L;
}
}
ret += read_ret;
if ((size_t) ret >= min_bytes) {
mongoc_counter_streams_ingress_add (ret);
RETURN (ret);
}
iov_pos += read_ret;
}
}
if (ret >= 0) {
mongoc_counter_streams_ingress_add (ret);
}
RETURN (ret);
}
