int read_inode(const bson * doc, struct inode * out) {
bson_iterator i, sub;
bson_type bt;
const char * key;
bson_iterator_init(&i, doc);
while((bt = bson_iterator_next(&i)) > 0) {
key = bson_iterator_key(&i);
if(strcmp(key, "_id") == 0)
memcpy(&out->oid, bson_iterator_oid(&i), sizeof(bson_oid_t));
else if(strcmp(key, "mode") == 0)
out->mode = bson_iterator_int(&i);
else if(strcmp(key, "owner") == 0)
out->owner = bson_iterator_long(&i);
else if(strcmp(key, "group") == 0)
out->group = bson_iterator_long(&i);
else if(strcmp(key, "size") == 0)
out->size = bson_iterator_long(&i);
else if(strcmp(key, "created") == 0)
out->created = bson_iterator_time_t(&i);
else if(strcmp(key, "modified") == 0)
out->modified = bson_iterator_time_t(&i);
else if(strcmp(key, "data") == 0) {
out->datalen = bson_iterator_string_len(&i);
out->data = malloc(out->datalen + 1);
strcpy(out->data, bson_iterator_string(&i));
}
else if(strcmp(key, "dirents") == 0) {
while(out->dirents) {
struct dirent * next = out->dirents->next;
free(out->dirents);
out->dirents = next;
}
bson_iterator_subiterator(&i, &sub);
while((bt = bson_iterator_next(&sub)) > 0) {
int len = bson_iterator_string_len(&sub);
struct dirent * cde = malloc(sizeof(struct dirent) + len);
if(!cde)
return -ENOMEM;
strcpy(cde->path, bson_iterator_string(&sub));
cde->len = bson_iterator_string_len(&sub);
cde->next = out->dirents;
out->dirents = cde;
out->direntcount++;
}
}
}
return 0;
}
void json_from_bson_string(yajl_gen *g, bson_iterator *it)
{
const char* value = bson_iterator_string( it );
int length = bson_iterator_string_len( it );
yajl_gen_string( *g, (unsigned char*)value, length - 1 );
}
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;
}
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;
}
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;
}