static int mongo_set_oauth_key(oauth_key_data_raw *key) { mongoc_collection_t * collection = mongo_get_collection("oauth_key"); if(!collection) return -1; bson_t query; bson_init(&query); BSON_APPEND_UTF8(&query, "kid", (const char *)key->kid); bson_t doc; bson_init(&doc); BSON_APPEND_UTF8(&doc, "kid", (const char *)key->kid); BSON_APPEND_UTF8(&doc, "as_rs_alg", (const char *)key->as_rs_alg); BSON_APPEND_UTF8(&doc, "ikm_key", (const char *)key->ikm_key); BSON_APPEND_INT64(&doc, "timestamp", (int64_t)key->timestamp); BSON_APPEND_INT32(&doc, "lifetime", (int32_t)key->lifetime); int ret = -1; if (!mongoc_collection_update(collection, MONGOC_UPDATE_UPSERT, &query, &doc, NULL, NULL)) { TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error inserting/updating oauth key information\n"); } else { ret = 0; } mongoc_collection_destroy(collection); bson_destroy(&doc); bson_destroy(&query); return ret; }
int mongodb_module_process(fieldset_t *fs) { bson_t *doc; if (!bulk) { return EXIT_FAILURE; } if (buffer_fill == BUFFER_SIZE) { if (mongodb_module_flush()) { return EXIT_FAILURE; } } doc = bson_new(); for (int i=0; i < fs->len; i++) { field_t *f = &(fs->fields[i]); if (f->type == FS_STRING) { BSON_APPEND_UTF8(doc,f->name,f->value.ptr); } else if (f->type == FS_UINT64) { BSON_APPEND_INT64(doc,f->name,(uint64_t) f->value.num); } else if (f->type == FS_BINARY) { BSON_APPEND_BINARY(doc,f->name, BSON_SUBTYPE_BINARY,f->value.ptr, f->len); } else if (f->type == FS_NULL) { // do nothing } else { log_fatal("mongodb", "received unknown output type"); } } mongoc_bulk_operation_insert(bulk,doc); buffer_fill++; return EXIT_SUCCESS; }
static void dump_message(ullong number, str_t type, msg_content_array_t* content) { bson_t document; bson_error_t error; time_t t; mongoc_collection_t* collection = mongoc_database_get_collection(robot.mongoc_database, "message"); char* json = msg_content_array_to_json_object_string(content, "content"); time(&t); if (!bson_init_from_json(&document, json, strlen(json), &error)) MONGOC_WARNING("%s\n", error.message); BSON_APPEND_INT64(&document, "from", number); BSON_APPEND_UTF8(&document, "type", type.ptr); BSON_APPEND_TIME_T(&document, "time", t); if (!mongoc_collection_insert(collection, MONGOC_INSERT_NONE, &document, NULL, &error)) MONGOC_WARNING("%s\n", error.message); bson_destroy(&document); free(json); }
bson_t* file_getBSON(file_t *file) { char arrayKey[16]; bson_t *bson = bson_new(); BSON_APPEND_UTF8(bson, "_id", file->id); BSON_APPEND_UTF8(bson, "name", file->name); BSON_APPEND_INT64(bson, "size", file->size); BSON_APPEND_UTF8(bson, "parentId", file->parentId); bson_t *bson_blocks = bson_new(); int blockIndex = 0; void listBlocks(t_list* blockCopies) { bson_t *bson_block_copies = bson_new(); int copyIndex = 0; void listBlockCopy(file_block_t *blockCopy) { sprintf(arrayKey, "%d", copyIndex); bson_t *bson_block_copy = file_block_getBSON(blockCopy); BSON_APPEND_DOCUMENT(bson_block_copies, arrayKey, bson_block_copy); bson_destroy(bson_block_copy); copyIndex++; }
void switch_value(lua_State *L, int index, bson_t* bson, int level, const char* key) { switch(lua_type(L, index)) { case LUA_TTABLE: { int is_a=is_array(L, index); if (is_a) { bson_t child; //start array BSON_APPEND_ARRAY_BEGIN(bson, key, &child); iterate_table(L, index, &child, 0, level+1, NULL); bson_append_array_end(bson, &child); } else { bson_t child; //start map BSON_APPEND_DOCUMENT_BEGIN(bson, key, &child); iterate_table(L, index, &child, 1, level+1, NULL); bson_append_document_end(bson, &child); } break; } case LUA_TNIL: { BSON_APPEND_NULL(bson, key); break; } case LUA_TNUMBER: { BSON_APPEND_DOUBLE(bson, key, lua_tonumber(L, index)); break; } case LUA_TBOOLEAN: { BSON_APPEND_BOOL(bson, key, lua_toboolean(L, index)); break; } case LUA_TSTRING: { BSON_APPEND_UTF8(bson, key, lua_tostring(L, index)); break; } case LUA_TUSERDATA: { // switch userdata type if (luaL_checkudata_ex(L, index, REGEX_METATABLE)) { cbson_regex_t* regex = check_cbson_regex(L, index); BSON_APPEND_REGEX (bson, key, regex->regex, regex->options); } else if (luaL_checkudata_ex(L, index, OID_METATABLE)) { cbson_oid_t* oid = check_cbson_oid(L, index); bson_oid_t boid; bson_oid_init_from_string (&boid, oid->oid); BSON_APPEND_OID (bson, key, &boid); } else if (luaL_checkudata_ex(L, index, BINARY_METATABLE)) { cbson_binary_t* bin = check_cbson_binary(L, index); size_t binary_len = b64_pton (bin->data, NULL, 0); unsigned char* buf=malloc(binary_len+1); b64_pton(bin->data, buf, binary_len+1); BSON_APPEND_BINARY(bson, key, bin->type, buf, binary_len); free(buf); } else if (luaL_checkudata_ex(L, index, SYMBOL_METATABLE)) { cbson_symbol_t* sym = check_cbson_symbol(L, index); BSON_APPEND_SYMBOL(bson, key, sym->symbol); } else if (luaL_checkudata_ex(L, index, REF_METATABLE)) { cbson_ref_t* ref = check_cbson_ref(L, index); bson_oid_t boid; bson_oid_init_from_string (&boid, ref->id); BSON_APPEND_DBPOINTER(bson, key, ref->ref, &boid); } else if (luaL_checkudata_ex(L, index, MINKEY_METATABLE)) { check_cbson_minkey(L, index); BSON_APPEND_MINKEY(bson, key); } else if (luaL_checkudata_ex(L, index, MAXKEY_METATABLE)) { check_cbson_maxkey(L, index); BSON_APPEND_MAXKEY(bson, key); } else if (luaL_checkudata_ex(L, index, TIMESTAMP_METATABLE)) { cbson_timestamp_t* time = check_cbson_timestamp(L, index); BSON_APPEND_TIMESTAMP(bson, key, time->timestamp, time->increment); } else if (luaL_checkudata_ex(L, index, INT64_METATABLE) || luaL_checkudata_ex(L, index, UINT64_METATABLE)) { cbson_int64_t i = cbson_int64_check(L, index); if (i < INT32_MIN || i > INT32_MAX) { BSON_APPEND_INT64(bson, key, i); } else { BSON_APPEND_INT32(bson, key, (int32_t)i); } } else if (luaL_checkudata_ex(L, index, CODE_METATABLE)) { cbson_code_t* code = check_cbson_code(L, index); BSON_APPEND_CODE(bson, key, code->code); } else if (luaL_checkudata_ex(L, index, CODEWSCOPE_METATABLE)) { cbson_codewscope_t* code = check_cbson_codewscope(L, index); BSON_APPEND_CODE_WITH_SCOPE(bson, key, code->code, NULL); } else if (luaL_checkudata_ex(L, index, UNDEFINED_METATABLE)) { check_cbson_undefined(L, index); BSON_APPEND_UNDEFINED(bson, key); } else if (luaL_checkudata_ex(L, index, DATE_METATABLE)) { BSON_APPEND_DATE_TIME(bson, key, cbson_date_check(L, index)); } break; } case LUA_TFUNCTION: case LUA_TTHREAD: case LUA_TLIGHTUSERDATA: default: break; // or bail out? } }
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)); }
static bool appendBsonValue(bson_t *bson, const QString &key, const QVariant &value) { const QLatin1String oidkey("_id"); bool ok = true; int type = value.type(); // _id if (key == oidkey) { QByteArray oidVal = value.toByteArray(); if (oidVal.length() == 24) { // ObjectId bson_oid_t oid; bson_oid_init_from_string(&oid, oidVal.data()); BSON_APPEND_OID(bson, oidkey.latin1(), &oid); } else { int id = value.toInt(&ok); if (ok) { BSON_APPEND_INT32(bson, oidkey.latin1(), id); } else { BSON_APPEND_UTF8(bson, oidkey.latin1(), value.toString().toUtf8().data()); } } return true; } switch (type) { case QVariant::Int: BSON_APPEND_INT32(bson, qPrintable(key), value.toInt(&ok)); break; case QVariant::String: BSON_APPEND_UTF8(bson, qPrintable(key), value.toString().toUtf8().data()); break; case QVariant::LongLong: BSON_APPEND_INT64(bson, qPrintable(key), value.toLongLong(&ok)); break; case QVariant::Map: BSON_APPEND_DOCUMENT(bson, qPrintable(key), (const bson_t *)TBson::toBson(value.toMap()).constData()); break; case QVariant::Double: BSON_APPEND_DOUBLE(bson, qPrintable(key), value.toDouble(&ok)); break; case QVariant::Bool: BSON_APPEND_BOOL(bson, qPrintable(key), value.toBool()); break; case QVariant::DateTime: { #if QT_VERSION >= 0x040700 BSON_APPEND_DATE_TIME(bson, qPrintable(key), value.toDateTime().toMSecsSinceEpoch()); #else QDateTime utcDate = value.toDateTime().toUTC(); qint64 ms = utcDate.time().msec(); qint64 tm = utcDate.toTime_t() * 1000LL; if (ms > 0) { tm += ms; } BSON_APPEND_DATE_TIME(bson, qPrintable(key), tm); #endif break; } case QVariant::ByteArray: { QByteArray ba = value.toByteArray(); BSON_APPEND_BINARY(bson, qPrintable(key), BSON_SUBTYPE_BINARY, (uint8_t *)ba.constData(), ba.length()); break; } case QVariant::List: // FALL THROUGH case QVariant::StringList: { bson_t child; BSON_APPEND_ARRAY_BEGIN(bson, qPrintable(key), &child); int i = 0; for (auto &var : value.toList()) { appendBsonValue(&child, QString::number(i++), var); } bson_append_array_end(bson, &child); break; } case QVariant::Invalid: BSON_APPEND_UNDEFINED(bson, qPrintable(key)); break; default: tError("toBson() failed to convert name:%s type:%d", qPrintable(key), type); ok = false; break; } return ok; }