void
mongoc_uri_append_host (mongoc_uri_t *uri,
const char *host,
uint16_t port)
{
mongoc_host_list_t *iter;
mongoc_host_list_t *link_;
link_ = (mongoc_host_list_t *)bson_malloc0(sizeof *link_);
mongoc_uri_lowercase_hostname(host, link_->host, sizeof link_->host);
if (strchr (host, ':')) {
bson_snprintf (link_->host_and_port, sizeof link_->host_and_port,
"[%s]:%hu", host, port);
link_->family = AF_INET6;
} else {
bson_snprintf (link_->host_and_port, sizeof link_->host_and_port,
"%s:%hu", host, port);
link_->family = strstr (host, ".sock") ? AF_UNIX : AF_INET;
}
link_->host_and_port[sizeof link_->host_and_port - 1] = '\0';
link_->port = port;
if ((iter = uri->hosts)) {
for (; iter && iter->next; iter = iter->next) {}
iter->next = link_;
} else {
uri->hosts = link_;
}
}
mongoc_gridfs_t *
_mongoc_gridfs_new (mongoc_client_t *client,
const char *db,
const char *prefix,
bson_error_t *error)
{
mongoc_gridfs_t *gridfs;
const mongoc_read_prefs_t *read_prefs;
const mongoc_read_concern_t *read_concern;
const mongoc_write_concern_t *write_concern;
char buf[128];
bool r;
uint32_t prefix_len;
ENTRY;
BSON_ASSERT (client);
BSON_ASSERT (db);
if (!prefix) {
prefix = "fs";
}
/* make sure prefix is short enough to bucket the chunks and files
* collections
*/
prefix_len = (uint32_t)strlen (prefix);
BSON_ASSERT (prefix_len + sizeof (".chunks") < sizeof (buf));
gridfs = (mongoc_gridfs_t *) bson_malloc0 (sizeof *gridfs);
gridfs->client = client;
read_prefs = mongoc_client_get_read_prefs (client);
read_concern = mongoc_client_get_read_concern (client);
write_concern = mongoc_client_get_write_concern (client);
bson_snprintf (buf, sizeof(buf), "%s.chunks", prefix);
gridfs->chunks = _mongoc_collection_new (client, db, buf, read_prefs,
read_concern, write_concern);
bson_snprintf (buf, sizeof(buf), "%s.files", prefix);
gridfs->files = _mongoc_collection_new (client, db, buf, read_prefs,
read_concern, write_concern);
r = _mongoc_gridfs_ensure_index (gridfs, error);
if (!r) {
mongoc_gridfs_destroy (gridfs);
RETURN (NULL);
}
RETURN (gridfs);
}
mongoc_cursor_t *
mongoc_client_command (mongoc_client_t *client,
const char *db_name,
mongoc_query_flags_t flags,
uint32_t skip,
uint32_t limit,
uint32_t batch_size,
const bson_t *query,
const bson_t *fields,
const mongoc_read_prefs_t *read_prefs)
{
char ns[MONGOC_NAMESPACE_MAX];
BSON_ASSERT (client);
BSON_ASSERT (db_name);
BSON_ASSERT (query);
if (!read_prefs) {
read_prefs = client->read_prefs;
}
/*
* Allow a caller to provide a fully qualified namespace. Otherwise,
* querying something like "$cmd.sys.inprog" is not possible.
*/
if (NULL == strstr (db_name, "$cmd")) {
bson_snprintf (ns, sizeof ns, "%s.$cmd", db_name);
db_name = ns;
}
return _mongoc_cursor_new (client, db_name, flags, skip, limit, batch_size,
true, query, fields, read_prefs);
}
bool
_mongoc_sasl_get_canonicalized_name (mongoc_stream_t *node_stream, /* IN */
char *name, /* OUT */
size_t namelen) /* OUT */
{
mongoc_stream_t *stream;
mongoc_socket_t *sock = NULL;
char *canonicalized;
ENTRY;
BSON_ASSERT (node_stream);
BSON_ASSERT (name);
stream = mongoc_stream_get_root_stream (node_stream);
BSON_ASSERT (stream);
if (stream->type == MONGOC_STREAM_SOCKET) {
sock =
mongoc_stream_socket_get_socket ((mongoc_stream_socket_t *) stream);
if (sock) {
canonicalized = mongoc_socket_getnameinfo (sock);
if (canonicalized) {
bson_snprintf (name, namelen, "%s", canonicalized);
bson_free (canonicalized);
RETURN (true);
}
}
}
RETURN (false);
}
mongoc_cursor_t *
mongoc_client_command (mongoc_client_t *client,
const char *db_name,
mongoc_query_flags_t flags,
uint32_t skip,
uint32_t limit,
uint32_t batch_size,
const bson_t *query,
const bson_t *fields,
const mongoc_read_prefs_t *read_prefs)
{
char ns[MONGOC_NAMESPACE_MAX];
BSON_ASSERT (client);
BSON_ASSERT (db_name);
BSON_ASSERT (query);
if (!read_prefs) {
read_prefs = client->read_prefs;
}
bson_snprintf (ns, sizeof ns, "%s.$cmd", db_name);
return _mongoc_cursor_new (client, ns, flags, skip, limit, batch_size, true,
query, fields, read_prefs);
}
mongoc_gridfs_t *
_mongoc_gridfs_new (mongoc_client_t *client,
const char *db,
const char *prefix,
bson_error_t *error)
{
mongoc_gridfs_t *gridfs;
char buf[128];
bool r;
ENTRY;
BSON_ASSERT (client);
BSON_ASSERT (db);
if (!prefix) {
prefix = "fs";
}
/* make sure prefix is short enough to bucket the chunks and files
* collections
*/
#ifndef BSON_DISABLE_ASSERT
{
uint32_t prefix_len;
prefix_len = (uint32_t)strlen (prefix);
BSON_ASSERT (prefix_len + sizeof (".chunks") < sizeof (buf));
}
#endif
gridfs = bson_malloc0 (sizeof *gridfs);
gridfs->client = client;
bson_snprintf (buf, sizeof(buf), "%s.chunks", prefix);
gridfs->chunks = _mongoc_collection_new (client, db, buf, NULL, NULL);
bson_snprintf (buf, sizeof(buf), "%s.files", prefix);
gridfs->files = _mongoc_collection_new (client, db, buf, NULL, NULL);
r = _mongoc_gridfs_ensure_index (gridfs, error);
if (!r) { return NULL; }
RETURN (gridfs);
}
/**
* mongoc_database_has_collection:
* @database: (in): A #mongoc_database_t.
* @name: (in): The name of the collection to check for.
* @error: (out) (allow-none): A location for a #bson_error_t, or %NULL.
*
* Checks to see if a collection exists within the database on the MongoDB
* server.
*
* This will return %false if their was an error communicating with the
* server, or if the collection does not exist.
*
* If @error is provided, it will first be zeroed. Upon error, error.domain
* will be set.
*
* Returns: %true if @name exists, otherwise %false. @error may be set.
*/
bool
mongoc_database_has_collection (mongoc_database_t *database,
const char *name,
bson_error_t *error)
{
mongoc_collection_t *collection;
mongoc_read_prefs_t *read_prefs;
mongoc_cursor_t *cursor;
const bson_t *doc;
bson_iter_t iter;
bool ret = false;
const char *cur_name;
bson_t q = BSON_INITIALIZER;
char ns[140];
ENTRY;
BSON_ASSERT (database);
BSON_ASSERT (name);
if (error) {
memset (error, 0, sizeof *error);
}
bson_snprintf (ns, sizeof ns, "%s.%s", database->name, name);
ns[sizeof ns - 1] = '\0';
read_prefs = mongoc_read_prefs_new (MONGOC_READ_PRIMARY);
collection = mongoc_client_get_collection (database->client,
database->name,
"system.namespaces");
cursor = mongoc_collection_find (collection, MONGOC_QUERY_NONE, 0, 0, 0, &q,
NULL, read_prefs);
while (!mongoc_cursor_error (cursor, error) &&
mongoc_cursor_more (cursor)) {
while (mongoc_cursor_next (cursor, &doc) &&
bson_iter_init_find (&iter, doc, "name") &&
BSON_ITER_HOLDS_UTF8 (&iter)) {
cur_name = bson_iter_utf8(&iter, NULL);
if (!strcmp(cur_name, ns)) {
ret = true;
GOTO(cleanup);
}
}
}
cleanup:
mongoc_cursor_destroy (cursor);
mongoc_collection_destroy (collection);
mongoc_read_prefs_destroy (read_prefs);
RETURN(ret);
}
static mongoc_stream_t *
mongoc_client_connect_unix (const mongoc_uri_t *uri,
const mongoc_host_list_t *host,
bson_error_t *error)
{
#ifdef _WIN32
ENTRY;
bson_set_error (error,
MONGOC_ERROR_STREAM,
MONGOC_ERROR_STREAM_CONNECT,
"UNIX domain sockets not supported on win32.");
RETURN (NULL);
#else
struct sockaddr_un saddr;
mongoc_socket_t *sock;
mongoc_stream_t *ret = NULL;
ENTRY;
bson_return_val_if_fail (uri, NULL);
bson_return_val_if_fail (host, NULL);
memset (&saddr, 0, sizeof saddr);
saddr.sun_family = AF_UNIX;
bson_snprintf (saddr.sun_path, sizeof saddr.sun_path - 1,
"%s", host->host_and_port);
sock = mongoc_socket_new (AF_UNIX, SOCK_STREAM, 0);
if (sock == NULL) {
bson_set_error (error,
MONGOC_ERROR_STREAM,
MONGOC_ERROR_STREAM_SOCKET,
"Failed to create socket.");
RETURN (NULL);
}
if (-1 == mongoc_socket_connect (sock,
(struct sockaddr *)&saddr,
sizeof saddr,
-1)) {
mongoc_socket_destroy (sock);
bson_set_error (error,
MONGOC_ERROR_STREAM,
MONGOC_ERROR_STREAM_CONNECT,
"Failed to connect to UNIX domain socket.");
RETURN (NULL);
}
ret = mongoc_stream_socket_new (sock);
RETURN (ret);
#endif
}
static void
mongoc_counters_destroy (void)
{
char name[32];
int pid;
pid = getpid();
bson_snprintf(name, sizeof name, "/mongoc-%u", pid);
name[sizeof name - 1] = '\0';
shm_unlink(name);
}
int
main (int argc,
char *argv[])
{
TestSuite suite;
int ret;
mongoc_init ();
bson_snprintf (MONGOC_TEST_UNIQUE, sizeof MONGOC_TEST_UNIQUE,
"test_%u_%u", (unsigned)time (NULL),
(unsigned)gettestpid ());
set_mongoc_test_host ();
mongoc_log_set_handler (log_handler, NULL);
TestSuite_Init (&suite, "", argc, argv);
test_array_install (&suite);
test_buffer_install (&suite);
test_client_install (&suite);
test_client_pool_install (&suite);
test_write_command_install (&suite);
test_bulk_install (&suite);
test_collection_install (&suite);
test_cursor_install (&suite);
test_database_install (&suite);
test_gridfs_install (&suite);
test_gridfs_file_page_install (&suite);
test_list_install (&suite);
test_matcher_install (&suite);
test_queue_install (&suite);
test_read_prefs_install (&suite);
test_rpc_install (&suite);
test_stream_install (&suite);
test_uri_install (&suite);
test_write_concern_install (&suite);
#ifdef MONGOC_ENABLE_SSL
test_x509_install (&suite);
test_stream_tls_install (&suite);
#endif
ret = TestSuite_Run (&suite);
TestSuite_Destroy (&suite);
mongoc_cleanup();
return ret;
}
/**
* mongoc_counters_alloc:
* @size: The size of the shared memory segment.
*
* This function allocates the shared memory segment for use by counters
* within the process.
*
* Returns: A shared memory segment, or malloc'd memory on failure.
*/
static void *
mongoc_counters_alloc (size_t size)
{
#ifdef BSON_OS_UNIX
void *mem;
char name[32];
int pid;
int fd;
if (!mongoc_counters_use_shm()) {
goto use_malloc;
}
pid = getpid();
bson_snprintf(name, sizeof name, "/mongoc-%u", pid);
name[sizeof name - 1] = '\0';
if (-1 == (fd = shm_open(name, O_CREAT|O_RDWR, S_IRUSR|S_IWUSR))) {
goto use_malloc;
}
/*
* NOTE:
*
* ftruncate() will cause reads to be zero. Therefore, we don't need to
* do write() of zeroes to initialize the shared memory area.
*/
if (-1 == ftruncate(fd, size)) {
goto failure;
}
mem = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
if (mem == MAP_FAILED) {
goto failure;
}
close(fd);
memset(mem, 0, size);
atexit(mongoc_counters_destroy);
return mem;
failure:
shm_unlink(name);
close(fd);
use_malloc:
#endif
return bson_malloc0(size);
}
static mongoc_gridfs_t *
get_test_gridfs (mongoc_client_t *client,
const char *name,
bson_error_t *error)
{
char *gen;
char n [48];
gen = gen_collection_name ("fs");
bson_snprintf (n, sizeof n, "%s_%s", gen, name);
bson_free (gen);
return mongoc_client_get_gridfs (client, "test", n, error);
}
void
mongoc_socket_inet_ntop (struct addrinfo *rp, /* IN */
char *buf, /* INOUT */
size_t buflen) /* IN */
{
void *ptr;
char tmp[256];
switch (rp->ai_family) {
case AF_INET:
ptr = &((struct sockaddr_in *) rp->ai_addr)->sin_addr;
inet_ntop (rp->ai_family, ptr, tmp, sizeof (tmp));
bson_snprintf (buf, buflen, "ipv4 %s", tmp);
break;
case AF_INET6:
ptr = &((struct sockaddr_in6 *) rp->ai_addr)->sin6_addr;
inet_ntop (rp->ai_family, ptr, tmp, sizeof (tmp));
bson_snprintf (buf, buflen, "ipv6 %s", tmp);
break;
default:
bson_snprintf (buf, buflen, "unknown ip %d", rp->ai_family);
break;
}
}
void
bson_oid_to_string
(const bson_oid_t *oid, /* IN */
char str[BSON_ENSURE_ARRAY_PARAM_SIZE(25)]) /* OUT */
{
#if !defined(__i386__) && !defined(__x86_64__) && \
!defined(_M_IX86) && !defined(_M_X64)
BSON_ASSERT (oid);
BSON_ASSERT (str);
bson_snprintf (str, 25,
"%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
oid->bytes[0],
oid->bytes[1],
oid->bytes[2],
oid->bytes[3],
oid->bytes[4],
oid->bytes[5],
oid->bytes[6],
oid->bytes[7],
oid->bytes[8],
oid->bytes[9],
oid->bytes[10],
oid->bytes[11]);
#else
uint16_t *dst;
uint8_t *id = (uint8_t *)oid;
BSON_ASSERT (oid);
BSON_ASSERT (str);
dst = (uint16_t *)(void *)str;
dst[0] = gHexCharPairs[id[0]];
dst[1] = gHexCharPairs[id[1]];
dst[2] = gHexCharPairs[id[2]];
dst[3] = gHexCharPairs[id[3]];
dst[4] = gHexCharPairs[id[4]];
dst[5] = gHexCharPairs[id[5]];
dst[6] = gHexCharPairs[id[6]];
dst[7] = gHexCharPairs[id[7]];
dst[8] = gHexCharPairs[id[8]];
dst[9] = gHexCharPairs[id[9]];
dst[10] = gHexCharPairs[id[10]];
dst[11] = gHexCharPairs[id[11]];
str[24] = '\0';
#endif
}
static char *
_get_os_version (void)
{
char *ret = bson_malloc (METADATA_OS_VERSION_MAX);
bool found = false;
#ifdef _WIN32
OSVERSIONINFO osvi;
ZeroMemory (&osvi, sizeof (OSVERSIONINFO));
osvi.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
if (GetVersionEx (&osvi)) {
bson_snprintf (ret,
METADATA_OS_VERSION_MAX,
"%d.%d (%d)",
osvi.dwMajorVersion,
osvi.dwMinorVersion,
osvi.dwBuildNumber);
found = true;
} else {
MONGOC_WARNING ("Error with GetVersionEx(): %d",
GetLastError ());
}
#elif defined (_POSIX_VERSION)
struct utsname system_info;
if (uname (&system_info) >= 0) {
bson_strncpy (ret, system_info.release,
METADATA_OS_VERSION_MAX);
found = true;
} else {
MONGOC_WARNING ("Error with uname(): %d", errno);
}
#endif
if (!found) {
bson_free (ret);
ret = NULL;
}
return ret;
}
char *
_mongoc_hex_md5 (const char *input)
{
uint8_t digest[16];
bson_md5_t md5;
char digest_str[33];
int i;
bson_md5_init(&md5);
bson_md5_append(&md5, (const uint8_t *)input, (uint32_t)strlen(input));
bson_md5_finish(&md5, digest);
for (i = 0; i < sizeof digest; i++) {
bson_snprintf(&digest_str[i*2], 3, "%02x", digest[i]);
}
digest_str[sizeof digest_str - 1] = '\0';
return bson_strdup(digest_str);
}
void
mongoc_read_prefs_add_tag (mongoc_read_prefs_t *read_prefs,
const bson_t *tag)
{
bson_t empty = BSON_INITIALIZER;
char str[16];
int key;
BSON_ASSERT (read_prefs);
key = bson_count_keys (&read_prefs->tags);
bson_snprintf (str, sizeof str, "%d", key);
if (tag) {
bson_append_document (&read_prefs->tags, str, -1, tag);
} else {
bson_append_document (&read_prefs->tags, str, -1, &empty);
}
}
static void
test_remove (void)
{
mongoc_gridfs_t *gridfs;
mongoc_gridfs_file_t *file;
mongoc_gridfs_file_opt_t opts = { 0 };
mongoc_client_t *client;
bson_error_t error;
bool r;
char name[32];
client = mongoc_client_new (gTestUri);
assert (client);
gridfs = mongoc_client_get_gridfs (client, "test", "foo", &error);
assert (gridfs);
mongoc_gridfs_drop (gridfs, &error);
bson_snprintf (name, sizeof name, "test-remove.%u", rand ());
opts.filename = name;
file = mongoc_gridfs_create_file (gridfs, &opts);
assert (file);
assert (mongoc_gridfs_file_save (file));
r = mongoc_gridfs_file_remove (file, &error);
if (!r) fprintf (stderr, "%s\n", error.message);
assert (r);
mongoc_gridfs_file_destroy (file);
file = mongoc_gridfs_find_one_by_filename (gridfs, name, &error);
assert (!file);
drop_collections (gridfs, &error);
mongoc_gridfs_destroy (gridfs);
mongoc_client_destroy (client);
}
size_t
bson_uint32_to_string (uint32_t value, /* IN */
const char **strptr, /* OUT */
char *str, /* OUT */
size_t size) /* IN */
{
if (value < 1000) {
*strptr = gUint32Strs[value];
if (value < 10) {
return 1;
} else if (value < 100) {
return 2;
} else {
return 3;
}
}
*strptr = str;
return bson_snprintf (str, size, "%u", value);
}
void
_mongoc_async_cmd_init_send (mongoc_async_cmd_t *acmd, const char *dbname)
{
bson_snprintf (acmd->ns, sizeof acmd->ns, "%s.$cmd", dbname);
acmd->rpc.header.msg_len = 0;
acmd->rpc.header.request_id = ++acmd->async->request_id;
acmd->rpc.header.response_to = 0;
acmd->rpc.header.opcode = MONGOC_OPCODE_QUERY;
acmd->rpc.query.flags = MONGOC_QUERY_SLAVE_OK;
acmd->rpc.query.collection = acmd->ns;
acmd->rpc.query.skip = 0;
acmd->rpc.query.n_return = -1;
acmd->rpc.query.query = bson_get_data (&acmd->cmd);
acmd->rpc.query.fields = NULL;
/* This will always be isMaster, which are not allowed to be compressed */
_mongoc_rpc_gather (&acmd->rpc, &acmd->array);
acmd->iovec = (mongoc_iovec_t *) acmd->array.data;
acmd->niovec = acmd->array.len;
_mongoc_rpc_swab_to_le (&acmd->rpc);
acmd->bytes_written = 0;
}
static void
mongoc_uri_parse_tags (mongoc_uri_t *uri, /* IN */
const char *str, /* IN */
bson_t *doc) /* IN */
{
const char *end_keyval;
const char *end_key;
bson_t b;
char *keyval;
char *key;
char keystr[32];
int i;
bson_init(&b);
again:
if ((keyval = scan_to_unichar(str, ',', &end_keyval))) {
if ((key = scan_to_unichar(keyval, ':', &end_key))) {
bson_append_utf8(&b, key, -1, end_key + 1, -1);
bson_free(key);
}
bson_free(keyval);
str = end_keyval + 1;
goto again;
} else {
if ((key = scan_to_unichar(str, ':', &end_key))) {
bson_append_utf8(&b, key, -1, end_key + 1, -1);
bson_free(key);
}
}
i = bson_count_keys(doc);
bson_snprintf(keystr, sizeof keystr, "%u", i);
bson_append_document(doc, keystr, -1, &b);
bson_destroy(&b);
}
static mongoc_stream_t *
mongoc_client_connect_tcp (const mongoc_uri_t *uri,
const mongoc_host_list_t *host,
bson_error_t *error)
{
mongoc_socket_t *sock = NULL;
struct addrinfo hints;
struct addrinfo *result, *rp;
int32_t connecttimeoutms = MONGOC_DEFAULT_CONNECTTIMEOUTMS;
int64_t expire_at;
const bson_t *options;
bson_iter_t iter;
char portstr [8];
int s;
ENTRY;
bson_return_val_if_fail (uri, NULL);
bson_return_val_if_fail (host, NULL);
if ((options = mongoc_uri_get_options (uri)) &&
bson_iter_init_find (&iter, options, "connecttimeoutms") &&
BSON_ITER_HOLDS_INT32 (&iter)) {
if (!(connecttimeoutms = bson_iter_int32(&iter))) {
connecttimeoutms = MONGOC_DEFAULT_CONNECTTIMEOUTMS;
}
}
BSON_ASSERT (connecttimeoutms);
expire_at = bson_get_monotonic_time () + (connecttimeoutms * 1000L);
bson_snprintf (portstr, sizeof portstr, "%hu", host->port);
memset (&hints, 0, sizeof hints);
hints.ai_family = host->family;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = 0;
hints.ai_protocol = 0;
s = getaddrinfo (host->host, portstr, &hints, &result);
if (s != 0) {
mongoc_counter_dns_failure_inc ();
bson_set_error(error,
MONGOC_ERROR_STREAM,
MONGOC_ERROR_STREAM_NAME_RESOLUTION,
"Failed to resolve %s",
host->host);
RETURN (NULL);
}
mongoc_counter_dns_success_inc ();
for (rp = result; rp; rp = rp->ai_next) {
/*
* Create a new non-blocking socket.
*/
if (!(sock = mongoc_socket_new (rp->ai_family,
rp->ai_socktype,
rp->ai_protocol))) {
continue;
}
/*
* Try to connect to the peer.
*/
if (0 != mongoc_socket_connect (sock,
rp->ai_addr,
(socklen_t)rp->ai_addrlen,
expire_at)) {
char errmsg_buf[32];
const char * errmsg;
errmsg = bson_strerror_r (mongoc_socket_errno (sock), errmsg_buf, sizeof errmsg_buf);
MONGOC_WARNING ("Failed to connect, error: %d, %s\n",
mongoc_socket_errno(sock),
errmsg);
mongoc_socket_destroy (sock);
sock = NULL;
continue;
}
break;
}
if (!sock) {
bson_set_error (error,
MONGOC_ERROR_STREAM,
MONGOC_ERROR_STREAM_CONNECT,
"Failed to connect to target host: %s",
host->host_and_port);
freeaddrinfo (result);
RETURN (NULL);
}
freeaddrinfo (result);
return mongoc_stream_socket_new (sock);
}
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);
}
void
_mongoc_write_command_delete_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)
{
int64_t started;
int32_t max_bson_obj_size;
const uint8_t *data;
mongoc_rpc_t rpc;
uint32_t request_id;
bson_iter_t q_iter;
uint32_t len;
int64_t limit = 0;
bson_t *gle = NULL;
char ns[MONGOC_NAMESPACE_MAX + 1];
bool r;
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);
if (!command->n_documents) {
bson_set_error (error,
MONGOC_ERROR_COLLECTION,
MONGOC_ERROR_COLLECTION_DELETE_FAILED,
"Cannot do an empty delete.");
result->failed = true;
EXIT;
}
bson_snprintf (ns, sizeof ns, "%s.%s", database, collection);
reader =
bson_reader_new_from_data (command->payload.data, command->payload.len);
while ((bson = bson_reader_read (reader, &eof))) {
/* the document is like { "q": { <selector> }, limit: <0 or 1> } */
r = (bson_iter_init (&q_iter, bson) && bson_iter_find (&q_iter, "q") &&
BSON_ITER_HOLDS_DOCUMENT (&q_iter));
BSON_ASSERT (r);
bson_iter_document (&q_iter, &len, &data);
BSON_ASSERT (data);
BSON_ASSERT (len >= 5);
if (len > max_bson_obj_size) {
_mongoc_write_command_too_large_error (
error, 0, len, max_bson_obj_size, NULL);
result->failed = true;
bson_reader_destroy (reader);
EXIT;
}
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_DELETE;
rpc.delete_.zero = 0;
rpc.delete_.collection = ns;
if (bson_iter_find (&q_iter, "limit") &&
(BSON_ITER_HOLDS_INT (&q_iter))) {
limit = bson_iter_as_int64 (&q_iter);
}
rpc.delete_.flags =
limit ? MONGOC_DELETE_SINGLE_REMOVE : MONGOC_DELETE_NONE;
rpc.delete_.selector = data;
_mongoc_monitor_legacy_write (client,
command,
database,
collection,
write_concern,
server_stream,
request_id);
if (!mongoc_cluster_legacy_rpc_sendv_to_server (
&client->cluster, &rpc, server_stream, write_concern, error)) {
result->failed = true;
bson_reader_destroy (reader);
EXIT;
}
if (mongoc_write_concern_is_acknowledged (write_concern)) {
if (!_mongoc_client_recv_gle (client, server_stream, &gle, error)) {
result->failed = true;
bson_reader_destroy (reader);
EXIT;
}
_mongoc_write_result_merge_legacy (
result,
command,
gle,
client->error_api_version,
MONGOC_ERROR_COLLECTION_DELETE_FAILED,
offset);
offset++;
}
_mongoc_monitor_legacy_write_succeeded (client,
bson_get_monotonic_time () -
started,
command,
gle,
server_stream,
request_id);
if (gle) {
bson_destroy (gle);
gle = NULL;
}
started = bson_get_monotonic_time ();
}
bson_reader_destroy (reader);
EXIT;
}
static void
test_list (void)
{
mongoc_gridfs_t *gridfs;
mongoc_gridfs_file_t *file;
mongoc_client_t *client;
bson_error_t error;
mongoc_gridfs_file_list_t *list;
mongoc_gridfs_file_opt_t opt = { 0 };
bson_t query, child;
char buf[100];
int i = 0;
client = mongoc_client_new (gTestUri);
assert (client);
gridfs = get_test_gridfs (client, "list", &error);
assert (gridfs);
mongoc_gridfs_drop (gridfs, &error);
for (i = 0; i < 3; i++) {
bson_snprintf (buf, sizeof buf, "file.%d", i);
opt.filename = buf;
file = mongoc_gridfs_create_file (gridfs, &opt);
assert (file);
assert (mongoc_gridfs_file_save (file));
mongoc_gridfs_file_destroy (file);
}
bson_init (&query);
bson_append_document_begin (&query, "$orderby", -1, &child);
bson_append_int32 (&child, "filename", -1, 1);
bson_append_document_end (&query, &child);
bson_append_document_begin (&query, "$query", -1, &child);
bson_append_document_end (&query, &child);
list = mongoc_gridfs_find (gridfs, &query);
bson_destroy (&query);
i = 0;
while ((file = mongoc_gridfs_file_list_next (list))) {
bson_snprintf (buf, sizeof buf, "file.%d", i++);
assert (strcmp (mongoc_gridfs_file_get_filename (file), buf) == 0);
mongoc_gridfs_file_destroy (file);
}
assert(i == 3);
mongoc_gridfs_file_list_destroy (list);
bson_init (&query);
bson_append_utf8 (&query, "filename", -1, "file.1", -1);
file = mongoc_gridfs_find_one (gridfs, &query, &error);
assert (file);
assert (strcmp (mongoc_gridfs_file_get_filename (file), "file.1") == 0);
mongoc_gridfs_file_destroy (file);
file = mongoc_gridfs_find_one_by_filename (gridfs, "file.1", &error);
assert (file);
assert (strcmp (mongoc_gridfs_file_get_filename (file), "file.1") == 0);
mongoc_gridfs_file_destroy (file);
drop_collections (gridfs, &error);
mongoc_gridfs_destroy (gridfs);
mongoc_client_destroy (client);
}
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;
}
static void
_mongoc_write_command_insert_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)
{
uint32_t current_offset;
mongoc_iovec_t *iov;
const uint8_t *data;
mongoc_rpc_t rpc;
bson_iter_t iter;
uint32_t len;
bson_t *gle = NULL;
uint32_t size = 0;
bool has_more;
char ns [MONGOC_NAMESPACE_MAX + 1];
bool r;
uint32_t n_docs_in_batch;
uint32_t idx = 0;
int32_t max_msg_size;
int32_t max_bson_obj_size;
bool singly;
ENTRY;
BSON_ASSERT (command);
BSON_ASSERT (client);
BSON_ASSERT (database);
BSON_ASSERT (server_stream);
BSON_ASSERT (collection);
BSON_ASSERT (command->type == MONGOC_WRITE_COMMAND_INSERT);
current_offset = offset;
max_bson_obj_size = mongoc_server_stream_max_bson_obj_size (server_stream);
max_msg_size = mongoc_server_stream_max_msg_size (server_stream);
singly = !command->u.insert.allow_bulk_op_insert;
r = bson_iter_init (&iter, command->documents);
if (!r) {
BSON_ASSERT (false);
EXIT;
}
if (!command->n_documents || !bson_iter_next (&iter)) {
bson_set_error (error,
MONGOC_ERROR_COLLECTION,
MONGOC_ERROR_COLLECTION_INSERT_FAILED,
"Cannot do an empty insert.");
result->failed = true;
EXIT;
}
bson_snprintf (ns, sizeof ns, "%s.%s", database, collection);
iov = (mongoc_iovec_t *)bson_malloc ((sizeof *iov) * command->n_documents);
again:
has_more = false;
n_docs_in_batch = 0;
size = (uint32_t)(sizeof (mongoc_rpc_header_t) +
4 +
strlen (database) +
1 +
strlen (collection) +
1);
do {
BSON_ASSERT (BSON_ITER_HOLDS_DOCUMENT (&iter));
BSON_ASSERT (n_docs_in_batch <= idx);
BSON_ASSERT (idx < command->n_documents);
bson_iter_document (&iter, &len, &data);
BSON_ASSERT (data);
BSON_ASSERT (len >= 5);
if (len > max_bson_obj_size) {
/* document is too large */
bson_t write_err_doc = BSON_INITIALIZER;
too_large_error (error, idx, len,
max_bson_obj_size, &write_err_doc);
_mongoc_write_result_merge_legacy (
result, command, &write_err_doc,
MONGOC_ERROR_COLLECTION_INSERT_FAILED, offset + idx);
bson_destroy (&write_err_doc);
if (command->flags.ordered) {
/* send the batch so far (if any) and return the error */
break;
}
} else if ((n_docs_in_batch == 1 && singly) || size > (max_msg_size - len)) {
/* batch is full, send it and then start the next batch */
has_more = true;
break;
} else {
/* add document to batch and continue building the batch */
iov[n_docs_in_batch].iov_base = (void *) data;
iov[n_docs_in_batch].iov_len = len;
size += len;
n_docs_in_batch++;
}
idx++;
} while (bson_iter_next (&iter));
if (n_docs_in_batch) {
rpc.insert.msg_len = 0;
rpc.insert.request_id = 0;
rpc.insert.response_to = 0;
rpc.insert.opcode = MONGOC_OPCODE_INSERT;
rpc.insert.flags = (
(command->flags.ordered) ? MONGOC_INSERT_NONE
: MONGOC_INSERT_CONTINUE_ON_ERROR);
rpc.insert.collection = ns;
rpc.insert.documents = iov;
rpc.insert.n_documents = n_docs_in_batch;
if (!mongoc_cluster_sendv_to_server (&client->cluster,
&rpc, 1, server_stream,
write_concern, error)) {
result->failed = true;
GOTO (cleanup);
}
if (_mongoc_write_concern_needs_gle (write_concern)) {
bool err = false;
bson_iter_t citer;
if (!_mongoc_client_recv_gle (client, server_stream, &gle, error)) {
result->failed = true;
GOTO (cleanup);
}
err = (bson_iter_init_find (&citer, gle, "err")
&& bson_iter_as_bool (&citer));
/*
* Overwrite the "n" field since it will be zero. Otherwise, our
* merge_legacy code will not know how many we tried in this batch.
*/
if (!err &&
bson_iter_init_find (&citer, gle, "n") &&
BSON_ITER_HOLDS_INT32 (&citer) &&
!bson_iter_int32 (&citer)) {
bson_iter_overwrite_int32 (&citer, n_docs_in_batch);
}
}
}
cleanup:
if (gle) {
_mongoc_write_result_merge_legacy (
result, command, gle, MONGOC_ERROR_COLLECTION_INSERT_FAILED,
current_offset);
current_offset = offset + idx;
bson_destroy (gle);
gle = NULL;
}
if (has_more) {
GOTO (again);
}
bson_free (iov);
EXIT;
}
static void
_mongoc_write_command_delete_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)
{
const uint8_t *data;
mongoc_rpc_t rpc;
bson_iter_t iter;
bson_iter_t q_iter;
uint32_t len;
bson_t *gle = NULL;
char ns [MONGOC_NAMESPACE_MAX + 1];
bool r;
ENTRY;
BSON_ASSERT (command);
BSON_ASSERT (client);
BSON_ASSERT (database);
BSON_ASSERT (server_stream);
BSON_ASSERT (collection);
r = bson_iter_init (&iter, command->documents);
if (!r) {
BSON_ASSERT (false);
EXIT;
}
if (!command->n_documents || !bson_iter_next (&iter)) {
bson_set_error (error,
MONGOC_ERROR_COLLECTION,
MONGOC_ERROR_COLLECTION_DELETE_FAILED,
"Cannot do an empty delete.");
result->failed = true;
EXIT;
}
bson_snprintf (ns, sizeof ns, "%s.%s", database, collection);
do {
/* the document is like { "q": { <selector> }, limit: <0 or 1> } */
r = (bson_iter_recurse (&iter, &q_iter) &&
bson_iter_find (&q_iter, "q") &&
BSON_ITER_HOLDS_DOCUMENT (&q_iter));
if (!r) {
BSON_ASSERT (false);
EXIT;
}
bson_iter_document (&q_iter, &len, &data);
BSON_ASSERT (data);
BSON_ASSERT (len >= 5);
rpc.delete_.msg_len = 0;
rpc.delete_.request_id = 0;
rpc.delete_.response_to = 0;
rpc.delete_.opcode = MONGOC_OPCODE_DELETE;
rpc.delete_.zero = 0;
rpc.delete_.collection = ns;
rpc.delete_.flags = command->u.delete_.multi ? MONGOC_DELETE_NONE
: MONGOC_DELETE_SINGLE_REMOVE;
rpc.delete_.selector = data;
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;
}
_mongoc_write_result_merge_legacy (
result, command, gle,
MONGOC_ERROR_COLLECTION_DELETE_FAILED, offset);
offset++;
bson_destroy (gle);
}
} while (bson_iter_next (&iter));
EXIT;
}
void transaction_bson(struct transaction const* tx, bson_t* out)
{
char key[9];
bson_t* input_list = bson_new();
// Version
BSON_APPEND_INT32(out, "version", (int)transaction_version(tx));
// Inputs
BSON_APPEND_ARRAY_BEGIN(out, "inputs", input_list);
size_t num_inputs = transaction_num_inputs(tx);
for(size_t i = 0; i < num_inputs; i++) {
struct transaction_input* input = transaction_input(tx, i);
bson_snprintf(key, sizeof(key), "%u", (unsigned int)i);
key[sizeof(key) - 1] = '\0';
bson_t* member = bson_new();
bson_append_document_begin(input_list, key, -1, member);
// Output Reference
struct transaction_output_reference* output_reference = transaction_input_output_reference(input);
unsigned char prevout_hash[32];
transaction_output_reference_hash(output_reference, prevout_hash);
bson_t* prevout = bson_new();
bson_append_document_begin(member, "output_reference", -1, prevout);
BSON_APPEND_BINARY(prevout, "hash", BSON_SUBTYPE_BINARY, (uint8_t*)prevout_hash, 32);
BSON_APPEND_INT32(prevout, "index", transaction_output_reference_index(output_reference));
bson_append_document_end(member, prevout);
// Script
struct script* script = transaction_input_script(input);
BSON_APPEND_BINARY(member, "script", BSON_SUBTYPE_BINARY, (uint8_t*)script_data(script), script_size(script));
// Sequence
BSON_APPEND_INT32(member, "sequence", transaction_input_sequence(input));
bson_append_document_end(input_list, member);
}
bson_append_array_end(out, input_list);
// Outputs
bson_t* output_list = bson_new();
BSON_APPEND_ARRAY_BEGIN(out, "outputs", output_list);
size_t num_outputs = transaction_num_outputs(tx);
for(size_t i = 0; i < num_outputs; i++) {
struct transaction_output* output = transaction_output(tx, i);
bson_snprintf(key, sizeof(key), "%u", (unsigned int)i);
key[sizeof(key) - 1] = '\0';
bson_t* member = bson_new();
bson_append_document_begin(output_list, key, -1, member);
// Value
BSON_APPEND_INT64(member, "value", transaction_output_value(output));
// Script
struct script* script = transaction_output_script(output);
BSON_APPEND_BINARY(member, "script", BSON_SUBTYPE_BINARY, (uint8_t*)script_data(script), script_size(script));
bson_append_document_end(output_list, member);
}
bson_append_array_end(out, output_list);
// Lock time
BSON_APPEND_INT32(out, "lock_time", (int)transaction_lock_time(tx));
}
struct transaction* transaction_from_bson(bson_t const* doc)
{
char key[9];
bson_iter_t iter;
bson_iter_t subiter;
struct transaction* tx = transaction_new();
if(!bson_iter_init_find(&iter, doc, "version") || !BSON_ITER_HOLDS_INT32(&iter)) goto error;
transaction_set_version(tx, bson_iter_int32(&iter));
// Read Inputs
if(!bson_iter_init_find(&iter, doc, "inputs") || !BSON_ITER_HOLDS_ARRAY(&iter)) goto error;
uint32_t inputs_doc_length;
uint8_t const* inputs_doc_data;
bson_iter_array(&iter, &inputs_doc_length, &inputs_doc_data);
bson_t inputs_doc;
bson_init_static(&inputs_doc, inputs_doc_data, inputs_doc_length);
size_t index = 0;
for(;;) {
bson_snprintf(key, sizeof(key), "%u", (unsigned int)index);
key[sizeof(key) - 1] = '\0';
// If the array key isn't found, then we reached the end of the array
if(!bson_iter_init_find(&subiter, &inputs_doc, key)) break;
// If it's not a document, then there's an error
if(!BSON_ITER_HOLDS_DOCUMENT(&subiter)) goto error;
struct transaction_input* input = transaction_input_new();
struct transaction_output_reference* output_reference = transaction_input_output_reference(input);
// Load the input document
bson_t element_doc;
uint32_t element_doc_length;
uint8_t const* element_doc_data;
bson_iter_document(&subiter, &element_doc_length, &element_doc_data);
bson_init_static(&element_doc, element_doc_data, element_doc_length);
bson_iter_t elementiter;
// Output reference
if(!bson_iter_init_find(&elementiter, &element_doc, "output_reference") || !BSON_ITER_HOLDS_DOCUMENT(&elementiter)) goto error;
bson_t output_reference_doc;
uint32_t output_reference_doc_length;
uint8_t const* output_reference_doc_data;
bson_iter_document(&elementiter, &output_reference_doc_length, &output_reference_doc_data);
bson_init_static(&output_reference_doc, output_reference_doc_data, output_reference_doc_length);
bson_iter_t output_reference_iter;
uint8_t const* hash;
uint32_t hash_size;
if(!bson_iter_init_find(&output_reference_iter, &output_reference_doc, "hash") || !BSON_ITER_HOLDS_BINARY(&output_reference_iter)) goto error;
bson_iter_binary(&output_reference_iter, BSON_SUBTYPE_BINARY, &hash_size, &hash);
assert(hash_size == 32);
transaction_output_reference_set_hash(output_reference, (unsigned char const*)hash);
if(!bson_iter_init_find(&output_reference_iter, &output_reference_doc, "index") || !BSON_ITER_HOLDS_INT32(&output_reference_iter)) goto error;
transaction_output_reference_set_index(output_reference, bson_iter_int32(&output_reference_iter));
// Script
if(!bson_iter_init_find(&elementiter, &element_doc, "script") || !BSON_ITER_HOLDS_BINARY(&elementiter)) goto error;
uint32_t script_size;
uint8_t const* script_data;
bson_iter_binary(&elementiter, BSON_SUBTYPE_BINARY, &script_size, &script_data);
struct script* script;
size_t script_size_result;
script_size_result = unserialize_script((unsigned char const*)script_data, script_size, &script, script_size);
assert(script_size_result == script_size);
transaction_input_set_script(input, script);
// Sequence
if(!bson_iter_init_find(&elementiter, &element_doc, "sequence") || !BSON_ITER_HOLDS_INT32(&elementiter)) goto error;
transaction_input_set_sequence(input, bson_iter_int32(&elementiter));
transaction_add_input(tx, input);
index += 1;
}
// Read Outputs
if(!bson_iter_init_find(&iter, doc, "outputs") || !BSON_ITER_HOLDS_ARRAY(&iter)) goto error;
uint32_t outputs_doc_length;
uint8_t const* outputs_doc_data;
bson_iter_array(&iter, &outputs_doc_length, &outputs_doc_data);
bson_t outputs_doc;
bson_init_static(&outputs_doc, outputs_doc_data, outputs_doc_length);
index = 0;
for(;;) {
bson_snprintf(key, sizeof(key), "%u", (unsigned int)index);
key[sizeof(key) - 1] = '\0';
// If the array key isn't found, then we reached the end of the array
if(!bson_iter_init_find(&subiter, &outputs_doc, key)) break;
// If it's not a document, then there's an error
if(!BSON_ITER_HOLDS_DOCUMENT(&subiter)) goto error;
struct transaction_output* output = transaction_output_new();
// Load the output document
bson_t element_doc;
uint32_t element_doc_length;
uint8_t const* element_doc_data;
bson_iter_document(&subiter, &element_doc_length, &element_doc_data);
bson_init_static(&element_doc, element_doc_data, element_doc_length);
bson_iter_t elementiter;
// Value
if(!bson_iter_init_find(&elementiter, &element_doc, "value") || !BSON_ITER_HOLDS_INT64(&elementiter)) goto error;
transaction_output_set_value(output, bson_iter_int64(&elementiter));
// Script
if(!bson_iter_init_find(&elementiter, &element_doc, "script") || !BSON_ITER_HOLDS_BINARY(&elementiter)) goto error;
uint32_t script_size;
uint8_t const* script_data;
bson_iter_binary(&elementiter, BSON_SUBTYPE_BINARY, &script_size, &script_data);
struct script* script;
size_t script_size_result;
script_size_result = unserialize_script((unsigned char const*)script_data, script_size, &script, script_size);
assert(script_size_result == script_size);
transaction_output_set_script(output, script);
transaction_add_output(tx, output);
index += 1;
}
if(!bson_iter_init_find(&iter, doc, "lock_time") || !BSON_ITER_HOLDS_INT32(&iter)) goto error;
transaction_set_lock_time(tx, bson_iter_int32(&iter));
return tx;
error:
return NULL;
}
