static void
test_mongoc_buffer_basic (void)
{
mongoc_stream_t *stream;
mongoc_buffer_t buf;
bson_uint8_t *data = bson_malloc0(1024);
bson_error_t error = { 0 };
bson_bool_t r;
int fd;
fd = open("tests/binary/reply1.dat", O_RDONLY);
assert(fd >= 0);
stream = mongoc_stream_unix_new(fd);
assert(stream);
_mongoc_buffer_init(&buf, data, 1024, bson_realloc);
r = _mongoc_buffer_fill(&buf, stream, 537, 0, &error);
assert_cmpint(r, ==, -1);
r = _mongoc_buffer_fill(&buf, stream, 536, 0, &error);
assert_cmpint(r, ==, 536);
assert(buf.len == 536);
_mongoc_buffer_destroy(&buf);
_mongoc_buffer_destroy(&buf);
_mongoc_buffer_destroy(&buf);
_mongoc_buffer_destroy(&buf);
mongoc_stream_destroy(stream);
}
mongoc_cursor_t *
_mongoc_cursor_clone (const mongoc_cursor_t *cursor)
{
mongoc_cursor_t *clone;
ENTRY;
BSON_ASSERT (cursor);
clone = bson_malloc0 (sizeof *clone);
clone->client = cursor->client;
clone->is_command = cursor->is_command;
clone->flags = cursor->flags;
clone->skip = cursor->skip;
clone->batch_size = cursor->batch_size;
clone->limit = cursor->limit;
clone->nslen = cursor->nslen;
if (cursor->read_prefs) {
clone->read_prefs = mongoc_read_prefs_copy (cursor->read_prefs);
}
bson_copy_to (&cursor->query, &clone->query);
bson_copy_to (&cursor->fields, &clone->fields);
memcpy (clone->ns, cursor->ns, sizeof clone->ns);
_mongoc_buffer_init (&clone->buffer, NULL, 0, NULL);
mongoc_counter_cursors_active_inc ();
RETURN(clone);
}
void
_mongoc_write_command_init_bulk (mongoc_write_command_t *command,
int type,
mongoc_bulk_write_flags_t flags,
int64_t operation_id,
const bson_t *opts)
{
ENTRY;
BSON_ASSERT (command);
command->type = type;
command->flags = flags;
command->operation_id = operation_id;
if (!bson_empty0 (opts)) {
bson_copy_to (opts, &command->cmd_opts);
} else {
bson_init (&command->cmd_opts);
}
_mongoc_buffer_init (&command->payload, NULL, 0, NULL, NULL);
command->n_documents = 0;
EXIT;
}
mongoc_stream_t *
mongoc_stream_buffered_new (mongoc_stream_t *base_stream, /* IN */
size_t buffer_size) /* IN */
{
mongoc_stream_buffered_t *stream;
void *buffer;
bson_return_val_if_fail(base_stream, NULL);
stream = bson_malloc0(sizeof *stream);
stream->stream.destroy = mongoc_stream_buffered_destroy;
stream->stream.close = mongoc_stream_buffered_close;
stream->stream.flush = mongoc_stream_buffered_flush;
stream->stream.writev = mongoc_stream_buffered_writev;
stream->stream.readv = mongoc_stream_buffered_readv;
stream->stream.cork = mongoc_stream_buffered_cork;
stream->stream.uncork = mongoc_stream_buffered_uncork;
stream->base_stream = base_stream;
buffer = bson_malloc0(buffer_size);
_mongoc_buffer_init (&stream->buffer, buffer, buffer_size, bson_realloc);
mongoc_counter_streams_active_inc();
return (mongoc_stream_t *)stream;
}
static void
test_mongoc_buffer_basic (void)
{
mongoc_stream_t *stream;
mongoc_buffer_t buf;
uint8_t *data = bson_malloc0(1024);
bson_error_t error = { 0 };
ssize_t r;
mongoc_fd_t fd;
fd = mongoc_open("tests/binary/reply1.dat", O_RDONLY);
ASSERT(mongoc_fd_is_valid(fd));
stream = mongoc_stream_unix_new(fd);
ASSERT(stream);
_mongoc_buffer_init(&buf, data, 1024, bson_realloc);
r = _mongoc_buffer_fill(&buf, stream, 537, 0, &error);
ASSERT_CMPINT((int)r, ==, -1);
r = _mongoc_buffer_fill(&buf, stream, 536, 0, &error);
ASSERT_CMPINT((int)r, ==, 536);
ASSERT(buf.len == 536);
_mongoc_buffer_destroy(&buf);
_mongoc_buffer_destroy(&buf);
_mongoc_buffer_destroy(&buf);
_mongoc_buffer_destroy(&buf);
mongoc_stream_destroy(stream);
}
mongoc_async_cmd_t *
mongoc_async_cmd_new (mongoc_async_t *async,
mongoc_stream_t *stream,
bool is_setup_done,
struct addrinfo *dns_result,
mongoc_async_cmd_initiate_t initiator,
int64_t initiate_delay_ms,
mongoc_async_cmd_setup_t setup,
void *setup_ctx,
const char *dbname,
const bson_t *cmd,
mongoc_async_cmd_cb_t cb,
void *cb_data,
int64_t timeout_msec)
{
mongoc_async_cmd_t *acmd;
BSON_ASSERT (cmd);
BSON_ASSERT (dbname);
acmd = (mongoc_async_cmd_t *) bson_malloc0 (sizeof (*acmd));
acmd->async = async;
acmd->dns_result = dns_result;
acmd->timeout_msec = timeout_msec;
acmd->stream = stream;
acmd->initiator = initiator;
acmd->initiate_delay_ms = initiate_delay_ms;
acmd->setup = setup;
acmd->setup_ctx = setup_ctx;
acmd->cb = cb;
acmd->data = cb_data;
acmd->connect_started = bson_get_monotonic_time ();
bson_copy_to (cmd, &acmd->cmd);
_mongoc_array_init (&acmd->array, sizeof (mongoc_iovec_t));
_mongoc_buffer_init (&acmd->buffer, NULL, 0, NULL, NULL);
_mongoc_async_cmd_init_send (acmd, dbname);
_mongoc_async_cmd_state_start (acmd, is_setup_done);
async->ncmds++;
DL_APPEND (async->cmds, acmd);
return acmd;
}
static void *
mock_server_worker (void *data)
{
mongoc_buffer_t buffer;
mongoc_stream_t *stream;
mock_server_t *server;
mongoc_rpc_t rpc;
bson_error_t error;
int32_t msg_len;
void **closure = data;
ENTRY;
BSON_ASSERT(closure);
server = closure[0];
stream = closure[1];
_mongoc_buffer_init(&buffer, NULL, 0, NULL, NULL);
again:
if (_mongoc_buffer_fill (&buffer, stream, 4, -1, &error) == -1) {
MONGOC_WARNING ("%s():%d: %s", __FUNCTION__, __LINE__, error.message);
GOTO (failure);
}
assert (buffer.len >= 4);
memcpy (&msg_len, buffer.data + buffer.off, 4);
msg_len = BSON_UINT32_FROM_LE (msg_len);
if (msg_len < 16) {
MONGOC_WARNING ("No data");
GOTO (failure);
}
if (_mongoc_buffer_fill (&buffer, stream, msg_len, -1, &error) == -1) {
MONGOC_WARNING ("%s():%d: %s", __FUNCTION__, __LINE__, error.message);
GOTO (failure);
}
assert (buffer.len >= (unsigned)msg_len);
DUMP_BYTES (buffer, buffer.data + buffer.off, buffer.len);
if (!_mongoc_rpc_scatter(&rpc, buffer.data + buffer.off, msg_len)) {
MONGOC_WARNING ("%s():%d: %s", __FUNCTION__, __LINE__, "Failed to scatter");
GOTO (failure);
}
_mongoc_rpc_swab_from_le(&rpc);
if (!handle_command(server, stream, &rpc)) {
server->handler(server, stream, &rpc, server->handler_data);
}
memmove (buffer.data, buffer.data + buffer.off + msg_len,
buffer.len - msg_len);
buffer.off = 0;
buffer.len -= msg_len;
GOTO (again);
failure:
mongoc_stream_close (stream);
mongoc_stream_destroy (stream);
bson_free(closure);
_mongoc_buffer_destroy (&buffer);
RETURN (NULL);
}
bool
_mongoc_client_recv_gle (mongoc_client_t *client,
uint32_t hint,
bson_t **gle_doc,
bson_error_t *error)
{
mongoc_buffer_t buffer;
mongoc_rpc_t rpc;
bson_iter_t iter;
bool ret = false;
bson_t b;
ENTRY;
bson_return_val_if_fail (client, false);
bson_return_val_if_fail (hint, false);
if (gle_doc) {
*gle_doc = NULL;
}
_mongoc_buffer_init (&buffer, NULL, 0, NULL, NULL);
if (!_mongoc_cluster_try_recv (&client->cluster, &rpc, &buffer,
hint, error)) {
GOTO (cleanup);
}
if (rpc.header.opcode != MONGOC_OPCODE_REPLY) {
bson_set_error (error,
MONGOC_ERROR_PROTOCOL,
MONGOC_ERROR_PROTOCOL_INVALID_REPLY,
"Received message other than OP_REPLY.");
GOTO (cleanup);
}
if (_mongoc_rpc_reply_get_first (&rpc.reply, &b)) {
if (gle_doc) {
*gle_doc = bson_copy (&b);
}
if ((rpc.reply.flags & MONGOC_REPLY_QUERY_FAILURE)) {
_bson_to_error (&b, error);
bson_destroy (&b);
GOTO (cleanup);
}
if (!bson_iter_init_find (&iter, &b, "ok") ||
BSON_ITER_HOLDS_DOUBLE (&iter)) {
if (bson_iter_double (&iter) == 0.0) {
_bson_to_error (&b, error);
}
}
bson_destroy (&b);
}
ret = true;
cleanup:
_mongoc_buffer_destroy (&buffer);
RETURN (ret);
}
/* TODO: factor */
static void *
worker_thread (void *data)
{
worker_closure_t *closure = (worker_closure_t *) data;
mock_server_t *server = closure->server;
mongoc_stream_t *client_stream = closure->client_stream;
mongoc_buffer_t buffer;
mongoc_rpc_t *rpc = NULL;
bool handled;
bson_error_t error;
int32_t msg_len;
bool stopped;
sync_queue_t *q;
request_t *request;
mongoc_array_t autoresponders;
ssize_t i;
autoresponder_handle_t handle;
#ifdef MONGOC_ENABLE_SSL
bool ssl;
#endif
ENTRY;
BSON_ASSERT(closure);
#ifdef MONGOC_ENABLE_SSL
mongoc_mutex_lock (&server->mutex);
ssl = server->ssl;
mongoc_mutex_unlock (&server->mutex);
if (ssl) {
if (!mongoc_stream_tls_handshake_block (client_stream, "localhost", TIMEOUT, &error)) {
MONGOC_ERROR("Blocking TLS handshake failed");
mongoc_stream_close (client_stream);
mongoc_stream_destroy (client_stream);
RETURN (NULL);
}
}
#endif
_mongoc_buffer_init (&buffer, NULL, 0, NULL, NULL);
_mongoc_array_init (&autoresponders, sizeof (autoresponder_handle_t));
again:
bson_free (rpc);
rpc = NULL;
handled = false;
mongoc_mutex_lock (&server->mutex);
stopped = server->stopped;
mongoc_mutex_unlock (&server->mutex);
if (stopped) {
GOTO(failure);
}
if (_mongoc_buffer_fill (&buffer, client_stream, 4, TIMEOUT, &error) == -1) {
GOTO (again);
}
assert (buffer.len >= 4);
memcpy (&msg_len, buffer.data + buffer.off, 4);
msg_len = BSON_UINT32_FROM_LE (msg_len);
if (msg_len < 16) {
MONGOC_WARNING ("No data");
GOTO (failure);
}
if (_mongoc_buffer_fill (&buffer, client_stream, (size_t) msg_len, -1,
&error) == -1) {
MONGOC_WARNING ("%s():%d: %s", BSON_FUNC, __LINE__, error.message);
GOTO (failure);
}
assert (buffer.len >= (unsigned) msg_len);
/* copies message from buffer */
request = request_new (&buffer, msg_len, server, client_stream,
closure->port);
mongoc_mutex_lock (&server->mutex);
_mongoc_array_copy (&autoresponders, &server->autoresponders);
mongoc_mutex_unlock (&server->mutex);
if (mock_server_get_verbose (server)) {
printf ("%5.2f %hu -> %hu %s\n",
mock_server_get_uptime_sec (server),
closure->port, server->port, request->as_str);
fflush (stdout);
}
/* run responders most-recently-added-first */
for (i = server->autoresponders.len - 1; i >= 0; i--) {
handle = _mongoc_array_index (&server->autoresponders,
autoresponder_handle_t,
i);
if (handle.responder (request, handle.data)) {
handled = true;
/* responder should destroy the request */
request = NULL;
break;
}
}
if (!handled) {
q = mock_server_get_queue (server);
q_put (q, (void *) request);
request = NULL;
}
memmove (buffer.data, buffer.data + buffer.off + msg_len,
buffer.len - msg_len);
buffer.off = 0;
buffer.len -= msg_len;
GOTO (again);
failure:
_mongoc_array_destroy (&autoresponders);
_mongoc_buffer_destroy (&buffer);
mongoc_stream_close (client_stream);
mongoc_stream_destroy (client_stream);
bson_free (rpc);
bson_free (closure);
_mongoc_buffer_destroy (&buffer);
RETURN (NULL);
}
mongoc_cursor_t *
_mongoc_cursor_new (mongoc_client_t *client,
const char *db_and_collection,
mongoc_query_flags_t flags,
bson_uint32_t skip,
bson_uint32_t limit,
bson_uint32_t batch_size,
bson_bool_t is_command,
const bson_t *query,
const bson_t *fields,
const mongoc_read_prefs_t *read_prefs)
{
mongoc_read_mode_t mode;
mongoc_cursor_t *cursor;
const bson_t *tags;
const char *mode_str;
bson_t child;
ENTRY;
BSON_ASSERT(client);
BSON_ASSERT(db_and_collection);
BSON_ASSERT(query);
/* we can't have exhaust queries with limits */
BSON_ASSERT (!((flags & MONGOC_QUERY_EXHAUST) && limit));
/* we can't have exhaust queries with sharded clusters */
BSON_ASSERT (!((flags & MONGOC_QUERY_EXHAUST) && client->cluster.isdbgrid));
/*
* Cursors execute their query lazily. This sadly means that we must copy
* some extra data around between the bson_t structures. This should be
* small in most cases, so it reduces to a pure memcpy. The benefit to this
* design is simplified error handling by API consumers.
*/
cursor = bson_malloc0(sizeof *cursor);
cursor->client = client;
strncpy(cursor->ns, db_and_collection, sizeof cursor->ns - 1);
cursor->nslen = strlen(cursor->ns);
cursor->flags = flags;
cursor->skip = skip;
cursor->limit = limit;
cursor->batch_size = cursor->batch_size;
cursor->is_command = is_command;
if (!bson_has_field (query, "$query")) {
bson_init (&cursor->query);
bson_append_document (&cursor->query, "$query", 6, query);
} else {
bson_copy_to (query, &cursor->query);
}
if (read_prefs) {
cursor->read_prefs = mongoc_read_prefs_copy (read_prefs);
mode = mongoc_read_prefs_get_mode (read_prefs);
tags = mongoc_read_prefs_get_tags (read_prefs);
if (mode != MONGOC_READ_PRIMARY) {
flags |= MONGOC_QUERY_SLAVE_OK;
if ((mode != MONGOC_READ_SECONDARY_PREFERRED) || tags) {
bson_append_document_begin (&cursor->query, "$readPreference",
15, &child);
mode_str = _mongoc_cursor_get_read_mode_string (mode);
bson_append_utf8 (&child, "mode", 4, mode_str, -1);
if (tags) {
bson_append_array (&child, "tags", 4, tags);
}
bson_append_document_end (&cursor->query, &child);
}
}
}
if (fields) {
bson_copy_to(fields, &cursor->fields);
} else {
bson_init(&cursor->fields);
}
_mongoc_buffer_init(&cursor->buffer, NULL, 0, NULL);
mongoc_counter_cursors_active_inc();
RETURN(cursor);
}
static void *
mock_server_worker (void *data)
{
mongoc_buffer_t buffer;
mongoc_stream_t *stream;
mock_server_t *server;
mongoc_rpc_t rpc;
bson_error_t error;
int32_t msg_len;
void **closure = data;
BSON_ASSERT(closure);
server = closure[0];
stream = closure[1];
_mongoc_buffer_init(&buffer, NULL, 0, NULL);
again:
if (_mongoc_buffer_fill (&buffer, stream, 4, INT_MAX, &error) == -1) {
MONGOC_WARNING ("%s", error.message);
goto failure;
}
assert (buffer.len >= 4);
memcpy(&msg_len, buffer.data + buffer.off, 4);
msg_len = BSON_UINT32_FROM_LE(msg_len);
if (msg_len < 16) {
MONGOC_WARNING ("No data");
goto failure;
}
if (_mongoc_buffer_fill (&buffer, stream, msg_len, INT_MAX, &error) == -1) {
MONGOC_WARNING ("%s", error.message);
goto failure;
}
assert (buffer.len >= msg_len);
DUMP_BYTES (buffer, buffer.data + buffer.off, buffer.len);
if (!_mongoc_rpc_scatter(&rpc, buffer.data + buffer.off, msg_len)) {
MONGOC_WARNING ("Failed to scatter");
goto failure;
}
_mongoc_rpc_swab_from_le(&rpc);
if (!handle_command(server, stream, &rpc)) {
server->handler(server, stream, &rpc, server->handler_data);
}
memmove (buffer.data, buffer.data + buffer.off + msg_len,
buffer.len - msg_len);
buffer.off = 0;
buffer.len -= msg_len;
goto again;
failure:
mongoc_stream_close(stream);
mongoc_stream_destroy(stream);
bson_free(closure);
return NULL;
}
mongoc_cursor_t *
_mongoc_cursor_new (mongoc_client_t *client,
const char *db_and_collection,
mongoc_query_flags_t flags,
uint32_t skip,
uint32_t limit,
uint32_t batch_size,
bool is_command,
const bson_t *query,
const bson_t *fields,
const mongoc_read_prefs_t *read_prefs)
{
mongoc_read_prefs_t *local_read_prefs = NULL;
mongoc_read_mode_t mode;
mongoc_cursor_t *cursor;
const bson_t *tags;
bson_iter_t iter;
const char *key;
const char *mode_str;
bson_t child;
bool found = false;
int i;
ENTRY;
BSON_ASSERT (client);
BSON_ASSERT (db_and_collection);
BSON_ASSERT (query);
if (!read_prefs) {
read_prefs = client->read_prefs;
}
cursor = bson_malloc0 (sizeof *cursor);
/*
* CDRIVER-244:
*
* If this is a command, we need to verify we can send it to the location
* specified by the read preferences. Otherwise, log a warning that we
* are rerouting to the primary instance.
*/
if (is_command &&
read_prefs &&
(mongoc_read_prefs_get_mode (read_prefs) != MONGOC_READ_PRIMARY) &&
bson_iter_init (&iter, query) &&
bson_iter_next (&iter) &&
(key = bson_iter_key (&iter))) {
for (i = 0; gSecondaryOkCommands [i]; i++) {
if (0 == strcasecmp (key, gSecondaryOkCommands [i])) {
found = true;
break;
}
}
if (!found) {
cursor->redir_primary = true;
local_read_prefs = mongoc_read_prefs_new (MONGOC_READ_PRIMARY);
read_prefs = local_read_prefs;
MONGOC_INFO ("Database command \"%s\" rerouted to primary node", key);
}
}
/*
* Cursors execute their query lazily. This sadly means that we must copy
* some extra data around between the bson_t structures. This should be
* small in most cases, so it reduces to a pure memcpy. The benefit to this
* design is simplified error handling by API consumers.
*/
cursor->client = client;
bson_strncpy (cursor->ns, db_and_collection, sizeof cursor->ns);
cursor->nslen = (uint32_t)strlen(cursor->ns);
cursor->flags = flags;
cursor->skip = skip;
cursor->limit = limit;
cursor->batch_size = batch_size;
cursor->is_command = is_command;
#define MARK_FAILED(c) \
do { \
(c)->failed = true; \
(c)->done = true; \
(c)->end_of_event = true; \
(c)->sent = true; \
} while (0)
/* we can't have exhaust queries with limits */
if ((flags & MONGOC_QUERY_EXHAUST) && limit) {
bson_set_error (&cursor->error,
MONGOC_ERROR_CURSOR,
MONGOC_ERROR_CURSOR_INVALID_CURSOR,
"Cannot specify MONGOC_QUERY_EXHAUST and set a limit.");
MARK_FAILED (cursor);
GOTO (finish);
}
/* we can't have exhaust queries with sharded clusters */
if ((flags & MONGOC_QUERY_EXHAUST) &&
(client->cluster.mode == MONGOC_CLUSTER_SHARDED_CLUSTER)) {
bson_set_error (&cursor->error,
MONGOC_ERROR_CURSOR,
MONGOC_ERROR_CURSOR_INVALID_CURSOR,
"Cannot specify MONGOC_QUERY_EXHAUST with sharded cluster.");
MARK_FAILED (cursor);
GOTO (finish);
}
/*
* Check types of various optional parameters.
*/
if (!is_command) {
if (bson_iter_init_find (&iter, query, "$explain") &&
!(BSON_ITER_HOLDS_BOOL (&iter) || BSON_ITER_HOLDS_INT32 (&iter))) {
bson_set_error (&cursor->error,
MONGOC_ERROR_CURSOR,
MONGOC_ERROR_CURSOR_INVALID_CURSOR,
"$explain must be a boolean.");
MARK_FAILED (cursor);
GOTO (finish);
}
if (bson_iter_init_find (&iter, query, "$snapshot") &&
!BSON_ITER_HOLDS_BOOL (&iter) &&
!BSON_ITER_HOLDS_INT32 (&iter)) {
bson_set_error (&cursor->error,
MONGOC_ERROR_CURSOR,
MONGOC_ERROR_CURSOR_INVALID_CURSOR,
"$snapshot must be a boolean.");
MARK_FAILED (cursor);
GOTO (finish);
}
}
if (!cursor->is_command && !bson_has_field (query, "$query")) {
bson_init (&cursor->query);
bson_append_document (&cursor->query, "$query", 6, query);
} else {
bson_copy_to (query, &cursor->query);
}
if (read_prefs) {
cursor->read_prefs = mongoc_read_prefs_copy (read_prefs);
mode = mongoc_read_prefs_get_mode (read_prefs);
tags = mongoc_read_prefs_get_tags (read_prefs);
if (mode != MONGOC_READ_PRIMARY) {
flags |= MONGOC_QUERY_SLAVE_OK;
if ((mode != MONGOC_READ_SECONDARY_PREFERRED) || tags) {
bson_append_document_begin (&cursor->query, "$readPreference",
15, &child);
mode_str = _mongoc_cursor_get_read_mode_string (mode);
bson_append_utf8 (&child, "mode", 4, mode_str, -1);
if (tags) {
bson_append_array (&child, "tags", 4, tags);
}
bson_append_document_end (&cursor->query, &child);
}
}
}
if (fields) {
bson_copy_to(fields, &cursor->fields);
} else {
bson_init(&cursor->fields);
}
_mongoc_buffer_init(&cursor->buffer, NULL, 0, NULL);
finish:
mongoc_counter_cursors_active_inc();
if (local_read_prefs) {
mongoc_read_prefs_destroy (local_read_prefs);
}
RETURN (cursor);
}
bool
_mongoc_client_recv_gle (mongoc_client_t *client,
mongoc_server_stream_t *server_stream,
bson_t **gle_doc,
bson_error_t *error)
{
mongoc_buffer_t buffer;
mongoc_rpc_t rpc;
bson_iter_t iter;
bool ret = false;
bson_t b;
ENTRY;
BSON_ASSERT (client);
BSON_ASSERT (server_stream);
if (gle_doc) {
*gle_doc = NULL;
}
_mongoc_buffer_init (&buffer, NULL, 0, NULL, NULL);
if (!mongoc_cluster_try_recv (&client->cluster, &rpc, &buffer,
server_stream, error)) {
mongoc_topology_invalidate_server (client->topology,
server_stream->sd->id);
GOTO (cleanup);
}
if (rpc.header.opcode != MONGOC_OPCODE_REPLY) {
bson_set_error (error,
MONGOC_ERROR_PROTOCOL,
MONGOC_ERROR_PROTOCOL_INVALID_REPLY,
"Received message other than OP_REPLY.");
GOTO (cleanup);
}
if (_mongoc_rpc_reply_get_first (&rpc.reply, &b)) {
if ((rpc.reply.flags & MONGOC_REPLY_QUERY_FAILURE)) {
_bson_to_error (&b, error);
bson_destroy (&b);
GOTO (cleanup);
}
if (gle_doc) {
*gle_doc = bson_copy (&b);
}
if (!bson_iter_init_find (&iter, &b, "ok") ||
BSON_ITER_HOLDS_DOUBLE (&iter)) {
if (bson_iter_double (&iter) == 0.0) {
_bson_to_error (&b, error);
}
}
bson_destroy (&b);
ret = true;
}
cleanup:
_mongoc_buffer_destroy (&buffer);
RETURN (ret);
}
static void *
worker_thread (void *data)
{
worker_closure_t *closure = (worker_closure_t *) data;
mock_server_t *server = closure->server;
mongoc_stream_t *client_stream = closure->client_stream;
mongoc_buffer_t buffer;
mongoc_rpc_t *rpc = NULL;
bool handled;
bson_error_t error;
int32_t msg_len;
sync_queue_t *requests;
sync_queue_t *replies;
request_t *request;
mongoc_array_t autoresponders;
ssize_t i;
autoresponder_handle_t handle;
reply_t *reply;
#ifdef MONGOC_ENABLE_SSL
bool ssl;
#endif
ENTRY;
/* queue of client replies sent over this worker's connection */
replies = q_new ();
#ifdef MONGOC_ENABLE_SSL
mongoc_mutex_lock (&server->mutex);
ssl = server->ssl;
mongoc_mutex_unlock (&server->mutex);
if (ssl) {
if (!mongoc_stream_tls_handshake_block (client_stream, "localhost",
TIMEOUT, &error)) {
mongoc_stream_close (client_stream);
mongoc_stream_destroy (client_stream);
RETURN (NULL);
}
}
#endif
_mongoc_buffer_init (&buffer, NULL, 0, NULL, NULL);
_mongoc_array_init (&autoresponders, sizeof (autoresponder_handle_t));
again:
/* loop, checking for requests to receive or replies to send */
bson_free (rpc);
rpc = NULL;
if (_mongoc_buffer_fill (&buffer, client_stream, 4, 10, &error) > 0) {
assert (buffer.len >= 4);
memcpy (&msg_len, buffer.data + buffer.off, 4);
msg_len = BSON_UINT32_FROM_LE (msg_len);
if (msg_len < 16) {
MONGOC_WARNING ("No data");
GOTO (failure);
}
if (_mongoc_buffer_fill (&buffer, client_stream, (size_t) msg_len, -1,
&error) == -1) {
MONGOC_WARNING ("%s():%d: %s", BSON_FUNC, __LINE__, error.message);
GOTO (failure);
}
assert (buffer.len >= (unsigned) msg_len);
/* copies message from buffer */
request = request_new (&buffer, msg_len, server, client_stream,
closure->port, replies);
memmove (buffer.data, buffer.data + buffer.off + msg_len,
buffer.len - msg_len);
buffer.off = 0;
buffer.len -= msg_len;
mongoc_mutex_lock (&server->mutex);
_mongoc_array_copy (&autoresponders, &server->autoresponders);
mongoc_mutex_unlock (&server->mutex);
test_suite_mock_server_log ("%5.2f %hu -> %hu %s",
mock_server_get_uptime_sec (server),
closure->port, server->port, request->as_str);
/* run responders most-recently-added-first */
handled = false;
for (i = server->autoresponders.len - 1; i >= 0; i--) {
handle = _mongoc_array_index (&server->autoresponders,
autoresponder_handle_t,
i);
if (handle.responder (request, handle.data)) {
/* responder destroyed request and enqueued a reply in "replies" */
handled = true;
request = NULL;
break;
}
}
if (!handled) {
/* pass to the main thread via the queue */
requests = mock_server_get_queue (server);
q_put (requests, (void *) request);
}
}
if (_mock_server_stopping (server)) {
GOTO (failure);
}
reply = q_get (replies, 10);
if (reply) {
_mock_server_reply_with_stream (server, reply, client_stream);
_reply_destroy (reply);
}
if (_mock_server_stopping (server)) {
GOTO (failure);
}
GOTO (again);
failure:
_mongoc_array_destroy (&autoresponders);
_mongoc_buffer_destroy (&buffer);
mongoc_stream_close (client_stream);
mongoc_stream_destroy (client_stream);
bson_free (rpc);
bson_free (closure);
_mongoc_buffer_destroy (&buffer);
while ((reply = q_get_nowait (replies))) {
_reply_destroy (reply);
}
q_destroy (replies);
RETURN (NULL);
}
mongoc_async_cmd_result_t
_mongoc_async_cmd_phase_recv_rpc (mongoc_async_cmd_t *acmd)
{
ssize_t bytes = _mongoc_buffer_try_append_from_stream (
&acmd->buffer, acmd->stream, acmd->bytes_to_read, 0);
if (bytes <= 0 && mongoc_stream_should_retry (acmd->stream)) {
return MONGOC_ASYNC_CMD_IN_PROGRESS;
}
if (bytes < 0) {
bson_set_error (&acmd->error,
MONGOC_ERROR_STREAM,
MONGOC_ERROR_STREAM_SOCKET,
"Failed to receive rpc bytes from server.");
return MONGOC_ASYNC_CMD_ERROR;
}
if (bytes == 0) {
bson_set_error (&acmd->error,
MONGOC_ERROR_STREAM,
MONGOC_ERROR_STREAM_SOCKET,
"Server closed connection.");
return MONGOC_ASYNC_CMD_ERROR;
}
acmd->bytes_to_read = (size_t) (acmd->bytes_to_read - bytes);
if (!acmd->bytes_to_read) {
if (!_mongoc_rpc_scatter (
&acmd->rpc, acmd->buffer.data, acmd->buffer.len)) {
bson_set_error (&acmd->error,
MONGOC_ERROR_PROTOCOL,
MONGOC_ERROR_PROTOCOL_INVALID_REPLY,
"Invalid reply from server.");
return MONGOC_ASYNC_CMD_ERROR;
}
if (BSON_UINT32_FROM_LE (acmd->rpc.header.opcode) ==
MONGOC_OPCODE_COMPRESSED) {
uint8_t *buf = NULL;
size_t len =
BSON_UINT32_FROM_LE (acmd->rpc.compressed.uncompressed_size) +
sizeof (mongoc_rpc_header_t);
buf = bson_malloc0 (len);
if (!_mongoc_rpc_decompress (&acmd->rpc, buf, len)) {
bson_free (buf);
bson_set_error (&acmd->error,
MONGOC_ERROR_PROTOCOL,
MONGOC_ERROR_PROTOCOL_INVALID_REPLY,
"Could not decompress server reply");
return MONGOC_ASYNC_CMD_ERROR;
}
_mongoc_buffer_destroy (&acmd->buffer);
_mongoc_buffer_init (&acmd->buffer, buf, len, NULL, NULL);
}
_mongoc_rpc_swab_from_le (&acmd->rpc);
if (!_mongoc_rpc_get_first_document (&acmd->rpc, &acmd->reply)) {
bson_set_error (&acmd->error,
MONGOC_ERROR_PROTOCOL,
MONGOC_ERROR_PROTOCOL_INVALID_REPLY,
"Invalid reply from server");
return MONGOC_ASYNC_CMD_ERROR;
}
acmd->reply_needs_cleanup = true;
return MONGOC_ASYNC_CMD_SUCCESS;
}
return MONGOC_ASYNC_CMD_IN_PROGRESS;
}
