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); }
void mongoc_log_trace_bytes (const char *domain, const uint8_t *_b, size_t _l) { bson_string_t *str, *astr; int32_t _i; uint8_t _v; #ifdef MONGOC_TRACE if (!gLogTrace) { return; } #endif str = bson_string_new(NULL); astr = bson_string_new(NULL); for (_i = 0; _i < _l; _i++) { _v = *(_b + _i); if ((_i % 16) == 0) { bson_string_append_printf(str, "%05x: ", _i); } bson_string_append_printf(str, " %02x", _v); if (isprint(_v)) { bson_string_append_printf(astr, " %c", _v); } else { bson_string_append(astr, " ."); } if ((_i % 16) == 15) { mongoc_log(MONGOC_LOG_LEVEL_TRACE, domain, "%s %s", str->str, astr->str); bson_string_truncate(str, 0); bson_string_truncate(astr, 0); } else if ((_i % 16) == 7) { bson_string_append(str, " "); bson_string_append(astr, " "); } } if (_i != 16) { mongoc_log(MONGOC_LOG_LEVEL_TRACE, domain, "%-56s %s", str->str, astr->str); } bson_string_free(str, true); bson_string_free(astr, true); }
mongoc_client_t * ha_sharded_cluster_get_client (ha_sharded_cluster_t *cluster) { const ha_node_t *iter; mongoc_client_t *client; bson_string_t *str; BSON_ASSERT (cluster); BSON_ASSERT (cluster->routers); str = bson_string_new ("mongodb://"); for (iter = cluster->routers; iter; iter = iter->next) { bson_string_append_printf (str, "127.0.0.1:%hu%s", iter->port, iter->next ? "," : ""); } bson_string_append (str, "/"); client = mongoc_client_new (str->str); bson_string_free (str, TRUE); return client; }
/* * If error is not set, set code from first document in array like * [{"code": 64, "errmsg": "duplicate"}, ...]. Format the error message * from all errors in array. */ static void _set_error_from_response (bson_t *bson_array, mongoc_error_domain_t domain, const char *error_type, bson_error_t *error /* OUT */) { bson_iter_t array_iter; bson_iter_t doc_iter; bson_string_t *compound_err; const char *errmsg = NULL; int32_t code = 0; uint32_t n_keys, i; compound_err = bson_string_new (NULL); n_keys = bson_count_keys (bson_array); if (n_keys > 1) { bson_string_append_printf ( compound_err, "Multiple %s errors: ", error_type); } if (!bson_empty0 (bson_array) && bson_iter_init (&array_iter, bson_array)) { /* get first code and all error messages */ i = 0; while (bson_iter_next (&array_iter)) { if (BSON_ITER_HOLDS_DOCUMENT (&array_iter) && bson_iter_recurse (&array_iter, &doc_iter)) { /* parse doc, which is like {"code": 64, "errmsg": "duplicate"} */ while (bson_iter_next (&doc_iter)) { /* use the first error code we find */ if (BSON_ITER_IS_KEY (&doc_iter, "code") && code == 0) { code = bson_iter_int32 (&doc_iter); } else if (BSON_ITER_IS_KEY (&doc_iter, "errmsg")) { errmsg = bson_iter_utf8 (&doc_iter, NULL); /* build message like 'Multiple write errors: "foo", "bar"' */ if (n_keys > 1) { bson_string_append_printf (compound_err, "\"%s\"", errmsg); if (i < n_keys - 1) { bson_string_append (compound_err, ", "); } } else { /* single error message */ bson_string_append (compound_err, errmsg); } } } i++; } } if (code && compound_err->len) { bson_set_error ( error, domain, (uint32_t) code, "%s", compound_err->str); } } bson_string_free (compound_err, true); }
static bool _mongoc_cyrus_is_failure (int status, bson_error_t *error) { bool ret = (status < 0); TRACE ("Got status: %d ok is %d, continue=%d interact=%d\n", status, SASL_OK, SASL_CONTINUE, SASL_INTERACT); if (ret) { switch (status) { case SASL_NOMEM: bson_set_error (error, MONGOC_ERROR_SASL, status, "SASL Failure: insufficient memory."); break; case SASL_NOMECH: { bson_string_t *str = bson_string_new ("available mechanisms: "); const char **mechs = sasl_global_listmech (); int i = 0; for (i = 0; mechs[i]; i++) { bson_string_append (str, mechs[i]); if (mechs[i + 1]) { bson_string_append (str, ","); } } bson_set_error (error, MONGOC_ERROR_SASL, status, "SASL Failure: failure to negotiate mechanism (%s)", str->str); bson_string_free (str, 0); } break; case SASL_BADPARAM: bson_set_error (error, MONGOC_ERROR_SASL, status, "Bad parameter supplied. Please file a bug " "with mongo-c-driver."); break; default: bson_set_error (error, MONGOC_ERROR_SASL, status, "SASL Failure: (%d): %s", status, sasl_errstring (status, NULL, NULL)); break; } } return ret; }
static void ha_config_add_shard (ha_node_t *node, ha_replica_set_t *replica_set) { mongoc_collection_t *collection; mongoc_client_t *client; bson_string_t *shardstr; bson_error_t error; bson_bool_t r; bson_t reply; bson_t cmd = BSON_INITIALIZER; char *uristr; uristr = bson_strdup_printf ("mongodb://127.0.0.1:%hu/", node->port); client = mongoc_client_new (uristr); collection = mongoc_client_get_collection (client, "admin", "fake"); shardstr = bson_string_new (NULL); bson_string_append_printf (shardstr, "%s/127.0.0.1:%hu", replica_set->name, replica_set->nodes->port); bson_append_utf8 (&cmd, "addShard", -1, shardstr->str, shardstr->len); bson_string_free (shardstr, TRUE); again: sleep (1); r = mongoc_collection_command_simple (collection, &cmd, NULL, &reply, &error); if (!r) { fprintf (stderr, "%s\n", error.message); goto again; } #if 1 { char *str; str = bson_as_json (&reply, NULL); printf ("%s\n", str); bson_free (str); } #endif bson_destroy (&reply); bson_destroy (&cmd); mongoc_collection_destroy (collection); mongoc_client_destroy (client); bson_free (uristr); }
bool _mongoc_cyrus_set_mechanism (mongoc_cyrus_t *sasl, const char *mechanism, bson_error_t *error) { bson_string_t *str = bson_string_new (""); const char **mechs = sasl_global_listmech (); int i = 0; bool ok = false; BSON_ASSERT (sasl); for (i = 0; mechs[i]; i++) { if (!strcmp (mechs[i], mechanism)) { ok = true; break; } bson_string_append (str, mechs[i]); if (mechs[i + 1]) { bson_string_append (str, ","); } } if (ok) { bson_free (sasl->credentials.mechanism); sasl->credentials.mechanism = mechanism ? bson_strdup (mechanism) : NULL; } else { bson_set_error (error, MONGOC_ERROR_SASL, SASL_NOMECH, "SASL Failure: Unsupported mechanism by client: %s. " "Available mechanisms: %s", mechanism, str->str); } bson_string_free (str, true); return ok; }
static void _set_platform_string (mongoc_handshake_t *handshake) { bson_string_t *str; char *config_str; str = bson_string_new (""); config_str = _mongoc_handshake_get_config_hex_string (); bson_string_append_printf (str, "cfg=%s", config_str); bson_free (config_str); #ifdef _POSIX_VERSION bson_string_append_printf (str, " posix=%ld", _POSIX_VERSION); #endif #ifdef __STDC_VERSION__ bson_string_append_printf (str, " stdc=%ld", __STDC_VERSION__); #endif bson_string_append_printf (str, " CC=%s", MONGOC_COMPILER); #ifdef MONGOC_COMPILER_VERSION bson_string_append_printf (str, " %s", MONGOC_COMPILER_VERSION); #endif if (strlen (MONGOC_EVALUATE_STR (MONGOC_USER_SET_CFLAGS)) > 0) { bson_string_append_printf ( str, " CFLAGS=%s", MONGOC_EVALUATE_STR (MONGOC_USER_SET_CFLAGS)); } if (strlen (MONGOC_EVALUATE_STR (MONGOC_USER_SET_LDFLAGS)) > 0) { bson_string_append_printf ( str, " LDFLAGS=%s", MONGOC_EVALUATE_STR (MONGOC_USER_SET_LDFLAGS)); } handshake->platform = bson_string_free (str, false); }
mongoc_client_t * ha_replica_set_create_client (ha_replica_set_t *replica_set) { mongoc_client_t *client; bson_string_t *str; ha_node_t *iter; char *portstr; str = bson_string_new("mongodb://"); for (iter = replica_set->nodes; iter; iter = iter->next) { bson_string_append(str, "127.0.0.1:"); portstr = bson_strdup_printf("%hu", iter->port); bson_string_append(str, portstr); bson_free(portstr); if (iter->next) { bson_string_append(str, ","); } } bson_string_append(str, "/?replicaSet="); bson_string_append(str, replica_set->name); client = mongoc_client_new(str->str); #ifdef MONGOC_ENABLE_SSL if (replica_set->ssl_opt) { mongoc_client_set_ssl_opts(client, replica_set->ssl_opt); } #endif bson_string_free(str, TRUE); return client; }
/* a uri with one bogus host */ mongoc_uri_t * uri_from_ismaster_plus_one (bson_t *ismaster_response) { /* start with one bad host and a comma */ bson_string_t *uri_str = bson_string_new ("mongodb://" BAD_HOST ","); char *name; bson_iter_t iter; bson_iter_t hosts_iter; if ((name = set_name (ismaster_response))) { bson_iter_init_find (&iter, ismaster_response, "hosts"); bson_iter_recurse (&iter, &hosts_iter); while (bson_iter_next (&hosts_iter)) { assert (BSON_ITER_HOLDS_UTF8 (&hosts_iter)); bson_string_append (uri_str, bson_iter_utf8 (&hosts_iter, NULL)); while (bson_iter_next (&hosts_iter)) { bson_string_append (uri_str, ","); bson_string_append (uri_str, bson_iter_utf8 (&hosts_iter, NULL)); } bson_string_append_printf ( uri_str, "/?replicaSet=%s&connecttimeoutms=1000", name); } bson_free (name); } else { char *host = test_framework_get_host (); bson_string_append (uri_str, host); bson_string_append (uri_str, "/?connecttimeoutms=1000"); bson_free (host); } return mongoc_uri_new (bson_string_free (uri_str, false)); }
void mock_server_reply_multi (request_t *request, mongoc_reply_flags_t flags, const bson_t *docs, int n_docs, int64_t cursor_id) { const mongoc_rpc_t *request_rpc; mock_server_t *server; mongoc_stream_t *client; char *doc_json; bson_string_t *docs_json; mongoc_iovec_t *iov; mongoc_array_t ar; mongoc_rpc_t r = {{ 0 }}; size_t expected = 0; ssize_t n_written; int iovcnt; int i; uint8_t *buf; uint8_t *ptr; size_t len; BSON_ASSERT (request); BSON_ASSERT (docs); request_rpc = &request->request_rpc; server = request->server; client = request->client; docs_json = bson_string_new (""); for (i = 0; i < n_docs; i++) { doc_json = bson_as_json (&docs[i], NULL); bson_string_append (docs_json, doc_json); bson_free (doc_json); if (i < n_docs - 1) { bson_string_append (docs_json, ", "); } } if (mock_server_get_verbose (request->server)) { printf ("%5.2f %hu <- %hu \t%s\n", mock_server_get_uptime_sec (request->server), request->client_port, mock_server_get_port (request->server), docs_json->str); fflush (stdout); } len = 0; for (i = 0; i < n_docs; i++) { len += docs[i].len; } ptr = buf = bson_malloc (len); for (i = 0; i < n_docs; i++) { memcpy (ptr, bson_get_data (&docs[i]), docs[i].len); ptr += docs[i].len; } _mongoc_array_init (&ar, sizeof (mongoc_iovec_t)); if (!(request->opcode == MONGOC_OPCODE_QUERY && request_rpc->query.flags & MONGOC_QUERY_EXHAUST)) { server->last_response_id++; } mongoc_mutex_lock (&server->mutex); r.reply.request_id = server->last_response_id; mongoc_mutex_unlock (&server->mutex); r.reply.msg_len = 0; r.reply.response_to = request_rpc->header.request_id; r.reply.opcode = MONGOC_OPCODE_REPLY; r.reply.flags = flags; r.reply.cursor_id = cursor_id; r.reply.start_from = 0; r.reply.n_returned = 1; r.reply.documents = buf; r.reply.documents_len = (uint32_t)len; _mongoc_rpc_gather (&r, &ar); _mongoc_rpc_swab_to_le (&r); iov = (mongoc_iovec_t *)ar.data; iovcnt = (int) ar.len; for (i = 0; i < iovcnt; i++) { expected += iov[i].iov_len; } n_written = mongoc_stream_writev (client, iov, (size_t) iovcnt, -1); assert (n_written == expected); bson_string_free (docs_json, true); _mongoc_array_destroy (&ar); bson_free (buf); }
/* Uses old way of querying system.namespaces. */ mongoc_cursor_t * _mongoc_database_find_collections_legacy (mongoc_database_t *database, const bson_t *filter, bson_error_t *error) { mongoc_collection_t *col; mongoc_cursor_t *cursor = NULL; mongoc_read_prefs_t *read_prefs; uint32_t dbname_len; bson_t legacy_filter; bson_iter_t iter; const char *col_filter; bson_t q = BSON_INITIALIZER; mongoc_database_find_collections_legacy_ctx_t *ctx; BSON_ASSERT (database); col = mongoc_client_get_collection (database->client, database->name, "system.namespaces"); BSON_ASSERT (col); dbname_len = (uint32_t)strlen (database->name); ctx = bson_malloc (sizeof (*ctx)); ctx->dbname = database->name; ctx->dbname_len = dbname_len; /* Filtering on name needs to be handled differently for old servers. */ if (filter && bson_iter_init_find (&iter, filter, "name")) { bson_string_t *buf; /* on legacy servers, this must be a string (i.e. not a regex) */ if (!BSON_ITER_HOLDS_UTF8 (&iter)) { bson_set_error (error, MONGOC_ERROR_NAMESPACE, MONGOC_ERROR_NAMESPACE_INVALID_FILTER_TYPE, "On legacy servers, a filter on name can only be a string."); goto cleanup_filter; } BSON_ASSERT (BSON_ITER_HOLDS_UTF8 (&iter)); col_filter = bson_iter_utf8 (&iter, NULL); bson_init (&legacy_filter); bson_copy_to_excluding_noinit (filter, &legacy_filter, "name", NULL); /* We must db-qualify filters on name. */ buf = bson_string_new (database->name); bson_string_append_c (buf, '.'); bson_string_append (buf, col_filter); BSON_APPEND_UTF8 (&legacy_filter, "name", buf->str); bson_string_free (buf, true); filter = &legacy_filter; } read_prefs = mongoc_read_prefs_new (MONGOC_READ_PRIMARY); cursor = mongoc_collection_find (col, MONGOC_QUERY_NONE, 0, 0, 0, filter ? filter : &q, NULL, read_prefs); _mongoc_cursor_transform_init ( cursor, _mongoc_database_find_collections_legacy_filter, _mongoc_database_find_collections_legacy_mutate, &bson_free, ctx); mongoc_read_prefs_destroy (read_prefs); cleanup_filter: mongoc_collection_destroy (col); return cursor; }
char * _mongoc_secure_transport_RFC2253_from_cert (SecCertificateRef cert) { CFTypeRef value; bson_string_t *retval; CFTypeRef subject_name; CFDictionaryRef cert_dict; cert_dict = SecCertificateCopyValues (cert, NULL, NULL); if (!cert_dict) { return NULL; } subject_name = CFDictionaryGetValue (cert_dict, kSecOIDX509V1SubjectName); if (!subject_name) { CFRelease (cert_dict); return NULL; } subject_name = CFDictionaryGetValue (subject_name, kSecPropertyKeyValue); if (!subject_name) { CFRelease (cert_dict); return NULL; } retval = bson_string_new ("");; value = _mongoc_secure_transport_dict_get (subject_name, kSecOIDCommonName); _bson_append_cftyperef (retval, "CN=", value); value = _mongoc_secure_transport_dict_get (subject_name, kSecOIDOrganizationalUnitName); if (value) { /* Can be either one unit name, or array of unit names */ if (CFGetTypeID(value) == CFStringGetTypeID()) { _bson_append_cftyperef (retval, ",OU=", value); } else if (CFGetTypeID(value) == CFArrayGetTypeID()) { CFIndex len = CFArrayGetCount(value); if (len > 0) { _bson_append_cftyperef (retval, ",OU=", CFArrayGetValueAtIndex(value, 0)); } if (len > 1) { _bson_append_cftyperef (retval, ",", CFArrayGetValueAtIndex(value, 1)); } if (len > 2) { _bson_append_cftyperef (retval, ",", CFArrayGetValueAtIndex(value, 2)); } } } value = _mongoc_secure_transport_dict_get (subject_name, kSecOIDOrganizationName); _bson_append_cftyperef (retval, ",O=", value); value = _mongoc_secure_transport_dict_get (subject_name, kSecOIDLocalityName); _bson_append_cftyperef (retval, ",L=", value); value = _mongoc_secure_transport_dict_get (subject_name, kSecOIDStateProvinceName); _bson_append_cftyperef (retval, ",ST=", value); value = _mongoc_secure_transport_dict_get (subject_name, kSecOIDCountryName); _bson_append_cftyperef (retval, ",C=", value); /* This seems rarely used */ value = _mongoc_secure_transport_dict_get (subject_name, kSecOIDStreetAddress); _bson_append_cftyperef (retval, ",STREET", value); CFRelease (cert_dict); return bson_string_free (retval, false); }
void mongoc_log_trace_iovec (const char *domain, const mongoc_iovec_t *_iov, size_t _iovcnt) { bson_string_t *str, *astr; const char *_b; unsigned _i = 0; unsigned _j = 0; unsigned _k = 0; size_t _l = 0; uint8_t _v; #ifdef MONGOC_TRACE if (!gLogTrace) { return; } #endif for (_i = 0; _i < _iovcnt; _i++) { _l += _iov[_i].iov_len; } _i = 0; str = bson_string_new(NULL); astr = bson_string_new(NULL); for (_j = 0; _j < _iovcnt; _j++) { _b = (char *)_iov[_j].iov_base; _l = _iov[_j].iov_len; for (_k = 0; _k < _l; _k++, _i++) { _v = *(_b + _k); if ((_i % 16) == 0) { bson_string_append_printf(str, "%05x: ", _i); } bson_string_append_printf(str, " %02x", _v); if (isprint(_v)) { bson_string_append_printf(astr, " %c", _v); } else { bson_string_append(astr, " ."); } if ((_i % 16) == 15) { mongoc_log(MONGOC_LOG_LEVEL_TRACE, domain, "%s %s", str->str, astr->str); bson_string_truncate(str, 0); bson_string_truncate(astr, 0); } else if ((_i % 16) == 7) { bson_string_append(str, " "); bson_string_append(astr, " "); } } } if (_i != 16) { mongoc_log(MONGOC_LOG_LEVEL_TRACE, domain, "%-56s %s", str->str, astr->str); } bson_string_free(str, true); bson_string_free(astr, true); }
void ha_sharded_cluster_start (ha_sharded_cluster_t *cluster) { bson_string_t *configopt; struct stat st; ha_node_t *iter; char *cmd; int i; bson_return_if_fail(cluster); if (!stat(cluster->name, &st)) { if (S_ISDIR(st.st_mode)) { /* Ayyyeeeeeee */ cmd = bson_strdup_printf("rm -rf \"%s\"", cluster->name); fprintf(stderr, "%s\n", cmd); system(cmd); bson_free(cmd); } } if (!!mkdir(cluster->name, 0750)) { fprintf(stderr, "Failed to create directory \"%s\"\n", cluster->name); abort(); } for (i = 0; i < 12; i++) { if (cluster->replicas[i]) { ha_replica_set_start(cluster->replicas[i]); } } configopt = bson_string_new (NULL); for (iter = cluster->configs; iter; iter = iter->next) { ha_node_setup(iter); ha_node_restart(iter); bson_string_append_printf (configopt, "127.0.0.1:%hu%s", iter->port, iter->next ? "," : ""); } sleep (5); for (iter = cluster->routers; iter; iter = iter->next) { bson_free (iter->configopt); iter->configopt = bson_strdup (configopt->str); ha_node_setup (iter); ha_node_restart (iter); } ha_sharded_cluster_wait_for_healthy (cluster); for (i = 0; i < 12; i++) { if (cluster->replicas[i]) { ha_config_add_shard (cluster->routers, cluster->replicas[i]); } } bson_string_free (configopt, TRUE); }
/* Uses old way of querying system.namespaces. */ bson_t * _mongoc_database_get_collection_info_legacy (mongoc_database_t *database, const bson_t *filter, bson_error_t *error) { mongoc_collection_t *col; mongoc_cursor_t *cursor; mongoc_read_prefs_t *read_prefs; uint32_t dbname_len; const bson_t *doc; bson_t legacy_filter; bson_iter_t iter; const char *name; const char *col_filter; bson_t q = BSON_INITIALIZER; bson_t *ret = NULL; bson_t col_array = BSON_INITIALIZER; const char *key; char keystr[16]; uint32_t n_cols = 0; BSON_ASSERT (database); col = mongoc_client_get_collection (database->client, database->name, "system.namespaces"); BSON_ASSERT (col); dbname_len = (uint32_t)strlen (database->name); /* Filtering on name needs to be handled differently for old servers. */ if (filter && bson_iter_init_find (&iter, filter, "name")) { /* on legacy servers, this must be a string (i.e. not a regex) */ if (!BSON_ITER_HOLDS_UTF8 (&iter)) { bson_set_error (error, MONGOC_ERROR_NAMESPACE, MONGOC_ERROR_NAMESPACE_INVALID_FILTER_TYPE, "On legacy servers, a filter on name can only be a string."); goto cleanup_filter; } BSON_ASSERT (BSON_ITER_HOLDS_UTF8 (&iter)); col_filter = bson_iter_utf8 (&iter, NULL); bson_init (&legacy_filter); bson_copy_to_excluding_noinit (filter, &legacy_filter, "name", NULL); /* We must db-qualify filters on name. */ bson_string_t *buf = bson_string_new (database->name); bson_string_append_c (buf, '.'); bson_string_append (buf, col_filter); BSON_APPEND_UTF8 (&legacy_filter, "name", buf->str); bson_string_free (buf, true); filter = &legacy_filter; } read_prefs = mongoc_read_prefs_new (MONGOC_READ_PRIMARY); cursor = mongoc_collection_find (col, MONGOC_QUERY_NONE, 0, 0, 0, filter ? filter : &q, NULL, read_prefs); ret = bson_new(); BSON_APPEND_ARRAY_BEGIN (ret, "collections", &col_array); while (mongoc_cursor_more (cursor) && !mongoc_cursor_error (cursor, error)) { if (mongoc_cursor_next (cursor, &doc)) { /* 2 gotchas here. * 1. need to ignore any system collections (prefixed with $) * 2. need to remove the database name from the collection so that clients * don't need to specialize their logic for old versions of the server. */ if (bson_iter_init_find (&iter, doc, "name") && BSON_ITER_HOLDS_UTF8 (&iter) && (name = bson_iter_utf8 (&iter, NULL)) && !strchr (name, '$') && (0 == strncmp (name, database->name, dbname_len))) { bson_t nprefix_col = BSON_INITIALIZER; bson_copy_to_excluding_noinit (doc, &nprefix_col, "name", NULL); BSON_APPEND_UTF8 (&nprefix_col, "name", name + (dbname_len + 1)); /* +1 for the '.' */ /* need to construct a key for this array element. */ bson_uint32_to_string(n_cols, &key, keystr, sizeof (keystr)); BSON_APPEND_DOCUMENT (&col_array, key, &nprefix_col); ++n_cols; } } } bson_append_array_end (ret, &col_array); mongoc_cursor_destroy (cursor); mongoc_read_prefs_destroy (read_prefs); cleanup_filter: mongoc_collection_destroy (col); return ret; }
/* returns a hex string for all config flag bits, which must be freed. */ char * _mongoc_handshake_get_config_hex_string (void) { uint32_t byte_count; uint8_t *bf; bson_string_t *str; int i; byte_count = (LAST_MONGOC_MD_FLAG + 7) / 8; /* ceil (num_bits / 8) */ /* allocate enough bytes to fit all config bits. */ bf = (uint8_t *) bson_malloc0 (byte_count); #ifdef MONGOC_ENABLE_SSL_SECURE_CHANNEL _set_bit (bf, byte_count, MONGOC_ENABLE_SSL_SECURE_CHANNEL); #endif #ifdef MONGOC_ENABLE_CRYPTO_CNG _set_bit (bf, byte_count, MONGOC_ENABLE_CRYPTO_CNG); #endif #ifdef MONGOC_ENABLE_SSL_SECURE_TRANSPORT _set_bit (bf, byte_count, MONGOC_MD_FLAG_ENABLE_SSL_SECURE_TRANSPORT); #endif #ifdef MONGOC_ENABLE_CRYPTO_COMMON_CRYPTO _set_bit (bf, byte_count, MONGOC_MD_FLAG_ENABLE_CRYPTO_COMMON_CRYPTO); #endif #ifdef MONGOC_ENABLE_SSL_OPENSSL _set_bit (bf, byte_count, MONGOC_MD_FLAG_ENABLE_SSL_OPENSSL); #endif #ifdef MONGOC_ENABLE_CRYPTO_LIBCRYPTO _set_bit (bf, byte_count, MONGOC_MD_FLAG_ENABLE_CRYPTO_LIBCRYPTO); #endif #ifdef MONGOC_ENABLE_SSL _set_bit (bf, byte_count, MONGOC_MD_FLAG_ENABLE_SSL); #endif #ifdef MONGOC_ENABLE_CRYPTO _set_bit (bf, byte_count, MONGOC_MD_FLAG_ENABLE_CRYPTO); #endif #ifdef MONGOC_ENABLE_CRYPTO_SYSTEM_PROFILE _set_bit (bf, byte_count, MONGOC_MD_FLAG_ENABLE_CRYPTO_SYSTEM_PROFILE); #endif #ifdef MONGOC_ENABLE_SASL _set_bit (bf, byte_count, MONGOC_MD_FLAG_ENABLE_SASL); #endif #ifdef MONGOC_HAVE_SASL_CLIENT_DONE _set_bit (bf, byte_count, MONGOC_MD_FLAG_HAVE_SASL_CLIENT_DONE); #endif #ifdef MONGOC_NO_AUTOMATIC_GLOBALS _set_bit (bf, byte_count, MONGOC_MD_FLAG_NO_AUTOMATIC_GLOBALS); #endif #ifdef MONGOC_EXPERIMENTAL_FEATURES _set_bit (bf, byte_count, MONGOC_MD_FLAG_EXPERIMENTAL_FEATURES); #endif #ifdef MONGOC_ENABLE_SSL_LIBRESSL _set_bit (bf, byte_count, MONGOC_MD_FLAG_ENABLE_SSL_LIBRESSL); #endif #ifdef MONGOC_ENABLE_SASL_CYRUS _set_bit (bf, byte_count, MONGOC_MD_FLAG_ENABLE_SASL_CYRUS); #endif #ifdef MONGOC_ENABLE_SASL_SSPI _set_bit (bf, byte_count, MONGOC_MD_FLAG_ENABLE_SASL_SSPI); #endif #ifdef MONGOC_HAVE_SOCKLEN _set_bit (bf, byte_count, MONGOC_MD_FLAG_HAVE_SOCKLEN); #endif #ifdef MONGOC_ENABLE_COMPRESSION _set_bit (bf, byte_count, MONGOC_MD_FLAG_ENABLE_COMPRESSION); #endif #ifdef MONGOC_ENABLE_COMPRESSION_SNAPPY _set_bit (bf, byte_count, MONGOC_MD_FLAG_ENABLE_COMPRESSION_SNAPPY); #endif #ifdef MONGOC_ENABLE_COMPRESSION_ZLIB _set_bit (bf, byte_count, MONGOC_MD_FLAG_ENABLE_COMPRESSION_ZLIB); #endif #ifdef MONGOC_MD_FLAG_ENABLE_SASL_GSSAPI _set_bit (bf, byte_count, MONGOC_MD_FLAG_ENABLE_SASL_GSSAPI); #endif #ifdef MONGOC_HAVE_RES_NSEARCH _set_bit (bf, byte_count, MONGOC_MD_FLAG_ENABLE_RES_NSEARCH); #endif #ifdef MONGOC_HAVE_RES_NDESTROY _set_bit (bf, byte_count, MONGOC_MD_FLAG_ENABLE_RES_NDESTROY); #endif #ifdef MONGOC_HAVE_RES_NCLOSE _set_bit (bf, byte_count, MONGOC_MD_FLAG_ENABLE_RES_NCLOSE); #endif #ifdef MONGOC_HAVE_RES_SEARCH _set_bit (bf, byte_count, MONGOC_MD_FLAG_ENABLE_RES_SEARCH); #endif #ifdef MONGOC_HAVE_DNSAPI _set_bit (bf, byte_count, MONGOC_MD_FLAG_ENABLE_DNSAPI); #endif #ifdef MONGOC_HAVE_RDTSCP _set_bit (bf, byte_count, MONGOC_MD_FLAG_ENABLE_RDTSCP); #endif #ifdef MONGOC_HAVE_SCHED_GETCPU _set_bit (bf, byte_count, MONGOC_MD_FLAG_HAVE_SCHED_GETCPU); #endif #ifdef MONGOC_ENABLE_SHM_COUNTERS _set_bit (bf, byte_count, MONGOC_MD_FLAG_ENABLE_SHM_COUNTERS); #endif #ifdef MONGOC_TRACE _set_bit (bf, byte_count, MONGOC_MD_FLAG_TRACE); #endif #ifdef MONGOC_ENABLE_ICU _set_bit (bf, byte_count, MONGOC_MD_FLAG_ENABLE_ICU); #endif str = bson_string_new ("0x"); for (i = 0; i < byte_count; i++) { bson_string_append_printf (str, "%02x", bf[i]); } bson_free (bf); /* free the bson_string_t, but keep the underlying char* alive. */ return bson_string_free (str, false); }