/*
* 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);
}
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;
}
static void
_bson_append_cftyperef (bson_string_t *retval, const char *label, CFTypeRef str)
{
char *cs;
if (str) {
cs = _mongoc_cfstringref_to_cstring (str);
if (cs) {
bson_string_append_printf (retval, "%s%s", label, cs);
bson_free (cs);
} else {
bson_string_append_printf (retval, "%s(null)", label);
}
}
}
void
_bson_append_cftyperef (bson_string_t *retval, const char *label, CFTypeRef str)
{
if (str) {
if (CFGetTypeID (str) == CFStringGetTypeID ()) {
const char *cs = CFStringGetCStringPtr (str, CFStringGetFastestEncoding(str));
bson_string_append_printf (retval, "%s%s", label, cs);
}
}
}
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);
}
/* 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));
}
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);
}
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);
}
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);
}
/* 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);
}