static ssize_t
_mongoc_stream_socket_writev (mongoc_stream_t *stream,
mongoc_iovec_t *iov,
size_t iovcnt,
int32_t timeout_msec)
{
mongoc_stream_socket_t *ss = (mongoc_stream_socket_t *) stream;
int64_t expire_at;
ssize_t ret;
ENTRY;
if (ss->sock) {
expire_at = get_expiration (timeout_msec);
ret = mongoc_socket_sendv (ss->sock, iov, iovcnt, expire_at);
errno = mongoc_socket_errno (ss->sock);
RETURN (ret);
}
RETURN (-1);
}
static mongoc_stream_t *
mongoc_client_connect_tcp (const mongoc_uri_t *uri,
const mongoc_host_list_t *host,
bson_error_t *error)
{
mongoc_socket_t *sock = NULL;
struct addrinfo hints;
struct addrinfo *result, *rp;
int32_t connecttimeoutms = MONGOC_DEFAULT_CONNECTTIMEOUTMS;
int64_t expire_at;
const bson_t *options;
bson_iter_t iter;
char portstr [8];
int s;
ENTRY;
bson_return_val_if_fail (uri, NULL);
bson_return_val_if_fail (host, NULL);
if ((options = mongoc_uri_get_options (uri)) &&
bson_iter_init_find (&iter, options, "connecttimeoutms") &&
BSON_ITER_HOLDS_INT32 (&iter)) {
if (!(connecttimeoutms = bson_iter_int32(&iter))) {
connecttimeoutms = MONGOC_DEFAULT_CONNECTTIMEOUTMS;
}
}
BSON_ASSERT (connecttimeoutms);
expire_at = bson_get_monotonic_time () + (connecttimeoutms * 1000L);
bson_snprintf (portstr, sizeof portstr, "%hu", host->port);
memset (&hints, 0, sizeof hints);
hints.ai_family = host->family;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = 0;
hints.ai_protocol = 0;
s = getaddrinfo (host->host, portstr, &hints, &result);
if (s != 0) {
mongoc_counter_dns_failure_inc ();
bson_set_error(error,
MONGOC_ERROR_STREAM,
MONGOC_ERROR_STREAM_NAME_RESOLUTION,
"Failed to resolve %s",
host->host);
RETURN (NULL);
}
mongoc_counter_dns_success_inc ();
for (rp = result; rp; rp = rp->ai_next) {
/*
* Create a new non-blocking socket.
*/
if (!(sock = mongoc_socket_new (rp->ai_family,
rp->ai_socktype,
rp->ai_protocol))) {
continue;
}
/*
* Try to connect to the peer.
*/
if (0 != mongoc_socket_connect (sock,
rp->ai_addr,
(socklen_t)rp->ai_addrlen,
expire_at)) {
char errmsg_buf[32];
const char * errmsg;
errmsg = bson_strerror_r (mongoc_socket_errno (sock), errmsg_buf, sizeof errmsg_buf);
MONGOC_WARNING ("Failed to connect, error: %d, %s\n",
mongoc_socket_errno(sock),
errmsg);
mongoc_socket_destroy (sock);
sock = NULL;
continue;
}
break;
}
if (!sock) {
bson_set_error (error,
MONGOC_ERROR_STREAM,
MONGOC_ERROR_STREAM_CONNECT,
"Failed to connect to target host: %s",
host->host_and_port);
freeaddrinfo (result);
RETURN (NULL);
}
freeaddrinfo (result);
return mongoc_stream_socket_new (sock);
}
static ssize_t
_mongoc_stream_socket_readv (mongoc_stream_t *stream,
mongoc_iovec_t *iov,
size_t iovcnt,
size_t min_bytes,
int32_t timeout_msec)
{
mongoc_stream_socket_t *ss = (mongoc_stream_socket_t *) stream;
int64_t expire_at;
ssize_t ret = 0;
ssize_t nread;
size_t cur = 0;
ENTRY;
BSON_ASSERT (ss);
BSON_ASSERT (ss->sock);
expire_at = get_expiration (timeout_msec);
/*
* This isn't ideal, we should plumb through to recvmsg(), but we
* don't actually use this in any way but to a single buffer
* currently anyway, so should be just fine.
*/
for (;;) {
nread = mongoc_socket_recv (
ss->sock, iov[cur].iov_base, iov[cur].iov_len, 0, expire_at);
if (nread <= 0) {
if (ret >= (ssize_t) min_bytes) {
RETURN (ret);
}
errno = mongoc_socket_errno (ss->sock);
RETURN (-1);
}
ret += nread;
while ((cur < iovcnt) && (nread >= (ssize_t) iov[cur].iov_len)) {
nread -= iov[cur++].iov_len;
}
if (cur == iovcnt) {
break;
}
if (ret >= (ssize_t) min_bytes) {
RETURN (ret);
}
iov[cur].iov_base = ((char *) iov[cur].iov_base) + nread;
iov[cur].iov_len -= nread;
BSON_ASSERT (iovcnt - cur);
BSON_ASSERT (iov[cur].iov_len);
}
RETURN (ret);
}
static ssize_t
_mongoc_socket_try_sendv_slow (mongoc_socket_t *sock, /* IN */
mongoc_iovec_t *iov, /* IN */
size_t iovcnt) /* IN */
{
ssize_t ret = 0;
size_t i;
ssize_t wrote;
ENTRY;
BSON_ASSERT (sock);
BSON_ASSERT (iov);
BSON_ASSERT (iovcnt);
for (i = 0; i < iovcnt; i++) {
wrote = send (sock->sd, iov[i].iov_base, iov[i].iov_len, 0);
#ifdef _WIN32
if (wrote == SOCKET_ERROR) {
#else
if (wrote == -1) {
#endif
_mongoc_socket_capture_errno (sock);
if (!_mongoc_socket_errno_is_again (sock)) {
RETURN (-1);
}
RETURN (ret ? ret : -1);
}
ret += wrote;
if (wrote != iov[i].iov_len) {
RETURN (ret);
}
}
RETURN (ret);
}
/*
*--------------------------------------------------------------------------
*
* _mongoc_socket_try_sendv --
*
* Helper used by mongoc_socket_sendv() to try to write as many
* bytes to the underlying socket until the socket buffer is full.
*
* This is performed in a non-blocking fashion.
*
* Returns:
* -1 on failure. the number of bytes written on success.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
static ssize_t
_mongoc_socket_try_sendv (mongoc_socket_t *sock, /* IN */
mongoc_iovec_t *iov, /* IN */
size_t iovcnt) /* IN */
{
#ifdef _WIN32
DWORD dwNumberofBytesSent = 0;
int ret;
#else
struct msghdr msg;
ssize_t ret;
#endif
ENTRY;
BSON_ASSERT (sock);
BSON_ASSERT (iov);
BSON_ASSERT (iovcnt);
DUMP_IOVEC (sendbuf, iov, iovcnt);
#ifdef _WIN32
ret = WSASend (
sock->sd, (LPWSABUF) iov, iovcnt, &dwNumberofBytesSent, 0, NULL, NULL);
TRACE ("WSASend sent: %ld (out of: %ld), ret: %d",
dwNumberofBytesSent,
iov->iov_len,
ret);
#else
memset (&msg, 0, sizeof msg);
msg.msg_iov = iov;
msg.msg_iovlen = (int) iovcnt;
ret = sendmsg (sock->sd,
&msg,
#ifdef MSG_NOSIGNAL
MSG_NOSIGNAL);
#else
0);
#endif
TRACE ("Send %ld out of %ld bytes", ret, iov->iov_len);
#endif
#ifdef _WIN32
if (ret == SOCKET_ERROR) {
#else
if (ret == -1) {
#endif
_mongoc_socket_capture_errno (sock);
/*
* Check to see if we have sent an iovec too large for sendmsg to
* complete. If so, we need to fallback to the slow path of multiple
* send() commands.
*/
#ifdef _WIN32
if (mongoc_socket_errno (sock) == WSAEMSGSIZE) {
#else
if (mongoc_socket_errno (sock) == EMSGSIZE) {
#endif
RETURN (_mongoc_socket_try_sendv_slow (sock, iov, iovcnt));
}
RETURN (-1);
}
#ifdef _WIN32
RETURN (dwNumberofBytesSent);
#else
RETURN (ret);
#endif
}
/*
*--------------------------------------------------------------------------
*
* mongoc_socket_sendv --
*
* A wrapper around using sendmsg() to send an iovec.
* This also deals with the structure differences between
* WSABUF and struct iovec.
*
* @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:
* -1 on failure.
* the number of bytes written on success.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
ssize_t
mongoc_socket_sendv (mongoc_socket_t *sock, /* IN */
mongoc_iovec_t *in_iov, /* IN */
size_t iovcnt, /* IN */
int64_t expire_at) /* IN */
{
ssize_t ret = 0;
ssize_t sent;
size_t cur = 0;
mongoc_iovec_t *iov;
ENTRY;
BSON_ASSERT (sock);
BSON_ASSERT (in_iov);
BSON_ASSERT (iovcnt);
iov = bson_malloc (sizeof (*iov) * iovcnt);
memcpy (iov, in_iov, sizeof (*iov) * iovcnt);
for (;;) {
sent = _mongoc_socket_try_sendv (sock, &iov[cur], iovcnt - cur);
TRACE (
"Sent %ld (of %ld) out of iovcnt=%ld", sent, iov[cur].iov_len, iovcnt);
/*
* If we failed with anything other than EAGAIN or EWOULDBLOCK,
* we should fail immediately as there is another issue with the
* underlying socket.
*/
if (sent == -1) {
if (!_mongoc_socket_errno_is_again (sock)) {
ret = -1;
GOTO (CLEANUP);
}
}
/*
* Update internal stream counters.
*/
if (sent > 0) {
ret += sent;
mongoc_counter_streams_egress_add (sent);
/*
* Subtract the sent amount from what we still need to send.
*/
while ((cur < iovcnt) && (sent >= (ssize_t) iov[cur].iov_len)) {
TRACE ("still got bytes left: sent -= iov_len: %ld -= %ld",
sent,
iov[cur].iov_len);
sent -= iov[cur++].iov_len;
}
/*
* Check if that made us finish all of the iovecs. If so, we are done
* sending data over the socket.
*/
if (cur == iovcnt) {
TRACE ("%s", "Finished the iovecs");
break;
}
/*
* Increment the current iovec buffer to its proper offset and adjust
* the number of bytes to write.
*/
TRACE ("Seeked io_base+%ld", sent);
TRACE (
"Subtracting iov_len -= sent; %ld -= %ld", iov[cur].iov_len, sent);
iov[cur].iov_base = ((char *) iov[cur].iov_base) + sent;
iov[cur].iov_len -= sent;
TRACE ("iov_len remaining %ld", iov[cur].iov_len);
BSON_ASSERT (iovcnt - cur);
BSON_ASSERT (iov[cur].iov_len);
} else if (OPERATION_EXPIRED (expire_at)) {
if (expire_at > 0) {
mongoc_counter_streams_timeout_inc ();
}
GOTO (CLEANUP);
}
/*
* Block on poll() until our desired condition is met.
*/
if (!_mongoc_socket_wait (sock, POLLOUT, expire_at)) {
GOTO (CLEANUP);
}
}
CLEANUP:
bson_free (iov);
RETURN (ret);
}
int
mongoc_socket_getsockname (mongoc_socket_t *sock, /* IN */
struct sockaddr *addr, /* OUT */
mongoc_socklen_t *addrlen) /* INOUT */
{
int ret;
ENTRY;
BSON_ASSERT (sock);
ret = getsockname (sock->sd, addr, addrlen);
_mongoc_socket_capture_errno (sock);
RETURN (ret);
}
