const char *gridfile_get_contenttype(gridfile* gfile)
{
bson_iterator it;
if (bson_find(&it, gfile->meta, "contentType"))
return bson_iterator_string( &it );
else return NULL;
}
UInfo* MongoLink::query(int uid) {
UInfo* uinfo = NULL;
bson query[1];
mongo_cursor cursor[1];
bson_init( query );
bson_append_int( query, "uid", uid );
bson_finish( query );
mongo_cursor_init( cursor, &m_mongo, m_strDBName.c_str() );
mongo_cursor_set_query( cursor, query );
if( mongo_cursor_next( cursor ) == MONGO_OK ) {
bson_iterator iterator[1];
uinfo = new UInfo();
//uinfo->linkid = 0;
if ( bson_find( iterator, mongo_cursor_bson( cursor ), "uid" ) != BSON_EOO ) {
uinfo->uid= bson_iterator_int( iterator );
}
if ( bson_find( iterator, mongo_cursor_bson( cursor ), "router" ) != BSON_EOO ) {
uinfo->router= bson_iterator_string( iterator );
}
if ( bson_find( iterator, mongo_cursor_bson( cursor ), "dispatcher" ) != BSON_EOO ) {
uinfo->dispatcher= bson_iterator_string( iterator );
}
if ( bson_find( iterator, mongo_cursor_bson( cursor ), "proxy" ) != BSON_EOO ) {
uinfo->proxy= bson_iterator_string( iterator );
}
} else {
LOG(TAG_ROUTER, "query uid failed, uid=%d.", uid);
}
exit:
bson_destroy( query );
mongo_cursor_destroy( cursor );
return uinfo;
}
static void bson_decode_tree(lua_State* L, bson_iterator* b,int set_t){
const char *key;
while(bson_iterator_next(b))
{
bson_type t = bson_iterator_type(b);
if(t == 0)
{
lua_pushnil(L);
break;
}
key = bson_iterator_key(b);
if(set_t)
{
lua_pushstring(L,key);
}
LOG_MSG("type %d,key %s",t,key);
switch(t)
{
case BSON_DOUBLE:
lua_pushnumber(L,bson_iterator_double(b));
break;
case BSON_STRING:
lua_pushstring(L,bson_iterator_string(b));
break;
case BSON_BOOL:
lua_pushboolean(L,bson_iterator_bool( b ) ? true : false );
break;
case BSON_NULL:
lua_pushnil(L);
break;
case BSON_INT:
lua_pushinteger(L,bson_iterator_int(b));
break;
case BSON_OBJECT:
bson_iterator t;
bson_iterator_subiterator(b,&t);
bson_decode_tree(L,&t);
lua_settable(L,-3);
break;
case BSON_ARRAY:
lua_newtable(L);
bson_iterator s;
bson_iterator_subiterator(b,&s);
bson_decode_tree(L,&s,1);
break;
default:
break;
}
if(set_t)
{
lua_settable(L,-3);
}
}
}
mongo_cursor* gridfile_get_chunks(gridfile* gfile, int start, int size)
{
bson_iterator it;
bson_oid_t id;
bson_buffer gte_buf;
bson gte_bson;
bson_buffer query_buf;
bson query_bson;
bson_buffer orderby_buf;
bson orderby_bson;
bson_buffer command_buf;
bson command_bson;
bson_type type;
char *id_str;
int id_int;
type = bson_find(&it, gfile->meta, "_id");
if( type == bson_oid ) {
id = *bson_iterator_oid(&it);
bson_buffer_init(&query_buf);
bson_append_oid(&query_buf, "files_id", &id);
} else if (type == bson_string) {
id_str = bson_iterator_string(&it);
bson_buffer_init(&query_buf);
bson_append_string(&query_buf, "files_id", id_str);
} else if (type == bson_string) {
id_int = bson_iterator_int(&it);
bson_buffer_init(&query_buf);
bson_append_int(&query_buf, "files_id", id_int);
} else return NULL;
if (size == 1) {
bson_append_int(&query_buf, "n", start);
} else {
bson_buffer_init(>e_buf);
bson_append_int(>e_buf, "$gte", start);
bson_from_buffer(>e_bson, >e_buf);
bson_append_bson(&query_buf, "n", >e_bson);
}
bson_from_buffer(&query_bson, &query_buf);
bson_buffer_init(&orderby_buf);
bson_append_int(&orderby_buf, "n", 1);
bson_from_buffer(&orderby_bson, &orderby_buf);
bson_buffer_init(&command_buf);
bson_append_bson(&command_buf, "query", &query_bson);
bson_append_bson(&command_buf, "orderby", &orderby_bson);
bson_from_buffer(&command_bson, &command_buf);
return mongo_find(gfile->gfs->client, gfile->gfs->chunks_ns,
&command_bson, NULL, size, 0, 0);
}
//------------------------------------------------------------------------------
int main( int argc, char * argv[] ){
mongo conn;
if( mongo_client( &conn , TEST_SERVER, TEST_PORT ) != MONGO_OK ) {
std::cout << "failed to connect\n";
return EXIT_FAILURE;
}
mongo_cursor cursor;
mongo_cursor_init( &cursor, &conn, "test.test" );
char hex_oid[25];
while( mongo_cursor_next( &cursor ) == MONGO_OK ) {
std::cout << "row:\n";
bson_iterator it;
bson_iterator_init( &it, mongo_cursor_bson( &cursor ) );
while( bson_iterator_next( &it ) ) {
std::cout << " " << bson_iterator_key( &it ) << " = ";
switch( bson_iterator_type( &it ) ) {
case BSON_DOUBLE:
std::cout << "(double) " << bson_iterator_double( &it ) << std::endl;
break;
case BSON_INT:
std::cout << "(int) " << bson_iterator_int( &it ) << std::endl;
break;
case BSON_STRING:
std::cout << "(string) \"" << bson_iterator_string( &it ) << "\"\n";
break;
case BSON_OID:
bson_oid_to_string( bson_iterator_oid( &it ), hex_oid );
std::cout << "(oid) \"" << hex_oid << "\"\n";
break;
case BSON_OBJECT:
std::cout << "(subobject) {...}\n";
break;
case BSON_ARRAY:
std::cout << "(array) [...]\n";
break;
case BSON_TIMESTAMP:
std::cout << "(timestamp) [...]\n";
break;
default:
std::cout << "(type " << bson_iterator_type( &it ) << std::endl;
break;
}
}
std::cout << std::endl;
}
mongo_disconnect( &conn );
return EXIT_SUCCESS;
}
void MongodbObject::EnableForEdit()
{
bson *newObject = new bson();
bson_init(newObject);
bson_iterator it;
bson_iterator_init(&it, objectData->object);
while (bson_iterator_next(&it))
{
const char * key = bson_iterator_key(&it);
bson_type type = bson_iterator_type(&it);
switch (type)
{
case BSON_STRING:
bson_append_string(newObject, key, bson_iterator_string(&it));
break;
case BSON_INT:
bson_append_int(newObject, key, bson_iterator_int(&it));
break;
case BSON_LONG:
bson_append_long(newObject, key, bson_iterator_long(&it));
break;
case BSON_DOUBLE:
bson_append_double(newObject, key, bson_iterator_double(&it));
break;
case BSON_OBJECT:
bson sub;
bson_iterator_subobject(&it, &sub);
bson_append_bson(newObject, key, &sub);
break;
case BSON_OID:
bson_append_oid(newObject, key, bson_iterator_oid(&it));
break;
default:
break;
}
}
bson_destroy(objectData->object);
SafeDelete(objectData->object);
objectData->object = newObject;
}
bson_bool_t mongo_cmd_authenticate( mongo *conn, const char *db, const char *user, const char *pass ) {
bson from_db;
bson cmd;
bson out;
const char *nonce;
bson_bool_t success = 0;
mongo_md5_state_t st;
mongo_md5_byte_t digest[16];
char hex_digest[33];
if( mongo_simple_int_command( conn, db, "getnonce", 1, &from_db ) == MONGO_OK ) {
bson_iterator it;
bson_find( &it, &from_db, "nonce" );
nonce = bson_iterator_string( &it );
} else {
return MONGO_ERROR;
}
mongo_pass_digest( user, pass, hex_digest );
mongo_md5_init( &st );
mongo_md5_append( &st, ( const mongo_md5_byte_t * )nonce, strlen( nonce ) );
mongo_md5_append( &st, ( const mongo_md5_byte_t * )user, strlen( user ) );
mongo_md5_append( &st, ( const mongo_md5_byte_t * )hex_digest, 32 );
mongo_md5_finish( &st, digest );
digest2hex( digest, hex_digest );
bson_init( &cmd );
bson_append_int( &cmd, "authenticate", 1 );
bson_append_string( &cmd, "user", user );
bson_append_string( &cmd, "nonce", nonce );
bson_append_string( &cmd, "key", hex_digest );
bson_finish( &cmd );
bson_destroy( &from_db );
/*bson_init( &from_db ); */
if( mongo_run_command( conn, db, &cmd, &out ) == MONGO_OK ) {
bson_iterator it;
if( bson_find( &it, &out, "ok" ) )
success = bson_iterator_bool( &it );
}
bson_destroy( &from_db );
bson_destroy( &cmd );
if( success )
return MONGO_OK;
else
return MONGO_ERROR;
}
SEXP mongo_get_database_collections(SEXP mongo_conn, SEXP db) {
mongo* conn = _checkMongo(mongo_conn);
const char* _db = CHAR(STRING_ELT(db, 0));
int len = strlen(_db);
char ns[512];
strcpy(ns, _db);
strcpy(ns+len, ".system.namespaces");
bson empty;
bson_empty(&empty);
mongo_cursor* cursor = mongo_find(conn, ns, NULL, &empty, 0, 0, 0);
int count = 0;
while (cursor && mongo_cursor_next(cursor) == MONGO_OK) {
bson_iterator iter;
if (bson_find(&iter, &cursor->current, "name")) {
const char* name = bson_iterator_string(&iter);
if (strstr(name, ".system.") || strchr(name, '$'))
continue;
++count;
}
}
mongo_cursor_destroy(cursor);
cursor = mongo_find(conn, ns, &empty, &empty, 0, 0, 0);
SEXP ret;
PROTECT(ret = allocVector(STRSXP, count));
int i = 0;
while (cursor && mongo_cursor_next(cursor) == MONGO_OK) {
bson_iterator iter;
if (bson_find(&iter, &cursor->current, "name")) {
const char* name = bson_iterator_string(&iter);
if (strstr(name, ".system.") || strchr(name, '$'))
continue;
SET_STRING_ELT(ret, i++, mkChar(name));
}
}
mongo_cursor_destroy(cursor);
UNPROTECT(1);
return ret;
}
void InitWith(bson *obj)
{
bson_iterator it;
bson_iterator_init(&it, obj);
while (bson_iterator_next(&it))
{
const char * key = bson_iterator_key(&it);
bson_type type = bson_iterator_type(&it);
switch (type)
{
case BSON_STRING:
bson_append_string(object, key, bson_iterator_string(&it));
break;
case BSON_INT:
bson_append_int(object, key, bson_iterator_int(&it));
break;
case BSON_LONG:
bson_append_long(object, key, bson_iterator_long(&it));
break;
case BSON_DOUBLE:
bson_append_double(object, key, bson_iterator_double(&it));
break;
case BSON_OBJECT:
{
bson sub;
bson_iterator_subobject(&it, &sub);
bson_append_bson(object, key, &sub);
break;
}
case BSON_OID:
bson_append_oid(object, key, bson_iterator_oid(&it));
break;
default:
DVASSERT(false);
Logger::Error("[MongodbObjectInternalData::InitWith] Not implemented type: %d", type);
break;
}
}
}
static apr_status_t fetch_mongodb_value(const char *host, int port,
const char *userfield, const char *passwordfield, const char *collection,
const char *user, char **value,
apr_pool_t *pool)
{
mongo_connection conn; /* ptr */
mongo_connection_options *opts;
mongo_conn_return mongo_status;
bson query[1];
bson *out;
bson_buffer query_buf[1];
bson_bool_t found;
mongo_cursor *cursor;
*value = NULL;
//conn = apr_palloc( pool, sizeof(mongo_connection));
opts = apr_palloc( pool, sizeof(mongo_connection_options));
strcpy( opts->host, host);
opts->port = port;
mongo_status = mongo_connect( pool, &conn, opts );
if ( mongo_status != mongo_conn_success) {
char buf[120];
ap_log_perror(APLOG_MARK, APLOG_ERR, 0, pool,"couldn't connect to mongoDB - (%s)", mongo_strerror( mongo_status, buf,sizeof(buf) ));
return APR_EGENERAL;
}
bson_buffer_init( pool, query_buf );
bson_append_string( query_buf, userfield, user);
bson_from_buffer( query, query_buf );
out = apr_palloc(pool, sizeof(bson));
found = mongo_find_one( &conn, collection, query, NULL, out );
bson_destroy( query );
if ( found ) {
bson_iterator it;
if (bson_find( &it, out, passwordfield )) {
// bson_iterator iCookies;
// bson_iterator_init( &iCookies , bson_iterator_value(&it));
*value = apr_pstrdup( pool,bson_iterator_string(&it));
}
}
mongo_destroy( &conn );
return APR_SUCCESS;
}
String MongodbObject::GetString(const String &fieldname)
{
String retValue = String("");
bson_iterator it;
bson_iterator_init(&it, objectData->object);
bson_iterator foundIt;
bool found = objectData->FindField(&it, &foundIt, fieldname, true);
if(found)
{
retValue = bson_iterator_string(&foundIt);
}
return retValue;
}
static void mongo_replset_check_seed( mongo_connection* conn ) {
bson out;
bson hosts;
const char* data;
bson_iterator it;
bson_iterator it_sub;
const char* host_string;
mongo_host_port *host_port = NULL;
out.data = NULL;
out.owned = 1;
hosts.data = NULL;
hosts.owned = 1;
if( mongo_simple_int_command(conn, "admin", "ismaster", 1, &out) == MONGO_OK ) {
if( bson_find( &it, &out, "hosts" ) ) {
data = bson_iterator_value( &it );
bson_iterator_init( &it_sub, data );
/* Iterate over host list, adding each host to the
* connection's host list. */
while( bson_iterator_next( &it_sub ) ) {
host_string = bson_iterator_string( &it_sub );
host_port = bson_malloc( sizeof( mongo_host_port ) );
mongo_parse_host( host_string, host_port );
if( host_port ) {
mongo_replset_add_node( &conn->replset->hosts,
host_port->host, host_port->port );
free( host_port );
host_port = NULL;
}
}
}
}
bson_destroy( &out );
bson_destroy( &hosts );
mongo_close_socket( conn->sock );
conn->sock = 0;
conn->connected = 0;
}
static int gridfs_insert_file2( gridfs *gfs, const char *name,
const bson_oid_t id, gridfs_offset length,
const char *contenttype, gridfile* gfile ) {
bson command;
bson ret;
bson res;
bson_iterator it;
int result;
int64_t d;
/* Check run md5 */
bson_init( &command );
bson_append_oid( &command, "filemd5", &id );
bson_append_string( &command, "root", gfs->prefix );
bson_finish( &command );
result = mongo_run_command( gfs->client, gfs->dbname, &command, &res );
bson_destroy( &command );
if (result != MONGO_OK)
return result;
/* Create and insert BSON for file metadata */
bson_init( &ret );
bson_append_oid( &ret, "_id", &id );
if ( name != NULL && *name != '\0' ) {
bson_append_string( &ret, "filename", name );
}
bson_append_long( &ret, "length", length );
bson_append_int( &ret, "chunkSize", DEFAULT_CHUNK_SIZE );
d = ( bson_date_t )1000*time( NULL );
bson_append_date( &ret, "uploadDate", d);
bson_find( &it, &res, "md5" );
bson_append_string( &ret, "md5", bson_iterator_string( &it ) );
bson_destroy( &res );
if ( contenttype != NULL && *contenttype != '\0' ) {
bson_append_string( &ret, "contentType", contenttype );
}
bson_append_bson(&ret, "metadata", gfile->meta);
bson_finish( &ret );
result = mongo_insert( gfs->client, gfs->files_ns, &ret );
bson_destroy( &ret );
return result;
}
MONGO_EXPORT int32_t mongo_run_command(mongo *conn, const char* db,
const bson *command, bson *out)
{
bson response[1];
bson_iterator it[1];
size_t sl = fibjs::qstrlen(db);
char *ns = (char *) bson_malloc(sl + 5 + 1);
int32_t res = 0;
strcpy(ns, db);
strcpy(ns + sl, ".$cmd");
res = mongo_find_one(conn, ns, command, bson_shared_empty(), response);
bson_free(ns);
if (res == MONGO_OK
&& (!bson_find(it, response, "ok") || !bson_iterator_bool(it)))
{
if (bson_find(it, response, "errmsg"))
{
int32_t result_len = bson_iterator_string_len(it);
const char *result_string = bson_iterator_string(it);
int32_t len = result_len < MONGO_ERR_LEN ? result_len : MONGO_ERR_LEN;
memcpy(conn->lasterrstr, result_string, len);
conn->lasterrcode = -1;
}
else
conn->err = MONGO_COMMAND_FAILED;
bson_destroy(response);
res = MONGO_ERROR;
}
if (out)
if (res == MONGO_OK)
*out = *response;
else
bson_init_zero(out);
else if (res == MONGO_OK)
bson_destroy(response);
return res;
}
char *mongodb_retrieve_key(bot_t * bot, char *db, char *key, char *which)
{
char *str = NULL;
bson b;
mongo_cursor cursor;
if (!db || !key || !which) {
return NULL;
}
debug(bot,
"mongodb_retrieve_key: Entered :db=%s. key=%s, which=%s\n", db,
key, which);
bson_init(&b);
bson_append_string(&b, "key", key);
bson_finish(&b);
mongo_cursor_init(&cursor, &gi->mongo_conn, db);
mongo_cursor_set_query(&cursor, &b);
if (mongo_cursor_next(&cursor) == MONGO_OK) {
bson_iterator i;
debug(bot, "mongodb_retrieve_key: Found!\n");
if (bson_find(&i, mongo_cursor_bson(&cursor), which)) {
str = (char *)bson_iterator_string(&i);
str = strdup(str);
}
bson_destroy(&b);
mongo_cursor_destroy(&cursor);
return str;
}
debug(bot, "mongodb_retrieve_key: Key not found\n");
bson_destroy(&b);
mongo_cursor_destroy(&cursor);
return NULL;
}
static void tutorial_simple_query( mongo *conn ) {
bson query[1];
mongo_cursor cursor[1];
bson_init( query );
bson_append_int( query, "age", 24 );
bson_finish( query );
mongo_cursor_init( cursor, conn, "tutorial.persons" );
mongo_cursor_set_query( cursor, query );
while( mongo_cursor_next( cursor ) == MONGO_OK ) {
bson_iterator iterator[1];
if ( bson_find( iterator, mongo_cursor_bson( cursor ), "name" )) {
printf( "name: %s\n", bson_iterator_string( iterator ) );
}
}
bson_destroy( query );
mongo_cursor_destroy( cursor );
}
static bson gridfs_insert_file( gridfs* gfs, const char* name,
const bson_oid_t id, gridfs_offset length,
const char* contenttype)
{
bson command;
bson res;
bson ret;
bson_buffer buf;
bson_iterator it;
/* Check run md5 */
bson_buffer_init(&buf);
bson_append_oid(&buf, "filemd5", &id);
bson_append_string(&buf, "root", gfs->prefix);
bson_from_buffer(&command, &buf);
assert(mongo_run_command(gfs->client, gfs->dbname,
&command, &res));
bson_destroy(&command);
/* Create and insert BSON for file metadata */
bson_buffer_init(&buf);
bson_append_oid(&buf, "_id", &id);
if (name != NULL && *name != '\0') {
bson_append_string(&buf, "filename", name);
}
bson_append_int(&buf, "length", length);
bson_append_int(&buf, "chunkSize", DEFAULT_CHUNK_SIZE);
bson_append_date(&buf, "uploadDate", (bson_date_t)1000*time(NULL));
bson_find(&it, &res, "md5");
bson_append_string(&buf, "md5", bson_iterator_string(&it));
bson_destroy(&res);
if (contenttype != NULL && *contenttype != '\0') {
bson_append_string(&buf, "contentType", contenttype);
}
bson_from_buffer(&ret, &buf);
mongo_insert(gfs->client, gfs->files_ns, &ret);
return ret;
}
void bson_print_raw( const char * data , int depth ){
bson_iterator i;
const char * key;
int temp;
bson_timestamp_t ts;
char oidhex[25];
bson_iterator_init( &i , data );
while ( bson_iterator_next( &i ) ){
bson_type t = bson_iterator_type( &i );
if ( t == 0 )
break;
key = bson_iterator_key( &i );
for ( temp=0; temp<=depth; temp++ )
printf( "\t" );
printf( "%s : %d \t " , key , t );
switch ( t ){
case bson_int: printf( "%d" , bson_iterator_int( &i ) ); break;
case bson_double: printf( "%f" , bson_iterator_double( &i ) ); break;
case bson_bool: printf( "%s" , bson_iterator_bool( &i ) ? "true" : "false" ); break;
case bson_string: printf( "%s" , bson_iterator_string( &i ) ); break;
case bson_null: printf( "null" ); break;
case bson_oid: bson_oid_to_string(bson_iterator_oid(&i), oidhex); printf( "%s" , oidhex ); break;
case bson_timestamp:
ts = bson_iterator_timestamp( &i );
printf("i: %d, t: %d", ts.i, ts.t);
break;
case bson_object:
case bson_array:
printf( "\n" );
bson_print_raw( bson_iterator_value( &i ) , depth + 1 );
break;
default:
fprintf( stderr , "can't print type : %d\n" , t );
}
printf( "\n" );
}
}
clsSiteData::clsSiteData(int id, const bson *info)
{
m_ID = id;
bson_iterator it[1];
bson_iterator_init(it, info);
while (bson_iterator_next(it))
{
if (strcmp("Name", bson_iterator_key(it)) == 0)
m_Name = bson_iterator_string(it);
//else if(strcmp("AREA", bson_iterator_key(it)) == 0)
// m_Area = (float)bson_iterator_double(it);
else if (strcmp("LocalX", bson_iterator_key(it)) == 0)
m_XPR = (float) bson_iterator_double(it);
else if (strcmp("LocalY", bson_iterator_key(it)) == 0)
m_YPR = (float) bson_iterator_double(it);
else if (strcmp("Lat", bson_iterator_key(it)) == 0)
m_Latitude = (float) bson_iterator_double(it);
else if (strcmp("Long", bson_iterator_key(it)) == 0)
m_Longitude = (float) bson_iterator_double(it);
else if (strcmp("Elevation", bson_iterator_key(it)) == 0)
m_Elevation = (float) bson_iterator_double(it);
}
}
static int mongo_cmd_get_error_helper( mongo *conn, const char *db,
bson *realout, const char *cmdtype ) {
bson out = {NULL,0};
bson_bool_t haserror = 0;
/* Reset last error codes. */
conn->lasterrcode = 0;
bson_free( conn->lasterrstr );
conn->lasterrstr = NULL;
/* If there's an error, store its code and string in the connection object. */
if( mongo_simple_int_command( conn, db, cmdtype, 1, &out ) == MONGO_OK ) {
bson_iterator it;
haserror = ( bson_find( &it, &out, "err" ) != BSON_NULL );
if( haserror ) {
conn->lasterrstr = ( char * )bson_malloc( bson_iterator_string_len( &it ) );
if( conn->lasterrstr ) {
strcpy( conn->lasterrstr, bson_iterator_string( &it ) );
}
if( bson_find( &it, &out, "code" ) != BSON_NULL )
conn->lasterrcode = bson_iterator_int( &it );
}
}
if( realout )
*realout = out; /* transfer of ownership */
else
bson_destroy( &out );
if( haserror )
return MONGO_ERROR;
else
return MONGO_OK;
}
void bson_print_raw( const char *data , int depth ) {
bson_iterator i;
const char *key;
int temp;
bson_timestamp_t ts;
char oidhex[25];
bson scope;
bson_iterator_from_buffer( &i, data );
while ( bson_iterator_next( &i ) ) {
bson_type t = bson_iterator_type( &i );
if ( t == 0 )
break;
key = bson_iterator_key( &i );
for ( temp=0; temp<=depth; temp++ )
printf( "\t" );
bson_printf( "%s : %d \t " , key , t );
switch ( t ) {
case BSON_DOUBLE:
printf( "%f" , bson_iterator_double( &i ) );
break;
case BSON_STRING:
printf( "%s" , bson_iterator_string( &i ) );
break;
case BSON_SYMBOL:
printf( "SYMBOL: %s" , bson_iterator_string( &i ) );
break;
case BSON_OID:
bson_oid_to_string( bson_iterator_oid( &i ), oidhex );
printf( "%s" , oidhex );
break;
case BSON_BOOL:
printf( "%s" , bson_iterator_bool( &i ) ? "true" : "false" );
break;
case BSON_DATE:
printf( "%ld" , ( long int )bson_iterator_date( &i ) );
break;
case BSON_BINDATA:
printf( "BSON_BINDATA" );
break;
case BSON_UNDEFINED:
printf( "BSON_UNDEFINED" );
break;
case BSON_NULL:
printf( "BSON_NULL" );
break;
case BSON_REGEX:
printf( "BSON_REGEX: %s", bson_iterator_regex( &i ) );
break;
case BSON_CODE:
printf( "BSON_CODE: %s", bson_iterator_code( &i ) );
break;
case BSON_CODEWSCOPE:
printf( "BSON_CODE_W_SCOPE: %s", bson_iterator_code( &i ) );
bson_init( &scope );
bson_iterator_code_scope( &i, &scope );
printf( "\n\t SCOPE: " );
bson_print( &scope );
break;
case BSON_INT:
printf( "%d" , bson_iterator_int( &i ) );
break;
case BSON_LONG:
printf( "%lld" , ( long long int )bson_iterator_long( &i ) );
break;
case BSON_TIMESTAMP:
ts = bson_iterator_timestamp( &i );
printf( "i: %d, t: %d", ts.i, ts.t );
break;
case BSON_OBJECT:
case BSON_ARRAY:
printf( "\n" );
bson_print_raw( bson_iterator_value( &i ) , depth + 1 );
break;
default:
bson_errprintf( "can't print type : %d\n" , t );
}
printf( "\n" );
}
}
void testCheckDuplicates(void) {
bson bs, bs2;
bson_iterator it;
bson_type bt;
bson_init(&bs);
bson_append_string(&bs, "a", "a");
bson_append_int(&bs, "b", 2);
bson_append_null(&bs, "c");
bson_append_start_object(&bs, "d");
bson_append_string(&bs, "a", "a");
bson_append_int(&bs, "e", 0);
bson_append_int(&bs, "d", 1);
bson_append_finish_object(&bs);
bson_finish(&bs);
CU_ASSERT_FALSE_FATAL(bs.err);
CU_ASSERT_FALSE(bson_check_duplicate_keys(&bs));
bson_destroy(&bs);
bson_init(&bs);
bson_append_string(&bs, "a", "a");
bson_append_int(&bs, "b", 2);
bson_append_null(&bs, "c");
bson_append_start_object(&bs, "d");
bson_append_string(&bs, "a", "a");
bson_append_int(&bs, "e", 0);
bson_append_int(&bs, "e", 1);
bson_append_finish_object(&bs);
bson_finish(&bs);
CU_ASSERT_FALSE_FATAL(bs.err);
CU_ASSERT_TRUE(bson_check_duplicate_keys(&bs));
bson_init(&bs2);
bson_fix_duplicate_keys(&bs, &bs2);
bson_finish(&bs2);
CU_ASSERT_FALSE(bson_check_duplicate_keys(&bs2));
BSON_ITERATOR_INIT(&it, &bs2);
bt = bson_find_fieldpath_value("d.e", &it);
CU_ASSERT_TRUE(BSON_IS_NUM_TYPE(bt));
CU_ASSERT_EQUAL(bson_iterator_int(&it), 1);
bson_destroy(&bs2);
bson_init(&bs);
bson_append_string(&bs, "a", "a");
bson_append_int(&bs, "b", 2);
bson_append_null(&bs, "c");
bson_append_start_object(&bs, "d");
bson_append_string(&bs, "a", "a");
bson_append_int(&bs, "e", 0);
bson_append_int(&bs, "d", 1);
bson_append_finish_object(&bs);
bson_append_start_array(&bs, "f");
bson_append_start_object(&bs, "0");
bson_append_string(&bs, "a", "a");
bson_append_string(&bs, "b", "b");
bson_append_int(&bs, "c", 1);
bson_append_finish_object(&bs);
bson_append_start_object(&bs, "1");
bson_append_string(&bs, "a", "a");
bson_append_string(&bs, "b", "b");
bson_append_int(&bs, "c", 1);
bson_append_finish_object(&bs);
bson_append_finish_array(&bs);
bson_finish(&bs);
CU_ASSERT_FALSE_FATAL(bs.err);
CU_ASSERT_FALSE(bson_check_duplicate_keys(&bs));
bson_init(&bs);
bson_append_string(&bs, "a", "a");
bson_append_int(&bs, "b", 2);
bson_append_null(&bs, "c");
bson_append_start_object(&bs, "d");
bson_append_string(&bs, "a", "a");
bson_append_int(&bs, "e", 0);
bson_append_int(&bs, "d", 1);
bson_append_start_object(&bs, "q");
bson_append_int(&bs, "w", 0);
bson_append_finish_object(&bs);
bson_append_finish_object(&bs);
bson_append_start_array(&bs, "f");
bson_append_start_object(&bs, "0");
bson_append_string(&bs, "a", "a");
bson_append_string(&bs, "b", "b");
bson_append_int(&bs, "a", 1);
bson_append_finish_object(&bs);
bson_append_start_object(&bs, "1");
bson_append_string(&bs, "a", "a");
bson_append_string(&bs, "b", "b");
bson_append_int(&bs, "c", 1);
bson_append_finish_object(&bs);
bson_append_finish_array(&bs);
bson_append_start_object(&bs, "a");
bson_append_finish_object(&bs);
bson_append_start_object(&bs, "d");
bson_append_start_object(&bs, "q");
bson_append_int(&bs, "e", 1);
bson_append_finish_object(&bs);
bson_append_finish_object(&bs);
bson_finish(&bs);
CU_ASSERT_FALSE_FATAL(bs.err);
CU_ASSERT_TRUE(bson_check_duplicate_keys(&bs));
bson_init(&bs2);
bson_fix_duplicate_keys(&bs, &bs2);
bson_finish(&bs2);
CU_ASSERT_FALSE(bson_check_duplicate_keys(&bs2));
BSON_ITERATOR_INIT(&it, &bs2);
bt = bson_find_fieldpath_value("f.0.a", &it);
CU_ASSERT_TRUE(BSON_IS_NUM_TYPE(bt));
CU_ASSERT_EQUAL(bson_iterator_int(&it), 1);
BSON_ITERATOR_INIT(&it, &bs2);
bt = bson_find_fieldpath_value("f.1.a", &it);
CU_ASSERT_TRUE(BSON_IS_STRING_TYPE(bt));
CU_ASSERT_FALSE(strcmp(bson_iterator_string(&it), "a"));
BSON_ITERATOR_INIT(&it, &bs2);
bt = bson_find_fieldpath_value("a", &it);
CU_ASSERT_EQUAL(bt, BSON_OBJECT);
BSON_ITERATOR_INIT(&it, &bs2);
bt = bson_find_fieldpath_value("d.q.w", &it);
CU_ASSERT_TRUE(BSON_IS_NUM_TYPE(bt));
CU_ASSERT_EQUAL(bson_iterator_int(&it), 0);
BSON_ITERATOR_INIT(&it, &bs2);
bt = bson_find_fieldpath_value("d.q.e", &it);
CU_ASSERT_TRUE(BSON_IS_NUM_TYPE(bt));
CU_ASSERT_EQUAL(bson_iterator_int(&it), 1);
}
static int mongo_cursor_op_query( mongo_cursor *cursor ) {
int res;
bson empty;
char *data;
mongo_message *mm;
bson temp;
bson_iterator it;
/* Clear any errors. */
bson_free( cursor->conn->lasterrstr );
cursor->conn->lasterrstr = NULL;
cursor->conn->lasterrcode = 0;
cursor->conn->err = 0;
cursor->err = 0;
/* Set up default values for query and fields, if necessary. */
if( ! cursor->query )
cursor->query = bson_empty( &empty );
else if( mongo_cursor_bson_valid( cursor, cursor->query ) != MONGO_OK )
return MONGO_ERROR;
if( ! cursor->fields )
cursor->fields = bson_empty( &empty );
else if( mongo_cursor_bson_valid( cursor, cursor->fields ) != MONGO_OK )
return MONGO_ERROR;
mm = mongo_message_create( 16 + /* header */
4 + /* options */
strlen( cursor->ns ) + 1 + /* ns */
4 + 4 + /* skip,return */
bson_size( cursor->query ) +
bson_size( cursor->fields ) ,
0 , 0 , MONGO_OP_QUERY );
data = &mm->data;
data = mongo_data_append32( data , &cursor->options );
data = mongo_data_append( data , cursor->ns , strlen( cursor->ns ) + 1 );
data = mongo_data_append32( data , &cursor->skip );
data = mongo_data_append32( data , &cursor->limit );
data = mongo_data_append( data , cursor->query->data , bson_size( cursor->query ) );
if ( cursor->fields )
data = mongo_data_append( data , cursor->fields->data , bson_size( cursor->fields ) );
bson_fatal_msg( ( data == ( ( char * )mm ) + mm->head.len ), "query building fail!" );
res = mongo_message_send( cursor->conn , mm );
if( res != MONGO_OK ) {
return MONGO_ERROR;
}
res = mongo_read_response( cursor->conn, ( mongo_reply ** )&( cursor->reply ) );
if( res != MONGO_OK ) {
return MONGO_ERROR;
}
if( cursor->reply->fields.num == 1 ) {
bson_init_data( &temp, &cursor->reply->objs );
if( bson_find( &it, &temp, "$err" ) ) {
cursor->conn->lasterrstr =
(char *)bson_malloc( bson_iterator_string_len( &it ) );
strcpy( cursor->conn->lasterrstr, bson_iterator_string( &it ) );
bson_find( &it, &temp, "code" );
cursor->conn->lasterrcode = bson_iterator_int( &it );
cursor->err = MONGO_CURSOR_QUERY_FAIL;
return MONGO_ERROR;
}
}
cursor->seen += cursor->reply->fields.num;
cursor->flags |= MONGO_CURSOR_QUERY_SENT;
return MONGO_OK;
}
uint8_t
XTDBUpdate(XTDBHandle* handle,bson* query,bson* newVal,uint8_t upsert) {
XTDBCursor* cur ;
BinaryStr key,value,newValueStr;
uint8_t updated = False,ret=True;
int nUpdated = 0;
bson_oid_t oid;
bson withOid;
int isMod;
XTDBUpdateStatus status;
status.upserted = False;
_S_FN(update);
handle->lastOp = XTDB_OP_UPDATE;
if (!(cur = XTDBFind(handle,query))) {
return False;
}
BsonToBStr(newVal,&newValueStr);
if ((handle->error = ObjModValidateValBson(newVal,&isMod))) {
return False;
}
while (XTDBCursorNextBStr(cur,&key,&value)) {
handle->gen++;
//updated = True;
// retain the oid with new object
if (!isMod) {
memcpy(oid.bytes,key.data,sizeof(oid.bytes));
if(!XTDBBsonAppendOid(handle,newVal,&withOid,&oid)) {
return False;
}
} else {
bson obj;
bson error;
bson outObj;
BStrToBson(&value,&obj);
handle->error = ObjModifyBson(&obj,newVal,&withOid,&error);
if (handle->error) {
bson_iterator itr;
bson_iterator_init(&itr,&error);
bson_find(&itr,&error,"error");
strncpy(handle->errorString,bson_iterator_string(&itr),sizeof(handle->errorString));
bson_destroy(&error);
return False;
}
}
BsonToBStr(&withOid,&newValueStr);
// Remove entry from index and re-insert
if (!XTDBUpdateIndex(handle,&key,&newValueStr,&value)) {
XTDBCursorFree(cur);
BinaryStrFree(&key);
BinaryStrFree(&value);
bson_destroy(&withOid);
return False;
}
//XTDBInsertToIndex(handle,&key,&newValueStr);
//XTDBRemoveFromIndex(handle,&key,&value);
if (!DBSet(handle->mainDB,&key,&newValueStr,False)) {
XTDBCursorFree(cur);
BinaryStrFree(&key);
BinaryStrFree(&value);
bson_destroy(&withOid);
handle->error = DBGetLastError(handle->mainDB);
return False;
}
BinaryStrFree(&key);
BinaryStrFree(&value);
bson_destroy(&withOid);
nUpdated++;
}
if (cur->error != XTDB_OK) {
handle->error = cur->error;
return False;
}
if ( !nUpdated && upsert) {
ret = XTDBInsert(handle,newVal);
memcpy(&status.newOid,&handle->status.insertStatus.newOid,sizeof(status.newOid));
status.upserted = True;
nUpdated = 1;
}
status.nUpdated = nUpdated;
handle->lastOp = XTDB_OP_UPDATE;
handle->status.updateStatus = status;
XTDBCursorFree(cur);
_E_FN(update);
return ret;
}
const char *gridfile_get_md5( gridfile *gfile ) {
bson_iterator it;
bson_find( &it, gfile->meta, "md5" );
return bson_iterator_string( &it );
}
void testBSONExportImport2(void) {
EJDB *jb = ejdbnew();
CU_ASSERT_TRUE_FATAL(ejdbopen(jb, "dbt4_export", JBOWRITER | JBOCREAT | JBOTRUNC));
EJCOLL *coll = ejdbcreatecoll(jb, "col1", NULL);
if (!coll) {
eprint(jb, __LINE__, "testBSONExportImport2");
}
CU_ASSERT_TRUE(coll != NULL);
bson_oid_t oid;
const char *log = NULL;
bson bv1;
bson_init(&bv1);
bson_append_int(&bv1, "a", 1);
bson_append_string(&bv1, "c", "d");
bson_finish(&bv1);
ejdbsavebson(coll, &bv1, &oid);
bson_destroy(&bv1);
EJCOLLOPTS copts = {0};
copts.large = true;
copts.records = 200000;
coll = ejdbcreatecoll(jb, "col2", &copts);
if (!coll) {
eprint(jb, __LINE__, "testBSONExportImport2");
}
CU_ASSERT_TRUE(coll != NULL);
CU_ASSERT_TRUE(ejdbsetindex(coll, "f", JBIDXSTR | JBIDXNUM));
bson_init(&bv1);
bson_append_int(&bv1, "e", 1);
bson_append_string(&bv1, "f", "g");
bson_finish(&bv1);
ejdbsavebson(coll, &bv1, &oid);
bson_destroy(&bv1);
bson_init(&bv1);
bson_append_int(&bv1, "e", 2);
bson_append_string(&bv1, "f", "g2");
bson_finish(&bv1);
ejdbsavebson(coll, &bv1, &oid);
bson_destroy(&bv1);
bson cmd;
bson_init(&cmd);
bson_append_start_object(&cmd, "export");
bson_append_string(&cmd, "path", "testBSONExportImport2");
bson_append_start_array(&cmd, "cnames");
bson_append_string(&cmd, "0", "col1");
bson_append_string(&cmd, "1", "col2");
bson_append_finish_array(&cmd);
bson_append_finish_object(&cmd);
bson_finish(&cmd);
bson *bret = ejdbcommand(jb, &cmd);
CU_ASSERT_PTR_NOT_NULL_FATAL(bret);
bson_destroy(&cmd);
bson_iterator it;
bson_iterator_init(&it, bret);
CU_ASSERT_TRUE(bson_find_fieldpath_value("error", &it) == BSON_EOO);
bson_iterator_init(&it, bret);
CU_ASSERT_TRUE(bson_compare_long(0, bson_data(bret), "errorCode") == 0);
bson_iterator_init(&it, bret);
CU_ASSERT_TRUE(bson_find_fieldpath_value("log", &it) == BSON_STRING);
bson_del(bret);
bson *ometa = ejdbmeta(jb);
CU_ASSERT_TRUE_FATAL(ometa != NULL);
ejdbclose(jb);
ejdbdel(jb);
//Restore data:
jb = ejdbnew();
CU_ASSERT_TRUE_FATAL(ejdbopen(jb, "dbt4_export", JBOWRITER | JBOCREAT));
coll = ejdbgetcoll(jb, "col1");
CU_ASSERT_PTR_NOT_NULL_FATAL(coll);
bson_init(&bv1);
bson_append_int(&bv1, "e", 2);
bson_finish(&bv1);
CU_ASSERT_TRUE(ejdbsavebson(coll, &bv1, &oid));
bson_destroy(&bv1);
bson_init(&cmd);
bson_append_start_object(&cmd, "import");
bson_append_string(&cmd, "path", "testBSONExportImport2");
bson_append_int(&cmd, "mode", JBIMPORTREPLACE);
bson_append_start_array(&cmd, "cnames");
bson_append_string(&cmd, "0", "col1");
bson_append_string(&cmd, "1", "col2");
bson_append_finish_array(&cmd);
bson_append_finish_object(&cmd);
bson_finish(&cmd);
bret = ejdbcommand(jb, &cmd);
CU_ASSERT_PTR_NOT_NULL_FATAL(bret);
bson_destroy(&cmd);
bson_iterator_init(&it, bret);
CU_ASSERT_TRUE_FATAL(bson_find_fieldpath_value("log", &it) == BSON_STRING);
log = bson_iterator_string(&it);
CU_ASSERT_PTR_NOT_NULL(strstr(log, "Replacing all data in 'col1'"));
CU_ASSERT_PTR_NOT_NULL(strstr(log, "1 objects imported into 'col1'"));
CU_ASSERT_PTR_NOT_NULL(strstr(log, "2 objects imported into 'col2'"));
bson_del(bret);
log = NULL;
bson *nmeta = ejdbmeta(jb);
CU_ASSERT_TRUE_FATAL(nmeta != NULL);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.0.name", strlen("collections.0.name")) == 0);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.0.records", strlen("collections.0.records")) == 0);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.name", strlen("collections.1.name")) == 0);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.records", strlen("collections.1.records")) == 0);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.options.buckets", strlen("collections.1.options.buckets")) == 0);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.options.large", strlen("collections.1.options.large")) == 0);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.indexes.0.field", strlen("collections.1.indexes.0.field")) == 0);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.indexes.0.type", strlen("collections.1.indexes.0.type")) == 0);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.indexes.0.records", strlen("collections.1.indexes.0.records")) == 0);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.indexes.1.field", strlen("collections.1.indexes.1.field")) == 0);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.indexes.1.type", strlen("collections.1.indexes.1.type")) == 0);
CU_ASSERT_TRUE(bson_compare(bson_data(ometa), bson_data(nmeta), "collections.1.indexes.1.records", strlen("collections.1.indexes.1.records")) == 0);
ejdbclose(jb);
ejdbdel(jb);
jb = ejdbnew();
CU_ASSERT_TRUE_FATAL(ejdbopen(jb, "dbt4_export", JBOWRITER | JBOCREAT | JBOTRUNC));
coll = ejdbcreatecoll(jb, "col1", NULL);
CU_ASSERT_PTR_NOT_NULL_FATAL(coll);
bson_init(&bv1);
bson_append_int(&bv1, "e", 2);
bson_finish(&bv1);
CU_ASSERT_TRUE(ejdbsavebson(coll, &bv1, &oid));
EJQ *q = ejdbcreatequery(jb, &bv1, NULL, 0, NULL);
CU_ASSERT_PTR_NOT_NULL_FATAL(q);
uint32_t count = 0;
ejdbqryexecute(coll, q, &count, JBQRYCOUNT, NULL);
CU_ASSERT_EQUAL(count, 1);
bson_init(&cmd);
bson_append_start_object(&cmd, "import");
bson_append_string(&cmd, "path", "testBSONExportImport2");
bson_append_int(&cmd, "mode", JBIMPORTUPDATE);
bson_append_finish_object(&cmd);
bson_finish(&cmd);
bret = ejdbcommand(jb, &cmd);
CU_ASSERT_PTR_NOT_NULL_FATAL(bret);
bson_destroy(&cmd);
bson_del(bret);
coll = ejdbcreatecoll(jb, "col1", NULL);
ejdbqryexecute(coll, q, &count, JBQRYCOUNT, NULL);
CU_ASSERT_EQUAL(count, 1);
ejdbquerydel(q);
bson_destroy(&bv1);
ejdbclose(jb);
ejdbdel(jb);
bson_del(ometa);
bson_del(nmeta);
}
void to_json(char *buf, const char * data, int depth){
int array_count = 0;
int object_count = 0;
bson_iterator i;
const char * key;
char oidhex[25];
bson_iterator_init( &i , data );
sprintf(buf+strlen(buf),"{");
while ( bson_iterator_next( &i ) ){
bson_type t = bson_iterator_type( &i );
if ( t == 0 )
break;
key = bson_iterator_key( &i );
if(object_count > 0){sprintf(buf+strlen(buf),",");}
else{object_count=1;}
sprintf(buf+strlen(buf), "\"%s\":" , key );
switch ( t ){
case bson_int:
sprintf(buf+strlen(buf), "%d" , bson_iterator_int( &i ) );
break;
case bson_double:
sprintf(buf+strlen(buf), "%f" , bson_iterator_double( &i ) );
break;
case bson_bool:
sprintf(buf+strlen(buf), "%s" , bson_iterator_bool( &i ) ? "true" : "false" );
break;
case bson_string:
sprintf(buf+strlen(buf), "\"%s\"" , bson_iterator_string( &i ) );
break;
case bson_null:
sprintf( buf+strlen(buf),"null" );
break;
case bson_oid:
bson_oid_to_string(bson_iterator_oid(&i), oidhex);
sprintf(buf+strlen(buf), "%s" , oidhex );
break;
case bson_object:
to_json(buf, bson_iterator_value( &i ) , depth + 1 );
break;
case bson_array:
sprintf(buf+strlen(buf), "[" );
bson_iterator j;
bson_iterator_init( &j , bson_iterator_value(&i) );
array_count =0;
while( bson_iterator_next(&j)){
if(array_count > 0){sprintf(buf+strlen(buf),",");}
else{array_count=1;}
to_json(buf, bson_iterator_value( &j ) , depth + 1 );
}
sprintf(buf+strlen(buf), "]" );
break;
default:
fprintf( stderr , "can't print type : %d\n" , t );
}
}
sprintf(buf+strlen(buf),"}");
}
duo_code_t
duo_login(struct duo_ctx *ctx, const char *username,
const char *client_ip, int flags, const char *command)
{
bson obj;
bson_iterator it;
duo_code_t ret;
char buf[256];
char *pushinfo = NULL;
const char *p;
int i;
const char *local_ip;
if (username == NULL) {
_duo_seterr(ctx, "need username to authenticate");
return (DUO_CLIENT_ERROR);
}
/* Check preauth status */
if ((ret = _duo_preauth(ctx, &obj, username, client_ip)) != DUO_CONTINUE) {
return (ret);
}
/* Handle factor selection */
if ((ret = _duo_prompt(ctx, &obj, flags, buf, sizeof(buf), &p)) != DUO_CONTINUE) {
return (ret);
}
/* Add request parameters */
if (duo_add_param(ctx, "user", username) != DUO_OK ||
duo_add_param(ctx, "factor", "auto") != DUO_OK ||
duo_add_param(ctx, "auto", p) != DUO_OK ||
duo_add_param(ctx, "async",
(flags & DUO_FLAG_SYNC) ? "0" : "1") != DUO_OK) {
return (DUO_LIB_ERROR);
}
/* Add client IP, if passed in */
if (client_ip) {
if (duo_add_param(ctx, "ipaddr", client_ip) != DUO_OK) {
return (DUO_LIB_ERROR);
}
}
/* Add pushinfo parameters */
local_ip = duo_local_ip();
if (asprintf(&pushinfo, "Server+IP=%s&Command=%s",
local_ip, command ? urlenc_encode(command) : "") < 0 ||
duo_add_param(ctx, "pushinfo", pushinfo) != DUO_OK) {
return (DUO_LIB_ERROR);
}
free(pushinfo);
/* Try Duo authentication */
if ((ret = duo_call(ctx, "POST", DUO_API_VERSION "/auth.bson")) != DUO_OK ||
(ret = _duo_bson_response(ctx, &obj)) != DUO_OK) {
return (ret);
}
/* Handle sync status */
if ((flags & DUO_FLAG_SYNC) != 0) {
_BSON_FIND(ctx, &it, &obj, "status", bson_string);
if (ctx->conv_status != NULL) {
ctx->conv_status(ctx->conv_arg,
bson_iterator_string(&it));
}
_BSON_FIND(ctx, &it, &obj, "result", bson_string);
p = bson_iterator_string(&it);
if (strcasecmp(p, "allow") == 0) {
ret = DUO_OK;
} else if (strcasecmp(p, "deny") == 0) {
ret = DUO_FAIL;
} else {
_duo_seterr(ctx, "BSON invalid 'result': %s", p);
ret = DUO_SERVER_ERROR;
}
return (ret);
}
/* Async status - long-poll on txid */
_BSON_FIND(ctx, &it, &obj, "txid", bson_string);
p = bson_iterator_string(&it);
if (strlcpy(buf, p, sizeof(buf)) >= sizeof(buf)) {
return (DUO_LIB_ERROR);
}
/* XXX newline between prompt and async status lines */
if (ctx->conv_status != NULL)
ctx->conv_status(ctx->conv_arg, "");
ret = DUO_SERVER_ERROR;
for (i = 0; i < 20; i++) {
if ((ret = duo_add_param(ctx, "txid", buf)) != DUO_OK ||
(ret = duo_call(ctx, "GET",
DUO_API_VERSION "/status.bson")) != DUO_OK ||
(ret = _duo_bson_response(ctx, &obj)) != DUO_OK) {
break;
}
if (bson_find(&it, &obj, "status") == bson_string) {
if (ctx->conv_status != NULL)
ctx->conv_status(ctx->conv_arg,
bson_iterator_string(&it));
}
if (bson_find(&it, &obj, "result") == bson_string) {
p = bson_iterator_string(&it);
if (strcasecmp(p, "allow") == 0) {
ret = DUO_OK;
} else if (strcasecmp(p, "deny") == 0) {
ret = DUO_FAIL;
} else {
_duo_seterr(ctx, "BSON invalid 'result': %s",
p);
ret = DUO_SERVER_ERROR;
}
break;
}
}
return (ret);
}
INT32 migExport::_run( const CHAR *pCSName, const CHAR *pCLName, INT32 &total )
{
INT32 rc = SDB_OK ;
const CHAR *pTemp = NULL ;
bson obj ;
bson_iterator it ;
bson_type type ;
bson_init( &obj ) ;
if ( ( pCSName == NULL && pCLName == NULL ) ||
( pCSName == NULL && pCLName != NULL ) )
{
//never cs cl
rc = _getCSList() ;
if ( rc )
{
PD_LOG ( PDERROR, "Failed to get collection space list, rc = %d",
rc ) ;
goto error ;
}
while( TRUE )
{
rc = sdbNext( _gCSList, &obj ) ;
if ( rc )
{
if ( SDB_DMS_EOC != rc )
{
PD_LOG ( PDERROR, "Failed to get collection space list, rc = %d",
rc ) ;
goto error ;
}
else
{
rc = SDB_OK ;
goto done ;
}
}
type = bson_find( &it, &obj, "Name" ) ;
if ( type != BSON_STRING )
{
rc = SDB_SYS ;
PD_LOG ( PDERROR, "List collection space does not string, rc = %d",
rc ) ;
goto error ;
}
pTemp = bson_iterator_string( &it ) ;
rc = _run( pTemp, pCLName, total ) ;
if ( rc )
{
PD_LOG ( PDERROR, "Faild to call _run, rc = %d", rc ) ;
goto error ;
}
}
}
else if ( pCSName != NULL && pCLName == NULL )
{
//cs
rc = _getCLList() ;
if ( rc )
{
PD_LOG ( PDERROR, "Failed to get collection list, rc = %d",
rc ) ;
goto error ;
}
while ( TRUE )
{
rc = sdbNext( _gCLList, &obj ) ;
if ( rc )
{
if ( SDB_DMS_EOC != rc )
{
PD_LOG ( PDERROR, "Failed to get collection list, rc = %d",
rc ) ;
goto error ;
}
else
{
rc = SDB_OK ;
goto done ;
}
}
type = bson_find( &it, &obj, "Name" ) ;
if ( type != BSON_STRING )
{
rc = SDB_SYS ;
PD_LOG ( PDERROR, "List collection does not string, rc = %d",
rc ) ;
goto error ;
}
pTemp = bson_iterator_string( &it ) ;
rc = _run( pCSName, pTemp, total ) ;
if ( rc )
{
PD_LOG ( PDERROR, "Faild to call _run, rc = %d", rc ) ;
goto error ;
}
}
}
else
{
//cs and cl
rc = _exportCL( pCSName, pCLName, total ) ;
if ( rc )
{
PD_LOG ( PDERROR, "Faild to call _export, rc = %d", rc ) ;
goto error ;
}
}
done:
bson_destroy ( &obj ) ;
return rc ;
error:
goto done ;
}
/**
* \brief This function tries to load tag from MongoDB
*/
static void vs_mongo_tag_load_data(struct VSTag *tag,
bson *bson_tag)
{
bson_iterator tag_iter;
if( bson_find(&tag_iter, bson_tag, "data") == BSON_ARRAY) {
bson_iterator data_iter;
uint8 val_uint8;
uint16 val_uint16;
uint32 val_uint32;
uint64 val_uint64;
real32 val_real32;
real64 val_real64;
const char *str_value;
int value_index = 0;
bson_iterator_subiterator(&tag_iter, &data_iter);
/* Go through all values */
switch(tag->data_type) {
case VRS_VALUE_TYPE_UINT8:
while( bson_iterator_next(&data_iter) == BSON_INT ) {
val_uint8 = (uint8)bson_iterator_int(&data_iter);
vs_tag_set_values(tag, 1, value_index, &val_uint8);
value_index++;
}
break;
case VRS_VALUE_TYPE_UINT16:
while( bson_iterator_next(&data_iter) == BSON_INT ) {
val_uint16 = (uint16)bson_iterator_int(&data_iter);
vs_tag_set_values(tag, 1, value_index, &val_uint16);
value_index++;
}
break;
case VRS_VALUE_TYPE_UINT32:
while( bson_iterator_next(&data_iter) == BSON_INT ) {
val_uint32 = (uint32)bson_iterator_int(&data_iter);
vs_tag_set_values(tag, 1, value_index, &val_uint32);
value_index++;
}
break;
case VRS_VALUE_TYPE_UINT64:
while( bson_iterator_next(&data_iter) == BSON_LONG ) {
val_uint64 = (uint64)bson_iterator_long(&data_iter);
vs_tag_set_values(tag, 1, value_index, &val_uint64);
value_index++;
}
break;
case VRS_VALUE_TYPE_REAL16:
/* TODO: add support for float16 */
break;
case VRS_VALUE_TYPE_REAL32:
while( bson_iterator_next(&data_iter) == BSON_DOUBLE ) {
val_real32 = (real32)bson_iterator_double(&data_iter);
vs_tag_set_values(tag, 1, value_index, &val_real32);
value_index++;
}
break;
case VRS_VALUE_TYPE_REAL64:
while( bson_iterator_next(&data_iter) == BSON_DOUBLE ) {
val_real64 = (real64)bson_iterator_double(&data_iter);
vs_tag_set_values(tag, 1, value_index, &val_real64);
value_index++;
}
break;
case VRS_VALUE_TYPE_STRING8:
str_value = bson_iterator_string(&data_iter);
strcpy(tag->value, str_value);
break;
}
}
}
