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); }