static void
_mongoc_cursor_populate_error (mongoc_cursor_t *cursor,
const bson_t *doc,
bson_error_t *error)
{
bson_uint32_t code = MONGOC_ERROR_QUERY_FAILURE;
bson_iter_t iter;
const char *msg = "Unknown query failure";
BSON_ASSERT (cursor);
BSON_ASSERT (doc);
BSON_ASSERT (error);
if (bson_iter_init_find (&iter, doc, "code") &&
BSON_ITER_HOLDS_INT32 (&iter)) {
code = bson_iter_int32 (&iter);
}
if (bson_iter_init_find (&iter, doc, "$err") &&
BSON_ITER_HOLDS_UTF8 (&iter)) {
msg = bson_iter_utf8 (&iter, NULL);
}
if (cursor->is_command &&
bson_iter_init_find (&iter, doc, "errmsg") &&
BSON_ITER_HOLDS_UTF8 (&iter)) {
msg = bson_iter_utf8 (&iter, NULL);
}
bson_set_error(error, MONGOC_ERROR_QUERY, code, "%s", msg);
}
void
_mongoc_sasl_set_properties (mongoc_sasl_t *sasl, const mongoc_uri_t *uri)
{
const bson_t *options;
bson_iter_t iter;
bson_t properties;
const char *service_name = NULL;
bool canonicalize = false;
_mongoc_sasl_set_pass(sasl, mongoc_uri_get_password(uri));
_mongoc_sasl_set_user(sasl, mongoc_uri_get_username(uri));
options = mongoc_uri_get_options (uri);
if (!mongoc_uri_get_mechanism_properties (uri, &properties)) {
bson_init (&properties);
}
if (bson_iter_init_find_case (
&iter, options, MONGOC_URI_GSSAPISERVICENAME) &&
BSON_ITER_HOLDS_UTF8 (&iter)) {
service_name = bson_iter_utf8 (&iter, NULL);
}
if (bson_iter_init_find_case (&iter, &properties, "SERVICE_NAME") &&
BSON_ITER_HOLDS_UTF8 (&iter)) {
/* newer "authMechanismProperties" URI syntax takes precedence */
service_name = bson_iter_utf8 (&iter, NULL);
}
_mongoc_sasl_set_service_name (sasl, service_name);
/*
* Driver Authentication Spec: "Drivers MAY allow the user to request
* canonicalization of the hostname. This might be required when the hosts
* report different hostnames than what is used in the kerberos database.
* The default is "false".
*
* Some underlying GSSAPI layers will do this for us, but can be disabled in
* their config (krb.conf).
*
* See CDRIVER-323 for more information.
*/
if (bson_iter_init_find_case (
&iter, options, MONGOC_URI_CANONICALIZEHOSTNAME) &&
BSON_ITER_HOLDS_BOOL (&iter)) {
canonicalize = bson_iter_bool (&iter);
}
if (bson_iter_init_find_case (
&iter, &properties, "CANONICALIZE_HOST_NAME") &&
BSON_ITER_HOLDS_UTF8 (&iter)) {
/* newer "authMechanismProperties" URI syntax takes precedence */
canonicalize = !strcasecmp (bson_iter_utf8 (&iter, NULL), "true");
}
sasl->canonicalize_host_name = canonicalize;
bson_destroy (&properties);
}
static void
test_bson_iter_utf8 (void)
{
uint32_t len = 0;
bson_iter_t iter;
bson_t *b;
char *s;
b = bson_new();
assert(bson_append_utf8(b, "foo", -1, "bar", -1));
assert(bson_append_utf8(b, "bar", -1, "baz", -1));
assert(bson_iter_init(&iter, b));
assert(bson_iter_next(&iter));
assert(BSON_ITER_HOLDS_UTF8(&iter));
assert(!strcmp(bson_iter_key(&iter), "foo"));
assert(!strcmp(bson_iter_utf8(&iter, NULL), "bar"));
s = bson_iter_dup_utf8(&iter, &len);
assert_cmpstr("bar", s);
assert_cmpint(len, ==, 3);
bson_free(s);
assert(bson_iter_next(&iter));
assert(BSON_ITER_HOLDS_UTF8(&iter));
assert(!strcmp(bson_iter_key(&iter), "bar"));
assert(!strcmp(bson_iter_utf8(&iter, NULL), "baz"));
assert(!bson_iter_next(&iter));
bson_destroy(b);
}
static int mongo_get_oauth_key(const u08bits *kid, oauth_key_data_raw *key) {
mongoc_collection_t * collection = mongo_get_collection("oauth_key");
if (!collection)
return -1;
bson_t query;
bson_init(&query);
BSON_APPEND_UTF8(&query, "kid", (const char *)kid);
bson_t fields;
bson_init(&fields);
BSON_APPEND_INT32(&fields, "lifetime", 1);
BSON_APPEND_INT32(&fields, "timestamp", 1);
BSON_APPEND_INT32(&fields, "as_rs_alg", 1);
BSON_APPEND_INT32(&fields, "ikm_key", 1);
mongoc_cursor_t * cursor;
cursor = mongoc_collection_find(collection, MONGOC_QUERY_NONE, 0, 1, 0,
&query, &fields, NULL);
int ret = -1;
ns_bzero(key,sizeof(oauth_key_data_raw));
STRCPY(key->kid,kid);
if (!cursor) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR,
"Error querying MongoDB collection 'oauth_key'\n");
} else {
const bson_t * item;
uint32_t length;
bson_iter_t iter;
if (mongoc_cursor_next(cursor, &item)) {
if (bson_iter_init(&iter, item) && bson_iter_find(&iter, "as_rs_alg") && BSON_ITER_HOLDS_UTF8(&iter)) {
STRCPY(key->as_rs_alg,bson_iter_utf8(&iter, &length));
}
if (bson_iter_init(&iter, item) && bson_iter_find(&iter, "ikm_key") && BSON_ITER_HOLDS_UTF8(&iter)) {
STRCPY(key->ikm_key,bson_iter_utf8(&iter, &length));
}
if (bson_iter_init(&iter, item) && bson_iter_find(&iter, "timestamp") && BSON_ITER_HOLDS_INT64(&iter)) {
key->timestamp = (u64bits)bson_iter_int64(&iter);
}
if (bson_iter_init(&iter, item) && bson_iter_find(&iter, "lifetime") && BSON_ITER_HOLDS_INT32(&iter)) {
key->lifetime = (u32bits)bson_iter_int32(&iter);
}
ret = 0;
}
mongoc_cursor_destroy(cursor);
}
mongoc_collection_destroy(collection);
bson_destroy(&query);
bson_destroy(&fields);
return ret;
}
static gboolean
sim_parser_connect_version (bson_iter_t *piter, const char *key, SimCommand *cmd)
{
g_return_val_if_fail (piter != NULL, FALSE);
g_return_val_if_fail (cmd != NULL, FALSE);
g_return_val_if_fail (key != NULL, FALSE);
cmd->data.connect.sensor_ver = g_new0 (SimVersion, 1);
if (BSON_ITER_HOLDS_UTF8(piter))
{
/* We need to split the version x.y.z.n */
const gchar *version = bson_iter_utf8 (piter, NULL);
if (strlen (version) > 0)
{
sim_version_parse (version,
&(cmd->data.connect.sensor_ver->major),
&(cmd->data.connect.sensor_ver->minor),
&(cmd->data.connect.sensor_ver->micro),
&(cmd->data.connect.sensor_ver->nano));
}
}
return TRUE;
}
bool
bson_find_create_table (bson_t *bson_schema,
const char *table_name,
bson_iter_t *iter_col)
{
bson_iter_t iter_json, iter_ary, iter_sql, iter_table_prop;
bson_iter_init_find (&iter_json, bson_schema, "json") || DIE;
BSON_ITER_HOLDS_ARRAY (&iter_json) || DIE;
bson_iter_recurse (&iter_json, &iter_ary) || DIE;
while (bson_iter_next (&iter_ary)) {
(BSON_ITER_HOLDS_DOCUMENT (&iter_ary) || DIE);
bson_iter_recurse (&iter_ary, &iter_sql) || DIE;
if (bson_iter_find (&iter_sql, "create_table") &&
(BSON_ITER_HOLDS_DOCUMENT (&iter_sql) || DIE) &&
(bson_iter_recurse (&iter_sql, &iter_table_prop) || DIE) &&
(bson_iter_find (&iter_table_prop, "table_name") || DIE) &&
(BSON_ITER_HOLDS_UTF8 (&iter_table_prop) || DIE) &&
(strcmp (bson_iter_utf8 (&iter_table_prop, NULL), table_name) == 0) &&
(bson_iter_find (&iter_table_prop, "columns") || DIE) &&
(BSON_ITER_HOLDS_ARRAY (&iter_table_prop) || DIE)) {
bson_iter_recurse (&iter_table_prop, iter_col) || DIE;
return true;
}
}
return (false);
}
static void
copy_labels_plus_unknown_commit_result (const bson_t *src, bson_t *dst)
{
bson_iter_t iter;
bson_iter_t src_label;
bson_t dst_labels;
char str[16];
uint32_t i = 0;
const char *key;
BSON_APPEND_ARRAY_BEGIN (dst, "errorLabels", &dst_labels);
BSON_APPEND_UTF8 (&dst_labels, "0", UNKNOWN_COMMIT_RESULT);
/* append any other errorLabels already in "src" */
if (bson_iter_init_find (&iter, src, "errorLabels") &&
bson_iter_recurse (&iter, &src_label)) {
while (bson_iter_next (&src_label) && BSON_ITER_HOLDS_UTF8 (&src_label)) {
if (strcmp (bson_iter_utf8 (&src_label, NULL),
UNKNOWN_COMMIT_RESULT) != 0) {
i++;
bson_uint32_to_string (i, &key, str, sizeof str);
BSON_APPEND_UTF8 (
&dst_labels, key, bson_iter_utf8 (&src_label, NULL));
}
}
}
bson_append_array_end (dst, &dst_labels);
}
static void
_mongoc_populate_query_error (const bson_t *doc,
int32_t error_api_version,
bson_error_t *error)
{
mongoc_error_domain_t domain =
error_api_version >= MONGOC_ERROR_API_VERSION_2
? MONGOC_ERROR_SERVER
: MONGOC_ERROR_QUERY;
uint32_t code = MONGOC_ERROR_QUERY_FAILURE;
bson_iter_t iter;
const char *msg = "Unknown query failure";
ENTRY;
BSON_ASSERT (doc);
if (bson_iter_init_find (&iter, doc, "code") &&
BSON_ITER_HOLDS_INT32 (&iter)) {
code = (uint32_t) bson_iter_int32 (&iter);
}
if (bson_iter_init_find (&iter, doc, "$err") &&
BSON_ITER_HOLDS_UTF8 (&iter)) {
msg = bson_iter_utf8 (&iter, NULL);
}
bson_set_error (error, domain, code, "%s", msg);
EXIT;
}
static int
_score_tags (const bson_t *read_tags,
const bson_t *node_tags)
{
uint32_t len;
bson_iter_t iter;
const char *key;
const char *str;
int count;
int i;
bson_return_val_if_fail(read_tags, -1);
bson_return_val_if_fail(node_tags, -1);
count = bson_count_keys(read_tags);
if (!bson_empty(read_tags) && bson_iter_init(&iter, read_tags)) {
for (i = count; bson_iter_next(&iter); i--) {
if (BSON_ITER_HOLDS_UTF8(&iter)) {
key = bson_iter_key(&iter);
str = bson_iter_utf8(&iter, &len);
if (_contains_tag(node_tags, key, str, len)) {
return count;
}
}
}
return -1;
}
return 0;
}
static int mongo_get_admin_user(const u08bits *usname, u08bits *realm, password_t pwd)
{
mongoc_collection_t * collection = mongo_get_collection("admin_user");
if(!collection)
return -1;
realm[0]=0;
pwd[0]=0;
bson_t query;
bson_init(&query);
BSON_APPEND_UTF8(&query, "name", (const char *)usname);
bson_t fields;
bson_init(&fields);
BSON_APPEND_INT32(&fields, "realm", 1);
BSON_APPEND_INT32(&fields, "password", 1);
mongoc_cursor_t * cursor;
cursor = mongoc_collection_find(collection, MONGOC_QUERY_NONE, 0, 1, 0, &query, &fields, NULL);
int ret = -1;
if (!cursor) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error querying MongoDB collection 'admin_user'\n");
} else {
const bson_t * item;
uint32_t length;
bson_iter_t iter;
if (mongoc_cursor_next(cursor, &item)) {
if (bson_iter_init(&iter, item) && bson_iter_find(&iter, "realm") && BSON_ITER_HOLDS_UTF8(&iter)) {
strncpy((char*)realm,bson_iter_utf8(&iter, &length),STUN_MAX_REALM_SIZE);
ret = 0;
}
if (bson_iter_init(&iter, item) && bson_iter_find(&iter, "password") && BSON_ITER_HOLDS_UTF8(&iter)) {
strncpy((char*)pwd,bson_iter_utf8(&iter, &length),STUN_MAX_PWD_SIZE);
ret = 0;
}
}
mongoc_cursor_destroy(cursor);
}
mongoc_collection_destroy(collection);
bson_destroy(&query);
bson_destroy(&fields);
return ret;
}
int
get_column_map (bson_t *bson_schema,
const char *table_name,
column_map_t **column_map,
int *column_map_size)
{
bson_iter_t iter_col, iter_dup;
int size;
column_map_t *column_map_p;
const char *data_type;
data_type_map_t *data_type_map_p;
bson_find_create_table (bson_schema, table_name, &iter_col) || DIE;
for (iter_dup = iter_col, size = 0; bson_iter_next (&iter_dup); size++)
;
*column_map = calloc (sizeof (column_map_t), size);
*column_map_size = size;
column_map_p = *column_map;
while (bson_iter_next (&iter_col)) {
bson_iter_t iter_col_prop;
BSON_ITER_HOLDS_DOCUMENT (&iter_col) || DIE;
bson_iter_recurse (&iter_col, &iter_col_prop) || DIE;
bson_iter_find (&iter_col_prop, "column_name") || DIE;
BSON_ITER_HOLDS_UTF8 (&iter_col_prop) || DIE;
column_map_p->column_name = bson_iter_dup_utf8 (&iter_col_prop, NULL);
bson_iter_find (&iter_col_prop, "data_type") || DIE;
BSON_ITER_HOLDS_UTF8 (&iter_col_prop) || DIE;
data_type = bson_iter_utf8 (&iter_col_prop, NULL);
column_map_p->data_type = data_type;
for (data_type_map_p = data_type_map;
data_type_map_p < (data_type_map + sizeof (data_type_map)) &&
strcmp (data_type_map_p->data_type, data_type) != 0;
data_type_map_p++)
;
if (data_type_map < (data_type_map + sizeof (data_type_map)))
column_map_p->bson_append_from_s = data_type_map_p->bson_append_from_s ?
data_type_map_p->bson_append_from_s : bson_append_utf8_from_s;
else
DIE;
column_map_p++;
}
return true;
}
static void
_test_bson_type_print_description (bson_iter_t *iter)
{
if (bson_iter_find (iter, "description") && BSON_ITER_HOLDS_UTF8 (iter)) {
if (test_suite_debug_output ()) {
fprintf (stderr, " - %s\n", bson_iter_utf8 (iter, NULL));
fflush (stderr);
}
}
}
static int
_score_tags (const bson_t *read_tags,
const bson_t *node_tags)
{
uint32_t len;
bson_iter_t iter;
bson_iter_t sub_iter;
const char *key;
const char *str;
int count;
bool node_matches_set;
bson_return_val_if_fail(read_tags, -1);
bson_return_val_if_fail(node_tags, -1);
count = bson_count_keys(read_tags);
/* Execute this block if read tags were provided, else bail and return 0 (all nodes equal) */
if (!bson_empty(read_tags) && bson_iter_init(&iter, read_tags)) {
/*
* Iterate over array of read tag sets provided (each element is a tag set)
* Tag sets are provided in order of preference so return the count of the
* first set that matches the node or -1 if no set matched the node.
*/
while (count && bson_iter_next(&iter)) {
if (BSON_ITER_HOLDS_DOCUMENT(&iter) && bson_iter_recurse(&iter, &sub_iter)) {
node_matches_set = true;
/* Iterate over the key/value pairs (tags) in the current set */
while (bson_iter_next(&sub_iter) && BSON_ITER_HOLDS_UTF8(&sub_iter)) {
key = bson_iter_key(&sub_iter);
str = bson_iter_utf8(&sub_iter, &len);
/* If any of the tags do not match, this node cannot satisfy this tag set. */
if (!_contains_tag(node_tags, key, str, len)) {
node_matches_set = false;
break;
}
}
/* This set matched, return the count as the score */
if (node_matches_set) {
return count;
}
/* Decrement the score and try to match the next set. */
count--;
}
}
return -1;
}
return 0;
}
/**
* mongoc_database_has_collection:
* @database: (in): A #mongoc_database_t.
* @name: (in): The name of the collection to check for.
* @error: (out) (allow-none): A location for a #bson_error_t, or %NULL.
*
* Checks to see if a collection exists within the database on the MongoDB
* server.
*
* This will return %false if their was an error communicating with the
* server, or if the collection does not exist.
*
* If @error is provided, it will first be zeroed. Upon error, error.domain
* will be set.
*
* Returns: %true if @name exists, otherwise %false. @error may be set.
*/
bool
mongoc_database_has_collection (mongoc_database_t *database,
const char *name,
bson_error_t *error)
{
mongoc_collection_t *collection;
mongoc_read_prefs_t *read_prefs;
mongoc_cursor_t *cursor;
const bson_t *doc;
bson_iter_t iter;
bool ret = false;
const char *cur_name;
bson_t q = BSON_INITIALIZER;
char ns[140];
ENTRY;
BSON_ASSERT (database);
BSON_ASSERT (name);
if (error) {
memset (error, 0, sizeof *error);
}
bson_snprintf (ns, sizeof ns, "%s.%s", database->name, name);
ns[sizeof ns - 1] = '\0';
read_prefs = mongoc_read_prefs_new (MONGOC_READ_PRIMARY);
collection = mongoc_client_get_collection (database->client,
database->name,
"system.namespaces");
cursor = mongoc_collection_find (collection, MONGOC_QUERY_NONE, 0, 0, 0, &q,
NULL, read_prefs);
while (!mongoc_cursor_error (cursor, error) &&
mongoc_cursor_more (cursor)) {
while (mongoc_cursor_next (cursor, &doc) &&
bson_iter_init_find (&iter, doc, "name") &&
BSON_ITER_HOLDS_UTF8 (&iter)) {
cur_name = bson_iter_utf8(&iter, NULL);
if (!strcmp(cur_name, ns)) {
ret = true;
GOTO(cleanup);
}
}
}
cleanup:
mongoc_cursor_destroy (cursor);
mongoc_collection_destroy (collection);
mongoc_read_prefs_destroy (read_prefs);
RETURN(ret);
}
static void
_bson_to_error (const bson_t *b,
bson_error_t *error)
{
bson_iter_t iter;
int code = 0;
BSON_ASSERT(b);
if (!error) {
return;
}
if (bson_iter_init_find(&iter, b, "code") && BSON_ITER_HOLDS_INT32(&iter)) {
code = bson_iter_int32(&iter);
}
if (bson_iter_init_find(&iter, b, "$err") && BSON_ITER_HOLDS_UTF8(&iter)) {
bson_set_error(error,
MONGOC_ERROR_QUERY,
code,
"%s",
bson_iter_utf8(&iter, NULL));
return;
}
if (bson_iter_init_find(&iter, b, "errmsg") && BSON_ITER_HOLDS_UTF8(&iter)) {
bson_set_error(error,
MONGOC_ERROR_QUERY,
code,
"%s",
bson_iter_utf8(&iter, NULL));
return;
}
bson_set_error(error,
MONGOC_ERROR_QUERY,
MONGOC_ERROR_QUERY_FAILURE,
"An unknown error ocurred on the server.");
}
/**
* mongoc_database_has_collection:
* @database: (in): A #mongoc_database_t.
* @name: (in): The name of the collection to check for.
* @error: (out) (allow-none): A location for a #bson_error_t, or %NULL.
*
* Checks to see if a collection exists within the database on the MongoDB
* server.
*
* This will return %false if their was an error communicating with the
* server, or if the collection does not exist.
*
* If @error is provided, it will first be zeroed. Upon error, error.domain
* will be set.
*
* Returns: %true if @name exists, otherwise %false. @error may be set.
*/
bool
mongoc_database_has_collection (mongoc_database_t *database,
const char *name,
bson_error_t *error)
{
bson_iter_t col_iter;
bool ret = false;
const char *cur_name;
bson_t filter = BSON_INITIALIZER;
mongoc_cursor_t *cursor;
const bson_t *doc;
ENTRY;
BSON_ASSERT (database);
BSON_ASSERT (name);
if (error) {
memset (error, 0, sizeof *error);
}
BSON_APPEND_UTF8 (&filter, "name", name);
cursor = mongoc_database_find_collections (database, &filter, error);
if (!cursor) {
return ret;
}
if (error &&
((error->domain != 0) ||
(error->code != 0))) {
GOTO (cleanup);
}
while (mongoc_cursor_next (cursor, &doc)) {
if (bson_iter_init (&col_iter, doc) &&
bson_iter_find (&col_iter, "name") &&
BSON_ITER_HOLDS_UTF8 (&col_iter) &&
(cur_name = bson_iter_utf8 (&col_iter, NULL))) {
if (!strcmp (cur_name, name)) {
ret = true;
GOTO (cleanup);
}
}
}
cleanup:
mongoc_cursor_destroy (cursor);
RETURN (ret);
}
const char *
mongoc_uri_get_auth_mechanism (const mongoc_uri_t *uri)
{
bson_iter_t iter;
BSON_ASSERT (uri);
if (bson_iter_init_find_case (&iter, &uri->credentials, "authMechanism") &&
BSON_ITER_HOLDS_UTF8 (&iter)) {
return bson_iter_utf8 (&iter, NULL);
}
return NULL;
}
const char *
mongoc_uri_get_replica_set (const mongoc_uri_t *uri)
{
bson_iter_t iter;
BSON_ASSERT (uri);
if (bson_iter_init_find_case(&iter, &uri->options, "replicaSet") &&
BSON_ITER_HOLDS_UTF8(&iter)) {
return bson_iter_utf8(&iter, NULL);
}
return NULL;
}
const char *
mongoc_uri_get_auth_mechanism (const mongoc_uri_t *uri)
{
bson_iter_t iter;
bson_return_val_if_fail (uri, NULL);
if (bson_iter_init_find_case (&iter, &uri->options, "authMechanism") &&
BSON_ITER_HOLDS_UTF8 (&iter)) {
return bson_iter_utf8 (&iter, NULL);
}
return NULL;
}
static gboolean
sim_parser_connect_hostname (bson_iter_t *piter, const char *key, SimCommand *cmd)
{
g_return_val_if_fail (piter != NULL, FALSE);
g_return_val_if_fail (cmd != NULL, FALSE);
g_return_val_if_fail (key != NULL, FALSE);
gboolean result = FALSE;
if (BSON_ITER_HOLDS_UTF8 (piter))
{
cmd->data.connect.hostname = g_strdup (bson_iter_utf8(piter, NULL));
result = TRUE;
}
return result;
}
const char*
mongoc_uri_get_option_as_utf8 (const mongoc_uri_t *uri, const char *option,
const char *fallback)
{
const bson_t *options;
bson_iter_t iter;
if ((options = mongoc_uri_get_options (uri)) &&
bson_iter_init_find_case (&iter, options, option) &&
BSON_ITER_HOLDS_UTF8 (&iter)) {
return bson_iter_utf8 (&iter, NULL);
}
return fallback;
}
bool
_mongoc_convert_utf8 (mongoc_client_t *client,
const bson_iter_t *iter,
const char **str,
bson_error_t *error)
{
if (BSON_ITER_HOLDS_UTF8 (iter)) {
*str = bson_iter_utf8 (iter, NULL);
return true;
}
CONVERSION_ERR ("Invalid field \"%s\" in opts, should contain string,"
" not %s",
bson_iter_key (iter),
_mongoc_bson_type_to_str (bson_iter_type (iter)));
}
static mongoc_cursor_transform_mode_t
_mongoc_database_find_collections_legacy_filter (const bson_t *bson,
void *ctx_)
{
bson_iter_t iter;
mongoc_database_find_collections_legacy_ctx_t *ctx;
ctx = ctx_;
if (bson_iter_init_find (&iter, bson, "name")
&& BSON_ITER_HOLDS_UTF8 (&iter)
&& (ctx->name = bson_iter_utf8 (&iter, NULL))
&& !strchr (ctx->name, '$')
&& (0 == strncmp (ctx->name, ctx->dbname, ctx->dbname_len))) {
return MONGO_CURSOR_TRANSFORM_MUTATE;
} else {
return MONGO_CURSOR_TRANSFORM_DROP;
}
}
static bool
_contains_tag (const bson_t *b,
const char *key,
const char *value,
size_t value_len)
{
bson_iter_t iter;
bson_return_val_if_fail(b, false);
bson_return_val_if_fail(key, false);
bson_return_val_if_fail(value, false);
if (bson_iter_init_find(&iter, b, key) &&
BSON_ITER_HOLDS_UTF8(&iter) &&
!strncmp(value, bson_iter_utf8(&iter, NULL), value_len)) {
return true;
}
return false;
}
static int mongo_get_auth_secrets(secrets_list_t *sl, u08bits *realm) {
mongoc_collection_t * collection = mongo_get_collection("turn_secret");
if(!collection)
return -1;
bson_t query;
bson_init(&query);
BSON_APPEND_UTF8(&query, "realm", (const char *)realm);
bson_t fields;
bson_init(&fields);
BSON_APPEND_INT32(&fields, "value", 1);
mongoc_cursor_t * cursor;
cursor = mongoc_collection_find(collection, MONGOC_QUERY_NONE, 0, 0, 0, &query, &fields, NULL);
int ret = -1;
if (!cursor) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error querying MongoDB collection 'turn_secret'\n");
} else {
const bson_t * item;
uint32_t length;
bson_iter_t iter;
const char * value;
while(mongoc_cursor_next(cursor, &item)) {
if (bson_iter_init(&iter, item) && bson_iter_find(&iter, "value") && BSON_ITER_HOLDS_UTF8(&iter)) {
value = bson_iter_utf8(&iter, &length);
add_to_secrets_list(sl, value);
}
}
mongoc_cursor_destroy(cursor);
ret = 0;
}
mongoc_collection_destroy(collection);
bson_destroy(&query);
bson_destroy(&fields);
return ret;
}
SEXP ConvertValue(bson_iter_t* iter){
if(BSON_ITER_HOLDS_INT32(iter)){
return ScalarInteger(bson_iter_int32(iter));
} else if(BSON_ITER_HOLDS_NULL(iter)){
return R_NilValue;
} else if(BSON_ITER_HOLDS_BOOL(iter)){
return ScalarLogical(bson_iter_bool(iter));
} else if(BSON_ITER_HOLDS_DOUBLE(iter)){
return ScalarReal(bson_iter_double(iter));
} else if(BSON_ITER_HOLDS_INT64(iter)){
return ScalarReal((double) bson_iter_int64(iter));
} else if(BSON_ITER_HOLDS_UTF8(iter)){
return mkStringUTF8(bson_iter_utf8(iter, NULL));
} else if(BSON_ITER_HOLDS_CODE(iter)){
return mkStringUTF8(bson_iter_code(iter, NULL));
} else if(BSON_ITER_HOLDS_BINARY(iter)){
return ConvertBinary(iter);
} else if(BSON_ITER_HOLDS_DATE_TIME(iter)){
return ConvertDate(iter);
} else if(BSON_ITER_HOLDS_OID(iter)){
const bson_oid_t *val = bson_iter_oid(iter);
char str[25];
bson_oid_to_string(val, str);
return mkString(str);
} else if(BSON_ITER_HOLDS_ARRAY(iter)){
bson_iter_t child1;
bson_iter_t child2;
bson_iter_recurse (iter, &child1);
bson_iter_recurse (iter, &child2);
return ConvertArray(&child1, &child2);
} else if(BSON_ITER_HOLDS_DOCUMENT(iter)){
bson_iter_t child1;
bson_iter_t child2;
bson_iter_recurse (iter, &child1);
bson_iter_recurse (iter, &child2);
return ConvertObject(&child1, &child2);
} else {
stop("Unimplemented BSON type %d\n", bson_iter_type(iter));
}
}
bool
_mongoc_populate_cmd_error (const bson_t *doc,
int32_t error_api_version,
bson_error_t *error)
{
mongoc_error_domain_t domain =
error_api_version >= MONGOC_ERROR_API_VERSION_2
? MONGOC_ERROR_SERVER
: MONGOC_ERROR_QUERY;
uint32_t code = MONGOC_ERROR_QUERY_FAILURE;
bson_iter_t iter;
const char *msg = "Unknown command error";
ENTRY;
BSON_ASSERT (doc);
if (bson_iter_init_find (&iter, doc, "ok") && bson_iter_as_bool (&iter)) {
/* no error */
RETURN (false);
}
if (bson_iter_init_find (&iter, doc, "code") &&
BSON_ITER_HOLDS_INT32 (&iter)) {
code = (uint32_t) bson_iter_int32 (&iter);
}
if (code == MONGOC_ERROR_PROTOCOL_ERROR || code == 13390) {
code = MONGOC_ERROR_QUERY_COMMAND_NOT_FOUND;
}
if (bson_iter_init_find (&iter, doc, "errmsg") &&
BSON_ITER_HOLDS_UTF8 (&iter)) {
msg = bson_iter_utf8 (&iter, NULL);
}
bson_set_error (error, domain, code, "%s", msg);
RETURN (true);
}
SEXP ConvertValue(bson_iter_t* iter){
if(BSON_ITER_HOLDS_INT32(iter)){
return ScalarInteger(bson_iter_int32(iter));
} else if(BSON_ITER_HOLDS_NULL(iter)){
return R_NilValue;
} else if(BSON_ITER_HOLDS_BOOL(iter)){
return ScalarLogical(bson_iter_bool(iter));
} else if(BSON_ITER_HOLDS_DOUBLE(iter)){
return ScalarReal(bson_iter_double(iter));
} else if(BSON_ITER_HOLDS_INT64(iter)){
return ScalarReal((double) bson_iter_int64(iter));
} else if(BSON_ITER_HOLDS_UTF8(iter)){
return mkStringUTF8(bson_iter_utf8(iter, NULL));
} else if(BSON_ITER_HOLDS_CODE(iter)){
return mkStringUTF8(bson_iter_code(iter, NULL));
} else if(BSON_ITER_HOLDS_BINARY(iter)){
return ConvertBinary(iter);
} else if(BSON_ITER_HOLDS_DATE_TIME(iter)){
return ConvertDate(iter);
} else if(BSON_ITER_HOLDS_OID(iter)){
//not sure if this casting works
return mkRaw((unsigned char *) bson_iter_oid(iter), 12);
} else if(BSON_ITER_HOLDS_ARRAY(iter)){
bson_iter_t child1;
bson_iter_t child2;
bson_iter_recurse (iter, &child1);
bson_iter_recurse (iter, &child2);
return ConvertArray(&child1, &child2);
} else if(BSON_ITER_HOLDS_DOCUMENT(iter)){
bson_iter_t child1;
bson_iter_t child2;
bson_iter_recurse (iter, &child1);
bson_iter_recurse (iter, &child2);
return ConvertObject(&child1, &child2);
} else {
stop("Unimplemented BSON type %d\n", bson_iter_type(iter));
}
}
int monary_load_string_value(const bson_iter_t* bsonit,
monary_column_item* citem,
int idx)
{
char* dest; // Pointer to the final location of the array in mem
const char* src; // Pointer to immutable buffer
int size;
uint32_t stringlen; // The size of the string according to iter_utf8
if (BSON_ITER_HOLDS_UTF8(bsonit)) {
src = bson_iter_utf8(bsonit, &stringlen);
size = citem->type_arg;
if (stringlen > size) {
stringlen = size;
}
dest = ((char*) citem->storage) + (idx * size);
// Note: numpy strings need not end in \0
memcpy(dest, src, stringlen);
return 1;
} else {
return 0;
}
}
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.");
}
}
