mongoc_client_t *
_mongoc_client_new_from_uri (const mongoc_uri_t *uri, mongoc_topology_t *topology)
{
mongoc_client_t *client;
const mongoc_read_prefs_t *read_prefs;
const mongoc_read_concern_t *read_concern;
const mongoc_write_concern_t *write_concern;
BSON_ASSERT (uri);
#ifndef MONGOC_ENABLE_SSL
if (mongoc_uri_get_ssl (uri)) {
MONGOC_ERROR ("Can't create SSL client, SSL not enabled in this build.");
return NULL;
}
#endif
client = (mongoc_client_t *)bson_malloc0(sizeof *client);
client->uri = mongoc_uri_copy (uri);
client->request_id = rand ();
client->initiator = mongoc_client_default_stream_initiator;
client->initiator_data = client;
client->topology = topology;
write_concern = mongoc_uri_get_write_concern (client->uri);
client->write_concern = mongoc_write_concern_copy (write_concern);
read_concern = mongoc_uri_get_read_concern (client->uri);
client->read_concern = mongoc_read_concern_copy (read_concern);
read_prefs = mongoc_uri_get_read_prefs_t (client->uri);
client->read_prefs = mongoc_read_prefs_copy (read_prefs);
mongoc_cluster_init (&client->cluster, client->uri, client);
#ifdef MONGOC_ENABLE_SSL
client->use_ssl = false;
if (mongoc_uri_get_ssl (client->uri)) {
/* sets use_ssl = true */
mongoc_client_set_ssl_opts (client, mongoc_ssl_opt_get_default ());
}
#endif
mongoc_counter_clients_active_inc ();
return client;
}
mongoc_client_pool_t *
mongoc_client_pool_new (const mongoc_uri_t *uri)
{
mongoc_topology_t *topology;
mongoc_client_pool_t *pool;
const bson_t *b;
bson_iter_t iter;
ENTRY;
BSON_ASSERT (uri);
#ifndef MONGOC_ENABLE_SSL
if (mongoc_uri_get_ssl (uri)) {
MONGOC_ERROR ("Can't create SSL client pool,"
" SSL not enabled in this build.");
return NULL;
}
#endif
pool = (mongoc_client_pool_t *)bson_malloc0(sizeof *pool);
mongoc_mutex_init(&pool->mutex);
_mongoc_queue_init(&pool->queue);
pool->uri = mongoc_uri_copy(uri);
pool->min_pool_size = 0;
pool->max_pool_size = 100;
pool->size = 0;
pool->topology_scanner_started = false;
topology = mongoc_topology_new(uri, false);
pool->topology = topology;
mongoc_client_metadata_init (&pool->topology->scanner->ismaster_metadata);
pool->error_api_version = MONGOC_ERROR_API_VERSION_LEGACY;
b = mongoc_uri_get_options(pool->uri);
if (bson_iter_init_find_case(&iter, b, "minpoolsize")) {
if (BSON_ITER_HOLDS_INT32(&iter)) {
pool->min_pool_size = BSON_MAX(0, bson_iter_int32(&iter));
}
}
if (bson_iter_init_find_case(&iter, b, "maxpoolsize")) {
if (BSON_ITER_HOLDS_INT32(&iter)) {
pool->max_pool_size = BSON_MAX(1, bson_iter_int32(&iter));
}
}
mongoc_counter_client_pools_active_inc();
RETURN(pool);
}
SEXP R_mongo_client_new(SEXP uri_string) {
mongoc_client_t *client = mongoc_client_new (translateCharUTF8(asChar(uri_string)));
if(!client)
stop("Invalid uri_string. Try mongodb://localhost");
//set ssl certificates here
if (mongoc_uri_get_ssl (mongoc_client_get_uri(client))) {
mongoc_client_set_ssl_opts(client, mongoc_ssl_opt_get_default());
}
//verify that server is online
//can fail if user has limited priv
/*
bson_error_t err;
if(!mongoc_client_get_server_status(client, NULL, NULL, &err)){
mongoc_client_destroy(client);
stop(err.message);
}
*/
return client2r(client);
}
static 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 = user_data;
const bson_t *options;
bson_iter_t iter;
const char *mechanism;
#endif
bson_return_val_if_fail (uri, NULL);
bson_return_val_if_fail (host, NULL);
#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) {
options = mongoc_uri_get_options (uri);
mechanism = mongoc_uri_get_auth_mechanism (uri);
if ((bson_iter_init_find_case (&iter, options, "ssl") &&
bson_iter_as_bool (&iter)) ||
(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;
}
if (!mongoc_stream_tls_do_handshake (base_stream, -1) ||
!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);
base_stream = NULL;
return NULL;
}
}
}
#endif
return base_stream ? mongoc_stream_buffered_new (base_stream, 1024) : NULL;
}
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;
}
bool uri::ssl() const {
return mongoc_uri_get_ssl(_impl->uri_t);
}
static bool hippo_mongo_driver_manager_apply_ssl_opts(mongoc_client_t *client, const Array options)
{
mongoc_ssl_opt_t ssl_opt = { NULL, NULL, NULL, NULL, NULL, true };
Array ssl;
bool apply_ssl = false;
if (!mongoc_uri_get_ssl(mongoc_client_get_uri(client))) {
return 0;
}
if (options.exists(s_MongoDBDriverManager_context)) {
Array context;
if (!options[s_MongoDBDriverManager_context].isResource()) {
return 0;
}
#if HIPPO_HHVM_VERSION >= 30900
req::ptr<StreamContext> sc;
#else
SmartPtr<StreamContext> sc;
#endif
sc = cast<StreamContext>(options[s_MongoDBDriverManager_context]);
context = sc->getOptions();
if (!context.exists(s_MongoDBDriverManager_context_ssl)) {
return 0;
}
if (!context[s_MongoDBDriverManager_context_ssl].isArray()) {
return 0;
}
ssl = context[s_MongoDBDriverManager_context_ssl].toArray();
} else {
ssl = options;
}
if (ssl.exists(s_MongoDBDriverManager_context_ssl_allow_self_signed) && ssl[s_MongoDBDriverManager_context_ssl_allow_self_signed].isBoolean()) {
apply_ssl = true;
ssl_opt.weak_cert_validation = (bool)true;//ssl[s_MongoDBDriverManager_context_ssl_allow_self_signed].toBoolean();
}
if (ssl.exists(s_MongoDBDriverManager_context_ssl_local_cert) && ssl[s_MongoDBDriverManager_context_ssl_local_cert].isString()) {
apply_ssl = true;
ssl_opt.pem_file = ssl[s_MongoDBDriverManager_context_ssl_local_cert].toString().c_str();
}
if (ssl.exists(s_MongoDBDriverManager_context_ssl_passphrase) && ssl[s_MongoDBDriverManager_context_ssl_passphrase].isString()) {
apply_ssl = true;
ssl_opt.pem_pwd = ssl[s_MongoDBDriverManager_context_ssl_passphrase].toString().c_str();
}
if (ssl.exists(s_MongoDBDriverManager_context_ssl_cafile) && ssl[s_MongoDBDriverManager_context_ssl_cafile].isString()) {
apply_ssl = true;
ssl_opt.ca_file = ssl[s_MongoDBDriverManager_context_ssl_cafile].toString().c_str();
}
if (ssl.exists(s_MongoDBDriverManager_context_ssl_capath) && ssl[s_MongoDBDriverManager_context_ssl_capath].isString()) {
apply_ssl = true;
ssl_opt.ca_dir = ssl[s_MongoDBDriverManager_context_ssl_capath].toString().c_str();
}
if (apply_ssl) {
mongoc_client_set_ssl_opts(client, &ssl_opt);
}
return 1;
}