static void
sd_to_bson (const mongoc_server_description_t *sd,
bson_t *bson)
{
mongoc_host_list_t *host_list;
host_list = mongoc_server_description_host (
(mongoc_server_description_t *) sd);
bson_init (bson);
BSON_APPEND_UTF8 (bson, "address", host_list->host_and_port);
append_array (bson, "arbiters", &sd->arbiters);
append_array (bson, "hosts", &sd->hosts);
append_array (bson, "passives", &sd->passives);
if (sd->current_primary) {
BSON_APPEND_UTF8 (bson, "primary", sd->current_primary);
}
if (sd->set_name) {
BSON_APPEND_UTF8 (bson, "setName", sd->set_name);
}
BSON_APPEND_UTF8 (
bson, "type",
mongoc_server_description_type ((mongoc_server_description_t *) sd));
}
static int mongo_set_oauth_key(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 *)key->kid);
bson_t doc;
bson_init(&doc);
BSON_APPEND_UTF8(&doc, "kid", (const char *)key->kid);
BSON_APPEND_UTF8(&doc, "as_rs_alg", (const char *)key->as_rs_alg);
BSON_APPEND_UTF8(&doc, "ikm_key", (const char *)key->ikm_key);
BSON_APPEND_INT64(&doc, "timestamp", (int64_t)key->timestamp);
BSON_APPEND_INT32(&doc, "lifetime", (int32_t)key->lifetime);
int ret = -1;
if (!mongoc_collection_update(collection, MONGOC_UPDATE_UPSERT, &query, &doc, NULL, NULL)) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error inserting/updating oauth key information\n");
} else {
ret = 0;
}
mongoc_collection_destroy(collection);
bson_destroy(&doc);
bson_destroy(&query);
return ret;
}
static int mongo_set_user_key(u08bits *usname, u08bits *realm, const char *key) {
mongoc_collection_t * collection = mongo_get_collection("turnusers_lt");
if(!collection)
return -1;
bson_t query;
bson_init(&query);
BSON_APPEND_UTF8(&query, "name", (const char *)usname);
BSON_APPEND_UTF8(&query, "realm", (const char *)realm);
bson_t doc;
bson_init(&doc);
BSON_APPEND_UTF8(&doc, "name", (const char *)usname);
BSON_APPEND_UTF8(&doc, "realm", (const char *)realm);
BSON_APPEND_UTF8(&doc, "hmackey", (const char *)key);
int ret = -1;
if (!mongoc_collection_update(collection, MONGOC_UPDATE_UPSERT, &query, &doc, NULL, NULL)) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error inserting/updating user key information\n");
} else {
ret = 0;
}
mongoc_collection_destroy(collection);
bson_destroy(&doc);
bson_destroy(&query);
return ret;
}
static int mongo_set_admin_user(const u08bits *usname, const u08bits *realm, const password_t pwd)
{
mongoc_collection_t * collection = mongo_get_collection("admin_user");
if(!collection)
return -1;
bson_t query;
bson_init(&query);
BSON_APPEND_UTF8(&query, "name", (const char *)usname);
bson_t doc;
bson_init(&doc);
BSON_APPEND_UTF8(&doc, "name", (const char *)usname);
BSON_APPEND_UTF8(&doc, "realm", (const char *)realm);
BSON_APPEND_UTF8(&doc, "password", (const char *)pwd);
int ret = -1;
if (!mongoc_collection_update(collection, MONGOC_UPDATE_UPSERT, &query, &doc, NULL, NULL)) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error inserting/updating admin user information\n");
} else {
ret = 0;
}
mongoc_collection_destroy(collection);
bson_destroy(&doc);
bson_destroy(&query);
return ret;
}
static int mongo_add_origin(u08bits *origin, u08bits *realm)
{
mongoc_collection_t * collection = mongo_get_collection("realm");
if(!collection)
return -1;
int ret = -1;
u08bits realm0[STUN_MAX_REALM_SIZE+1] = "\0";
if(!realm) realm=realm0;
bson_t query, doc, child;
bson_init(&query);
BSON_APPEND_UTF8(&query, "realm", (const char *)realm);
bson_init(&doc);
bson_append_document_begin(&doc, "$addToSet", -1, &child);
BSON_APPEND_UTF8(&child, "origin", (const char *)origin);
bson_append_document_end(&doc, &child);
if (!mongoc_collection_update(collection, MONGOC_UPDATE_UPSERT, &query, &doc, NULL, NULL)) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error inserting/updating realm origin information\n");
} else {
ret = 0;
}
mongoc_collection_destroy(collection);
bson_destroy(&query);
bson_destroy(&doc);
return ret;
}
/* check version */
static gboolean
sim_parser_connect_test4 (void)
{
{
bson_t *bson_connect = bson_new ();
bson_t child;
SimParser *parser = NULL;
SimCommand *cmd = NULL;
gboolean result = FALSE;
uint8_t uuid[]={0x07,0x92,0xd6,0x72,0xf4,0xce,0x11,0xe4,0x9d,0xe2,0x00,0x0c,0x29,0xd9,0x46,0xde};
bson_append_document_begin (bson_connect,"connect", -1, &child);
BSON_APPEND_UTF8 (&child, "id", "bad id");
BSON_APPEND_INT32 (&child, "type", SIM_SESSION_TYPE_WEB);
BSON_APPEND_UTF8 (&child, "version", "x.x.x");
if (bson_append_binary (&child, "sensor_id", -1, BSON_SUBTYPE_UUID, uuid, 16) == FALSE)
return FALSE;
bson_append_document_end (bson_connect, &child);
do{
if ((parser = sim_parser_new()) == NULL)
{
result = FALSE;
break;
}
if ((cmd = sim_parser_bson (parser, bson_get_data (bson_connect), bson_connect->len)) != NULL)
{
result = FALSE;
break;
}
result = TRUE;
} while (0);
return result;
}
}
static void
td_to_bson (const mongoc_topology_description_t *td,
bson_t *bson)
{
size_t i;
bson_t servers = BSON_INITIALIZER;
bson_t server;
char str[16];
const char *key;
for (i = 0; i < td->servers->items_len; i++) {
bson_uint32_to_string ((uint32_t) i, &key, str, sizeof str);
sd_to_bson (mongoc_set_get_item (td->servers, (int) i), &server);
BSON_APPEND_DOCUMENT (&servers, key, &server);
bson_destroy (&server);
}
bson_init (bson);
BSON_APPEND_UTF8 (bson, "topologyType",
mongoc_topology_description_type (td));
if (td->set_name) {
BSON_APPEND_UTF8 (bson, "setName", td->set_name);
}
BSON_APPEND_ARRAY (bson, "servers", &servers);
bson_destroy (&servers);
}
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);
}
bson_t* dir_getBSON(dir_t *dir) {
bson_t *bson = bson_new();
BSON_APPEND_UTF8(bson, "_id", dir->id);
BSON_APPEND_UTF8(bson, "name", dir->name);
BSON_APPEND_UTF8(bson, "parentId", dir->parentId);
return bson;
}
static bool
mongoc_uri_parse_option (mongoc_uri_t *uri,
const char *str)
{
int32_t v_int;
const char *end_key;
char *key;
char *value;
if (!(key = scan_to_unichar(str, '=', &end_key))) {
return false;
}
value = bson_strdup(end_key + 1);
mongoc_uri_do_unescape(&value);
if (!strcasecmp(key, "connecttimeoutms") ||
!strcasecmp(key, "sockettimeoutms") ||
!strcasecmp(key, "maxpoolsize") ||
!strcasecmp(key, "minpoolsize") ||
!strcasecmp(key, "maxidletimems") ||
!strcasecmp(key, "waitqueuemultiple") ||
!strcasecmp(key, "waitqueuetimeoutms") ||
!strcasecmp(key, "wtimeoutms")) {
v_int = strtol(value, NULL, 10);
bson_append_int32(&uri->options, key, -1, v_int);
} else if (!strcasecmp(key, "w")) {
if (*value == '-' || isdigit(*value)) {
v_int = strtol (value, NULL, 10);
BSON_APPEND_INT32 (&uri->options, "w", v_int);
} else if (0 == strcasecmp (value, "majority")) {
BSON_APPEND_UTF8 (&uri->options, "w", "majority");
} else if (*value) {
BSON_APPEND_UTF8 (&uri->options, "W", value);
}
} else if (!strcasecmp(key, "canonicalizeHostname") ||
!strcasecmp(key, "journal") ||
!strcasecmp(key, "safe") ||
!strcasecmp(key, "slaveok") ||
!strcasecmp(key, "ssl")) {
bson_append_bool (&uri->options, key, -1,
(0 == strcasecmp (value, "true")) ||
(0 == strcasecmp (value, "t")) ||
(0 == strcmp (value, "1")));
} else if (!strcasecmp(key, "readpreferencetags")) {
mongoc_uri_parse_tags(uri, value, &uri->read_prefs);
} else {
bson_append_utf8(&uri->options, key, -1, value, -1);
}
bson_free(key);
bson_free(value);
return true;
}
static void
test_find_and_modify_write_concern_wire_32_failure (void *context)
{
mongoc_collection_t *collection;
mongoc_client_t *client;
bson_error_t error;
mongoc_find_and_modify_opts_t *opts;
bson_t reply;
bson_t query = BSON_INITIALIZER;
bson_t *update;
bool success;
mongoc_write_concern_t *wc;
client = test_framework_client_new ();
collection = get_test_collection (client, "writeFailure");
wc = mongoc_write_concern_new ();
mongoc_write_concern_set_w (wc, 42);
mongoc_collection_set_write_concern (collection, wc);
/* Find Zlatan Ibrahimovic, the striker */
BSON_APPEND_UTF8 (&query, "firstname", "Zlatan");
BSON_APPEND_UTF8 (&query, "lastname", "Ibrahimovic");
BSON_APPEND_UTF8 (&query, "profession", "Football player");
BSON_APPEND_INT32 (&query, "age", 34);
BSON_APPEND_INT32 (
&query, "goals", (16 + 35 + 23 + 57 + 16 + 14 + 28 + 84) + (1 + 6 + 62));
/* Add his football position */
update = BCON_NEW ("$set", "{", "position", BCON_UTF8 ("striker"), "}");
opts = mongoc_find_and_modify_opts_new ();
mongoc_find_and_modify_opts_set_update (opts, update);
/* Create the document if it didn't exist, and return the updated document */
mongoc_find_and_modify_opts_set_flags (
opts, MONGOC_FIND_AND_MODIFY_UPSERT | MONGOC_FIND_AND_MODIFY_RETURN_NEW);
success = mongoc_collection_find_and_modify_with_opts (
collection, &query, opts, &reply, &error);
ASSERT (!success);
ASSERT_ERROR_CONTAINS (
error, MONGOC_ERROR_WRITE_CONCERN, 100, "Write Concern error:");
bson_destroy (&reply);
bson_destroy (update);
bson_destroy (&query);
mongoc_find_and_modify_opts_destroy (opts);
mongoc_collection_drop (collection, NULL);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
}
void SettingsOutput::SetSubbasinIDs()
{
bson_t *b = bson_new();
bson_t *child = bson_new();
bson_t *child2 = bson_new();
bson_t *child3 = bson_new();
BSON_APPEND_DOCUMENT_BEGIN(b, "$query", child);
BSON_APPEND_DOCUMENT_BEGIN(child, PARAM_FLD_NAME, child2);
BSON_APPEND_ARRAY_BEGIN(child2, "$in", child3);
BSON_APPEND_UTF8(child3,PARAM_FLD_NAME, VAR_OUTLETID);
BSON_APPEND_UTF8(child3,PARAM_FLD_NAME, VAR_SUBBSNID_NUM);
bson_append_array_end(child2, child3);
bson_append_document_end(child, child2);
bson_append_document_end(b, child);
//printf("%s\n",bson_as_json(b,NULL));
mongoc_cursor_t *cursor;
const bson_t *bsonTable;
mongoc_collection_t *collection;
collection = mongoc_client_get_collection(m_conn, m_dbName.c_str(), DB_TAB_PARAMETERS);
cursor = mongoc_collection_find(collection, MONGOC_QUERY_NONE, 0, 0, 0, b, NULL, NULL);
bson_iter_t iter;
while (mongoc_cursor_more(cursor) && mongoc_cursor_next(cursor, &bsonTable))
{
string nameTmp = "";
int numTmp = -1;
if (bson_iter_init_find(&iter, bsonTable, PARAM_FLD_NAME))
nameTmp = GetStringFromBSONITER(&iter);
if (bson_iter_init_find(&iter, bsonTable, PARAM_FLD_VALUE))
numTmp = GetIntFromBSONITER(&iter);
if(!StringMatch(nameTmp, "") && numTmp != -1)
{
if(StringMatch(nameTmp, VAR_OUTLETID))
m_outletID = GetIntFromBSONITER(&iter);
else if (StringMatch(nameTmp, VAR_SUBBSNID_NUM))
m_nSubbasins = GetIntFromBSONITER(&iter);
}
else
throw ModelException("SettingOutput","SetSubbasinIDs","No valid values found in MongoDB!");
}
bson_destroy(child);
bson_destroy(child2);
bson_destroy(child3);
bson_destroy(b);
mongoc_collection_destroy(collection);
mongoc_cursor_destroy(cursor);
return;
}
static future_t *
collection_drop (func_ctx_t *ctx, bson_t *cmd)
{
BSON_APPEND_UTF8 (cmd, "drop", "collection");
return future_collection_drop_with_opts (
ctx->collection, ctx->opts, &ctx->error);
}
static future_t *
estimated_document_count (func_ctx_t *ctx, bson_t *cmd)
{
BSON_APPEND_UTF8 (cmd, "count", "collection");
return future_collection_estimated_document_count (
ctx->collection, ctx->opts, ctx->prefs, NULL, &ctx->error);
}
static future_t *
drop_index (func_ctx_t *ctx, bson_t *cmd)
{
BSON_APPEND_UTF8 (cmd, "dropIndexes", "collection");
return future_collection_drop_index_with_opts (
ctx->collection, "index name", ctx->opts, &ctx->error);
}
static future_t *
create_index (func_ctx_t *ctx, bson_t *cmd)
{
BSON_APPEND_UTF8 (cmd, "createIndexes", "collection");
return future_collection_create_index_with_opts (
ctx->collection, tmp_bson ("{}"), NULL, ctx->opts, NULL, &ctx->error);
}
static future_t *
db_write_cmd (func_ctx_t *ctx, bson_t *cmd)
{
BSON_APPEND_UTF8 (cmd, "foo", "db");
return future_database_write_command_with_opts (
ctx->db, tmp_bson ("{'foo': 'db'}"), ctx->opts, NULL, &ctx->error);
}
static int mongo_del_origin(u08bits *origin)
{
mongoc_collection_t * collection = mongo_get_collection("realm");
if(!collection)
return -1;
int ret = -1;
bson_t query, doc, child;
bson_init(&query);
bson_init(&doc);
bson_append_document_begin(&doc, "$pull", -1, &child);
BSON_APPEND_UTF8(&child, "origin", (const char *)origin);
bson_append_document_end(&doc, &child);
if (!mongoc_collection_update(collection, MONGOC_UPDATE_MULTI_UPDATE, &query, &doc, NULL, NULL)) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error deleting origin information\n");
} else {
ret = 0;
}
mongoc_collection_destroy(collection);
bson_destroy(&query);
bson_destroy(&doc);
return ret;
}
static bool
bulk_insert (mongoc_bulk_operation_t *bulk, bson_error_t *error, bson_t *cmd)
{
BSON_APPEND_UTF8 (cmd, "insert", "collection");
return mongoc_bulk_operation_insert_with_opts (
bulk, tmp_bson ("{}"), NULL, error);
}
/* Check a correct CONNECT message */
static gboolean
sim_parser_connect_test1 (void)
{
bson_t *bson_connect = bson_new ();
bson_t child;
uint8_t uuid[]={0x07,0x92,0xd6,0x72,0xf4,0xce,0x11,0xe4,0x9d,0xe2,0x00,0x0c,0x29,0xd9,0x46,0xde};
SimParser *parser = NULL;
SimCommand *cmd = NULL;
gboolean result = FALSE;
bson_append_document_begin (bson_connect,"connect", -1, &child);
BSON_APPEND_INT32 (&child, "id", 10);
BSON_APPEND_INT32 (&child, "type", SIM_SESSION_TYPE_WEB);
BSON_APPEND_UTF8 (&child, "version", "5.0.1");
if (bson_append_binary (&child, "sensor_id", -1, BSON_SUBTYPE_UUID, uuid, 16) == FALSE)
return FALSE;
bson_append_document_end (bson_connect, &child);
/* Check */
bson_iter_t iter;
bson_iter_init (&iter, bson_connect);
do{
if ((parser = sim_parser_new()) == NULL)
{
result = FALSE;
break;
}
if ((cmd = sim_parser_bson (parser, bson_get_data (bson_connect), bson_connect->len)) == NULL)
{
result = FALSE;
break;
}
if (cmd->type != SIM_COMMAND_TYPE_CONNECT)
{
result = FALSE;
break;
}
if (cmd->data.connect.sensor_ver->major != 5 || cmd->data.connect.sensor_ver->minor != 0 || cmd->data.connect.sensor_ver->micro != 1)
{
result = FALSE;
break;
}
if (cmd->data.connect.sensor_id == NULL)
{
result = FALSE;
break;
}
/* Check uuid */
SimUuid * uuidbin = sim_uuid_new_from_bin (uuid);
gboolean test = sim_uuid_equal (uuidbin, cmd->data.connect.sensor_id);
g_object_unref (uuidbin);
if (!test)
{
result = FALSE;
break;
}
result = TRUE;
} while (0);
bson_destroy (bson_connect);
g_object_unref (parser);
return result;
}
int mongodb_module_process(fieldset_t *fs)
{
bson_t *doc;
if (!bulk) {
return EXIT_FAILURE;
}
if (buffer_fill == BUFFER_SIZE) {
if (mongodb_module_flush()) {
return EXIT_FAILURE;
}
}
doc = bson_new();
for (int i=0; i < fs->len; i++) {
field_t *f = &(fs->fields[i]);
if (f->type == FS_STRING) {
BSON_APPEND_UTF8(doc,f->name,f->value.ptr);
} else if (f->type == FS_UINT64) {
BSON_APPEND_INT64(doc,f->name,(uint64_t) f->value.num);
} else if (f->type == FS_BINARY) {
BSON_APPEND_BINARY(doc,f->name, BSON_SUBTYPE_BINARY,f->value.ptr, f->len);
} else if (f->type == FS_NULL) {
// do nothing
} else {
log_fatal("mongodb", "received unknown output type");
}
}
mongoc_bulk_operation_insert(bulk,doc);
buffer_fill++;
return EXIT_SUCCESS;
}
/* check a missing mandatory fix */
static gboolean
sim_parser_connect_test2 (void)
{
bson_t *bson_connect = bson_new ();
bson_t child;
SimParser *parser = NULL;
SimCommand *cmd = NULL;
gboolean result = FALSE;
bson_append_document_begin (bson_connect,"connect", -1, &child);
BSON_APPEND_INT32 (&child, "id", 10);
BSON_APPEND_INT32 (&child, "type", SIM_SESSION_TYPE_WEB);
BSON_APPEND_UTF8 (&child, "version", "5.0.1");
bson_append_document_end (bson_connect, &child);
do{
if ((parser = sim_parser_new()) == NULL)
{
result = FALSE;
break;
}
if ((cmd = sim_parser_bson (parser, bson_get_data (bson_connect), bson_connect->len)) != NULL)
{
result = FALSE;
break;
}
result = TRUE;
} while (0);
return result;
}
static future_t *
delete_many (func_ctx_t *ctx, bson_t *cmd)
{
BSON_APPEND_UTF8 (cmd, "delete", "collection");
BSON_ASSERT (!ctx->prefs);
return future_collection_delete_many (
ctx->collection, tmp_bson ("{}"), ctx->opts, NULL, &ctx->error);
}
static future_t *
insert_one (func_ctx_t *ctx, bson_t *cmd)
{
BSON_APPEND_UTF8 (cmd, "insert", "collection");
BSON_ASSERT (!ctx->prefs);
return future_collection_insert_one (
ctx->collection, tmp_bson ("{}"), ctx->opts, NULL, &ctx->error);
}
void fam_flags(mongoc_collection_t *collection)
{
mongoc_find_and_modify_opts_t *opts;
bson_t reply;
bson_error_t error;
bson_t query = BSON_INITIALIZER;
bson_t *update;
bool success;
/* Find Zlatan Ibrahimovic, the striker */
BSON_APPEND_UTF8 (&query, "firstname", "Zlatan");
BSON_APPEND_UTF8 (&query, "lastname", "Ibrahimovic");
BSON_APPEND_UTF8 (&query, "profession", "Football player");
BSON_APPEND_INT32 (&query, "age", 34);
BSON_APPEND_INT32 (&query, "goals", (16+35+23+57+16+14+28+84)+(1+6+62));
/* Add his football position */
update = BCON_NEW ("$set", "{",
"position", BCON_UTF8 ("striker"),
"}");
opts = mongoc_find_and_modify_opts_new ();
mongoc_find_and_modify_opts_set_update (opts, update);
/* Create the document if it didn't exist, and return the updated document */
mongoc_find_and_modify_opts_set_flags (opts, MONGOC_FIND_AND_MODIFY_UPSERT|MONGOC_FIND_AND_MODIFY_RETURN_NEW);
success = mongoc_collection_find_and_modify_with_opts (collection, &query, opts, &reply, &error);
if (success) {
char *str;
str = bson_as_json (&reply, NULL);
printf ("%s\n", str);
bson_free (str);
} else {
fprintf(stderr, "Got error: \"%s\" on line %d\n", error.message, __LINE__);
}
bson_destroy (&reply);
bson_destroy (update);
bson_destroy (&query);
mongoc_find_and_modify_opts_destroy (opts);
}
int main (int argc, char *argv[])
{
mongoc_client_t *client;
mongoc_collection_t *collection;
bson_error_t error;
bson_oid_t oid;
bson_t *doc;
/* Init mongo C driver */
mongoc_init ();
/* Create a new connection to the database a get the specified collection */
client = mongoc_client_new ("mongodb://localhost:27017/");
if (!client) {
fprintf(stderr, "Connection to database failed!");
mongoc_cleanup();
return 0;
} else {
printf("Connected to the database successfully\n");
}
collection = mongoc_client_get_collection (client, "testdb", "users");
/* Create a new document (All the documents must have the _id field to be used as primary key) */
doc = bson_new ();
bson_oid_init (&oid, NULL);
BSON_APPEND_OID (doc, "_id", &oid);
BSON_APPEND_UTF8 (doc, "username", "John");
BSON_APPEND_UTF8 (doc, "password", "123456");
/* Insert the document into the collection */
if (!mongoc_collection_insert (collection, MONGOC_INSERT_NONE, doc, NULL, &error)) {
printf ("Error inserting the document. - %s\n", error.message);
} else {
printf ("Document successfully inserted!\n");
}
/* Clean the doc, colletion and client allocations */
bson_destroy (doc);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
/* Cleanup after mongo C driver */
mongoc_cleanup();
return 0;
}
static int mongo_set_permission_ip(const char *kind, u08bits *realm, const char* ip, int del)
{
char sub_collection_name[129];
snprintf(sub_collection_name,sizeof(sub_collection_name)-1,"%s_peer_ip",kind);
mongoc_collection_t * collection = mongo_get_collection("realm");
if(!collection)
return -1;
int ret = -1;
u08bits realm0[STUN_MAX_REALM_SIZE+1] = "\0";
if(!realm) realm=realm0;
bson_t query, doc, child;
bson_init(&query);
BSON_APPEND_UTF8(&query, "realm", (const char *)realm);
bson_init(&doc);
if(del) {
bson_append_document_begin(&doc, "$pull", -1, &child);
} else {
bson_append_document_begin(&doc, "$addToSet", -1, &child);
}
BSON_APPEND_UTF8(&child, sub_collection_name, (const char *)ip);
bson_append_document_end(&doc, &child);
mongoc_update_flags_t flags = MONGOC_UPDATE_NONE;
if(del) {
flags = MONGOC_UPDATE_MULTI_UPDATE;
} else {
flags = MONGOC_UPDATE_UPSERT;
}
if (!mongoc_collection_update(collection, flags, &query, &doc, NULL, NULL)) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error inserting permission ip information\n");
} else {
ret = 0;
}
mongoc_collection_destroy(collection);
bson_destroy(&query);
bson_destroy(&doc);
return ret;
}
static void saveAlarmLog(mongoc_collection_t *coll,char* se_id,int code,char * tel,char * msg,char* userId,char * device_name,char* name,char * de_id){
bson_t *sdoc = bson_new ();
bson_oid_t a_oid;
bson_oid_init (&a_oid, NULL);
BSON_APPEND_OID (sdoc, "_id", &a_oid);
//BSON_APPEND_OID (sdoc, "device_id", de_oid);
//BSON_APPEND_UTF8 (sdoc, "name", name);
//BSON_APPEND_INT32 (sdoc, "sensorType", sensorType);
BSON_APPEND_INT32 (sdoc, "code", code);
BSON_APPEND_UTF8 (sdoc, "mobile", tel);
BSON_APPEND_UTF8 (sdoc, "sendmsg", msg);
BSON_APPEND_UTF8 (sdoc, "user_id", userId);
BSON_APPEND_UTF8 (sdoc, "se_id", se_id);
BSON_APPEND_UTF8 (sdoc, "de_id", de_id);
BSON_APPEND_UTF8 (sdoc, "device_name", device_name);
BSON_APPEND_UTF8 (sdoc, "sensor_name", name);
time_t timep;
time(&timep);
BSON_APPEND_DOUBLE (sdoc, "time", timep);
bson_error_t serror;
if (!mongoc_collection_insert (coll, MONGOC_INSERT_NONE, sdoc, NULL, &serror)) {
fprintf (stderr, "%s\n", serror.message);
}
bson_destroy (sdoc);
}
static bool
bulk_update_one (mongoc_bulk_operation_t *bulk,
bson_error_t *error,
bson_t *cmd)
{
BSON_APPEND_UTF8 (cmd, "update", "collection");
return mongoc_bulk_operation_update_one_with_opts (
bulk, tmp_bson ("{}"), tmp_bson ("{}"), NULL, error);
}
static void
test_large_return (void)
{
mongoc_collection_t *collection;
mongoc_client_t *client;
mongoc_cursor_t *cursor;
bson_error_t error;
const bson_t *doc = NULL;
bson_oid_t oid;
bson_t insert_doc = BSON_INITIALIZER;
bson_t query = BSON_INITIALIZER;
size_t len;
char *str;
bool r;
client = mongoc_client_new (gTestUri);
ASSERT (client);
collection = get_test_collection (client, "test_large_return");
ASSERT (collection);
len = 1024 * 1024 * 4;
str = bson_malloc (len);
memset (str, (int)' ', len);
str [len - 1] = '\0';
bson_oid_init (&oid, NULL);
BSON_APPEND_OID (&insert_doc, "_id", &oid);
BSON_APPEND_UTF8 (&insert_doc, "big", str);
r = mongoc_collection_insert (collection, MONGOC_INSERT_NONE, &insert_doc, NULL, &error);
assert (r);
bson_destroy (&insert_doc);
BSON_APPEND_OID (&query, "_id", &oid);
cursor = mongoc_collection_find (collection, MONGOC_QUERY_NONE, 0, 0, 0, &query, NULL, NULL);
assert (cursor);
bson_destroy (&query);
r = mongoc_cursor_next (cursor, &doc);
assert (r);
assert (doc);
r = mongoc_cursor_next (cursor, &doc);
assert (!r);
mongoc_cursor_destroy (cursor);
r = mongoc_collection_drop (collection, &error);
assert (r);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
bson_free (str);
}
