bson_bool_t
_mongoc_rpc_reply_get_first (mongoc_rpc_reply_t *reply,
bson_t *bson)
{
bson_int32_t len;
bson_return_val_if_fail(reply, FALSE);
bson_return_val_if_fail(bson, FALSE);
if (!reply->documents || reply->documents_len < 4) {
return FALSE;
}
memcpy(&len, reply->documents, 4);
len = BSON_UINT32_FROM_LE(len);
if (reply->documents_len < len) {
return FALSE;
}
return bson_init_static(bson, reply->documents, len);
}
/**
* bson_utf8_next_char:
* @utf8: A string containing validated UTF-8.
*
* Returns an incremented pointer to the beginning of the next multi-byte
* sequence in @utf8.
*
* Returns: An incremented pointer in @utf8.
*/
const char *
bson_utf8_next_char (const char *utf8)
{
bson_uint8_t mask;
bson_uint8_t num;
bson_return_val_if_fail (utf8, NULL);
bson_utf8_get_sequence (utf8, &num, &mask);
return utf8 + num;
}
/**
* mongoc_stream_readv:
* @stream: A mongoc_stream_t.
* @iov: An array of iovec containing the location and sizes to read.
* @iovcnt: the number of elements in @iov.
* @min_bytes: the minumum number of bytes to return, or -1.
*
* Reads into the various buffers pointed to by @iov and associated
* buffer lengths.
*
* If @min_bytes is specified, then at least min_bytes will be returned unless
* eof is encountered. This may result in ETIMEDOUT
*
* Returns: the number of bytes read or -1 on failure.
*/
ssize_t
mongoc_stream_readv (mongoc_stream_t *stream,
mongoc_iovec_t *iov,
size_t iovcnt,
size_t min_bytes,
int32_t timeout_msec)
{
ssize_t ret;
ENTRY;
bson_return_val_if_fail (stream, -1);
bson_return_val_if_fail (iov, -1);
bson_return_val_if_fail (iovcnt, -1);
BSON_ASSERT (stream->readv);
ret = stream->readv (stream, iov, iovcnt, min_bytes, timeout_msec);
RETURN (ret);
}
static int
mongoc_stream_unix_uncork (mongoc_stream_t *stream)
{
mongoc_stream_unix_t *file = (mongoc_stream_unix_t *)stream;
int state = 0;
bson_return_val_if_fail(stream, -1);
#ifdef __linux__
return setsockopt(file->fd, IPPROTO_TCP, TCP_CORK, &state, sizeof(state));
#else
return setsockopt(file->fd, IPPROTO_TCP, TCP_NOPUSH, &state, sizeof(state));
#endif
}
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_delete (col,
MONGOC_DELETE_SINGLE_REMOVE,
&cmd,
NULL,
error);
bson_destroy (&cmd);
mongoc_collection_destroy (col);
}
RETURN (ret);
}
const char *
mongoc_uri_get_auth_source (const mongoc_uri_t *uri)
{
bson_iter_t iter;
bson_return_val_if_fail(uri, NULL);
if (bson_iter_init_find_case(&iter, &uri->options, "authSource")) {
return bson_iter_utf8(&iter, NULL);
}
return uri->database ? uri->database : "admin";
}
/**
* mongoc_stream_read:
* @stream: A mongoc_stream_t.
* @buf: A buffer to write into.
* @count: The number of bytes to write into @buf.
*
* Simplified access to mongoc_stream_readv(). Creates a single iovec
* with the buffer provided.
*
* Returns: -1 on failure, otherwise the number of bytes read.
*/
ssize_t
mongoc_stream_read (mongoc_stream_t *stream,
void *buf,
size_t count,
bson_uint32_t timeout_msec)
{
struct iovec iov;
bson_return_val_if_fail(stream, -1);
bson_return_val_if_fail(buf, -1);
if (!count) {
return 0;
}
iov.iov_base = buf;
iov.iov_len = count;
BSON_ASSERT(stream->readv);
return stream->readv(stream, &iov, 1, timeout_msec);
}
bson_bool_t
_mongoc_host_list_from_string (mongoc_host_list_t *host_list,
const char *host_and_port)
{
bson_uint16_t port;
const char *end_host;
char *hostname = NULL;
bson_return_val_if_fail(host_list, FALSE);
bson_return_val_if_fail(host_and_port, FALSE);
memset(host_list, 0, sizeof *host_list);
if ((hostname = scan_to_unichar(host_and_port, ':', &end_host))) {
end_host++;
if (!isdigit(*end_host)) {
bson_free(hostname);
return FALSE;
}
sscanf(end_host, "%hu", &port);
} else {
hostname = bson_strdup(host_and_port);
port = MONGOC_DEFAULT_PORT;
}
strncpy(host_list->host_and_port, host_and_port,
sizeof host_list->host_and_port - 1);
host_list->host_and_port[sizeof host_list->host_and_port-1] = '\0';
strncpy(host_list->host, hostname, sizeof host_list->host - 1);
host_list->host[sizeof host_list->host-1] = '\0';
host_list->port = port;
host_list->family = AF_INET;
bson_free(hostname);
return TRUE;
}
static off_t
_bson_reader_handle_tell (bson_reader_handle_t *reader) /* IN */
{
off_t off;
bson_return_val_if_fail (reader, -1);
off = (off_t)reader->bytes_read;
off -= (off_t)reader->end;
off += (off_t)reader->offset;
return off;
}
static bson_off_t
_bson_reader_fd_tell (bson_reader_fd_t *reader)
{
bson_off_t off;
bson_return_val_if_fail (reader, -1);
off = bson_lseek (reader->fd, 0, SEEK_CUR);
off -= reader->end;
off += reader->offset;
return off;
}
bool
_mongoc_cursor_more (mongoc_cursor_t *cursor)
{
bson_return_val_if_fail(cursor, false);
if (cursor->failed) {
return false;
}
return (!cursor->sent ||
cursor->rpc.reply.cursor_id ||
!cursor->end_of_event);
}
/**
* mongoc_stream_close:
* @stream: A mongoc_stream_t.
*
* Closes the underlying file-descriptor used by @stream.
*
* Returns: 0 on success, -1 on failure.
*/
int
mongoc_stream_close (mongoc_stream_t *stream)
{
int ret;
ENTRY;
bson_return_val_if_fail(stream, -1);
ret = stream->close(stream);
RETURN (ret);
}
static const bson_t *
_bson_reader_handle_read (bson_reader_handle_t *reader, /* IN */
bool *reached_eof) /* IN */
{
int32_t blen;
bson_return_val_if_fail (reader, NULL);
if (reached_eof) {
*reached_eof = false;
}
while (!reader->done) {
if ((reader->end - reader->offset) < 4) {
_bson_reader_handle_fill_buffer (reader);
continue;
}
memcpy (&blen, &reader->data[reader->offset], sizeof blen);
blen = BSON_UINT32_FROM_LE (blen);
if (blen < 5) {
return NULL;
}
if (blen > (int32_t)(reader->end - reader->offset)) {
if (blen > (int32_t)reader->len) {
_bson_reader_handle_grow_buffer (reader);
}
_bson_reader_handle_fill_buffer (reader);
continue;
}
if (!bson_init_static (&reader->inline_bson,
&reader->data[reader->offset],
(uint32_t)blen)) {
return NULL;
}
reader->offset += blen;
return &reader->inline_bson;
}
if (reached_eof) {
*reached_eof = reader->done && !reader->failed;
}
return NULL;
}
const char *
mongoc_uri_get_replica_set (const mongoc_uri_t *uri)
{
bson_iter_t iter;
bson_return_val_if_fail(uri, NULL);
if (bson_iter_init_find_case(&iter, &uri->options, "replicaSet") &&
BSON_ITER_HOLDS_UTF8(&iter)) {
return bson_iter_utf8(&iter, NULL);
}
return NULL;
}
const char *
mongoc_uri_get_auth_mechanism (const mongoc_uri_t *uri)
{
bson_iter_t iter;
bson_return_val_if_fail (uri, NULL);
if (bson_iter_init_find_case (&iter, &uri->options, "authMechanism") &&
BSON_ITER_HOLDS_UTF8 (&iter)) {
return bson_iter_utf8 (&iter, NULL);
}
return NULL;
}
uint32_t
_mongoc_queue_get_length (const mongoc_queue_t *queue)
{
mongoc_queue_item_t *item;
uint32_t count = 0;
bson_return_val_if_fail(queue, 0);
for (item = queue->head; item; item = item->next) {
count++;
}
return count;
}
/** create an empty gridfs file */
mongoc_gridfs_file_t *
mongoc_gridfs_create_file (mongoc_gridfs_t *gridfs,
mongoc_gridfs_file_opt_t *opt)
{
mongoc_gridfs_file_t *file;
ENTRY;
bson_return_val_if_fail (gridfs, NULL);
file = _mongoc_gridfs_file_new (gridfs, opt);
RETURN (file);
}
/**
* mongoc_stream_write:
* @stream: A mongoc_stream_t.
* @buf: A buffer to write.
* @count: The number of bytes to write into @buf.
*
* Simplified access to mongoc_stream_writev(). Creates a single iovec
* with the buffer provided.
*
* Returns: -1 on failure, otherwise the number of bytes write.
*/
ssize_t
mongoc_stream_write (mongoc_stream_t *stream,
void *buf,
size_t count,
int32_t timeout_msec)
{
mongoc_iovec_t iov;
ssize_t ret;
ENTRY;
bson_return_val_if_fail (stream, -1);
bson_return_val_if_fail (buf, -1);
iov.iov_base = buf;
iov.iov_len = count;
BSON_ASSERT (stream->writev);
ret = mongoc_stream_writev (stream, &iov, 1, timeout_msec);
RETURN (ret);
}
int
_mongoc_read_prefs_score (const mongoc_read_prefs_t *read_prefs,
const mongoc_cluster_node_t *node)
{
bson_return_val_if_fail(read_prefs, -1);
bson_return_val_if_fail(node, -1);
switch (read_prefs->mode) {
case MONGOC_READ_PRIMARY:
return _mongoc_read_prefs_score_primary(read_prefs, node);
case MONGOC_READ_PRIMARY_PREFERRED:
return _mongoc_read_prefs_score_primary_preferred(read_prefs, node);
case MONGOC_READ_SECONDARY:
return _mongoc_read_prefs_score_secondary(read_prefs, node);
case MONGOC_READ_SECONDARY_PREFERRED:
return _mongoc_read_prefs_score_secondary_preferred(read_prefs, node);
case MONGOC_READ_NEAREST:
return _mongoc_read_prefs_score_nearest(read_prefs, node);
default:
BSON_ASSERT(false);
return -1;
}
}
char *
bson_strndup (const char *str, /* IN */
size_t n_bytes) /* IN */
{
char *ret;
bson_return_val_if_fail (str, NULL);
ret = bson_malloc (n_bytes + 1);
memcpy (ret, str, n_bytes);
ret[n_bytes] = '\0';
return ret;
}
char *
mongoc_uri_unescape (const char *escaped_string)
{
bson_unichar_t c;
bson_string_t *str;
unsigned int hex = 0;
const char *ptr;
const char *end;
size_t len;
bson_return_val_if_fail(escaped_string, NULL);
len = strlen(escaped_string);
/*
* Double check that this is a UTF-8 valid string. Bail out if necessary.
*/
if (!bson_utf8_validate(escaped_string, len, FALSE)) {
MONGOC_WARNING("%s(): escaped_string contains invalid UTF-8",
__FUNCTION__);
return FALSE;
}
ptr = escaped_string;
end = ptr + len;
str = bson_string_new(NULL);
for (; *ptr; ptr = bson_utf8_next_char(ptr)) {
c = bson_utf8_get_char(ptr);
switch (c) {
case '%':
if (((end - ptr) < 2) ||
!isxdigit(ptr[1]) ||
!isxdigit(ptr[2]) ||
(1 != sscanf(&ptr[1], "%02x", &hex)) ||
!isprint(hex)) {
bson_string_free(str, TRUE);
return NULL;
}
bson_string_append_c(str, hex);
ptr += 2;
break;
default:
bson_string_append_unichar(str, c);
break;
}
}
return bson_string_free(str, FALSE);
}
static bson_bool_t
_mongoc_cursor_unwrap_failure (mongoc_cursor_t *cursor)
{
bson_iter_t iter;
bson_t b;
ENTRY;
bson_return_val_if_fail(cursor, FALSE);
if (cursor->rpc.header.opcode != MONGOC_OPCODE_REPLY) {
bson_set_error(&cursor->error,
MONGOC_ERROR_PROTOCOL,
MONGOC_ERROR_PROTOCOL_INVALID_REPLY,
"Received rpc other than OP_REPLY.");
RETURN(TRUE);
}
if ((cursor->rpc.reply.flags & MONGOC_REPLY_QUERY_FAILURE)) {
if (_mongoc_rpc_reply_get_first(&cursor->rpc.reply, &b)) {
_mongoc_cursor_populate_error(cursor, &b, &cursor->error);
bson_destroy(&b);
} else {
bson_set_error(&cursor->error,
MONGOC_ERROR_QUERY,
MONGOC_ERROR_QUERY_FAILURE,
"Unknown query failure.");
}
RETURN(TRUE);
} else if (cursor->is_command) {
if (!_mongoc_rpc_reply_get_first(&cursor->rpc.reply, &b) ||
!bson_iter_init_find(&iter, &b, "ok") ||
!bson_iter_as_bool(&iter)) {
_mongoc_cursor_populate_error(cursor, &b, &cursor->error);
bson_destroy(&b);
RETURN(TRUE);
}
}
if ((cursor->rpc.reply.flags & MONGOC_REPLY_CURSOR_NOT_FOUND)) {
bson_set_error(&cursor->error,
MONGOC_ERROR_CURSOR,
MONGOC_ERROR_CURSOR_INVALID_CURSOR,
"The cursor is invalid or has expired.");
RETURN(TRUE);
}
RETURN(FALSE);
}
char *
bson_strdup_printf (const char *format, /* IN */
...) /* IN */
{
va_list args;
char *ret;
bson_return_val_if_fail (format, NULL);
va_start (args, format);
ret = bson_strdupv_printf (format, args);
va_end (args);
return ret;
}
static bool
cbson_loads_visit_array (const bson_iter_t *iter,
const char *key,
const bson_t *v_array,
void *data)
{
bson_iter_t child;
Array * ret = (Array *) data;
Array obj;
bson_return_val_if_fail(iter, true);
bson_return_val_if_fail(key, true);
bson_return_val_if_fail(v_array, true);
if (bson_iter_init(&child, v_array))
{
obj = Array();
if (!bson_iter_visit_all(&child, &gLoadsVisitors, &obj))
{
ret->add(String(key), obj);
}
}
return false;
}
static bson_bool_t
cbson_loads_visit_array (const bson_iter_t *iter,
const char *key,
const bson_t *v_array,
void *data)
{
bson_iter_t child;
PyObject **ret = data;
PyObject *obj;
bson_return_val_if_fail(iter, TRUE);
bson_return_val_if_fail(key, TRUE);
bson_return_val_if_fail(v_array, TRUE);
if (bson_iter_init(&child, v_array)) {
obj = PyList_New(0);
if (!bson_iter_visit_all(&child, &gLoadsVisitors, &obj)) {
cbson_loads_set_item(*ret, key, obj);
}
Py_XDECREF(obj);
}
return FALSE;
}
static ssize_t
mongoc_stream_buffered_writev (mongoc_stream_t *stream, /* IN */
struct iovec *iov, /* IN */
size_t iovcnt, /* IN */
int32_t timeout_msec) /* IN */
{
mongoc_stream_buffered_t *buffered = (mongoc_stream_buffered_t *)stream;
bson_return_val_if_fail(buffered, -1);
return mongoc_stream_writev(buffered->base_stream,
iov,
iovcnt,
timeout_msec);
}
/**
* mongoc_stream_writev:
* @stream: A mongoc_stream_t.
* @iov: An array of iovec to write to the stream.
* @iovcnt: The number of elements in @iov.
*
* Writes an array of iovec buffers to the underlying stream.
*
* Returns: the number of bytes written, or -1 upon failure.
*/
ssize_t
mongoc_stream_writev (mongoc_stream_t *stream,
mongoc_iovec_t *iov,
size_t iovcnt,
int32_t timeout_msec)
{
ssize_t ret;
ENTRY;
bson_return_val_if_fail(stream, -1);
bson_return_val_if_fail(iov, -1);
bson_return_val_if_fail(iovcnt, -1);
BSON_ASSERT(stream->writev);
if (timeout_msec < 0) {
timeout_msec = MONGOC_DEFAULT_TIMEOUT_MSEC;
}
ret = stream->writev(stream, iov, iovcnt, timeout_msec);
RETURN (ret);
}
int
mongoc_stream_setsockopt (mongoc_stream_t *stream,
int level,
int optname,
void *optval,
socklen_t optlen)
{
bson_return_val_if_fail(stream, -1);
if (stream->setsockopt) {
return stream->setsockopt(stream, level, optname, optval, optlen);
}
return 0;
}
bson_reader_t *
bson_reader_new_from_fd (int fd, /* IN */
bool close_on_destroy) /* IN */
{
bson_reader_handle_fd_t *handle;
bson_return_val_if_fail (fd != -1, NULL);
handle = bson_malloc0 (sizeof *handle);
handle->fd = fd;
handle->do_close = close_on_destroy;
return bson_reader_new_from_handle (handle,
_bson_reader_handle_fd_read,
_bson_reader_handle_fd_destroy);
}
bson_reader_t *
bson_reader_new_from_data (const uint8_t *data, /* IN */
size_t length) /* IN */
{
bson_reader_data_t *real;
bson_return_val_if_fail (data, NULL);
real = bson_malloc0 (sizeof *real);
real->type = BSON_READER_DATA;
real->data = data;
real->length = length;
real->offset = 0;
return (bson_reader_t *)real;
}
