void
mongoc_log_trace_iovec (const char *domain, const mongoc_iovec_t *_iov, size_t _iovcnt)
{
bson_string_t *str, *astr;
const char *_b;
unsigned _i = 0;
unsigned _j = 0;
unsigned _k = 0;
size_t _l = 0;
uint8_t _v;
#ifdef MONGOC_TRACE
if (!gLogTrace) {
return;
}
#endif
for (_i = 0; _i < _iovcnt; _i++) {
_l += _iov[_i].iov_len;
}
_i = 0;
str = bson_string_new(NULL);
astr = bson_string_new(NULL);
for (_j = 0; _j < _iovcnt; _j++) {
_b = (char *)_iov[_j].iov_base;
_l = _iov[_j].iov_len;
for (_k = 0; _k < _l; _k++, _i++) {
_v = *(_b + _k);
if ((_i % 16) == 0) {
bson_string_append_printf(str, "%05x: ", _i);
}
bson_string_append_printf(str, " %02x", _v);
if (isprint(_v)) {
bson_string_append_printf(astr, " %c", _v);
} else {
bson_string_append(astr, " .");
}
if ((_i % 16) == 15) {
mongoc_log(MONGOC_LOG_LEVEL_TRACE, domain,
"%s %s", str->str, astr->str);
bson_string_truncate(str, 0);
bson_string_truncate(astr, 0);
} else if ((_i % 16) == 7) {
bson_string_append(str, " ");
bson_string_append(astr, " ");
}
}
}
if (_i != 16) {
mongoc_log(MONGOC_LOG_LEVEL_TRACE, domain,
"%-56s %s", str->str, astr->str);
}
bson_string_free(str, true);
bson_string_free(astr, true);
}
/* Uses old way of querying system.namespaces. */
mongoc_cursor_t *
_mongoc_database_find_collections_legacy (mongoc_database_t *database,
const bson_t *filter,
bson_error_t *error)
{
mongoc_collection_t *col;
mongoc_cursor_t *cursor = NULL;
mongoc_read_prefs_t *read_prefs;
uint32_t dbname_len;
bson_t legacy_filter;
bson_iter_t iter;
const char *col_filter;
bson_t q = BSON_INITIALIZER;
mongoc_database_find_collections_legacy_ctx_t *ctx;
BSON_ASSERT (database);
col = mongoc_client_get_collection (database->client,
database->name,
"system.namespaces");
BSON_ASSERT (col);
dbname_len = (uint32_t)strlen (database->name);
ctx = (mongoc_database_find_collections_legacy_ctx_t *)bson_malloc (sizeof (*ctx));
ctx->dbname = database->name;
ctx->dbname_len = dbname_len;
/* Filtering on name needs to be handled differently for old servers. */
if (filter && bson_iter_init_find (&iter, filter, "name")) {
bson_string_t *buf;
/* on legacy servers, this must be a string (i.e. not a regex) */
if (!BSON_ITER_HOLDS_UTF8 (&iter)) {
bson_set_error (error,
MONGOC_ERROR_NAMESPACE,
MONGOC_ERROR_NAMESPACE_INVALID_FILTER_TYPE,
"On legacy servers, a filter on name can only be a string.");
bson_free (ctx);
goto cleanup_filter;
}
BSON_ASSERT (BSON_ITER_HOLDS_UTF8 (&iter));
col_filter = bson_iter_utf8 (&iter, NULL);
bson_init (&legacy_filter);
bson_copy_to_excluding_noinit (filter, &legacy_filter, "name", NULL);
/* We must db-qualify filters on name. */
buf = bson_string_new (database->name);
bson_string_append_c (buf, '.');
bson_string_append (buf, col_filter);
BSON_APPEND_UTF8 (&legacy_filter, "name", buf->str);
bson_string_free (buf, true);
filter = &legacy_filter;
}
read_prefs = mongoc_read_prefs_new (MONGOC_READ_PRIMARY);
cursor = mongoc_collection_find (col, MONGOC_QUERY_NONE, 0, 0, 0,
filter ? filter : &q, NULL, read_prefs);
_mongoc_cursor_transform_init (
cursor,
_mongoc_database_find_collections_legacy_filter,
_mongoc_database_find_collections_legacy_mutate,
&bson_free,
ctx);
mongoc_read_prefs_destroy (read_prefs);
cleanup_filter:
mongoc_collection_destroy (col);
return cursor;
}
void
mock_server_reply_multi (request_t *request,
mongoc_reply_flags_t flags,
const bson_t *docs,
int n_docs,
int64_t cursor_id)
{
const mongoc_rpc_t *request_rpc;
mock_server_t *server;
mongoc_stream_t *client;
char *doc_json;
bson_string_t *docs_json;
mongoc_iovec_t *iov;
mongoc_array_t ar;
mongoc_rpc_t r = {{ 0 }};
size_t expected = 0;
ssize_t n_written;
int iovcnt;
int i;
uint8_t *buf;
uint8_t *ptr;
size_t len;
BSON_ASSERT (request);
BSON_ASSERT (docs);
request_rpc = &request->request_rpc;
server = request->server;
client = request->client;
docs_json = bson_string_new ("");
for (i = 0; i < n_docs; i++) {
doc_json = bson_as_json (&docs[i], NULL);
bson_string_append (docs_json, doc_json);
bson_free (doc_json);
if (i < n_docs - 1) {
bson_string_append (docs_json, ", ");
}
}
if (mock_server_get_verbose (request->server)) {
printf ("%5.2f %hu <- %hu \t%s\n",
mock_server_get_uptime_sec (request->server),
request->client_port,
mock_server_get_port (request->server),
docs_json->str);
fflush (stdout);
}
len = 0;
for (i = 0; i < n_docs; i++) {
len += docs[i].len;
}
ptr = buf = bson_malloc (len);
for (i = 0; i < n_docs; i++) {
memcpy (ptr, bson_get_data (&docs[i]), docs[i].len);
ptr += docs[i].len;
}
_mongoc_array_init (&ar, sizeof (mongoc_iovec_t));
mongoc_mutex_lock (&server->mutex);
if (!(request->opcode == MONGOC_OPCODE_QUERY &&
request_rpc->query.flags & MONGOC_QUERY_EXHAUST)) {
server->last_response_id++;
}
r.reply.request_id = server->last_response_id;
mongoc_mutex_unlock (&server->mutex);
r.reply.msg_len = 0;
r.reply.response_to = request_rpc->header.request_id;
r.reply.opcode = MONGOC_OPCODE_REPLY;
r.reply.flags = flags;
r.reply.cursor_id = cursor_id;
r.reply.start_from = 0;
r.reply.n_returned = 1;
r.reply.documents = buf;
r.reply.documents_len = (uint32_t)len;
_mongoc_rpc_gather (&r, &ar);
_mongoc_rpc_swab_to_le (&r);
iov = (mongoc_iovec_t *)ar.data;
iovcnt = (int) ar.len;
for (i = 0; i < iovcnt; i++) {
expected += iov[i].iov_len;
}
n_written = mongoc_stream_writev (client, iov, (size_t) iovcnt, -1);
assert (n_written == expected);
bson_string_free (docs_json, true);
_mongoc_array_destroy (&ar);
bson_free (buf);
}
