static void
test_delete (void)
{
mongoc_collection_t *collection;
mongoc_database_t *database;
mongoc_client_t *client;
bson_context_t *context;
bson_error_t error;
bool r;
bson_oid_t oid;
bson_t b;
int i;
client = mongoc_client_new(gTestUri);
ASSERT (client);
database = get_test_database (client);
ASSERT (database);
collection = get_test_collection (client, "test_delete");
ASSERT (collection);
context = bson_context_new(BSON_CONTEXT_NONE);
ASSERT (context);
for (i = 0; i < 100; i++) {
bson_init(&b);
bson_oid_init(&oid, context);
bson_append_oid(&b, "_id", 3, &oid);
bson_append_utf8(&b, "hello", 5, "world", 5);
r = mongoc_collection_insert(collection, MONGOC_INSERT_NONE, &b, NULL,
&error);
if (!r) {
MONGOC_WARNING("%s\n", error.message);
}
ASSERT (r);
bson_destroy(&b);
bson_init(&b);
bson_append_oid(&b, "_id", 3, &oid);
r = mongoc_collection_delete(collection, MONGOC_DELETE_NONE, &b, NULL,
&error);
if (!r) {
MONGOC_WARNING("%s\n", error.message);
}
ASSERT (r);
bson_destroy(&b);
}
r = mongoc_collection_drop (collection, &error);
ASSERT (r);
mongoc_collection_destroy(collection);
mongoc_database_destroy(database);
bson_context_destroy(context);
mongoc_client_destroy(client);
}
bool
mongoc_uncompress (int32_t compressor_id,
const uint8_t *compressed,
size_t compressed_len,
uint8_t *uncompressed,
size_t *uncompressed_len)
{
TRACE ("Uncompressing with '%s' (%d)",
mongoc_compressor_id_to_name (compressor_id),
compressor_id);
switch (compressor_id) {
case MONGOC_COMPRESSOR_SNAPPY_ID: {
#ifdef MONGOC_ENABLE_COMPRESSION_SNAPPY
snappy_status status;
status = snappy_uncompress ((const char *) compressed,
compressed_len,
(char *) uncompressed,
uncompressed_len);
return status == SNAPPY_OK;
#else
MONGOC_WARNING ("Received snappy compressed opcode, but snappy "
"compression is not compiled in");
return false;
#endif
break;
}
case MONGOC_COMPRESSOR_ZLIB_ID: {
#ifdef MONGOC_ENABLE_COMPRESSION_ZLIB
int ok;
ok = uncompress (uncompressed,
(unsigned long *) uncompressed_len,
compressed,
compressed_len);
return ok == Z_OK;
#else
MONGOC_WARNING ("Received zlib compressed opcode, but zlib "
"compression is not compiled in");
return false;
#endif
break;
}
case MONGOC_COMPRESSOR_NOOP_ID:
memcpy (uncompressed, compressed, compressed_len);
*uncompressed_len = compressed_len;
return true;
default:
MONGOC_WARNING ("Unknown compressor ID %d", compressor_id);
}
return false;
}
void
_mongoc_rpc_printf (mongoc_rpc_t *rpc)
{
bson_return_if_fail(rpc);
switch ((mongoc_opcode_t)rpc->header.opcode) {
case MONGOC_OPCODE_REPLY:
_mongoc_rpc_printf_reply(&rpc->reply);
break;
case MONGOC_OPCODE_MSG:
_mongoc_rpc_printf_msg(&rpc->msg);
break;
case MONGOC_OPCODE_UPDATE:
_mongoc_rpc_printf_update(&rpc->update);
break;
case MONGOC_OPCODE_INSERT:
_mongoc_rpc_printf_insert(&rpc->insert);
break;
case MONGOC_OPCODE_QUERY:
_mongoc_rpc_printf_query(&rpc->query);
break;
case MONGOC_OPCODE_GET_MORE:
_mongoc_rpc_printf_get_more(&rpc->get_more);
break;
case MONGOC_OPCODE_DELETE:
_mongoc_rpc_printf_delete(&rpc->delete);
break;
case MONGOC_OPCODE_KILL_CURSORS:
_mongoc_rpc_printf_kill_cursors(&rpc->kill_cursors);
break;
default:
MONGOC_WARNING("Unknown rpc type: 0x%08x", rpc->header.opcode);
break;
}
}
void
mongoc_bulk_operation_replace_one (mongoc_bulk_operation_t *bulk,
const bson_t *selector,
const bson_t *document,
bool upsert)
{
mongoc_write_command_t command = { 0 };
size_t err_off;
bson_return_if_fail (bulk);
bson_return_if_fail (selector);
bson_return_if_fail (document);
ENTRY;
if (!bson_validate (document,
(BSON_VALIDATE_DOT_KEYS | BSON_VALIDATE_DOLLAR_KEYS),
&err_off)) {
MONGOC_WARNING ("%s(): replacement document may not contain "
"$ or . in keys. Ingoring document.",
__FUNCTION__);
EXIT;
}
_mongoc_write_command_init_update (&command, selector, document, upsert,
false, bulk->ordered);
_mongoc_array_append_val (&bulk->commands, command);
EXIT;
}
void
mongoc_bulk_operation_update_one (mongoc_bulk_operation_t *bulk,
const bson_t *selector,
const bson_t *document,
bool upsert)
{
mongoc_write_command_t command = { 0 };
bson_iter_t iter;
bson_return_if_fail (bulk);
bson_return_if_fail (selector);
bson_return_if_fail (document);
ENTRY;
if (bson_iter_init (&iter, document)) {
while (bson_iter_next (&iter)) {
if (!strchr (bson_iter_key (&iter), '$')) {
MONGOC_WARNING ("%s(): update_one only works with $ operators.",
__FUNCTION__);
EXIT;
}
}
}
_mongoc_write_command_init_update (&command, selector, document, upsert,
false, bulk->ordered);
_mongoc_array_append_val (&bulk->commands, command);
EXIT;
}
static const char *
_mongoc_socket_sockopt_value_to_name (int value)
{
switch (value) {
#ifdef TCP_KEEPIDLE
case TCP_KEEPIDLE:
return "TCP_KEEPIDLE";
#endif
#ifdef TCP_KEEPALIVE
case TCP_KEEPALIVE:
return "TCP_KEEPALIVE";
#endif
#ifdef TCP_KEEPINTVL
case TCP_KEEPINTVL:
return "TCP_KEEPINTVL";
#endif
#ifdef TCP_KEEPCNT
case TCP_KEEPCNT:
return "TCP_KEEPCNT";
#endif
default:
MONGOC_WARNING ("Don't know what socketopt %d is", value);
return "Unknown option name";
}
}
void
mongoc_bulk_operation_update_one (mongoc_bulk_operation_t *bulk,
const bson_t *selector,
const bson_t *document,
bool upsert)
{
bson_t opts;
bson_error_t *error = &bulk->result.error;
ENTRY;
BULK_EXIT_IF_PRIOR_ERROR;
bson_init (&opts);
BSON_APPEND_BOOL (&opts, "upsert", upsert);
mongoc_bulk_operation_update_one_with_opts (
bulk, selector, document, &opts, error);
bson_destroy (&opts);
if (error->domain) {
MONGOC_WARNING ("%s", error->message);
}
EXIT;
}
static void
test_count (void)
{
mongoc_collection_t *collection;
mongoc_client_t *client;
bson_error_t error;
int64_t count;
bson_t b;
client = mongoc_client_new(gTestUri);
ASSERT (client);
collection = mongoc_client_get_collection(client, "test", "test");
ASSERT (collection);
bson_init(&b);
count = mongoc_collection_count(collection, MONGOC_QUERY_NONE, &b,
0, 0, NULL, &error);
bson_destroy(&b);
if (count == -1) {
MONGOC_WARNING("%s\n", error.message);
}
ASSERT (count != -1);
mongoc_collection_destroy(collection);
mongoc_client_destroy(client);
}
void
mock_server_replies (request_t *request,
mongoc_reply_flags_t flags,
int64_t cursor_id,
int32_t starting_from,
int32_t number_returned,
const char *docs_json)
{
char *quotes_replaced;
bson_t doc;
bson_error_t error;
bool r;
assert (request);
if (docs_json) {
quotes_replaced = single_quotes_to_double (docs_json);
r = bson_init_from_json (&doc, quotes_replaced, -1, &error);
if (!r) {
MONGOC_WARNING ("%s", error.message);
return;
}
bson_free (quotes_replaced);
} else {
r = bson_init_from_json (&doc, "{}", -1, &error);
}
mock_server_reply_multi (request,
flags,
&doc,
1,
cursor_id);
bson_destroy (&doc);
}
/**
* mongoc_stream_new_from_unix:
* @fd: A unix style file-descriptor.
*
* Create a new mongoc_stream_t for a UNIX file descriptor. This is
* expected to be a socket of some sort (such as a UNIX or TCP socket).
*
* This may be useful after having connected to a peer to provide a
* higher level API for reading and writing. It also allows for
* interoperability with external stream abstractions in higher level
* languages.
*
* Returns: A newly allocated mongoc_stream_t that should be freed with
* mongoc_stream_destroy().
*/
mongoc_stream_t *
mongoc_stream_new_from_unix (int fd)
{
mongoc_stream_unix_t *stream;
int flags;
bson_return_val_if_fail(fd != -1, NULL);
/*
* If we cannot put the file-descriptor in O_NONBLOCK mode, there isn't much
* we can do. Just fail.
*/
flags = fcntl(fd, F_GETFD);
if ((flags & O_NONBLOCK) != O_NONBLOCK) {
if (fcntl(fd, F_SETFD, flags | O_NONBLOCK) == -1) {
MONGOC_WARNING("Failed to set O_NONBLOCK on file descriptor!");
return NULL;
}
}
stream = bson_malloc0(sizeof *stream);
stream->fd = fd;
stream->stream.destroy = mongoc_stream_unix_destroy;
stream->stream.close = mongoc_stream_unix_close;
stream->stream.flush = mongoc_stream_unix_flush;
stream->stream.writev = mongoc_stream_unix_writev;
stream->stream.readv = mongoc_stream_unix_readv;
stream->stream.cork = mongoc_stream_unix_cork;
stream->stream.uncork = mongoc_stream_unix_uncork;
return (mongoc_stream_t *)stream;
}
void
_mongoc_rpc_gather (mongoc_rpc_t *rpc,
mongoc_array_t *array)
{
bson_return_if_fail(rpc);
bson_return_if_fail(array);
switch ((mongoc_opcode_t)rpc->header.opcode) {
case MONGOC_OPCODE_REPLY:
return _mongoc_rpc_gather_reply(&rpc->reply, array);
case MONGOC_OPCODE_MSG:
return _mongoc_rpc_gather_msg(&rpc->msg, array);
case MONGOC_OPCODE_UPDATE:
return _mongoc_rpc_gather_update(&rpc->update, array);
case MONGOC_OPCODE_INSERT:
return _mongoc_rpc_gather_insert(&rpc->insert, array);
case MONGOC_OPCODE_QUERY:
return _mongoc_rpc_gather_query(&rpc->query, array);
case MONGOC_OPCODE_GET_MORE:
return _mongoc_rpc_gather_get_more(&rpc->get_more, array);
case MONGOC_OPCODE_DELETE:
return _mongoc_rpc_gather_delete(&rpc->delete, array);
case MONGOC_OPCODE_KILL_CURSORS:
return _mongoc_rpc_gather_kill_cursors(&rpc->kill_cursors, array);
default:
MONGOC_WARNING("Unknown rpc type: 0x%08x", rpc->header.opcode);
break;
}
}
char *
_mongoc_secure_transport_extract_subject (const char *filename, const char *passphrase)
{
char *retval = NULL;
CFArrayRef items = NULL;
SecExternalItemType type = kSecItemTypeCertificate;
bool success = _mongoc_secure_transport_import_pem (filename, passphrase, &items, &type);
if (!success) {
MONGOC_WARNING("Can't find certificate in '%s'", filename);
return NULL;
}
if (type == kSecItemTypeAggregate) {
for (CFIndex i = 0; i < CFArrayGetCount (items); ++i) {
CFTypeID item_id = CFGetTypeID (CFArrayGetValueAtIndex (items, i));
if (item_id == SecCertificateGetTypeID()) {
retval = _mongoc_secure_transport_RFC2253_from_cert ((SecCertificateRef)CFArrayGetValueAtIndex (items, i));
break;
}
}
} else if (type == kSecItemTypeCertificate) {
retval = _mongoc_secure_transport_RFC2253_from_cert ((SecCertificateRef)items);
}
if (items) {
CFRelease (items);
}
return retval;
}
static void
test_insert (void)
{
mongoc_database_t *database;
mongoc_collection_t *collection;
mongoc_client_t *client;
bson_context_t *context;
bson_error_t error;
bool r;
bson_oid_t oid;
unsigned i;
bson_t b;
client = mongoc_client_new(gTestUri);
ASSERT (client);
database = get_test_database (client);
ASSERT (database);
collection = get_test_collection (client, "test_insert");
ASSERT (collection);
mongoc_collection_drop(collection, &error);
context = bson_context_new(BSON_CONTEXT_NONE);
ASSERT (context);
for (i = 0; i < 10; i++) {
bson_init(&b);
bson_oid_init(&oid, context);
bson_append_oid(&b, "_id", 3, &oid);
bson_append_utf8(&b, "hello", 5, "/world", 5);
r = mongoc_collection_insert(collection, MONGOC_INSERT_NONE, &b, NULL,
&error);
if (!r) {
MONGOC_WARNING("%s\n", error.message);
}
ASSERT (r);
bson_destroy(&b);
}
bson_init (&b);
BSON_APPEND_INT32 (&b, "$hello", 1);
r = mongoc_collection_insert (collection, MONGOC_INSERT_NONE, &b, NULL,
&error);
ASSERT (!r);
ASSERT (error.domain == MONGOC_ERROR_BSON);
ASSERT (error.code == MONGOC_ERROR_BSON_INVALID);
bson_destroy (&b);
r = mongoc_collection_drop (collection, &error);
ASSERT (r);
mongoc_collection_destroy(collection);
mongoc_database_destroy(database);
bson_context_destroy(context);
mongoc_client_destroy(client);
}
void
ha_node_setup (ha_node_t *node)
{
if (!!mkdir(node->dbpath, 0750)) {
MONGOC_WARNING("Failed to create directory \"%s\"",
node->dbpath);
abort();
}
}
static BSON_INLINE bool
_mongoc_write_concern_warn_frozen (mongoc_write_concern_t *write_concern)
{
if (write_concern->frozen) {
MONGOC_WARNING("Cannot modify a frozen write-concern.");
}
return write_concern->frozen;
}
static char *
_get_os_version (void)
{
char *ret = bson_malloc (METADATA_OS_VERSION_MAX);
bool found = false;
#ifdef _WIN32
OSVERSIONINFO osvi;
ZeroMemory (&osvi, sizeof (OSVERSIONINFO));
osvi.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
if (GetVersionEx (&osvi)) {
bson_snprintf (ret,
METADATA_OS_VERSION_MAX,
"%d.%d (%d)",
osvi.dwMajorVersion,
osvi.dwMinorVersion,
osvi.dwBuildNumber);
found = true;
} else {
MONGOC_WARNING ("Error with GetVersionEx(): %d",
GetLastError ());
}
#elif defined (_POSIX_VERSION)
struct utsname system_info;
if (uname (&system_info) >= 0) {
bson_strncpy (ret, system_info.release,
METADATA_OS_VERSION_MAX);
found = true;
} else {
MONGOC_WARNING ("Error with uname(): %d", errno);
}
#endif
if (!found) {
bson_free (ret);
ret = NULL;
}
return ret;
}
static bool
txn_abort (mongoc_client_session_t *session, bson_t *reply, bson_error_t *error)
{
bson_t cmd = BSON_INITIALIZER;
bson_t opts = BSON_INITIALIZER;
bson_error_t err_local;
bson_error_t *err_ptr = error ? error : &err_local;
bson_t reply_local = BSON_INITIALIZER;
mongoc_write_err_type_t error_type;
bool r = false;
_mongoc_bson_init_if_set (reply);
if (!mongoc_client_session_append (session, &opts, err_ptr)) {
GOTO (done);
}
if (session->txn.opts.write_concern) {
if (!mongoc_write_concern_append (session->txn.opts.write_concern,
&opts)) {
bson_set_error (err_ptr,
MONGOC_ERROR_TRANSACTION,
MONGOC_ERROR_TRANSACTION_INVALID_STATE,
"Invalid transaction write concern");
GOTO (done);
}
}
BSON_APPEND_INT32 (&cmd, "abortTransaction", 1);
/* will be reinitialized by mongoc_client_write_command_with_opts */
bson_destroy (&reply_local);
r = mongoc_client_write_command_with_opts (
session->client, "admin", &cmd, &opts, &reply_local, err_ptr);
/* Transactions Spec: "Drivers MUST retry the commitTransaction command once
* after it fails with a retryable error", same for abort */
error_type = _mongoc_write_error_get_type (r, err_ptr, &reply_local);
if (error_type == MONGOC_WRITE_ERR_RETRY) {
bson_destroy (&reply_local);
r = mongoc_client_write_command_with_opts (
session->client, "admin", &cmd, &opts, &reply_local, err_ptr);
}
if (!r) {
/* we won't return an error from abortTransaction, so warn */
MONGOC_WARNING ("Error in abortTransaction: %s", err_ptr->message);
}
done:
bson_destroy (&reply_local);
bson_destroy (&cmd);
bson_destroy (&opts);
return r;
}
char *
mongoc_ssl_extract_subject (const char *filename, const char *passphrase)
{
char *retval;
if (!filename) {
MONGOC_ERROR ("No filename provided to extract subject from");
return NULL;
}
#ifdef _WIN32
if (_access (filename, 0) != 0) {
#else
if (access (filename, R_OK) != 0) {
#endif
MONGOC_ERROR ("Can't extract subject from unreadable file: '%s'",
filename);
return NULL;
}
#if defined(MONGOC_ENABLE_SSL_OPENSSL)
retval = _mongoc_openssl_extract_subject (filename, passphrase);
#elif defined(MONGOC_ENABLE_SSL_LIBRESSL)
MONGOC_WARNING (
"libtls doesn't support automatically extracting subject from "
"certificate to use with authentication");
retval = NULL;
#elif defined(MONGOC_ENABLE_SSL_SECURE_TRANSPORT)
retval = _mongoc_secure_transport_extract_subject (filename, passphrase);
#elif defined(MONGOC_ENABLE_SSL_SECURE_CHANNEL)
retval = _mongoc_secure_channel_extract_subject (filename, passphrase);
#endif
if (!retval) {
MONGOC_ERROR ("Can't extract subject from file '%s'", filename);
}
return retval;
}
void
_mongoc_ssl_opts_copy_to (const mongoc_ssl_opt_t *src, mongoc_ssl_opt_t *dst)
{
BSON_ASSERT (src);
BSON_ASSERT (dst);
dst->pem_file = bson_strdup (src->pem_file);
dst->pem_pwd = bson_strdup (src->pem_pwd);
dst->ca_file = bson_strdup (src->ca_file);
dst->ca_dir = bson_strdup (src->ca_dir);
dst->crl_file = bson_strdup (src->crl_file);
dst->weak_cert_validation = src->weak_cert_validation;
dst->allow_invalid_hostname = src->allow_invalid_hostname;
}
char *
mongoc_uri_unescape (const char *escaped_string)
{
bson_unichar_t c;
bson_string_t *str;
unsigned int hex = 0;
const char *ptr;
const char *end;
size_t len;
BSON_ASSERT (escaped_string);
len = strlen(escaped_string);
/*
* Double check that this is a UTF-8 valid string. Bail out if necessary.
*/
if (!bson_utf8_validate(escaped_string, len, false)) {
MONGOC_WARNING("%s(): escaped_string contains invalid UTF-8",
BSON_FUNC);
return NULL;
}
ptr = escaped_string;
end = ptr + len;
str = bson_string_new(NULL);
for (; *ptr; ptr = bson_utf8_next_char(ptr)) {
c = bson_utf8_get_char(ptr);
switch (c) {
case '%':
if (((end - ptr) < 2) ||
!isxdigit(ptr[1]) ||
!isxdigit(ptr[2]) ||
#ifdef _MSC_VER
(1 != sscanf_s(&ptr[1], "%02x", &hex)) ||
#else
(1 != sscanf(&ptr[1], "%02x", &hex)) ||
#endif
!isprint(hex)) {
bson_string_free(str, true);
return NULL;
}
bson_string_append_c(str, hex);
ptr += 2;
break;
default:
bson_string_append_unichar(str, c);
break;
}
}
return bson_string_free(str, false);
}
static bool
_mongoc_matcher_op_lte_match (mongoc_matcher_op_compare_t *compare, /* IN */
bson_iter_t *iter) /* IN */
{
int code;
BSON_ASSERT (compare);
BSON_ASSERT (iter);
code = _TYPE_CODE (bson_iter_type (&compare->iter),
bson_iter_type (iter));
switch (code) {
/* Double on Left Side */
case _TYPE_CODE(BSON_TYPE_DOUBLE, BSON_TYPE_DOUBLE):
return _LTE_COMPARE (_double, _double);
case _TYPE_CODE(BSON_TYPE_DOUBLE, BSON_TYPE_BOOL):
return _LTE_COMPARE (_double, _bool);
case _TYPE_CODE(BSON_TYPE_DOUBLE, BSON_TYPE_INT32):
return _LTE_COMPARE (_double, _int32);
case _TYPE_CODE(BSON_TYPE_DOUBLE, BSON_TYPE_INT64):
return _LTE_COMPARE (_double, _int64);
/* Int32 on Left Side */
case _TYPE_CODE(BSON_TYPE_INT32, BSON_TYPE_DOUBLE):
return _LTE_COMPARE (_int32, _double);
case _TYPE_CODE(BSON_TYPE_INT32, BSON_TYPE_BOOL):
return _LTE_COMPARE (_int32, _bool);
case _TYPE_CODE(BSON_TYPE_INT32, BSON_TYPE_INT32):
return _LTE_COMPARE (_int32, _int32);
case _TYPE_CODE(BSON_TYPE_INT32, BSON_TYPE_INT64):
return _LTE_COMPARE (_int32, _int64);
/* Int64 on Left Side */
case _TYPE_CODE(BSON_TYPE_INT64, BSON_TYPE_DOUBLE):
return _LTE_COMPARE (_int64, _double);
case _TYPE_CODE(BSON_TYPE_INT64, BSON_TYPE_BOOL):
return _LTE_COMPARE (_int64, _bool);
case _TYPE_CODE(BSON_TYPE_INT64, BSON_TYPE_INT32):
return _LTE_COMPARE (_int64, _int32);
case _TYPE_CODE(BSON_TYPE_INT64, BSON_TYPE_INT64):
return _LTE_COMPARE (_int64, _int64);
default:
MONGOC_WARNING ("Implement for (Type(%d) <= Type(%d))",
bson_iter_type (&compare->iter),
bson_iter_type (iter));
break;
}
return false;
}
static void
test_load (mongoc_client_t *client,
unsigned iterations)
{
mongoc_collection_t *col;
mongoc_database_t *db;
bson_error_t error;
unsigned i;
bson_t b;
bson_t q;
bson_init(&b);
bson_append_int32(&b, "ping", 4, 1);
bson_init(&q);
db = mongoc_client_get_database(client, "admin");
col = mongoc_client_get_collection(client, "test", "test");
for (i = 0; i < iterations; i++) {
ping(db, &b);
fetch(col, &q);
}
if (!mongoc_collection_drop(col, &error)) {
MONGOC_WARNING("Failed to drop collection: %s", error.message);
}
mongoc_database_destroy(db);
db = mongoc_client_get_database(client, "test");
if (!mongoc_database_drop(db, &error)) {
MONGOC_WARNING("Failed to drop database: %s", error.message);
}
mongoc_database_destroy(db);
mongoc_collection_destroy(col);
bson_destroy(&b);
}
bool
mongoc_secure_transport_setup_ca (mongoc_stream_tls_secure_transport_t *secure_transport,
mongoc_ssl_opt_t *opt)
{
if (opt->ca_file) {
CFArrayRef items;
SecExternalItemType type = kSecItemTypeCertificate;
bool success = _mongoc_secure_transport_import_pem (opt->ca_file, NULL, &items, &type);
if (!success) {
MONGOC_WARNING("Can't find certificate in '%s'", opt->ca_file);
return false;
}
if (type == kSecItemTypeAggregate) {
CFMutableArrayRef anchors = CFArrayCreateMutable (kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
for (CFIndex i = 0; i < CFArrayGetCount (items); ++i) {
CFTypeID item_id = CFGetTypeID (CFArrayGetValueAtIndex (items, i));
if (item_id == SecCertificateGetTypeID()) {
CFArrayAppendValue (anchors, CFArrayGetValueAtIndex (items, i));
}
}
secure_transport->anchors = CFRetain (anchors);
CFRelease (items);
} else if (type == kSecItemTypeCertificate) {
secure_transport->anchors = CFRetain (items);
}
/* This should be SSLSetCertificateAuthorities But the /TLS/ tests fail when it is */
success = !SSLSetTrustedRoots (secure_transport->ssl_ctx_ref, secure_transport->anchors, true);
MONGOC_DEBUG("Setting certificate authority %s (%s)", success ? "succeeded" : "failed", opt->ca_file);
return true;
}
MONGOC_WARNING("No CA provided, using defaults");
return false;
}
static void
_mongoc_uri_assign_read_prefs_mode (mongoc_uri_t *uri) /* IN */
{
const char *str;
bson_iter_t iter;
BSON_ASSERT(uri);
if (mongoc_uri_get_option_as_bool (uri, "slaveok", false)) {
mongoc_read_prefs_set_mode(uri->read_prefs, MONGOC_READ_SECONDARY_PREFERRED);
}
if (bson_iter_init_find_case(&iter, &uri->options, "readpreference") &&
BSON_ITER_HOLDS_UTF8(&iter)) {
str = bson_iter_utf8(&iter, NULL);
if (0 == strcasecmp("primary", str)) {
mongoc_read_prefs_set_mode(uri->read_prefs, MONGOC_READ_PRIMARY);
} else if (0 == strcasecmp("primarypreferred", str)) {
mongoc_read_prefs_set_mode(uri->read_prefs, MONGOC_READ_PRIMARY_PREFERRED);
} else if (0 == strcasecmp("secondary", str)) {
mongoc_read_prefs_set_mode(uri->read_prefs, MONGOC_READ_SECONDARY);
} else if (0 == strcasecmp("secondarypreferred", str)) {
mongoc_read_prefs_set_mode(uri->read_prefs, MONGOC_READ_SECONDARY_PREFERRED);
} else if (0 == strcasecmp("nearest", str)) {
mongoc_read_prefs_set_mode(uri->read_prefs, MONGOC_READ_NEAREST);
} else {
MONGOC_WARNING("Unsupported readPreference value [readPreference=%s].", str);
}
}
/* Warn on conflict, since read preference will be validated later */
if (mongoc_read_prefs_get_mode(uri->read_prefs) == MONGOC_READ_PRIMARY &&
!bson_empty(mongoc_read_prefs_get_tags(uri->read_prefs))) {
MONGOC_WARNING("Primary read preference mode conflicts with tags.");
}
}
bool
_mongoc_openssl_import_cert_store (LPWSTR store_name,
DWORD dwFlags,
X509_STORE *openssl_store)
{
PCCERT_CONTEXT cert = NULL;
HCERTSTORE cert_store;
cert_store = CertOpenStore (
CERT_STORE_PROV_SYSTEM, /* provider */
X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, /* certificate encoding */
0, /* unused */
dwFlags, /* dwFlags */
store_name); /* system store name. "My" or "Root" */
if (cert_store == NULL) {
LPTSTR msg = NULL;
FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_ARGUMENT_ARRAY,
NULL,
GetLastError (),
LANG_NEUTRAL,
(LPTSTR) &msg,
0,
NULL);
MONGOC_ERROR ("Can't open CA store: 0x%.8X: '%s'", (unsigned int) GetLastError (), msg);
LocalFree (msg);
return false;
}
while ((cert = CertEnumCertificatesInStore (cert_store, cert)) != NULL) {
X509 *x509Obj = d2i_X509 (NULL,
(const unsigned char **) &cert->pbCertEncoded,
cert->cbCertEncoded);
if (x509Obj == NULL) {
MONGOC_WARNING (
"Error parsing X509 object from Windows certificate store");
continue;
}
X509_STORE_add_cert (openssl_store, x509Obj);
X509_free (x509Obj);
}
CertCloseStore (cert_store, 0);
return true;
}
void
mongoc_bulk_operation_insert (mongoc_bulk_operation_t *bulk,
const bson_t *document)
{
ENTRY;
BSON_ASSERT (bulk);
BSON_ASSERT (document);
if (!mongoc_bulk_operation_insert_with_opts (
bulk, document, NULL /* opts */, &bulk->result.error)) {
MONGOC_WARNING ("%s", bulk->result.error.message);
}
EXIT;
}
static void dump_message(ullong number, str_t type, msg_content_array_t* content)
{
bson_t document;
bson_error_t error;
time_t t;
mongoc_collection_t* collection = mongoc_database_get_collection(robot.mongoc_database, "message");
char* json = msg_content_array_to_json_object_string(content, "content");
time(&t);
if (!bson_init_from_json(&document, json, strlen(json), &error)) MONGOC_WARNING("%s\n", error.message);
BSON_APPEND_INT64(&document, "from", number);
BSON_APPEND_UTF8(&document, "type", type.ptr);
BSON_APPEND_TIME_T(&document, "time", t);
if (!mongoc_collection_insert(collection, MONGOC_INSERT_NONE, &document, NULL, &error)) MONGOC_WARNING("%s\n", error.message);
bson_destroy(&document);
free(json);
}
bool
_mongoc_rpc_scatter (mongoc_rpc_t *rpc,
const uint8_t *buf,
size_t buflen)
{
mongoc_opcode_t opcode;
bson_return_val_if_fail(rpc, false);
bson_return_val_if_fail(buf, false);
bson_return_val_if_fail(buflen, false);
memset (rpc, 0, sizeof *rpc);
if (BSON_UNLIKELY(buflen < 16)) {
return false;
}
if (!_mongoc_rpc_scatter_header(&rpc->header, buf, 16)) {
return false;
}
opcode = BSON_UINT32_FROM_LE(rpc->header.opcode);
switch (opcode) {
case MONGOC_OPCODE_REPLY:
return _mongoc_rpc_scatter_reply(&rpc->reply, buf, buflen);
case MONGOC_OPCODE_MSG:
return _mongoc_rpc_scatter_msg(&rpc->msg, buf, buflen);
case MONGOC_OPCODE_UPDATE:
return _mongoc_rpc_scatter_update(&rpc->update, buf, buflen);
case MONGOC_OPCODE_INSERT:
return _mongoc_rpc_scatter_insert(&rpc->insert, buf, buflen);
case MONGOC_OPCODE_QUERY:
return _mongoc_rpc_scatter_query(&rpc->query, buf, buflen);
case MONGOC_OPCODE_GET_MORE:
return _mongoc_rpc_scatter_get_more(&rpc->get_more, buf, buflen);
case MONGOC_OPCODE_DELETE:
return _mongoc_rpc_scatter_delete(&rpc->delete, buf, buflen);
case MONGOC_OPCODE_KILL_CURSORS:
return _mongoc_rpc_scatter_kill_cursors(&rpc->kill_cursors, buf, buflen);
default:
MONGOC_WARNING("Unknown rpc type: 0x%08x", opcode);
return false;
}
}
void
_mongoc_cursor_get_host (mongoc_cursor_t *cursor,
mongoc_host_list_t *host)
{
bson_return_if_fail(cursor);
bson_return_if_fail(host);
memset(host, 0, sizeof *host);
if (!cursor->hint) {
MONGOC_WARNING("%s(): Must send query before fetching peer.",
__FUNCTION__);
return;
}
*host = cursor->client->cluster.nodes[cursor->hint - 1].host;
host->next = NULL;
}
void
mongoc_bulk_operation_remove_one (mongoc_bulk_operation_t *bulk, /* IN */
const bson_t *selector) /* IN */
{
bson_error_t *error = &bulk->result.error;
ENTRY;
BULK_EXIT_IF_PRIOR_ERROR;
mongoc_bulk_operation_remove_one_with_opts (bulk, selector, NULL, error);
if (error->domain) {
MONGOC_WARNING ("%s", error->message);
}
EXIT;
}
static void
fetch (mongoc_collection_t *col,
const bson_t *spec)
{
mongoc_cursor_t *cursor;
const bson_t *b;
bson_error_t error;
cursor = mongoc_collection_find(col, MONGOC_QUERY_NONE, 0, 0, spec, NULL, NULL);
while (mongoc_cursor_next(cursor, &b)) {
BSON_ASSERT(b);
print_doc(b);
}
if (mongoc_cursor_error(cursor, &error)) {
MONGOC_WARNING("Cursor error: %s", error.message);
}
mongoc_cursor_destroy(cursor);
}
