bool
mongoc_database_remove_all_users (mongoc_database_t *database,
bson_error_t *error)
{
mongoc_collection_t *col;
bson_error_t lerror;
bson_t cmd;
bool ret;
ENTRY;
bson_return_val_if_fail (database, false);
bson_init (&cmd);
BSON_APPEND_INT32 (&cmd, "dropAllUsersFromDatabase", 1);
ret = mongoc_database_command_simple (database, &cmd, NULL, NULL, &lerror);
bson_destroy (&cmd);
if (!ret && (lerror.code == MONGOC_ERROR_QUERY_COMMAND_NOT_FOUND)) {
bson_init (&cmd);
col = mongoc_client_get_collection (database->client, database->name,
"system.users");
BSON_ASSERT (col);
ret = mongoc_collection_delete (col, MONGOC_DELETE_NONE, &cmd, NULL,
error);
bson_destroy (&cmd);
mongoc_collection_destroy (col);
}
RETURN (ret);
}
static void
test_command (void)
{
mongoc_database_t *database;
mongoc_client_t *client;
mongoc_cursor_t *cursor;
bson_error_t error;
const bson_t *doc;
bool r;
bson_t cmd = BSON_INITIALIZER;
bson_t reply;
client = mongoc_client_new (gTestUri);
assert (client);
database = mongoc_client_get_database (client, "admin");
/*
* Test a known working command, "ping".
*/
bson_append_int32 (&cmd, "ping", 4, 1);
cursor = mongoc_database_command (database, MONGOC_QUERY_NONE, 0, 1, 0, &cmd, NULL, NULL);
assert (cursor);
r = mongoc_cursor_next (cursor, &doc);
assert (r);
assert (doc);
r = mongoc_cursor_next (cursor, &doc);
assert (!r);
assert (!doc);
mongoc_cursor_destroy (cursor);
/*
* Test a non-existing command to ensure we get the failure.
*/
bson_reinit (&cmd);
bson_append_int32 (&cmd, "a_non_existing_command", -1, 1);
r = mongoc_database_command_simple (database, &cmd, NULL, &reply, &error);
assert (!r);
assert (error.domain == MONGOC_ERROR_QUERY);
assert (error.code == MONGOC_ERROR_QUERY_COMMAND_NOT_FOUND);
assert (!strcmp ("no such cmd: a_non_existing_command", error.message));
mongoc_database_destroy (database);
mongoc_client_destroy (client);
bson_destroy (&cmd);
}
bool
mongoc_database_drop (mongoc_database_t *database,
bson_error_t *error)
{
bool ret;
bson_t cmd;
bson_return_val_if_fail(database, false);
bson_init(&cmd);
bson_append_int32(&cmd, "dropDatabase", 12, 1);
ret = mongoc_database_command_simple(database, &cmd, NULL, NULL, error);
bson_destroy(&cmd);
return ret;
}
bson_t *
mongoc_database_get_collection_info (mongoc_database_t *database,
const bson_t *filter,
bson_error_t *error)
{
mongoc_read_prefs_t *read_prefs;
bson_t *reply = bson_new();
bson_t cmd = BSON_INITIALIZER;
bool cmd_success;
BSON_ASSERT (database);
BSON_APPEND_INT32 (&cmd, "listCollections", 1);
if (filter) {
BSON_APPEND_DOCUMENT (&cmd, "filter", filter);
}
read_prefs = mongoc_read_prefs_new (MONGOC_READ_PRIMARY);
cmd_success = mongoc_database_command_simple (database, &cmd, read_prefs,
reply, error);
if (cmd_success) {
/* intentionally empty */
} else if (error->code == MONGOC_ERROR_QUERY_COMMAND_NOT_FOUND) {
bson_destroy (reply);
/* We are talking to a server that doesn' support listCollections. */
/* clear out the error. */
error->code = 0;
error->domain = 0;
/* try again with using system.namespaces */
reply =
_mongoc_database_get_collection_info_legacy (database, filter, error);
} else {
/* network error */
bson_destroy (reply);
reply = NULL;
}
bson_destroy (&cmd);
mongoc_read_prefs_destroy (read_prefs);
return reply;
}
bool
mongoc_database_remove_user (mongoc_database_t *database,
const char *username,
bson_error_t *error)
{
mongoc_collection_t *col;
bson_error_t lerror;
bson_t cmd;
bool ret;
ENTRY;
bson_return_val_if_fail (database, false);
bson_return_val_if_fail (username, false);
bson_init (&cmd);
BSON_APPEND_UTF8 (&cmd, "dropUser", username);
ret = mongoc_database_command_simple (database, &cmd, NULL, NULL, &lerror);
bson_destroy (&cmd);
if (!ret && (lerror.code == MONGOC_ERROR_QUERY_COMMAND_NOT_FOUND)) {
bson_init (&cmd);
BSON_APPEND_UTF8 (&cmd, "user", username);
col = mongoc_client_get_collection (database->client, database->name,
"system.users");
BSON_ASSERT (col);
ret = mongoc_collection_remove (col,
MONGOC_REMOVE_SINGLE_REMOVE,
&cmd,
NULL,
error);
bson_destroy (&cmd);
mongoc_collection_destroy (col);
} else if (error) {
memcpy (error, &lerror, sizeof *error);
}
RETURN (ret);
}
bool
copydb (mongoc_client_t *client, const char *other_host_and_port)
{
mongoc_database_t *admindb;
bson_t *command;
bson_t reply;
bson_error_t error;
bool res;
BSON_ASSERT (other_host_and_port);
/* Must do this from the admin db */
admindb = mongoc_client_get_database (client, "admin");
command = BCON_NEW ("copydb",
BCON_INT32 (1),
"fromdb",
BCON_UTF8 ("test"),
"todb",
BCON_UTF8 ("test2"),
/* If you want from a different host */
"fromhost",
BCON_UTF8 (other_host_and_port));
res =
mongoc_database_command_simple (admindb, command, NULL, &reply, &error);
if (!res) {
fprintf (stderr, "Error with copydb: %s\n", error.message);
goto cleanup;
}
/* Do something with the reply */
print_res (&reply);
cleanup:
bson_destroy (&reply);
bson_destroy (command);
mongoc_database_destroy (admindb);
return res;
}
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;
}
/**
* mongoc_database_add_user:
* @database: A #mongoc_database_t.
* @username: A string containing the username.
* @password: (allow-none): A string containing password, or NULL.
* @roles: (allow-none): An optional bson_t of roles.
* @custom_data: (allow-none): An optional bson_t of data to store.
* @error: (out) (allow-none): A location for a bson_error_t or %NULL.
*
* Creates a new user with access to @database.
*
* Returns: None.
* Side effects: None.
*/
bool
mongoc_database_add_user (mongoc_database_t *database,
const char *username,
const char *password,
const bson_t *roles,
const bson_t *custom_data,
bson_error_t *error)
{
bson_error_t lerror;
bson_t cmd;
bson_t ar;
char *input;
char *hashed_password;
bool ret = false;
ENTRY;
BSON_ASSERT (database);
BSON_ASSERT (username);
/*
* CDRIVER-232:
*
* Perform a (slow and tedious) round trip to mongod to determine if
* we can safely call createUser. Otherwise, we will fallback and
* perform legacy insertion into users collection.
*/
bson_init (&cmd);
BSON_APPEND_UTF8 (&cmd, "usersInfo", username);
ret = mongoc_database_command_simple (database, &cmd, NULL, NULL, &lerror);
bson_destroy (&cmd);
if (!ret && (lerror.code == MONGOC_ERROR_QUERY_COMMAND_NOT_FOUND)) {
ret = mongoc_database_add_user_legacy (database, username, password, error);
} else if (ret || (lerror.code == 13)) {
/* usersInfo succeeded or failed with auth err, we're on modern mongod */
input = bson_strdup_printf ("%s:mongo:%s", username, password);
hashed_password = _mongoc_hex_md5 (input);
bson_free (input);
bson_init (&cmd);
BSON_APPEND_UTF8 (&cmd, "createUser", username);
BSON_APPEND_UTF8 (&cmd, "pwd", hashed_password);
BSON_APPEND_BOOL (&cmd, "digestPassword", false);
if (custom_data) {
BSON_APPEND_DOCUMENT (&cmd, "customData", custom_data);
}
if (roles) {
BSON_APPEND_ARRAY (&cmd, "roles", roles);
} else {
bson_append_array_begin (&cmd, "roles", 5, &ar);
bson_append_array_end (&cmd, &ar);
}
ret = mongoc_database_command_simple (database, &cmd, NULL, NULL, error);
bson_free (hashed_password);
bson_destroy (&cmd);
} else if (error) {
memcpy (error, &lerror, sizeof *error);
}
RETURN (ret);
}
bool map_reduce_basic (mongoc_database_t* database)
{
bson_t reply;
bson_t* command;
bool res;
bson_error_t error;
mongoc_cursor_t* cursor;
const bson_t* doc;
bool map_reduce_done = false;
bool query_done = false;
const char* out_collection_name = "outCollection";
mongoc_collection_t* out_collection;
/* Empty find query */
bson_t find_query = BSON_INITIALIZER;
/* Construct the mapReduce command */
/* Other arguments can also be specified here, like "query" or
"limit" and so on */
command = BCON_NEW ("mapReduce", BCON_UTF8 (COLLECTION_NAME),
"map", BCON_CODE (MAPPER),
"reduce", BCON_CODE (REDUCER),
"out", BCON_UTF8 (out_collection_name));
res = mongoc_database_command_simple (database, command, NULL,
&reply, &error);
map_reduce_done = true;
if (!res) {
fprintf (stderr, "MapReduce failed: %s\n", error.message);
goto cleanup;
}
/* Do something with the reply (it doesn't contain the mapReduce results) */
print_res (&reply);
/* Now we'll query outCollection to see what the results are */
out_collection = mongoc_database_get_collection (database,
out_collection_name);
cursor = mongoc_collection_find_with_opts (out_collection, &find_query,
NULL, NULL);
query_done = true;
/* Do something with the results */
while (mongoc_cursor_next (cursor, &doc)) {
print_res (doc);
}
if (mongoc_cursor_error (cursor, &error)) {
fprintf (stderr, "ERROR: %s\n", error.message);
res = false;
goto cleanup;
}
cleanup:
/* cleanup */
if (query_done) {
mongoc_cursor_destroy (cursor);
mongoc_collection_destroy (out_collection);
}
if (map_reduce_done) {
bson_destroy (&reply);
bson_destroy (command);
}
return res;
}
