bson_reader_t *
bson_reader_new_from_file (const char *path, /* IN */
bson_error_t *error) /* OUT */
{
char errmsg[32];
int fd;
bson_return_val_if_fail (path, NULL);
#ifdef BSON_OS_WIN32
fd = _open (path, (_O_RDONLY | _O_BINARY));
#else
fd = open (path, O_RDONLY);
#endif
if (fd == -1) {
bson_strerror_r (errno, errmsg, sizeof errmsg);
bson_set_error (error,
BSON_ERROR_READER,
BSON_ERROR_READER_BADFD,
"%s", errmsg);
return NULL;
}
return bson_reader_new_from_fd (fd, true);
}
bson_reader_t *
bson_reader_new_from_file (const char *path, /* IN */
bson_error_t *error) /* OUT */
{
char errmsg_buf[BSON_ERROR_BUFFER_SIZE];
char *errmsg;
int fd;
bson_return_val_if_fail (path, NULL);
#ifdef BSON_OS_WIN32
if (_sopen_s (&fd, path, (_O_RDONLY | _O_BINARY), _SH_DENYNO, 0) != 0) {
fd = -1;
}
#else
fd = open (path, O_RDONLY);
#endif
if (fd == -1) {
errmsg = bson_strerror_r (errno, errmsg_buf, sizeof errmsg_buf);
bson_set_error (error,
BSON_ERROR_READER,
BSON_ERROR_READER_BADFD,
"%s", errmsg);
return NULL;
}
return bson_reader_new_from_fd (fd, true);
}
bool
_mongoc_stream_writev_full (mongoc_stream_t *stream,
mongoc_iovec_t *iov,
size_t iovcnt,
int32_t timeout_msec,
bson_error_t *error)
{
size_t total_bytes = 0;
int i;
ssize_t r;
ENTRY;
for (i = 0; i < iovcnt; i++) {
total_bytes += iov[i].iov_len;
}
r = mongoc_stream_writev (stream, iov, iovcnt, timeout_msec);
TRACE ("writev returned: %ld", r);
if (r < 0) {
if (error) {
char buf[128];
char *errstr;
errstr = bson_strerror_r (errno, buf, sizeof (buf));
bson_set_error (error,
MONGOC_ERROR_STREAM,
MONGOC_ERROR_STREAM_SOCKET,
"Failure during socket delivery: %s (%d)",
errstr,
errno);
}
RETURN (false);
}
if (r != total_bytes) {
bson_set_error (error,
MONGOC_ERROR_STREAM,
MONGOC_ERROR_STREAM_SOCKET,
"Failure to send all requested bytes (only sent: %" PRIu64
"/%" PRId64 " in %dms) during socket delivery",
(uint64_t) r,
(int64_t) total_bytes,
timeout_msec);
RETURN (false);
}
RETURN (true);
}
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);
}
