static void
test_write_concern_bson_includes_false_fsync_and_journal (void)
{
mongoc_write_concern_t *write_concern;
const bson_t *gle;
const bson_t *bson;
bson_iter_t iter;
write_concern = mongoc_write_concern_new();
/*
* Check generated bson.
*/
ASSERT(write_concern);
mongoc_write_concern_set_fsync(write_concern, false);
mongoc_write_concern_set_journal(write_concern, false);
gle = _mongoc_write_concern_get_gle(write_concern);
ASSERT(bson_iter_init_find(&iter, gle, "getlasterror") && BSON_ITER_HOLDS_INT32(&iter) && bson_iter_int32(&iter) == 1);
ASSERT(bson_iter_init_find(&iter, gle, "fsync") && BSON_ITER_HOLDS_BOOL(&iter) && !bson_iter_bool(&iter));
ASSERT(bson_iter_init_find(&iter, gle, "j") && BSON_ITER_HOLDS_BOOL(&iter) && !bson_iter_bool(&iter));
ASSERT(!bson_iter_init_find(&iter, gle, "w"));
ASSERT(gle);
bson = _mongoc_write_concern_get_bson(write_concern);
ASSERT(!bson_iter_init_find(&iter, bson, "getlasterror"));
ASSERT(bson_iter_init_find(&iter, bson, "fsync") && BSON_ITER_HOLDS_BOOL(&iter) && !bson_iter_bool(&iter));
ASSERT(bson_iter_init_find(&iter, bson, "j") && BSON_ITER_HOLDS_BOOL(&iter) && !bson_iter_bool(&iter));
ASSERT(!bson_iter_init_find(&iter, bson, "w"));
ASSERT(bson);
mongoc_write_concern_destroy(write_concern);
}
static void
test_write_concern_basic (void)
{
mongoc_write_concern_t *write_concern;
const bson_t *b;
bson_iter_t iter;
write_concern = mongoc_write_concern_new();
/*
* Test defaults.
*/
assert(write_concern);
assert(!mongoc_write_concern_get_fsync(write_concern));
assert(!mongoc_write_concern_get_journal(write_concern));
assert(mongoc_write_concern_get_w(write_concern) == MONGOC_WRITE_CONCERN_W_DEFAULT);
assert(!mongoc_write_concern_get_wtimeout(write_concern));
assert(!mongoc_write_concern_get_wmajority(write_concern));
mongoc_write_concern_set_fsync(write_concern, TRUE);
assert(mongoc_write_concern_get_fsync(write_concern));
mongoc_write_concern_set_fsync(write_concern, FALSE);
assert(!mongoc_write_concern_get_fsync(write_concern));
mongoc_write_concern_set_journal(write_concern, TRUE);
assert(mongoc_write_concern_get_journal(write_concern));
mongoc_write_concern_set_journal(write_concern, FALSE);
assert(!mongoc_write_concern_get_journal(write_concern));
/*
* Test changes to w.
*/
mongoc_write_concern_set_w(write_concern, MONGOC_WRITE_CONCERN_W_MAJORITY);
assert(mongoc_write_concern_get_wmajority(write_concern));
mongoc_write_concern_set_w(write_concern, MONGOC_WRITE_CONCERN_W_DEFAULT);
assert(!mongoc_write_concern_get_wmajority(write_concern));
mongoc_write_concern_set_wmajority(write_concern, 1000);
assert(mongoc_write_concern_get_wmajority(write_concern));
assert(mongoc_write_concern_get_wtimeout(write_concern) == 1000);
mongoc_write_concern_set_wtimeout(write_concern, 0);
assert(!mongoc_write_concern_get_wtimeout(write_concern));
mongoc_write_concern_set_w(write_concern, MONGOC_WRITE_CONCERN_W_DEFAULT);
assert(mongoc_write_concern_get_w(write_concern) == MONGOC_WRITE_CONCERN_W_DEFAULT);
mongoc_write_concern_set_w(write_concern, 3);
assert(mongoc_write_concern_get_w(write_concern) == 3);
/*
* Check generated bson.
*/
mongoc_write_concern_set_fsync(write_concern, TRUE);
mongoc_write_concern_set_journal(write_concern, TRUE);
b = _mongoc_write_concern_freeze(write_concern);
assert(bson_iter_init_find(&iter, b, "fsync") && BSON_ITER_HOLDS_BOOL(&iter) && bson_iter_bool(&iter));
assert(bson_iter_init_find(&iter, b, "j") && BSON_ITER_HOLDS_BOOL(&iter) && bson_iter_bool(&iter));
assert(bson_iter_init_find(&iter, b, "w") && BSON_ITER_HOLDS_INT32(&iter) && bson_iter_int32(&iter) == 3);
assert(b);
mongoc_write_concern_destroy(write_concern);
}
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);
}
int monary_load_bool_value(const bson_iter_t* bsonit,
monary_column_item* citem,
int idx)
{
bool value;
value = bson_iter_bool(bsonit);
memcpy(((bool*) citem->storage) + idx, &value, sizeof(bool));
return 1;
}
bool
mongoc_uri_get_ssl (const mongoc_uri_t *uri) /* IN */
{
bson_iter_t iter;
bson_return_val_if_fail (uri, false);
return (bson_iter_init_find_case (&iter, &uri->options, "ssl") &&
BSON_ITER_HOLDS_BOOL (&iter) &&
bson_iter_bool (&iter));
}
bool
mongoc_uri_get_ssl (const mongoc_uri_t *uri) /* IN */
{
bson_iter_t iter;
BSON_ASSERT (uri);
return (bson_iter_init_find_case (&iter, &uri->options, "ssl") &&
BSON_ITER_HOLDS_BOOL (&iter) &&
bson_iter_bool (&iter));
}
mongoc_client_t *
mongoc_client_new (const char *uri_string)
{
const mongoc_write_concern_t *write_concern;
mongoc_client_t *client;
mongoc_uri_t *uri;
const bson_t *options;
bson_iter_t iter;
bool has_ssl = false;
if (!uri_string) {
uri_string = "mongodb://127.0.0.1/";
}
if (!(uri = mongoc_uri_new(uri_string))) {
return NULL;
}
options = mongoc_uri_get_options (uri);
if (bson_iter_init_find (&iter, options, "ssl") &&
BSON_ITER_HOLDS_BOOL (&iter) &&
bson_iter_bool (&iter)) {
has_ssl = true;
}
client = bson_malloc0(sizeof *client);
client->uri = uri;
client->request_id = rand ();
client->initiator = mongoc_client_default_stream_initiator;
client->initiator_data = client;
write_concern = mongoc_uri_get_write_concern (uri);
client->write_concern = mongoc_write_concern_copy (write_concern);
client->read_prefs = mongoc_read_prefs_new (MONGOC_READ_PRIMARY);
_mongoc_cluster_init (&client->cluster, client->uri, client);
#ifdef MONGOC_ENABLE_SSL
if (has_ssl) {
mongoc_client_set_ssl_opts (client, mongoc_ssl_opt_get_default ());
}
#endif
mongoc_counter_clients_active_inc ();
return client;
}
bool
mongoc_uri_get_option_as_bool (const mongoc_uri_t *uri, const char *option,
bool 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_BOOL (&iter)) {
return bson_iter_bool (&iter);
}
return fallback;
}
bool
_mongoc_convert_bool (mongoc_client_t *client,
const bson_iter_t *iter,
bool *flag,
bson_error_t *error)
{
if (BSON_ITER_HOLDS_BOOL (iter)) {
*flag = bson_iter_bool (iter);
return true;
}
CONVERSION_ERR ("Invalid field \"%s\" in opts, should contain bool,"
" not %s",
bson_iter_key (iter),
_mongoc_bson_type_to_str (bson_iter_type (iter)));
}
bool
_mongoc_convert_mongoc_write_bypass_document_validation_t (
mongoc_client_t *client,
const bson_iter_t *iter,
mongoc_write_bypass_document_validation_t *bdv,
bson_error_t *error)
{
if (BSON_ITER_HOLDS_BOOL (iter)) {
if (bson_iter_bool (iter) == true) {
*bdv = MONGOC_BYPASS_DOCUMENT_VALIDATION_TRUE;
} else {
*bdv = MONGOC_BYPASS_DOCUMENT_VALIDATION_FALSE;
}
return true;
}
CONVERSION_ERR ("Invalid field \"%s\" in opts", bson_iter_key (iter));
}
mongoc_client_t *
_mongoc_client_new_from_uri (const mongoc_uri_t *uri, mongoc_topology_t *topology)
{
mongoc_client_t *client;
const mongoc_read_prefs_t *read_prefs;
const mongoc_write_concern_t *write_concern;
#ifdef MONGOC_ENABLE_SSL
const bson_t *options;
bson_iter_t iter;
#endif
BSON_ASSERT (uri);
client = (mongoc_client_t *)bson_malloc0(sizeof *client);
client->uri = mongoc_uri_copy (uri);
client->request_id = rand ();
client->initiator = mongoc_client_default_stream_initiator;
client->initiator_data = client;
client->topology = topology;
write_concern = mongoc_uri_get_write_concern (client->uri);
client->write_concern = mongoc_write_concern_copy (write_concern);
read_prefs = mongoc_uri_get_read_prefs_t (client->uri);
client->read_prefs = mongoc_read_prefs_copy (read_prefs);
mongoc_cluster_init (&client->cluster, client->uri, client);
#ifdef MONGOC_ENABLE_SSL
options = mongoc_uri_get_options (client->uri);
if (bson_iter_init_find (&iter, options, "ssl") &&
BSON_ITER_HOLDS_BOOL (&iter) &&
bson_iter_bool (&iter)) {
mongoc_client_set_ssl_opts (client, mongoc_ssl_opt_get_default ());
}
#endif
mongoc_counter_clients_active_inc ();
return client;
}
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));
}
}
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));
}
}
static void
_mongoc_write_command_update_legacy (mongoc_write_command_t *command,
mongoc_client_t *client,
mongoc_server_stream_t *server_stream,
const char *database,
const char *collection,
const mongoc_write_concern_t *write_concern,
uint32_t offset,
mongoc_write_result_t *result,
bson_error_t *error)
{
mongoc_rpc_t rpc;
bson_iter_t iter, subiter, subsubiter;
bson_t doc;
bool has_update, has_selector, is_upsert;
bson_t update, selector;
bson_t *gle = NULL;
const uint8_t *data = NULL;
uint32_t len = 0;
size_t err_offset;
bool val = false;
char ns [MONGOC_NAMESPACE_MAX + 1];
int32_t affected = 0;
int vflags = (BSON_VALIDATE_UTF8 | BSON_VALIDATE_UTF8_ALLOW_NULL
| BSON_VALIDATE_DOLLAR_KEYS | BSON_VALIDATE_DOT_KEYS);
ENTRY;
BSON_ASSERT (command);
BSON_ASSERT (client);
BSON_ASSERT (database);
BSON_ASSERT (server_stream);
BSON_ASSERT (collection);
bson_iter_init (&iter, command->documents);
while (bson_iter_next (&iter)) {
if (bson_iter_recurse (&iter, &subiter) &&
bson_iter_find (&subiter, "u") &&
BSON_ITER_HOLDS_DOCUMENT (&subiter)) {
bson_iter_document (&subiter, &len, &data);
bson_init_static (&doc, data, len);
if (bson_iter_init (&subsubiter, &doc) &&
bson_iter_next (&subsubiter) &&
(bson_iter_key (&subsubiter) [0] != '$') &&
!bson_validate (&doc, (bson_validate_flags_t)vflags, &err_offset)) {
result->failed = true;
bson_set_error (error,
MONGOC_ERROR_BSON,
MONGOC_ERROR_BSON_INVALID,
"update document is corrupt or contains "
"invalid keys including $ or .");
EXIT;
}
} else {
result->failed = true;
bson_set_error (error,
MONGOC_ERROR_BSON,
MONGOC_ERROR_BSON_INVALID,
"updates is malformed.");
EXIT;
}
}
bson_snprintf (ns, sizeof ns, "%s.%s", database, collection);
bson_iter_init (&iter, command->documents);
while (bson_iter_next (&iter)) {
rpc.update.msg_len = 0;
rpc.update.request_id = 0;
rpc.update.response_to = 0;
rpc.update.opcode = MONGOC_OPCODE_UPDATE;
rpc.update.zero = 0;
rpc.update.collection = ns;
rpc.update.flags = MONGOC_UPDATE_NONE;
has_update = false;
has_selector = false;
is_upsert = false;
bson_iter_recurse (&iter, &subiter);
while (bson_iter_next (&subiter)) {
if (strcmp (bson_iter_key (&subiter), "u") == 0) {
bson_iter_document (&subiter, &len, &data);
rpc.update.update = data;
bson_init_static (&update, data, len);
has_update = true;
} else if (strcmp (bson_iter_key (&subiter), "q") == 0) {
bson_iter_document (&subiter, &len, &data);
rpc.update.selector = data;
bson_init_static (&selector, data, len);
has_selector = true;
} else if (strcmp (bson_iter_key (&subiter), "multi") == 0) {
val = bson_iter_bool (&subiter);
if (val) {
rpc.update.flags = (mongoc_update_flags_t)(
rpc.update.flags | MONGOC_UPDATE_MULTI_UPDATE);
}
} else if (strcmp (bson_iter_key (&subiter), "upsert") == 0) {
val = bson_iter_bool (&subiter);
if (val) {
rpc.update.flags = (mongoc_update_flags_t)(
rpc.update.flags | MONGOC_UPDATE_UPSERT);
}
is_upsert = true;
}
}
if (!mongoc_cluster_sendv_to_server (&client->cluster,
&rpc, 1, server_stream,
write_concern, error)) {
result->failed = true;
EXIT;
}
if (_mongoc_write_concern_needs_gle (write_concern)) {
if (!_mongoc_client_recv_gle (client, server_stream, &gle, error)) {
result->failed = true;
EXIT;
}
if (bson_iter_init_find (&subiter, gle, "n") &&
BSON_ITER_HOLDS_INT32 (&subiter)) {
affected = bson_iter_int32 (&subiter);
}
/*
* CDRIVER-372:
*
* Versions of MongoDB before 2.6 don't return the _id for an
* upsert if _id is not an ObjectId.
*/
if (is_upsert &&
affected &&
!bson_iter_init_find (&subiter, gle, "upserted") &&
bson_iter_init_find (&subiter, gle, "updatedExisting") &&
BSON_ITER_HOLDS_BOOL (&subiter) &&
!bson_iter_bool (&subiter)) {
if (has_update && bson_iter_init_find (&subiter, &update, "_id")) {
_ignore_value (bson_append_iter (gle, "upserted", 8, &subiter));
} else if (has_selector &&
bson_iter_init_find (&subiter, &selector, "_id")) {
_ignore_value (bson_append_iter (gle, "upserted", 8, &subiter));
}
}
_mongoc_write_result_merge_legacy (
result, command, gle,
MONGOC_ERROR_COLLECTION_UPDATE_FAILED, offset);
offset++;
bson_destroy (gle);
}
}
EXIT;
}
void
_mongoc_write_result_merge_legacy (mongoc_write_result_t *result, /* IN */
mongoc_write_command_t *command, /* IN */
const bson_t *reply, /* IN */
mongoc_error_code_t default_code,
uint32_t offset)
{
const bson_value_t *value;
bson_t holder, write_errors, child;
bson_iter_t iter;
bson_iter_t ar;
bson_iter_t citer;
const char *err = NULL;
int32_t code = 0;
int32_t n = 0;
int32_t upsert_idx = 0;
ENTRY;
BSON_ASSERT (result);
BSON_ASSERT (reply);
if (bson_iter_init_find (&iter, reply, "n") &&
BSON_ITER_HOLDS_INT32 (&iter)) {
n = bson_iter_int32 (&iter);
}
if (bson_iter_init_find (&iter, reply, "err") &&
BSON_ITER_HOLDS_UTF8 (&iter)) {
err = bson_iter_utf8 (&iter, NULL);
}
if (bson_iter_init_find (&iter, reply, "code") &&
BSON_ITER_HOLDS_INT32 (&iter)) {
code = bson_iter_int32 (&iter);
}
if (code || err) {
if (!code) {
code = default_code;
}
if (!err) {
err = "unknown error";
}
bson_set_error (&result->error,
MONGOC_ERROR_COLLECTION,
code,
"%s", err);
result->failed = true;
bson_init(&holder);
bson_append_array_begin(&holder, "0", 1, &write_errors);
bson_append_document_begin(&write_errors, "0", 1, &child);
bson_append_int32(&child, "index", 5, 0);
bson_append_int32(&child, "code", 4, code);
bson_append_utf8(&child, "errmsg", 6, err, -1);
bson_append_document_end(&write_errors, &child);
bson_append_array_end(&holder, &write_errors);
bson_iter_init(&iter, &holder);
bson_iter_next(&iter);
_mongoc_write_result_merge_arrays (offset, result, &result->writeErrors,
&iter);
bson_destroy(&holder);
}
switch (command->type) {
case MONGOC_WRITE_COMMAND_INSERT:
if (n) {
result->nInserted += n;
}
break;
case MONGOC_WRITE_COMMAND_DELETE:
result->nRemoved += n;
break;
case MONGOC_WRITE_COMMAND_UPDATE:
if (bson_iter_init_find (&iter, reply, "upserted") &&
!BSON_ITER_HOLDS_ARRAY (&iter)) {
result->nUpserted += n;
value = bson_iter_value (&iter);
_mongoc_write_result_append_upsert (result, offset, value);
} else if (bson_iter_init_find (&iter, reply, "upserted") &&
BSON_ITER_HOLDS_ARRAY (&iter)) {
result->nUpserted += n;
if (bson_iter_recurse (&iter, &ar)) {
while (bson_iter_next (&ar)) {
if (BSON_ITER_HOLDS_DOCUMENT (&ar) &&
bson_iter_recurse (&ar, &citer) &&
bson_iter_find (&citer, "_id")) {
value = bson_iter_value (&citer);
_mongoc_write_result_append_upsert (result,
offset + upsert_idx,
value);
upsert_idx++;
}
}
}
} else if ((n == 1) &&
bson_iter_init_find (&iter, reply, "updatedExisting") &&
BSON_ITER_HOLDS_BOOL (&iter) &&
!bson_iter_bool (&iter)) {
result->nUpserted += n;
} else {
result->nMatched += n;
}
break;
default:
break;
}
result->omit_nModified = true;
EXIT;
}
/*!
* \brief Convert rows from mongodb to db API representation
* \param _h database connection
* \param _r database result set
* \return 0 on success, negative on failure
*/
static int db_mongodb_convert_bson(const db1_con_t* _h, db1_res_t* _r,
int _row, const bson_t *_rdoc)
{
static str dummy_string = {"", 0};
int col;
db_mongodb_result_t *mgres;
const char *colname;
bson_type_t coltype;
bson_iter_t riter;
bson_iter_t citer;
bson_iter_t *piter;
db_val_t* dval;
uint32_t i32tmp;
bson_subtype_t subtype;
bson_t *cdoc;
mgres = (db_mongodb_result_t*)RES_PTR(_r);
if(mgres->nrcols==0) {
LM_ERR("no fields to convert\n");
return -1;
}
if(mgres->colsdoc==NULL) {
cdoc = (bson_t*)_rdoc;
} else {
cdoc = (bson_t*)mgres->colsdoc;
}
if (!bson_iter_init (&citer, cdoc)) {
LM_ERR("failed to initialize columns iterator\n");
return -3;
}
if(mgres->colsdoc) {
if (!bson_iter_init (&riter, _rdoc)) {
LM_ERR("failed to initialize result iterator\n");
return -3;
}
}
if (db_allocate_row(_r, &(RES_ROWS(_r)[_row])) != 0) {
LM_ERR("could not allocate row: %d\n", _row);
return -2;
}
col = 0;
while (bson_iter_next (&citer)) {
if(col >= RES_COL_N(_r)) {
LM_ERR("invalid number of columns (%d/%d)\n", col, RES_COL_N(_r));
return -4;
}
colname = bson_iter_key (&citer);
LM_DBG("looking for field[%d] named: %s\n", col, colname);
if(mgres->colsdoc) {
if(!bson_iter_find(&riter, colname)) {
LM_ERR("field [%s] not found in result iterator\n",
colname);
return -4;
}
piter = &riter;
} else {
piter = &citer;
}
coltype = bson_iter_type(piter);
dval = &(ROW_VALUES(&(RES_ROWS(_r)[_row]))[col]);
VAL_TYPE(dval) = RES_TYPES(_r)[col];
switch(coltype) {
case BSON_TYPE_BOOL:
VAL_INT(dval) = (int)bson_iter_bool (piter);
break;
case BSON_TYPE_INT32:
VAL_INT(dval) = bson_iter_int32 (piter);
break;
case BSON_TYPE_TIMESTAMP:
bson_iter_timestamp (piter,
(uint32_t*)&VAL_INT(dval), &i32tmp);
break;
case BSON_TYPE_INT64:
VAL_BIGINT(dval) = bson_iter_int64 (piter);
break;
case BSON_TYPE_DOUBLE:
VAL_DOUBLE(dval) = bson_iter_double (piter);
break;
case BSON_TYPE_DATE_TIME:
VAL_TIME(dval) = (time_t)(bson_iter_date_time (piter)/1000);
break;
case BSON_TYPE_BINARY:
bson_iter_binary (piter, &subtype,
(uint32_t*)&VAL_BLOB(dval).len, (const uint8_t**)&VAL_BLOB(dval).s);
break;
case BSON_TYPE_UTF8:
VAL_STRING(dval) = (char*)bson_iter_utf8 (piter, &i32tmp);
break;
case BSON_TYPE_OID:
break;
case BSON_TYPE_NULL:
memset(dval, 0, sizeof(db_val_t));
/* Initialize the string pointers to a dummy empty
* string so that we do not crash when the NULL flag
* is set but the module does not check it properly
*/
VAL_STRING(dval) = dummy_string.s;
VAL_STR(dval) = dummy_string;
VAL_BLOB(dval) = dummy_string;
VAL_TYPE(dval) = RES_TYPES(_r)[col];
VAL_NULL(dval) = 1;
break;
#if 0
case BSON_TYPE_EOD:
case BSON_TYPE_DOCUMENT:
case BSON_TYPE_ARRAY:
case BSON_TYPE_UNDEFINED:
case BSON_TYPE_REGEX:
case BSON_TYPE_DBPOINTER:
case BSON_TYPE_CODE:
case BSON_TYPE_SYMBOL:
case BSON_TYPE_CODEWSCOPE:
case BSON_TYPE_MAXKEY:
case BSON_TYPE_MINKEY:
#endif
default:
LM_WARN("unhandled data type column (%.*s) type id (%d), "
"use DB1_STRING as default\n", RES_NAMES(_r)[col]->len,
RES_NAMES(_r)[col]->s, coltype);
RES_TYPES(_r)[col] = DB1_STRING;
break;
}
LM_DBG("RES_NAMES(%p)[%d]=[%.*s] (%d)\n", RES_NAMES(_r)[col], col,
RES_NAMES(_r)[col]->len, RES_NAMES(_r)[col]->s, coltype);
col++;
}
return 0;
}
static void
test_mongoc_uri_new (void)
{
const mongoc_host_list_t *hosts;
const bson_t *options;
const bson_t *credentials;
bson_t properties;
mongoc_uri_t *uri;
bson_iter_t iter;
bson_iter_t child;
/* bad uris */
ASSERT(!mongoc_uri_new("mongodb://"));
ASSERT(!mongoc_uri_new("mongodb://::"));
ASSERT(!mongoc_uri_new("mongodb://*****:*****@localhost:27017/foo/?authSource=abcd");
ASSERT(uri);
ASSERT_CMPSTR(mongoc_uri_get_username(uri), "christian");
ASSERT_CMPSTR(mongoc_uri_get_password(uri), "secret");
ASSERT_CMPSTR(mongoc_uri_get_auth_source(uri), "abcd");
mongoc_uri_destroy(uri);
/* should use the default auth source and mechanism */
uri = mongoc_uri_new("mongodb://*****:*****@localhost:27017");
ASSERT(uri);
ASSERT_CMPSTR(mongoc_uri_get_auth_source(uri), "admin");
ASSERT(!mongoc_uri_get_auth_mechanism(uri));
mongoc_uri_destroy(uri);
/* should use the db when no authSource is specified */
uri = mongoc_uri_new("mongodb://*****:*****@localhost/foo");
ASSERT(uri);
ASSERT_CMPSTR(mongoc_uri_get_auth_source(uri), "foo");
mongoc_uri_destroy(uri);
/* should recognize an empty password */
uri = mongoc_uri_new("mongodb://samantha:@localhost");
ASSERT(uri);
ASSERT_CMPSTR(mongoc_uri_get_username(uri), "samantha");
ASSERT_CMPSTR(mongoc_uri_get_password(uri), "");
mongoc_uri_destroy(uri);
/* should recognize no password */
uri = mongoc_uri_new("mongodb://christian@localhost:27017");
ASSERT(uri);
ASSERT_CMPSTR(mongoc_uri_get_username(uri), "christian");
ASSERT(!mongoc_uri_get_password(uri));
mongoc_uri_destroy(uri);
/* should recognize a url escaped character in the username */
uri = mongoc_uri_new("mongodb://christian%40realm:pwd@localhost:27017");
ASSERT(uri);
ASSERT_CMPSTR(mongoc_uri_get_username(uri), "christian@realm");
mongoc_uri_destroy(uri);
/* while you shouldn't do this, lets test for it */
uri = mongoc_uri_new("mongodb://christian%40realm@localhost:27017/db%2ename");
ASSERT(uri);
ASSERT_CMPSTR(mongoc_uri_get_database(uri), "db.name");
mongoc_uri_destroy(uri);
uri = mongoc_uri_new("mongodb://christian%40realm@localhost:27017/db%2Ename");
ASSERT(uri);
ASSERT_CMPSTR(mongoc_uri_get_database(uri), "db.name");
mongoc_uri_destroy(uri);
uri = mongoc_uri_new("mongodb://christian%40realm@localhost:27017/?abcd=%20");
ASSERT(uri);
options = mongoc_uri_get_options(uri);
ASSERT(options);
ASSERT(bson_iter_init_find(&iter, options, "abcd"));
ASSERT(BSON_ITER_HOLDS_UTF8(&iter));
ASSERT_CMPSTR(bson_iter_utf8(&iter, NULL), " ");
mongoc_uri_destroy(uri);
uri = mongoc_uri_new("mongodb://christian%40realm@[::6]:27017/?abcd=%20");
ASSERT(uri);
options = mongoc_uri_get_options(uri);
ASSERT(options);
ASSERT(bson_iter_init_find(&iter, options, "abcd"));
ASSERT(BSON_ITER_HOLDS_UTF8(&iter));
ASSERT_CMPSTR(bson_iter_utf8(&iter, NULL), " ");
mongoc_uri_destroy(uri);
/* GSSAPI-specific options */
/* should recognize the GSSAPI mechanism, and use $external as source */
uri = mongoc_uri_new("mongodb://user%40DOMAIN.COM:password@localhost/?authMechanism=GSSAPI");
ASSERT(uri);
ASSERT_CMPSTR(mongoc_uri_get_auth_mechanism(uri), "GSSAPI");
/*ASSERT_CMPSTR(mongoc_uri_get_auth_source(uri), "$external");*/
mongoc_uri_destroy(uri);
/* use $external as source when db is specified */
uri = mongoc_uri_new("mongodb://user%40DOMAIN.COM:password@localhost/foo/?authMechanism=GSSAPI");
ASSERT(uri);
ASSERT_CMPSTR(mongoc_uri_get_auth_source(uri), "$external");
mongoc_uri_destroy(uri);
/* should not accept authSource other than $external */
ASSERT(!mongoc_uri_new("mongodb://user%40DOMAIN.COM:password@localhost/foo/?authMechanism=GSSAPI&authSource=bar"));
/* should accept authMechanismProperties */
uri = mongoc_uri_new("mongodb://user%40DOMAIN.COM:password@localhost/?authMechanism=GSSAPI"
"&authMechanismProperties=SERVICE_NAME:other,CANONICALIZE_HOST_NAME:true");
ASSERT(uri);
credentials = mongoc_uri_get_credentials(uri);
ASSERT(credentials);
ASSERT(mongoc_uri_get_mechanism_properties(uri, &properties));
assert (bson_iter_init_find_case (&iter, &properties, "SERVICE_NAME") &&
BSON_ITER_HOLDS_UTF8 (&iter) &&
(0 == strcmp (bson_iter_utf8 (&iter, NULL), "other")));
assert (bson_iter_init_find_case (&iter, &properties, "CANONICALIZE_HOST_NAME") &&
BSON_ITER_HOLDS_UTF8 (&iter) &&
(0 == strcmp (bson_iter_utf8 (&iter, NULL), "true")));
mongoc_uri_destroy(uri);
/* reverse order of arguments to ensure parsing still succeeds */
uri = mongoc_uri_new("mongodb://user@localhost/"
"?authMechanismProperties=SERVICE_NAME:other"
"&authMechanism=GSSAPI");
ASSERT(uri);
mongoc_uri_destroy(uri);
/* deprecated gssapiServiceName option */
uri = mongoc_uri_new("mongodb://christian%40realm.cc@localhost:27017/?authMechanism=GSSAPI&gssapiServiceName=blah");
ASSERT(uri);
options = mongoc_uri_get_options(uri);
ASSERT(options);
assert (0 == strcmp (mongoc_uri_get_auth_mechanism (uri), "GSSAPI"));
assert (0 == strcmp (mongoc_uri_get_username (uri), "*****@*****.**"));
assert (bson_iter_init_find_case (&iter, options, "gssapiServiceName") &&
BSON_ITER_HOLDS_UTF8 (&iter) &&
(0 == strcmp (bson_iter_utf8 (&iter, NULL), "blah")));
mongoc_uri_destroy(uri);
/* MONGODB-CR */
/* should recognize this mechanism */
uri = mongoc_uri_new("mongodb://user@localhost/?authMechanism=MONGODB-CR");
ASSERT(uri);
ASSERT_CMPSTR(mongoc_uri_get_auth_mechanism(uri), "MONGODB-CR");
mongoc_uri_destroy(uri);
/* X509 */
/* should recognize this mechanism, and use $external as the source */
uri = mongoc_uri_new("mongodb://user@localhost/?authMechanism=MONGODB-X509");
ASSERT(uri);
ASSERT_CMPSTR(mongoc_uri_get_auth_mechanism(uri), "MONGODB-X509");
/*ASSERT_CMPSTR(mongoc_uri_get_auth_source(uri), "$external");*/
mongoc_uri_destroy(uri);
/* use $external as source when db is specified */
uri = mongoc_uri_new("mongodb://CN%3DmyName%2COU%3DmyOrgUnit%2CO%3DmyOrg%2CL%3DmyLocality"
"%2CST%3DmyState%2CC%3DmyCountry@localhost/foo/?authMechanism=MONGODB-X509");
ASSERT(uri);
ASSERT_CMPSTR(mongoc_uri_get_auth_source(uri), "$external");
mongoc_uri_destroy(uri);
/* should not accept authSource other than $external */
ASSERT(!mongoc_uri_new("mongodb://CN%3DmyName%2COU%3DmyOrgUnit%2CO%3DmyOrg%2CL%3DmyLocality"
"%2CST%3DmyState%2CC%3DmyCountry@localhost/foo/?authMechanism=MONGODB-X509&authSource=bar"));
/* should recognize the encoded username */
uri = mongoc_uri_new("mongodb://CN%3DmyName%2COU%3DmyOrgUnit%2CO%3DmyOrg%2CL%3DmyLocality"
"%2CST%3DmyState%2CC%3DmyCountry@localhost/?authMechanism=MONGODB-X509");
ASSERT(uri);
ASSERT_CMPSTR(mongoc_uri_get_username(uri), "CN=myName,OU=myOrgUnit,O=myOrg,L=myLocality,ST=myState,C=myCountry");
mongoc_uri_destroy(uri);
/* PLAIN */
/* should recognize this mechanism */
uri = mongoc_uri_new("mongodb://user@localhost/?authMechanism=PLAIN");
ASSERT(uri);
ASSERT_CMPSTR(mongoc_uri_get_auth_mechanism(uri), "PLAIN");
mongoc_uri_destroy(uri);
/* SCRAM-SHA1 */
/* should recognize this mechanism */
uri = mongoc_uri_new("mongodb://user@localhost/?authMechanism=SCRAM-SHA1");
ASSERT(uri);
ASSERT_CMPSTR(mongoc_uri_get_auth_mechanism(uri), "SCRAM-SHA1");
mongoc_uri_destroy(uri);
}
static void
_mongoc_uri_build_write_concern (mongoc_uri_t *uri) /* IN */
{
mongoc_write_concern_t *write_concern;
const char *str;
bson_iter_t iter;
int32_t wtimeoutms;
int value;
BSON_ASSERT (uri);
write_concern = mongoc_write_concern_new ();
if (bson_iter_init_find_case (&iter, &uri->options, "safe") &&
BSON_ITER_HOLDS_BOOL (&iter)) {
mongoc_write_concern_set_w (write_concern,
bson_iter_bool (&iter) ? 1 : MONGOC_WRITE_CONCERN_W_UNACKNOWLEDGED);
}
wtimeoutms = mongoc_uri_get_option_as_int32(uri, "wtimeoutms", 0);
if (bson_iter_init_find_case (&iter, &uri->options, "journal") &&
BSON_ITER_HOLDS_BOOL (&iter)) {
mongoc_write_concern_set_journal (write_concern, bson_iter_bool (&iter));
}
if (bson_iter_init_find_case (&iter, &uri->options, "w")) {
if (BSON_ITER_HOLDS_INT32 (&iter)) {
value = bson_iter_int32 (&iter);
switch (value) {
case MONGOC_WRITE_CONCERN_W_ERRORS_IGNORED:
case MONGOC_WRITE_CONCERN_W_UNACKNOWLEDGED:
/* Warn on conflict, since write concern will be validated later */
if (mongoc_write_concern_get_journal(write_concern)) {
MONGOC_WARNING("Journal conflicts with w value [w=%d].", value);
}
mongoc_write_concern_set_w(write_concern, value);
break;
default:
if (value > 0) {
mongoc_write_concern_set_w (write_concern, value);
if (value > 1) {
mongoc_write_concern_set_wtimeout (write_concern, wtimeoutms);
}
break;
}
MONGOC_WARNING ("Unsupported w value [w=%d].", value);
break;
}
} else if (BSON_ITER_HOLDS_UTF8 (&iter)) {
str = bson_iter_utf8 (&iter, NULL);
if (0 == strcasecmp ("majority", str)) {
mongoc_write_concern_set_wmajority (write_concern, wtimeoutms);
} else {
mongoc_write_concern_set_wtag (write_concern, str);
mongoc_write_concern_set_wtimeout (write_concern, wtimeoutms);
}
} else {
BSON_ASSERT (false);
}
}
uri->write_concern = write_concern;
}
void
_mongoc_write_result_merge_legacy (mongoc_write_result_t *result, /* IN */
mongoc_write_command_t *command, /* IN */
const bson_t *reply, /* IN */
int32_t error_api_version,
mongoc_error_code_t default_code,
uint32_t offset)
{
const bson_value_t *value;
bson_iter_t iter;
bson_iter_t ar;
bson_iter_t citer;
const char *err = NULL;
int32_t code = 0;
int32_t n = 0;
int32_t upsert_idx = 0;
mongoc_error_domain_t domain;
ENTRY;
BSON_ASSERT (result);
BSON_ASSERT (reply);
domain = error_api_version >= MONGOC_ERROR_API_VERSION_2
? MONGOC_ERROR_SERVER
: MONGOC_ERROR_COLLECTION;
if (bson_iter_init_find (&iter, reply, "n") &&
BSON_ITER_HOLDS_INT32 (&iter)) {
n = bson_iter_int32 (&iter);
}
if (bson_iter_init_find (&iter, reply, "err") &&
BSON_ITER_HOLDS_UTF8 (&iter)) {
err = bson_iter_utf8 (&iter, NULL);
}
if (bson_iter_init_find (&iter, reply, "code") &&
BSON_ITER_HOLDS_INT32 (&iter)) {
code = bson_iter_int32 (&iter);
}
if (_is_duplicate_key_error (code)) {
code = MONGOC_ERROR_DUPLICATE_KEY;
}
if (code || err) {
if (!err) {
err = "unknown error";
}
if (bson_iter_init_find (&iter, reply, "wtimeout") &&
bson_iter_as_bool (&iter)) {
if (!code) {
code = (int32_t) MONGOC_ERROR_WRITE_CONCERN_ERROR;
}
_append_write_concern_err_legacy (result, err, code);
} else {
if (!code) {
code = (int32_t) default_code;
}
_append_write_err_legacy (result, err, domain, code, offset);
}
}
switch (command->type) {
case MONGOC_WRITE_COMMAND_INSERT:
if (n) {
result->nInserted += n;
}
break;
case MONGOC_WRITE_COMMAND_DELETE:
result->nRemoved += n;
break;
case MONGOC_WRITE_COMMAND_UPDATE:
if (bson_iter_init_find (&iter, reply, "upserted") &&
!BSON_ITER_HOLDS_ARRAY (&iter)) {
result->nUpserted += n;
value = bson_iter_value (&iter);
_mongoc_write_result_append_upsert (result, offset, value);
} else if (bson_iter_init_find (&iter, reply, "upserted") &&
BSON_ITER_HOLDS_ARRAY (&iter)) {
result->nUpserted += n;
if (bson_iter_recurse (&iter, &ar)) {
while (bson_iter_next (&ar)) {
if (BSON_ITER_HOLDS_DOCUMENT (&ar) &&
bson_iter_recurse (&ar, &citer) &&
bson_iter_find (&citer, "_id")) {
value = bson_iter_value (&citer);
_mongoc_write_result_append_upsert (
result, offset + upsert_idx, value);
upsert_idx++;
}
}
}
} else if ((n == 1) &&
bson_iter_init_find (&iter, reply, "updatedExisting") &&
BSON_ITER_HOLDS_BOOL (&iter) && !bson_iter_bool (&iter)) {
result->nUpserted += n;
} else {
result->nMatched += n;
}
break;
default:
break;
}
result->omit_nModified = true;
EXIT;
}
static void
test_find_and_modify (void)
{
mongoc_collection_t *collection;
mongoc_client_t *client;
bson_error_t error;
bson_iter_t iter;
bson_iter_t citer;
bson_t *update;
bson_t doc = BSON_INITIALIZER;
bson_t reply;
bool r;
client = mongoc_client_new (gTestUri);
ASSERT (client);
collection = get_test_collection (client, "test_find_and_modify");
ASSERT (collection);
BSON_APPEND_INT32 (&doc, "superduper", 77889);
r = mongoc_collection_insert (collection, MONGOC_INSERT_NONE, &doc, NULL, &error);
assert (r);
update = BCON_NEW ("$set", "{",
"superduper", BCON_INT32 (1234),
"}");
r = mongoc_collection_find_and_modify (collection,
&doc,
NULL,
update,
NULL,
false,
false,
true,
&reply,
&error);
assert (r);
assert (bson_iter_init_find (&iter, &reply, "value"));
assert (BSON_ITER_HOLDS_DOCUMENT (&iter));
assert (bson_iter_recurse (&iter, &citer));
assert (bson_iter_find (&citer, "superduper"));
assert (BSON_ITER_HOLDS_INT32 (&citer));
assert (bson_iter_int32 (&citer) == 1234);
assert (bson_iter_init_find (&iter, &reply, "lastErrorObject"));
assert (BSON_ITER_HOLDS_DOCUMENT (&iter));
assert (bson_iter_recurse (&iter, &citer));
assert (bson_iter_find (&citer, "updatedExisting"));
assert (BSON_ITER_HOLDS_BOOL (&citer));
assert (bson_iter_bool (&citer));
bson_destroy (&reply);
bson_destroy (update);
r = mongoc_collection_drop (collection, &error);
assert (r);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
bson_destroy (&doc);
}
static void
_mongoc_uri_build_write_concern (mongoc_uri_t *uri) /* IN */
{
mongoc_write_concern_t *write_concern;
const char *str;
bson_iter_t iter;
int32_t wtimeoutms = 0;
int value;
BSON_ASSERT (uri);
write_concern = mongoc_write_concern_new ();
if (bson_iter_init_find_case (&iter, &uri->options, "safe") &&
BSON_ITER_HOLDS_BOOL (&iter) &&
!bson_iter_bool (&iter)) {
mongoc_write_concern_set_w (write_concern,
MONGOC_WRITE_CONCERN_W_UNACKNOWLEDGED);
}
if (bson_iter_init_find_case (&iter, &uri->options, "wtimeoutms") &&
BSON_ITER_HOLDS_INT32 (&iter)) {
wtimeoutms = bson_iter_int32 (&iter);
}
if (bson_iter_init_find_case (&iter, &uri->options, "w")) {
if (BSON_ITER_HOLDS_INT32 (&iter)) {
value = bson_iter_int32 (&iter);
switch (value) {
case -1:
mongoc_write_concern_set_w (write_concern,
MONGOC_WRITE_CONCERN_W_ERRORS_IGNORED);
break;
case 0:
mongoc_write_concern_set_w (write_concern,
MONGOC_WRITE_CONCERN_W_UNACKNOWLEDGED);
break;
case 1:
mongoc_write_concern_set_w (write_concern,
MONGOC_WRITE_CONCERN_W_DEFAULT);
break;
default:
if (value > 1) {
mongoc_write_concern_set_w (write_concern, value);
break;
}
MONGOC_WARNING ("Unsupported w value [w=%d].", value);
break;
}
} else if (BSON_ITER_HOLDS_UTF8 (&iter)) {
str = bson_iter_utf8 (&iter, NULL);
if (0 == strcasecmp ("majority", str)) {
mongoc_write_concern_set_wmajority (write_concern, wtimeoutms);
} else {
mongoc_write_concern_set_wtag (write_concern, str);
}
} else {
BSON_ASSERT (false);
}
}
uri->write_concern = write_concern;
}
static void
test_find_and_modify (void)
{
mongoc_collection_t *collection;
mongoc_client_t *client;
bson_error_t error;
bson_iter_t iter;
bson_iter_t citer;
bson_t *update;
bson_t doc = BSON_INITIALIZER;
bson_t reply;
mongoc_find_and_modify_opts_t *opts;
client = test_framework_client_new ();
ASSERT (client);
collection = get_test_collection (client, "test_find_and_modify");
ASSERT (collection);
BSON_APPEND_INT32 (&doc, "superduper", 77889);
ASSERT_OR_PRINT (mongoc_collection_insert (
collection, MONGOC_INSERT_NONE, &doc, NULL, &error),
error);
update = BCON_NEW ("$set", "{", "superduper", BCON_INT32 (1234), "}");
opts = mongoc_find_and_modify_opts_new ();
mongoc_find_and_modify_opts_set_update (opts, update);
mongoc_find_and_modify_opts_set_fields (opts,
tmp_bson ("{'superduper': 1}"));
mongoc_find_and_modify_opts_set_sort (opts, tmp_bson ("{'superduper': 1}"));
mongoc_find_and_modify_opts_set_flags (opts,
MONGOC_FIND_AND_MODIFY_RETURN_NEW);
ASSERT_OR_PRINT (mongoc_collection_find_and_modify_with_opts (
collection, &doc, opts, &reply, &error),
error);
assert (bson_iter_init_find (&iter, &reply, "value"));
assert (BSON_ITER_HOLDS_DOCUMENT (&iter));
assert (bson_iter_recurse (&iter, &citer));
assert (bson_iter_find (&citer, "superduper"));
assert (BSON_ITER_HOLDS_INT32 (&citer));
assert (bson_iter_int32 (&citer) == 1234);
assert (bson_iter_init_find (&iter, &reply, "lastErrorObject"));
assert (BSON_ITER_HOLDS_DOCUMENT (&iter));
assert (bson_iter_recurse (&iter, &citer));
assert (bson_iter_find (&citer, "updatedExisting"));
assert (BSON_ITER_HOLDS_BOOL (&citer));
assert (bson_iter_bool (&citer));
bson_destroy (&reply);
bson_destroy (update);
ASSERT_OR_PRINT (mongoc_collection_drop (collection, &error), error);
mongoc_find_and_modify_opts_destroy (opts);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
bson_destroy (&doc);
}
void
mongoc_server_description_handle_ismaster (
mongoc_server_description_t *sd,
const bson_t *ismaster_response,
int64_t rtt_msec,
bson_error_t *error)
{
bson_iter_t iter;
bool is_master = false;
bool is_shard = false;
bool is_secondary = false;
bool is_arbiter = false;
bool is_replicaset = false;
bool is_hidden = false;
const uint8_t *bytes;
uint32_t len;
int num_keys = 0;
ENTRY;
BSON_ASSERT (sd);
mongoc_server_description_reset (sd);
if (!ismaster_response) {
EXIT;
}
bson_destroy (&sd->last_is_master);
bson_copy_to (ismaster_response, &sd->last_is_master);
sd->has_is_master = true;
bson_iter_init (&iter, &sd->last_is_master);
while (bson_iter_next (&iter)) {
num_keys++;
if (strcmp ("ok", bson_iter_key (&iter)) == 0) {
/* ismaster responses never have ok: 0, but spec requires we check */
if (! bson_iter_as_bool (&iter)) goto failure;
} else if (strcmp ("ismaster", bson_iter_key (&iter)) == 0) {
if (! BSON_ITER_HOLDS_BOOL (&iter)) goto failure;
is_master = bson_iter_bool (&iter);
} else if (strcmp ("maxMessageSizeBytes", bson_iter_key (&iter)) == 0) {
if (! BSON_ITER_HOLDS_INT32 (&iter)) goto failure;
sd->max_msg_size = bson_iter_int32 (&iter);
} else if (strcmp ("maxBsonObjectSize", bson_iter_key (&iter)) == 0) {
if (! BSON_ITER_HOLDS_INT32 (&iter)) goto failure;
sd->max_bson_obj_size = bson_iter_int32 (&iter);
} else if (strcmp ("maxWriteBatchSize", bson_iter_key (&iter)) == 0) {
if (! BSON_ITER_HOLDS_INT32 (&iter)) goto failure;
sd->max_write_batch_size = bson_iter_int32 (&iter);
} else if (strcmp ("minWireVersion", bson_iter_key (&iter)) == 0) {
if (! BSON_ITER_HOLDS_INT32 (&iter)) goto failure;
sd->min_wire_version = bson_iter_int32 (&iter);
} else if (strcmp ("maxWireVersion", bson_iter_key (&iter)) == 0) {
if (! BSON_ITER_HOLDS_INT32 (&iter)) goto failure;
sd->max_wire_version = bson_iter_int32 (&iter);
} else if (strcmp ("msg", bson_iter_key (&iter)) == 0) {
if (! BSON_ITER_HOLDS_UTF8 (&iter)) goto failure;
is_shard = !!bson_iter_utf8 (&iter, NULL);
} else if (strcmp ("setName", bson_iter_key (&iter)) == 0) {
if (! BSON_ITER_HOLDS_UTF8 (&iter)) goto failure;
sd->set_name = bson_iter_utf8 (&iter, NULL);
} else if (strcmp ("secondary", bson_iter_key (&iter)) == 0) {
if (! BSON_ITER_HOLDS_BOOL (&iter)) goto failure;
is_secondary = bson_iter_bool (&iter);
} else if (strcmp ("hosts", bson_iter_key (&iter)) == 0) {
if (! BSON_ITER_HOLDS_ARRAY (&iter)) goto failure;
bson_iter_array (&iter, &len, &bytes);
bson_init_static (&sd->hosts, bytes, len);
} else if (strcmp ("passives", bson_iter_key (&iter)) == 0) {
if (! BSON_ITER_HOLDS_ARRAY (&iter)) goto failure;
bson_iter_array (&iter, &len, &bytes);
bson_init_static (&sd->passives, bytes, len);
} else if (strcmp ("arbiters", bson_iter_key (&iter)) == 0) {
if (! BSON_ITER_HOLDS_ARRAY (&iter)) goto failure;
bson_iter_array (&iter, &len, &bytes);
bson_init_static (&sd->arbiters, bytes, len);
} else if (strcmp ("primary", bson_iter_key (&iter)) == 0) {
if (! BSON_ITER_HOLDS_UTF8 (&iter)) goto failure;
sd->current_primary = bson_iter_utf8 (&iter, NULL);
} else if (strcmp ("arbiterOnly", bson_iter_key (&iter)) == 0) {
if (! BSON_ITER_HOLDS_BOOL (&iter)) goto failure;
is_arbiter = bson_iter_bool (&iter);
} else if (strcmp ("isreplicaset", bson_iter_key (&iter)) == 0) {
if (! BSON_ITER_HOLDS_BOOL (&iter)) goto failure;
is_replicaset = bson_iter_bool (&iter);
} else if (strcmp ("tags", bson_iter_key (&iter)) == 0) {
if (! BSON_ITER_HOLDS_DOCUMENT (&iter)) goto failure;
bson_iter_document (&iter, &len, &bytes);
bson_init_static (&sd->tags, bytes, len);
} else if (strcmp ("hidden", bson_iter_key (&iter)) == 0) {
is_hidden = bson_iter_bool (&iter);
}
}
if (is_shard) {
sd->type = MONGOC_SERVER_MONGOS;
} else if (sd->set_name) {
if (is_hidden) {
sd->type = MONGOC_SERVER_RS_OTHER;
} else if (is_master) {
sd->type = MONGOC_SERVER_RS_PRIMARY;
} else if (is_secondary) {
sd->type = MONGOC_SERVER_RS_SECONDARY;
} else if (is_arbiter) {
sd->type = MONGOC_SERVER_RS_ARBITER;
} else {
sd->type = MONGOC_SERVER_RS_OTHER;
}
} else if (is_replicaset) {
sd->type = MONGOC_SERVER_RS_GHOST;
} else if (num_keys > 0) {
sd->type = MONGOC_SERVER_STANDALONE;
} else {
sd->type = MONGOC_SERVER_UNKNOWN;
}
mongoc_server_description_update_rtt(sd, rtt_msec);
EXIT;
failure:
sd->type = MONGOC_SERVER_UNKNOWN;
sd->round_trip_time = -1;
EXIT;
}
static mongoc_matcher_op_t *
_mongoc_matcher_parse_compare (bson_iter_t *iter, /* IN */
const char *path, /* IN */
bson_error_t *error) /* OUT */
{
const char * key;
mongoc_matcher_op_t * op = NULL, * op_child;
bson_iter_t child;
BSON_ASSERT (iter);
BSON_ASSERT (path);
if (bson_iter_type (iter) == BSON_TYPE_DOCUMENT) {
if (!bson_iter_recurse (iter, &child) ||
!bson_iter_next (&child)) {
bson_set_error (error,
MONGOC_ERROR_MATCHER,
MONGOC_ERROR_MATCHER_INVALID,
"Document contains no operations.");
return NULL;
}
key = bson_iter_key (&child);
if (key[0] != '$') {
op = _mongoc_matcher_op_compare_new (MONGOC_MATCHER_OPCODE_EQ, path,
iter);
} else if (strcmp(key, "$not") == 0) {
if (!(op_child = _mongoc_matcher_parse_compare (&child, path,
error))) {
return NULL;
}
op = _mongoc_matcher_op_not_new (path, op_child);
} else if (strcmp(key, "$gt") == 0) {
op = _mongoc_matcher_op_compare_new (MONGOC_MATCHER_OPCODE_GT, path,
&child);
} else if (strcmp(key, "$gte") == 0) {
op = _mongoc_matcher_op_compare_new (MONGOC_MATCHER_OPCODE_GTE, path,
&child);
} else if (strcmp(key, "$in") == 0) {
op = _mongoc_matcher_op_compare_new (MONGOC_MATCHER_OPCODE_IN, path,
&child);
} else if (strcmp(key, "$lt") == 0) {
op = _mongoc_matcher_op_compare_new (MONGOC_MATCHER_OPCODE_LT, path,
&child);
} else if (strcmp(key, "$lte") == 0) {
op = _mongoc_matcher_op_compare_new (MONGOC_MATCHER_OPCODE_LTE, path,
&child);
} else if (strcmp(key, "$ne") == 0) {
op = _mongoc_matcher_op_compare_new (MONGOC_MATCHER_OPCODE_NE, path,
&child);
} else if (strcmp(key, "$nin") == 0) {
op = _mongoc_matcher_op_compare_new (MONGOC_MATCHER_OPCODE_NIN, path,
&child);
} else if (strcmp(key, "$exists") == 0) {
op = _mongoc_matcher_op_exists_new (path, bson_iter_bool (&child));
} else if (strcmp(key, "$type") == 0) {
op = _mongoc_matcher_op_type_new (path, bson_iter_type (&child));
} else {
bson_set_error (error,
MONGOC_ERROR_MATCHER,
MONGOC_ERROR_MATCHER_INVALID,
"Invalid operator \"%s\"",
key);
return NULL;
}
} else {
op = _mongoc_matcher_op_compare_new (MONGOC_MATCHER_OPCODE_EQ, path, iter);
}
BSON_ASSERT (op);
return op;
}
static void
test_mongoc_uri_new (void)
{
const mongoc_host_list_t *hosts;
const bson_t *options;
mongoc_uri_t *uri;
bson_iter_t iter;
bson_iter_t child;
ASSERT(!mongoc_uri_new("mongodb://"));
ASSERT(!mongoc_uri_new("mongodb://::"));
ASSERT(!mongoc_uri_new("mongodb://*****:*****@localhost:27017?authSource=abcd");
ASSERT(uri);
ASSERT_CMPSTR(mongoc_uri_get_username(uri), "christian");
ASSERT_CMPSTR(mongoc_uri_get_password(uri), "secret");
ASSERT_CMPSTR(mongoc_uri_get_auth_source(uri), "abcd");
mongoc_uri_destroy(uri);
uri = mongoc_uri_new("mongodb://*****:*****@localhost:27017");
ASSERT(uri);
ASSERT_CMPSTR(mongoc_uri_get_auth_source(uri), "admin");
mongoc_uri_destroy(uri);
uri = mongoc_uri_new("mongodb://christian@localhost:27017");
ASSERT(uri);
ASSERT_CMPSTR(mongoc_uri_get_username(uri), "christian");
mongoc_uri_destroy(uri);
uri = mongoc_uri_new("mongodb://christian%40realm@localhost:27017");
ASSERT(uri);
ASSERT_CMPSTR(mongoc_uri_get_username(uri), "christian@realm");
mongoc_uri_destroy(uri);
/* while you shouldn't do this, lets test for it */
uri = mongoc_uri_new("mongodb://christian%40realm@localhost:27017/db%2ename");
ASSERT(uri);
ASSERT_CMPSTR(mongoc_uri_get_database(uri), "db.name");
mongoc_uri_destroy(uri);
uri = mongoc_uri_new("mongodb://christian%40realm@localhost:27017/db%2Ename");
ASSERT(uri);
ASSERT_CMPSTR(mongoc_uri_get_database(uri), "db.name");
mongoc_uri_destroy(uri);
uri = mongoc_uri_new("mongodb://christian%40realm@localhost:27017/?abcd=%20");
ASSERT(uri);
options = mongoc_uri_get_options(uri);
ASSERT(options);
ASSERT(bson_iter_init_find(&iter, options, "abcd"));
ASSERT(BSON_ITER_HOLDS_UTF8(&iter));
ASSERT_CMPSTR(bson_iter_utf8(&iter, NULL), " ");
mongoc_uri_destroy(uri);
uri = mongoc_uri_new("mongodb://christian%40realm.cc@localhost:27017/?authmechanism=GSSAPI&gssapiservicename=blah");
ASSERT(uri);
options = mongoc_uri_get_options(uri);
ASSERT(options);
assert (0 == strcmp (mongoc_uri_get_auth_mechanism (uri), "GSSAPI"));
assert (0 == strcmp (mongoc_uri_get_username (uri), "*****@*****.**"));
assert (bson_iter_init_find_case (&iter, options, "gssapiservicename") &&
BSON_ITER_HOLDS_UTF8 (&iter) &&
(0 == strcmp (bson_iter_utf8 (&iter, NULL), "blah")));
mongoc_uri_destroy(uri);
uri = mongoc_uri_new("mongodb://christian%40realm@[::6]:27017/?abcd=%20");
ASSERT(uri);
options = mongoc_uri_get_options(uri);
ASSERT(options);
ASSERT(bson_iter_init_find(&iter, options, "abcd"));
ASSERT(BSON_ITER_HOLDS_UTF8(&iter));
ASSERT_CMPSTR(bson_iter_utf8(&iter, NULL), " ");
mongoc_uri_destroy(uri);
}
void
_mongoc_write_command_update_legacy (mongoc_write_command_t *command,
mongoc_client_t *client,
mongoc_server_stream_t *server_stream,
const char *database,
const char *collection,
uint32_t offset,
mongoc_write_result_t *result,
bson_error_t *error)
{
int64_t started;
int32_t max_bson_obj_size;
mongoc_rpc_t rpc;
uint32_t request_id = 0;
bson_iter_t subiter, subsubiter;
bson_t doc;
bson_t update, selector;
const uint8_t *data = NULL;
uint32_t len = 0;
size_t err_offset;
bool val = false;
char ns[MONGOC_NAMESPACE_MAX + 1];
int vflags = (BSON_VALIDATE_UTF8 | BSON_VALIDATE_UTF8_ALLOW_NULL |
BSON_VALIDATE_DOLLAR_KEYS | BSON_VALIDATE_DOT_KEYS);
bson_reader_t *reader;
const bson_t *bson;
bool eof;
ENTRY;
BSON_ASSERT (command);
BSON_ASSERT (client);
BSON_ASSERT (database);
BSON_ASSERT (server_stream);
BSON_ASSERT (collection);
started = bson_get_monotonic_time ();
max_bson_obj_size = mongoc_server_stream_max_bson_obj_size (server_stream);
reader =
bson_reader_new_from_data (command->payload.data, command->payload.len);
while ((bson = bson_reader_read (reader, &eof))) {
if (bson_iter_init (&subiter, bson) && bson_iter_find (&subiter, "u") &&
BSON_ITER_HOLDS_DOCUMENT (&subiter)) {
bson_iter_document (&subiter, &len, &data);
BSON_ASSERT (bson_init_static (&doc, data, len));
if (bson_iter_init (&subsubiter, &doc) &&
bson_iter_next (&subsubiter) &&
(bson_iter_key (&subsubiter)[0] != '$') &&
!bson_validate (
&doc, (bson_validate_flags_t) vflags, &err_offset)) {
result->failed = true;
bson_set_error (error,
MONGOC_ERROR_BSON,
MONGOC_ERROR_BSON_INVALID,
"update document is corrupt or contains "
"invalid keys including $ or .");
bson_reader_destroy (reader);
EXIT;
}
} else {
result->failed = true;
bson_set_error (error,
MONGOC_ERROR_BSON,
MONGOC_ERROR_BSON_INVALID,
"updates is malformed.");
bson_reader_destroy (reader);
EXIT;
}
}
bson_snprintf (ns, sizeof ns, "%s.%s", database, collection);
bson_reader_destroy (reader);
reader =
bson_reader_new_from_data (command->payload.data, command->payload.len);
while ((bson = bson_reader_read (reader, &eof))) {
request_id = ++client->cluster.request_id;
rpc.header.msg_len = 0;
rpc.header.request_id = request_id;
rpc.header.response_to = 0;
rpc.header.opcode = MONGOC_OPCODE_UPDATE;
rpc.update.zero = 0;
rpc.update.collection = ns;
rpc.update.flags = MONGOC_UPDATE_NONE;
BSON_ASSERT (bson_iter_init (&subiter, bson));
while (bson_iter_next (&subiter)) {
if (strcmp (bson_iter_key (&subiter), "u") == 0) {
bson_iter_document (&subiter, &len, &data);
if (len > max_bson_obj_size) {
_mongoc_write_command_too_large_error (
error, 0, len, max_bson_obj_size);
result->failed = true;
bson_reader_destroy (reader);
EXIT;
}
rpc.update.update = data;
BSON_ASSERT (bson_init_static (&update, data, len));
} else if (strcmp (bson_iter_key (&subiter), "q") == 0) {
bson_iter_document (&subiter, &len, &data);
if (len > max_bson_obj_size) {
_mongoc_write_command_too_large_error (
error, 0, len, max_bson_obj_size);
result->failed = true;
bson_reader_destroy (reader);
EXIT;
}
rpc.update.selector = data;
BSON_ASSERT (bson_init_static (&selector, data, len));
} else if (strcmp (bson_iter_key (&subiter), "multi") == 0) {
val = bson_iter_bool (&subiter);
if (val) {
rpc.update.flags = (mongoc_update_flags_t) (
rpc.update.flags | MONGOC_UPDATE_MULTI_UPDATE);
}
} else if (strcmp (bson_iter_key (&subiter), "upsert") == 0) {
val = bson_iter_bool (&subiter);
if (val) {
rpc.update.flags = (mongoc_update_flags_t) (
rpc.update.flags | MONGOC_UPDATE_UPSERT);
}
}
}
_mongoc_monitor_legacy_write (
client, command, database, collection, server_stream, request_id);
if (!mongoc_cluster_legacy_rpc_sendv_to_server (
&client->cluster, &rpc, server_stream, error)) {
result->failed = true;
bson_reader_destroy (reader);
EXIT;
}
_mongoc_monitor_legacy_write_succeeded (client,
bson_get_monotonic_time () -
started,
command,
server_stream,
request_id);
started = bson_get_monotonic_time ();
}
bson_reader_destroy (reader);
}
mongoc_collection_t *
mongoc_database_create_collection (mongoc_database_t *database,
const char *name,
const bson_t *options,
bson_error_t *error)
{
mongoc_collection_t *collection = NULL;
bson_iter_t iter;
bson_t cmd;
bool capped = false;
bson_return_val_if_fail (database, NULL);
bson_return_val_if_fail (name, NULL);
if (strchr (name, '$')) {
bson_set_error (error,
MONGOC_ERROR_NAMESPACE,
MONGOC_ERROR_NAMESPACE_INVALID,
"The namespace \"%s\" is invalid.",
name);
return NULL;
}
if (options) {
if (bson_iter_init_find (&iter, options, "capped")) {
if (!BSON_ITER_HOLDS_BOOL (&iter)) {
bson_set_error (error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_COMMAND_INVALID_ARG,
"The argument \"capped\" must be a boolean.");
return NULL;
}
capped = bson_iter_bool (&iter);
}
if (bson_iter_init_find (&iter, options, "autoIndexId") &&
!BSON_ITER_HOLDS_BOOL (&iter)) {
bson_set_error (error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_COMMAND_INVALID_ARG,
"The argument \"autoIndexId\" must be a boolean.");
return NULL;
}
if (bson_iter_init_find (&iter, options, "size")) {
if (!BSON_ITER_HOLDS_INT32 (&iter) &&
!BSON_ITER_HOLDS_INT64 (&iter)) {
bson_set_error (error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_COMMAND_INVALID_ARG,
"The argument \"size\" must be an integer.");
return NULL;
}
if (!capped) {
bson_set_error (error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_COMMAND_INVALID_ARG,
"The \"size\" parameter requires {\"capped\": true}");
return NULL;
}
}
if (bson_iter_init_find (&iter, options, "max")) {
if (!BSON_ITER_HOLDS_INT32 (&iter) &&
!BSON_ITER_HOLDS_INT64 (&iter)) {
bson_set_error (error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_COMMAND_INVALID_ARG,
"The argument \"max\" must be an integer.");
return NULL;
}
if (!capped) {
bson_set_error (error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_COMMAND_INVALID_ARG,
"The \"size\" parameter requires {\"capped\": true}");
return NULL;
}
}
if (bson_iter_init_find (&iter, options, "storage")) {
if (!BSON_ITER_HOLDS_DOCUMENT (&iter)) {
bson_set_error (error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_COMMAND_INVALID_ARG,
"The \"storage\" parameter must be a document");
return NULL;
}
if (bson_iter_find (&iter, "wiredtiger")) {
if (!BSON_ITER_HOLDS_DOCUMENT (&iter)) {
bson_set_error (error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_COMMAND_INVALID_ARG,
"The \"wiredtiger\" option must take a document argument with a \"configString\" field");
return NULL;
}
if (bson_iter_find (&iter, "configString")) {
if (!BSON_ITER_HOLDS_UTF8 (&iter)) {
bson_set_error (error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_COMMAND_INVALID_ARG,
"The \"configString\" parameter must be a string");
return NULL;
}
} else {
bson_set_error (error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_COMMAND_INVALID_ARG,
"The \"wiredtiger\" option must take a document argument with a \"configString\" field");
return NULL;
}
}
}
}
bson_init (&cmd);
BSON_APPEND_UTF8 (&cmd, "create", name);
if (options) {
if (!bson_iter_init (&iter, options)) {
bson_set_error (error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_COMMAND_INVALID_ARG,
"The argument \"options\" is corrupt or invalid.");
bson_destroy (&cmd);
return NULL;
}
while (bson_iter_next (&iter)) {
if (!bson_append_iter (&cmd, bson_iter_key (&iter), -1, &iter)) {
bson_set_error (error,
MONGOC_ERROR_COMMAND,
MONGOC_ERROR_COMMAND_INVALID_ARG,
"Failed to append \"options\" to create command.");
bson_destroy (&cmd);
return NULL;
}
}
}
if (mongoc_database_command_simple (database, &cmd, NULL, NULL, error)) {
collection = _mongoc_collection_new (database->client,
database->name,
name,
database->read_prefs,
database->write_concern);
}
bson_destroy (&cmd);
return collection;
}
void bsonToBool(bson_iter_t* iter, Array* output) {
output->add(
String(bson_iter_key(iter)),
bson_iter_bool(iter)
);
}
static void
test_write_concern_basic (void)
{
mongoc_write_concern_t *write_concern;
const bson_t *gle;
const bson_t *bson;
bson_iter_t iter;
write_concern = mongoc_write_concern_new();
BEGIN_IGNORE_DEPRECATIONS;
/*
* Test defaults.
*/
ASSERT(write_concern);
ASSERT(!mongoc_write_concern_get_fsync(write_concern));
ASSERT(!mongoc_write_concern_get_journal(write_concern));
ASSERT(mongoc_write_concern_get_w(write_concern) == MONGOC_WRITE_CONCERN_W_DEFAULT);
ASSERT(!mongoc_write_concern_get_wtimeout(write_concern));
ASSERT(!mongoc_write_concern_get_wmajority(write_concern));
mongoc_write_concern_set_fsync(write_concern, true);
ASSERT(mongoc_write_concern_get_fsync(write_concern));
mongoc_write_concern_set_fsync(write_concern, false);
ASSERT(!mongoc_write_concern_get_fsync(write_concern));
mongoc_write_concern_set_journal(write_concern, true);
ASSERT(mongoc_write_concern_get_journal(write_concern));
mongoc_write_concern_set_journal(write_concern, false);
ASSERT(!mongoc_write_concern_get_journal(write_concern));
/*
* Test changes to w.
*/
mongoc_write_concern_set_w(write_concern, MONGOC_WRITE_CONCERN_W_MAJORITY);
ASSERT(mongoc_write_concern_get_wmajority(write_concern));
mongoc_write_concern_set_w(write_concern, MONGOC_WRITE_CONCERN_W_DEFAULT);
ASSERT(!mongoc_write_concern_get_wmajority(write_concern));
mongoc_write_concern_set_wmajority(write_concern, 1000);
ASSERT(mongoc_write_concern_get_wmajority(write_concern));
ASSERT(mongoc_write_concern_get_wtimeout(write_concern) == 1000);
mongoc_write_concern_set_wtimeout(write_concern, 0);
ASSERT(!mongoc_write_concern_get_wtimeout(write_concern));
mongoc_write_concern_set_w(write_concern, MONGOC_WRITE_CONCERN_W_DEFAULT);
ASSERT(mongoc_write_concern_get_w(write_concern) == MONGOC_WRITE_CONCERN_W_DEFAULT);
mongoc_write_concern_set_w(write_concern, 3);
ASSERT(mongoc_write_concern_get_w(write_concern) == 3);
/*
* Check generated bson.
*/
mongoc_write_concern_set_fsync(write_concern, true);
mongoc_write_concern_set_journal(write_concern, true);
gle = _mongoc_write_concern_get_gle(write_concern);
ASSERT(bson_iter_init_find(&iter, gle, "getlasterror") && BSON_ITER_HOLDS_INT32(&iter) && bson_iter_int32(&iter) == 1);
ASSERT(bson_iter_init_find(&iter, gle, "fsync") && BSON_ITER_HOLDS_BOOL(&iter) && bson_iter_bool(&iter));
ASSERT(bson_iter_init_find(&iter, gle, "j") && BSON_ITER_HOLDS_BOOL(&iter) && bson_iter_bool(&iter));
ASSERT(bson_iter_init_find(&iter, gle, "w") && BSON_ITER_HOLDS_INT32(&iter) && bson_iter_int32(&iter) == 3);
ASSERT(gle);
bson = _mongoc_write_concern_get_bson(write_concern);
ASSERT(!bson_iter_init_find(&iter, bson, "getlasterror"));
ASSERT(bson_iter_init_find(&iter, bson, "fsync") && BSON_ITER_HOLDS_BOOL(&iter) && bson_iter_bool(&iter));
ASSERT(bson_iter_init_find(&iter, bson, "j") && BSON_ITER_HOLDS_BOOL(&iter) && bson_iter_bool(&iter));
ASSERT(bson_iter_init_find(&iter, bson, "w") && BSON_ITER_HOLDS_INT32(&iter) && bson_iter_int32(&iter) == 3);
ASSERT(bson);
mongoc_write_concern_destroy(write_concern);
END_IGNORE_DEPRECATIONS;
}
types::b_bool element::get_bool() const {
BSONCXX_TYPE_CHECK(k_bool);
BSONCXX_CITER;
return types::b_bool{bson_iter_bool(&iter)};
}
