mongoc_uri_t *
mongoc_uri_new (const char *uri_string)
{
mongoc_uri_t *uri;
#ifdef MONGOC_EXPERIMENTAL_FEATURES
int32_t max_staleness_ms;
#endif
uri = (mongoc_uri_t *)bson_malloc0(sizeof *uri);
bson_init(&uri->options);
bson_init(&uri->credentials);
/* Initialize read_prefs since tag parsing may add to it */
uri->read_prefs = mongoc_read_prefs_new(MONGOC_READ_PRIMARY);
/* Initialize empty read_concern */
uri->read_concern = mongoc_read_concern_new ();
if (!uri_string) {
uri_string = "mongodb://127.0.0.1/";
}
if (!mongoc_uri_parse(uri, uri_string)) {
mongoc_uri_destroy(uri);
return NULL;
}
uri->str = bson_strdup(uri_string);
_mongoc_uri_assign_read_prefs_mode(uri);
#ifdef MONGOC_EXPERIMENTAL_FEATURES
max_staleness_ms = mongoc_uri_get_option_as_int32 (uri, "maxstalenessms", 0);
mongoc_read_prefs_set_max_staleness_ms (uri->read_prefs, max_staleness_ms);
#endif
if (!mongoc_read_prefs_is_valid(uri->read_prefs)) {
mongoc_uri_destroy(uri);
return NULL;
}
_mongoc_uri_build_write_concern (uri);
if (!mongoc_write_concern_is_valid (uri->write_concern)) {
mongoc_uri_destroy(uri);
return NULL;
}
return uri;
}
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;
int64_t expire_at;
char portstr [8];
int s;
ENTRY;
BSON_ASSERT (uri);
BSON_ASSERT (host);
connecttimeoutms = mongoc_uri_get_option_as_int32 (
uri, "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;
char errmsg_buf[BSON_ERROR_BUFFER_SIZE];
char ip[255];
mongoc_socket_inet_ntop (rp, ip, sizeof ip);
errmsg = bson_strerror_r (
mongoc_socket_errno (sock), errmsg_buf, sizeof errmsg_buf);
MONGOC_WARNING ("Failed to connect to: %s:%d, error: %d, %s\n",
ip,
host->port,
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);
}
mongoc_stream_t *
mongoc_client_default_stream_initiator (const mongoc_uri_t *uri,
const mongoc_host_list_t *host,
void *user_data,
bson_error_t *error)
{
mongoc_stream_t *base_stream = NULL;
#ifdef MONGOC_ENABLE_SSL
mongoc_client_t *client = (mongoc_client_t *)user_data;
const char *mechanism;
int32_t connecttimeoutms;
#endif
BSON_ASSERT (uri);
BSON_ASSERT (host);
#ifndef MONGOC_ENABLE_SSL
if (mongoc_uri_get_ssl (uri)) {
bson_set_error (error,
MONGOC_ERROR_CLIENT,
MONGOC_ERROR_CLIENT_NO_ACCEPTABLE_PEER,
"SSL is not enabled in this build of mongo-c-driver.");
return NULL;
}
#endif
switch (host->family) {
#if defined(AF_INET6)
case AF_INET6:
#endif
case AF_INET:
base_stream = mongoc_client_connect_tcp (uri, host, error);
break;
case AF_UNIX:
base_stream = mongoc_client_connect_unix (uri, host, error);
break;
default:
bson_set_error (error,
MONGOC_ERROR_STREAM,
MONGOC_ERROR_STREAM_INVALID_TYPE,
"Invalid address family: 0x%02x", host->family);
break;
}
#ifdef MONGOC_ENABLE_SSL
if (base_stream) {
mechanism = mongoc_uri_get_auth_mechanism (uri);
if (client->use_ssl ||
(mechanism && (0 == strcmp (mechanism, "MONGODB-X509")))) {
base_stream = mongoc_stream_tls_new (base_stream, &client->ssl_opts,
true);
if (!base_stream) {
bson_set_error (error,
MONGOC_ERROR_STREAM,
MONGOC_ERROR_STREAM_SOCKET,
"Failed initialize TLS state.");
return NULL;
}
connecttimeoutms = mongoc_uri_get_option_as_int32 (
uri, "connecttimeoutms", MONGOC_DEFAULT_CONNECTTIMEOUTMS);
if (!mongoc_stream_tls_do_handshake (base_stream, connecttimeoutms) ||
!mongoc_stream_tls_check_cert (base_stream, host->host)) {
bson_set_error (error,
MONGOC_ERROR_STREAM,
MONGOC_ERROR_STREAM_SOCKET,
"Failed to handshake and validate TLS certificate.");
mongoc_stream_destroy (base_stream);
return NULL;
}
}
}
#endif
return base_stream ? mongoc_stream_buffered_new (base_stream, 1024) : NULL;
}
static void
_mongoc_uri_build_write_concern (mongoc_uri_t *uri) /* IN */
{
mongoc_write_concern_t *write_concern;
const char *str;
bson_iter_t iter;
int32_t wtimeoutms;
int value;
BSON_ASSERT (uri);
write_concern = mongoc_write_concern_new ();
if (bson_iter_init_find_case (&iter, &uri->options, "safe") &&
BSON_ITER_HOLDS_BOOL (&iter)) {
mongoc_write_concern_set_w (write_concern,
bson_iter_bool (&iter) ? 1 : MONGOC_WRITE_CONCERN_W_UNACKNOWLEDGED);
}
wtimeoutms = mongoc_uri_get_option_as_int32(uri, "wtimeoutms", 0);
if (bson_iter_init_find_case (&iter, &uri->options, "journal") &&
BSON_ITER_HOLDS_BOOL (&iter)) {
mongoc_write_concern_set_journal (write_concern, bson_iter_bool (&iter));
}
if (bson_iter_init_find_case (&iter, &uri->options, "w")) {
if (BSON_ITER_HOLDS_INT32 (&iter)) {
value = bson_iter_int32 (&iter);
switch (value) {
case MONGOC_WRITE_CONCERN_W_ERRORS_IGNORED:
case MONGOC_WRITE_CONCERN_W_UNACKNOWLEDGED:
/* Warn on conflict, since write concern will be validated later */
if (mongoc_write_concern_get_journal(write_concern)) {
MONGOC_WARNING("Journal conflicts with w value [w=%d].", value);
}
mongoc_write_concern_set_w(write_concern, value);
break;
default:
if (value > 0) {
mongoc_write_concern_set_w (write_concern, value);
if (value > 1) {
mongoc_write_concern_set_wtimeout (write_concern, wtimeoutms);
}
break;
}
MONGOC_WARNING ("Unsupported w value [w=%d].", value);
break;
}
} else if (BSON_ITER_HOLDS_UTF8 (&iter)) {
str = bson_iter_utf8 (&iter, NULL);
if (0 == strcasecmp ("majority", str)) {
mongoc_write_concern_set_wmajority (write_concern, wtimeoutms);
} else {
mongoc_write_concern_set_wtag (write_concern, str);
mongoc_write_concern_set_wtimeout (write_concern, wtimeoutms);
}
} else {
BSON_ASSERT (false);
}
}
uri->write_concern = write_concern;
}
