//Casts to an int
int get_bson_int(const bson_t *obj, char *name) {
bson_iter_t i;
bson_iter_t t;
if (bson_iter_init(&i, obj)) {
if (bson_iter_find_descendant(&i, name, &t)) {
if (bson_iter_type(&t) == BSON_TYPE_INT32) {
return bson_iter_int32(&t);
}
if (bson_iter_type(&t) == BSON_TYPE_DOUBLE) {
return (int) bson_iter_double(&t);
}
}
}
return 0;
}
SEXP ConvertValue(bson_iter_t* iter){
if(BSON_ITER_HOLDS_INT32(iter)){
return ScalarInteger(bson_iter_int32(iter));
} else if(BSON_ITER_HOLDS_NULL(iter)){
return R_NilValue;
} else if(BSON_ITER_HOLDS_BOOL(iter)){
return ScalarLogical(bson_iter_bool(iter));
} else if(BSON_ITER_HOLDS_DOUBLE(iter)){
return ScalarReal(bson_iter_double(iter));
} else if(BSON_ITER_HOLDS_INT64(iter)){
return ScalarReal((double) bson_iter_int64(iter));
} else if(BSON_ITER_HOLDS_UTF8(iter)){
return mkStringUTF8(bson_iter_utf8(iter, NULL));
} else if(BSON_ITER_HOLDS_CODE(iter)){
return mkStringUTF8(bson_iter_code(iter, NULL));
} else if(BSON_ITER_HOLDS_BINARY(iter)){
return ConvertBinary(iter);
} else if(BSON_ITER_HOLDS_DATE_TIME(iter)){
return ConvertDate(iter);
} else if(BSON_ITER_HOLDS_OID(iter)){
const bson_oid_t *val = bson_iter_oid(iter);
char str[25];
bson_oid_to_string(val, str);
return mkString(str);
} else if(BSON_ITER_HOLDS_ARRAY(iter)){
bson_iter_t child1;
bson_iter_t child2;
bson_iter_recurse (iter, &child1);
bson_iter_recurse (iter, &child2);
return ConvertArray(&child1, &child2);
} else if(BSON_ITER_HOLDS_DOCUMENT(iter)){
bson_iter_t child1;
bson_iter_t child2;
bson_iter_recurse (iter, &child1);
bson_iter_recurse (iter, &child2);
return ConvertObject(&child1, &child2);
} else {
stop("Unimplemented BSON type %d\n", bson_iter_type(iter));
}
}
SEXP ConvertValue(bson_iter_t* iter){
if(BSON_ITER_HOLDS_INT32(iter)){
return ScalarInteger(bson_iter_int32(iter));
} else if(BSON_ITER_HOLDS_NULL(iter)){
return R_NilValue;
} else if(BSON_ITER_HOLDS_BOOL(iter)){
return ScalarLogical(bson_iter_bool(iter));
} else if(BSON_ITER_HOLDS_DOUBLE(iter)){
return ScalarReal(bson_iter_double(iter));
} else if(BSON_ITER_HOLDS_INT64(iter)){
return ScalarReal((double) bson_iter_int64(iter));
} else if(BSON_ITER_HOLDS_UTF8(iter)){
return mkStringUTF8(bson_iter_utf8(iter, NULL));
} else if(BSON_ITER_HOLDS_CODE(iter)){
return mkStringUTF8(bson_iter_code(iter, NULL));
} else if(BSON_ITER_HOLDS_BINARY(iter)){
return ConvertBinary(iter);
} else if(BSON_ITER_HOLDS_DATE_TIME(iter)){
return ConvertDate(iter);
} else if(BSON_ITER_HOLDS_OID(iter)){
//not sure if this casting works
return mkRaw((unsigned char *) bson_iter_oid(iter), 12);
} else if(BSON_ITER_HOLDS_ARRAY(iter)){
bson_iter_t child1;
bson_iter_t child2;
bson_iter_recurse (iter, &child1);
bson_iter_recurse (iter, &child2);
return ConvertArray(&child1, &child2);
} else if(BSON_ITER_HOLDS_DOCUMENT(iter)){
bson_iter_t child1;
bson_iter_t child2;
bson_iter_recurse (iter, &child1);
bson_iter_recurse (iter, &child2);
return ConvertObject(&child1, &child2);
} else {
stop("Unimplemented BSON type %d\n", bson_iter_type(iter));
}
}
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);
}
/*!
* \brief Convert rows from mongodb to db API representation
* \param _h database connection
* \param _r database result set
* \return 0 on success, negative on failure
*/
static int db_mongodb_convert_bson(const db1_con_t* _h, db1_res_t* _r,
int _row, const bson_t *_rdoc)
{
static str dummy_string = {"", 0};
int col;
db_mongodb_result_t *mgres;
const char *colname;
bson_type_t coltype;
bson_iter_t riter;
bson_iter_t citer;
bson_iter_t *piter;
db_val_t* dval;
uint32_t i32tmp;
bson_subtype_t subtype;
bson_t *cdoc;
mgres = (db_mongodb_result_t*)RES_PTR(_r);
if(mgres->nrcols==0) {
LM_ERR("no fields to convert\n");
return -1;
}
if(mgres->colsdoc==NULL) {
cdoc = (bson_t*)_rdoc;
} else {
cdoc = (bson_t*)mgres->colsdoc;
}
if (!bson_iter_init (&citer, cdoc)) {
LM_ERR("failed to initialize columns iterator\n");
return -3;
}
if(mgres->colsdoc) {
if (!bson_iter_init (&riter, _rdoc)) {
LM_ERR("failed to initialize result iterator\n");
return -3;
}
}
if (db_allocate_row(_r, &(RES_ROWS(_r)[_row])) != 0) {
LM_ERR("could not allocate row: %d\n", _row);
return -2;
}
col = 0;
while (bson_iter_next (&citer)) {
if(col >= RES_COL_N(_r)) {
LM_ERR("invalid number of columns (%d/%d)\n", col, RES_COL_N(_r));
return -4;
}
colname = bson_iter_key (&citer);
LM_DBG("looking for field[%d] named: %s\n", col, colname);
if(mgres->colsdoc) {
if(!bson_iter_find(&riter, colname)) {
LM_ERR("field [%s] not found in result iterator\n",
colname);
return -4;
}
piter = &riter;
} else {
piter = &citer;
}
coltype = bson_iter_type(piter);
dval = &(ROW_VALUES(&(RES_ROWS(_r)[_row]))[col]);
VAL_TYPE(dval) = RES_TYPES(_r)[col];
switch(coltype) {
case BSON_TYPE_BOOL:
VAL_INT(dval) = (int)bson_iter_bool (piter);
break;
case BSON_TYPE_INT32:
VAL_INT(dval) = bson_iter_int32 (piter);
break;
case BSON_TYPE_TIMESTAMP:
bson_iter_timestamp (piter,
(uint32_t*)&VAL_INT(dval), &i32tmp);
break;
case BSON_TYPE_INT64:
VAL_BIGINT(dval) = bson_iter_int64 (piter);
break;
case BSON_TYPE_DOUBLE:
VAL_DOUBLE(dval) = bson_iter_double (piter);
break;
case BSON_TYPE_DATE_TIME:
VAL_TIME(dval) = (time_t)(bson_iter_date_time (piter)/1000);
break;
case BSON_TYPE_BINARY:
bson_iter_binary (piter, &subtype,
(uint32_t*)&VAL_BLOB(dval).len, (const uint8_t**)&VAL_BLOB(dval).s);
break;
case BSON_TYPE_UTF8:
VAL_STRING(dval) = (char*)bson_iter_utf8 (piter, &i32tmp);
break;
case BSON_TYPE_OID:
break;
case BSON_TYPE_NULL:
memset(dval, 0, sizeof(db_val_t));
/* Initialize the string pointers to a dummy empty
* string so that we do not crash when the NULL flag
* is set but the module does not check it properly
*/
VAL_STRING(dval) = dummy_string.s;
VAL_STR(dval) = dummy_string;
VAL_BLOB(dval) = dummy_string;
VAL_TYPE(dval) = RES_TYPES(_r)[col];
VAL_NULL(dval) = 1;
break;
#if 0
case BSON_TYPE_EOD:
case BSON_TYPE_DOCUMENT:
case BSON_TYPE_ARRAY:
case BSON_TYPE_UNDEFINED:
case BSON_TYPE_REGEX:
case BSON_TYPE_DBPOINTER:
case BSON_TYPE_CODE:
case BSON_TYPE_SYMBOL:
case BSON_TYPE_CODEWSCOPE:
case BSON_TYPE_MAXKEY:
case BSON_TYPE_MINKEY:
#endif
default:
LM_WARN("unhandled data type column (%.*s) type id (%d), "
"use DB1_STRING as default\n", RES_NAMES(_r)[col]->len,
RES_NAMES(_r)[col]->s, coltype);
RES_TYPES(_r)[col] = DB1_STRING;
break;
}
LM_DBG("RES_NAMES(%p)[%d]=[%.*s] (%d)\n", RES_NAMES(_r)[col], col,
RES_NAMES(_r)[col]->len, RES_NAMES(_r)[col]->s, coltype);
col++;
}
return 0;
}
types::b_double element::get_double() const {
BSONCXX_TYPE_CHECK(k_double);
BSONCXX_CITER;
return types::b_double{bson_iter_double(&iter)};
}
void bsonToDouble(bson_iter_t* iter, Array* output) {
output->add(
String(bson_iter_key(iter)),
bson_iter_double(iter)
);
}
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);
}
types::b_double element::get_double() const {
CITER;
return types::b_double{bson_iter_double(&iter)};
}
double
BsonIterDouble(BSON_ITERATOR *it)
{
return bson_iter_double(it);
}
QVariantMap TBson::fromBson(const TBsonObject *obj)
{
QVariantMap ret;
bson_iter_t it;
const bson_t *bson = (const bson_t *)obj;
bson_iter_init(&it, bson);
while (bson_iter_next(&it)) {
bson_type_t t = bson_iter_type(&it);
QString key(bson_iter_key(&it));
switch (t) {
case BSON_TYPE_EOD:
return ret;
break;
case BSON_TYPE_DOUBLE:
ret[key] = bson_iter_double(&it);
break;
case BSON_TYPE_UTF8:
ret[key] = QString::fromUtf8(bson_iter_utf8(&it, nullptr));
break;
case BSON_TYPE_ARRAY: {
const uint8_t *docbuf = nullptr;
uint32_t doclen = 0;
bson_t sub[1];
bson_iter_array(&it, &doclen, &docbuf);
if (bson_init_static(sub, docbuf, doclen)) {
ret[key] = fromBson(sub).values();
}
break; }
case BSON_TYPE_DOCUMENT: {
const uint8_t *docbuf = nullptr;
uint32_t doclen = 0;
bson_t sub[1];
bson_iter_document(&it, &doclen, &docbuf);
if (bson_init_static(sub, docbuf, doclen)) {
ret[key] = fromBson(sub);
}
break; }
case BSON_TYPE_BINARY: {
const uint8_t *binary = nullptr;
bson_subtype_t subtype = BSON_SUBTYPE_BINARY;
uint32_t len = 0;
bson_iter_binary(&it, &subtype, &len, &binary);
if (binary) {
ret[key] = QByteArray((char *)binary, len);
}
break; }
case BSON_TYPE_UNDEFINED:
ret[key] = QVariant();
break;
case BSON_TYPE_OID: {
char oidhex[25];
bson_oid_to_string(bson_iter_oid(&it), oidhex);
ret[key] = QString(oidhex);
break; }
case BSON_TYPE_BOOL:
ret[key] = (bool)bson_iter_bool(&it);
break;
case BSON_TYPE_DATE_TIME: {
#if QT_VERSION >= 0x040700
QDateTime date;
date.setMSecsSinceEpoch(bson_iter_date_time(&it));
#else
qint64 val = bson_iter_date_time(&it);
qint64 days = val / 86400000; // 24*60*60*1000
int msecs = val % 86400000;
QDate dt = QDate(1970, 1, 1).addDays(days);
QTime tm = QTime(0, 0, 0).addMSecs(msecs);
QDateTime date(dt, tm, Qt::UTC);
#endif
ret[key] = date;
break; }
case BSON_TYPE_NULL:
ret[key] = QVariant();
break;
case BSON_TYPE_REGEX:
ret[key] = QRegExp(QLatin1String(bson_iter_regex(&it, nullptr)));
break;
case BSON_TYPE_CODE:
ret[key] = QString(bson_iter_code(&it, nullptr));
break;
case BSON_TYPE_SYMBOL:
ret[key] = QString(bson_iter_symbol(&it, nullptr));
break;
case BSON_TYPE_INT32:
ret[key] = bson_iter_int32(&it);
break;
case BSON_TYPE_INT64:
ret[key] = (qint64)bson_iter_int64(&it);
break;
case BSON_TYPE_CODEWSCOPE: // FALL THROUGH
case BSON_TYPE_TIMESTAMP: // FALL THROUGH (internal use)
// do nothing
break;
default:
tError("fromBson() unknown type: %d", t);
break;
}
//tSystemDebug("fromBson : t:%d key:%s = %s", t, qPrintable(key), qPrintable(ret[key].toString()));
}
return ret;
}
static int mongo_list_realm_options(u08bits *realm) {
mongoc_collection_t * collection = mongo_get_collection("realm");
if(!collection)
return -1;
bson_t query, child;
bson_init(&query);
bson_append_document_begin(&query, "$orderby", -1, &child);
BSON_APPEND_INT32(&child, "realm", 1);
bson_append_document_end(&query, &child);
bson_append_document_begin(&query, "$query", -1, &child);
if (realm && realm[0]) {
BSON_APPEND_UTF8(&child, "realm", (const char *)realm);
}
bson_append_document_end(&query, &child);
bson_t fields;
bson_init(&fields);
BSON_APPEND_INT32(&fields, "options", 1);
BSON_APPEND_INT32(&fields, "realm", 1);
mongoc_cursor_t * cursor;
cursor = mongoc_collection_find(collection, MONGOC_QUERY_NONE, 0, 0, 0, &query, &fields, NULL);
int ret = -1;
if (!cursor) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error querying MongoDB collection 'realm'\n");
} else {
const bson_t * item;
uint32_t length;
bson_iter_t iter;
while (mongoc_cursor_next(cursor, &item)) {
if (bson_iter_init(&iter, item) && bson_iter_find(&iter, "realm") && BSON_ITER_HOLDS_UTF8(&iter)) {
const char * _realm = bson_iter_utf8(&iter, &length);
if (bson_iter_init(&iter, item) && bson_iter_find(&iter, "options") && BSON_ITER_HOLDS_DOCUMENT(&iter)) {
const uint8_t *docbuf = NULL;
uint32_t doclen = 0;
bson_t options;
bson_iter_t options_iter;
bson_iter_document(&iter, &doclen, &docbuf);
bson_init_static(&options, docbuf, doclen);
if (bson_iter_init(&options_iter, &options)) {
while(bson_iter_next(&options_iter)) {
const char * _k = bson_iter_key(&options_iter);
if (BSON_ITER_HOLDS_DOUBLE(&options_iter)) {
int32_t _v = (int32_t)bson_iter_double(&options_iter);
printf("%s[%s]=%d\n", _k, _realm, _v);
} else if (BSON_ITER_HOLDS_INT32(&options_iter)) {
int32_t _v = bson_iter_int32(&options_iter);
printf("%s[%s]=%d\n", _k, _realm, _v);
} else if (BSON_ITER_HOLDS_INT64(&options_iter)) {
int32_t _v = (int32_t)bson_iter_int64(&options_iter);
printf("%s[%s]=%d\n", _k, _realm, _v);
}
}
}
}
}
}
mongoc_cursor_destroy(cursor);
ret = 0;
}
mongoc_collection_destroy(collection);
bson_destroy(&query);
bson_destroy(&fields);
return ret;
}
static void mongo_reread_realms(secrets_list_t * realms_list) {
UNUSED_ARG(realms_list);
mongoc_collection_t * collection = mongo_get_collection("realm");
if (!collection)
return;
bson_t query;
bson_init(&query);
bson_t fields;
bson_init(&fields);
BSON_APPEND_INT32(&fields, "realm", 1);
BSON_APPEND_INT32(&fields, "origin", 1);
BSON_APPEND_INT32(&fields, "options", 1);
mongoc_cursor_t * cursor;
cursor = mongoc_collection_find(collection, MONGOC_QUERY_NONE, 0, 0, 0,
&query, &fields, NULL);
if (!cursor) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR,
"Error querying MongoDB collection 'realm'\n");
} else {
ur_string_map *o_to_realm_new = ur_string_map_create(turn_free_simple);
const bson_t * item;
uint32_t length;
bson_iter_t iter;
while (mongoc_cursor_next(cursor, &item)) {
if (bson_iter_init(&iter, item) && bson_iter_find(&iter, "realm")
&& BSON_ITER_HOLDS_UTF8(&iter)) {
char * _realm = turn_strdup(bson_iter_utf8(&iter, &length));
get_realm(_realm);
if (bson_iter_init(&iter, item) && bson_iter_find(&iter,
"origin") && BSON_ITER_HOLDS_ARRAY(&iter)) {
const uint8_t *docbuf = NULL;
uint32_t doclen = 0;
bson_t origin_array;
bson_iter_t origin_iter;
bson_iter_array(&iter, &doclen, &docbuf);
bson_init_static(&origin_array, docbuf, doclen);
if (bson_iter_init(&origin_iter, &origin_array)) {
while (bson_iter_next(&origin_iter)) {
if (BSON_ITER_HOLDS_UTF8(&origin_iter)) {
char* _origin = turn_strdup(bson_iter_utf8(&origin_iter, &length));
char *rval = turn_strdup(_realm);
ur_string_map_value_type value =
(ur_string_map_value_type) (rval);
ur_string_map_put(o_to_realm_new,
(const ur_string_map_key_type) _origin,
value);
turn_free(_origin,strlen(_origin)+1);
}
}
}
}
realm_params_t* rp = get_realm(_realm);
lock_realms();
rp->options.perf_options.max_bps = turn_params.max_bps;
rp->options.perf_options.total_quota = turn_params.total_quota;
rp->options.perf_options.user_quota = turn_params.user_quota;
unlock_realms();
if (bson_iter_init(&iter, item) && bson_iter_find(&iter,
"options") && BSON_ITER_HOLDS_DOCUMENT(&iter)) {
const uint8_t *docbuf = NULL;
uint32_t doclen = 0;
bson_t options;
bson_iter_t options_iter;
bson_iter_document(&iter, &doclen, &docbuf);
bson_init_static(&options, docbuf, doclen);
if (bson_iter_init(&options_iter, &options)) {
while (bson_iter_next(&options_iter)) {
const char * _k = bson_iter_key(&options_iter);
uint64_t _v = 0;
if (BSON_ITER_HOLDS_DOUBLE(&options_iter)) {
_v = (uint64_t) bson_iter_double(&options_iter);
} else if (BSON_ITER_HOLDS_INT32(&options_iter)) {
_v = (uint64_t)bson_iter_int32(&options_iter);
} else if (BSON_ITER_HOLDS_INT64(&options_iter)) {
_v = (uint64_t) bson_iter_int64(&options_iter);
}
if (_v) {
if (!strcmp(_k, "max-bps"))
rp->options.perf_options.max_bps = (band_limit_t) _v;
else if (!strcmp(_k, "total-quota"))
rp->options.perf_options.total_quota = (vint) _v;
else if (!strcmp(_k, "user-quota"))
rp->options.perf_options.user_quota = (vint) _v;
else {
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR,
"Unknown realm option: %s\n", _k);
}
}
}
}
}
turn_free(_realm,strlen(_realm)+1);
}
}
update_o_to_realm(o_to_realm_new);
mongoc_cursor_destroy(cursor);
}
mongoc_collection_destroy(collection);
bson_destroy(&query);
bson_destroy(&fields);
}