MONGO_EXPORT int bson_size( const bson *b ) { int i; if ( ! b || ! b->data ) return 0; bson_little_endian32( &i, b->data ); return i; }
/* Always calls free(mm) */ void mongo_message_send(mongo_connection * conn, mongo_message* mm){ mongo_header head; /* little endian */ bson_little_endian32(&head.len, &mm->head.len); bson_little_endian32(&head.id, &mm->head.id); bson_little_endian32(&head.responseTo, &mm->head.responseTo); bson_little_endian32(&head.op, &mm->head.op); MONGO_TRY{ looping_write(conn, &head, sizeof(head)); looping_write(conn, &mm->data, mm->head.len - sizeof(head)); }MONGO_CATCH{ //free(mm); MONGO_RETHROW(); } //free(mm); }
static inline int ElemToLong(BSONElem* val2,int64_t* outVal){ int32_t int32; int64_t d2; int64_t lng; double doVal; switch(val2->type) { case BSON_INT: bson_little_endian32(&int32,val2->value); d2 = int32; break; case BSON_LONG: case BSON_DATE: bson_little_endian64(&lng,val2->value); d2 = lng; break; case BSON_DOUBLE: bson_little_endian64(&doVal,val2->value); d2 = doVal; break; default: return -1; } *outVal = d2; return 0; }
MONGO_EXPORT int bson_size( const bson *b ) { int i; if ( ! b || ! b->data ) return 0; check_mongo_object( (void*)b ); bson_little_endian32( &i, b->data ); return i; }
mongo_reply * mongo_read_response( mongo_connection * conn ){ mongo_header head; /* header from network */ mongo_reply_fields fields; /* header from network */ mongo_reply * out; /* native endian */ int len; looping_read(conn, &head, sizeof(head)); looping_read(conn, &fields, sizeof(fields)); bson_little_endian32(&len, &head.len); if (len < sizeof(head)+sizeof(fields) || len > 64*1024*1024) MONGO_THROW(MONGO_EXCEPT_NETWORK); /* most likely corruption */ out = (mongo_reply*)bson_malloc(len); out->head.len = len; bson_little_endian32(&out->head.id, &head.id); bson_little_endian32(&out->head.responseTo, &head.responseTo); bson_little_endian32(&out->head.op, &head.op); bson_little_endian32(&out->fields.flag, &fields.flag); bson_little_endian64(&out->fields.cursorID, &fields.cursorID); bson_little_endian32(&out->fields.start, &fields.start); bson_little_endian32(&out->fields.num, &fields.num); MONGO_TRY{ looping_read(conn, &out->objs, len-sizeof(head)-sizeof(fields)); }MONGO_CATCH{ free(out); MONGO_RETHROW(); } return out; }
mongo_reply * mongo_read_response( mongo_connection * conn ){ mongo_header head; /* header from network */ mongo_reply_fields fields; /* header from network */ mongo_reply * out; /* native endian */ int len; looping_read(conn, &head, sizeof(head)); looping_read(conn, &fields, sizeof(fields)); bson_little_endian32(&len, &head.len); out = (mongo_reply*)apr_palloc(conn->p, len); out->head.len = len; bson_little_endian32(&out->head.id, &head.id); bson_little_endian32(&out->head.responseTo, &head.responseTo); bson_little_endian32(&out->head.op, &head.op); bson_little_endian32(&out->fields.flag, &fields.flag); bson_little_endian64(&out->fields.cursorID, &fields.cursorID); bson_little_endian32(&out->fields.start, &fields.start); bson_little_endian32(&out->fields.num, &fields.num); MONGO_TRY{ looping_read(conn, &out->objs, len-sizeof(head)-sizeof(fields)); }MONGO_CATCH{ //free(out); MONGO_RETHROW(); } return out; }
void bson_iterator_code_scope(const bson_iterator * i, bson * scope){ if (bson_iterator_type(i) == bson_codewscope){ int code_len; bson_little_endian32(&code_len, bson_iterator_value(i)+4); bson_init(scope, (void*)(bson_iterator_value(i)+8+code_len), 0); }else{ bson_empty(scope); } }
void bson_iterator_code_scope( const bson_iterator *i, bson *scope ) { if ( bson_iterator_type( i ) == BSON_CODEWSCOPE ) { int code_len; bson_little_endian32( &code_len, bson_iterator_value( i )+4 ); bson_init_data( scope, ( void * )( bson_iterator_value( i )+8+code_len ) ); } else { bson_empty( scope ); } }
char* Namespace::getNextRecordData(int &recordSize) { Record *rec; if (extentCursor.isNull()) // the first time after connection the extent cursor will be null { extentCursor = firstExtentLoc; // so, get the first extent of the colection if (_DEBUG) LOGI("getting first extent"); } if (extentCursor.isNull()) // if first extent is null, then no extents exist return NULL; // no extents Extent* extent = db->getExtent(extentCursor); if (recordCursor == -1) // the first time the record cursor will be null as well { recordCursor = extent->firstRecord; // get the first record of the extent if (recordCursor == -1) // if first record is null, then no records exist return NULL; // no records rec = extent->getRecord(recordCursor); } else // else, the cursor shows the previous record, should take the next one and return its data { rec = extent->getRecord(recordCursor); if (rec->nextRecLoc == -1) // if its next record is null, then go to next extent { if (extent->nextExtent.isNull()) // if the next extent is null, then no more extents { return NULL; // no more records } else // proceed with the next extent { extentCursor = extent->nextExtent; recordCursor = -1; return getNextRecordData(recordSize); } } else { recordCursor = rec->nextRecLoc; // next record exists, so put the cursor on it if (_DEBUG) LOGI("getting next record"); rec = extent->getRecord(recordCursor); } } int bsonSize = 0; bson_little_endian32( &bsonSize, rec->data); char *val = (char*) malloc((bsonSize + 128) * sizeof(char)); int cur = 0; return bson_to_json(val, rec->data, 0, true, 0, recordSize, cur); }
char * bson_buffer_finish( bson_buffer * b ){ int i; if ( ! b->finished ){ if ( ! bson_ensure_space( b , 1 ) ) return 0; bson_append_byte( b , 0 ); i = b->cur - b->buf; bson_little_endian32(b->buf, &i); b->finished = 1; } return b->buf; }
/** * Add null byte, mark as finished, and return buffer. * Note that the buffer will now be owned by the bson * object created from a call to bson_from_buffer. * This buffer is then deallocated by calling * bson_destroy(). */ int bson_buffer_finish( bson_buffer * b ){ int i; if ( ! b->finished ){ if ( bson_ensure_space( b, 1 ) == BSON_ERROR ) return BSON_ERROR; bson_append_byte( b, 0 ); i = b->cur - b->buf; bson_little_endian32(b->buf, &i); b->finished = 1; } return BSON_OK; }
int bson_append_finish_object( bson *b ) { char *start; int i; if ( bson_ensure_space( b, 1 ) == BSON_ERROR ) return BSON_ERROR; bson_append_byte( b , 0 ); start = b->data + b->stack[ --b->stackPos ]; i = b->cur - start; bson_little_endian32( start, &i ); return BSON_OK; }
bson_buffer * bson_append_finish_object( bson_buffer * b ){ char * start; int i; if ( ! bson_ensure_space( b , 1 ) ) return 0; bson_append_byte( b , 0 ); start = b->buf + b->stack[ --b->stackPos ]; i = b->cur - start; bson_little_endian32(start, &i); return b; }
MONGO_EXPORT void bson_iterator_code_scope( const bson_iterator *i, bson *scope ) { check_mongo_object( (void*)scope ); check_mongo_object( (void*)i ); if ( bson_iterator_type( i ) == BSON_CODEWSCOPE ) { int code_len; bson_little_endian32( &code_len, bson_iterator_value( i )+4 ); bson_init_data( scope, ( void * )( bson_iterator_value( i )+8+code_len ) ); _bson_reset( scope ); scope->finished = 1; } else { bson_empty( scope ); } }
/* Always calls bson_free(mm) */ int mongo_message_send( mongo *conn, mongo_message *mm ) { mongo_header head; /* little endian */ int res; bson_little_endian32( &head.len, &mm->head.len ); bson_little_endian32( &head.id, &mm->head.id ); bson_little_endian32( &head.responseTo, &mm->head.responseTo ); bson_little_endian32( &head.op, &mm->head.op ); res = mongo_write_socket( conn, &head, sizeof( head ) ); if( res != MONGO_OK ) { bson_free( mm ); return res; } res = mongo_write_socket( conn, &mm->data, mm->head.len - sizeof( head ) ); if( res != MONGO_OK ) { bson_free( mm ); return res; } bson_free( mm ); return MONGO_OK; }
char* Namespace::getNextBatch(int &count) { if (_DEBUG) LOGI("get next batch"); int batchSize = 0; int sizes[count]; int jsonSize = 0; char *records[count]; //= (char**)malloc(count*sizeof(char*)); int lastRetrievedRecord = -1, recordSize, skip = 0; int i = 0; Extent *extent = getFirstExtent(); while (extent != NULL) { lastRetrievedRecord = -1; Record *record = extent->getFirstRecord(); while (record != NULL && i < count) { recordSize = 0; int bsonSize = 0; bson_little_endian32( &bsonSize, record->data); //FORCE_LOG_INT("bsonSize: ", bsonSize); char *val = (char*) malloc((bsonSize + 100) * sizeof(char)); int cur = 0; val = bson_to_json(val, record->data, 0, true, bsonSize, recordSize, cur); records[i] = val; batchSize += recordSize; sizes[i] = recordSize; jsonSize += recordSize; record = extent->getRecord(record->nextRecLoc); i++; } extent = db->getExtent(extent->nextExtent); } count = i; FORCE_LOG_INT("count: ", i); return serializeJSON(records, jsonSize, count, sizes); }
int bson_finish( bson *b ) { int i; if( b->err & BSON_NOT_UTF8 ) return BSON_ERROR; if ( ! b->finished ) { if ( bson_ensure_space( b, 1 ) == BSON_ERROR ) return BSON_ERROR; bson_append_byte( b, 0 ); i = b->cur - b->data; bson_little_endian32( b->data, &i ); b->finished = 1; } return BSON_OK; }
MONGO_EXPORT int bson_append_finish_object( bson *b ) { char *start; int i; if (!b) return BSON_ERROR; if (!b->stackPos) { b->err = BSON_NOT_IN_SUBOBJECT; return BSON_ERROR; } if ( bson_ensure_space( b, 1 ) == BSON_ERROR ) return BSON_ERROR; bson_append_byte( b , 0 ); start = b->data + b->stack[ --b->stackPos ]; if ( b->cur - start >= INT32_MAX ) { b->err = BSON_SIZE_OVERFLOW; return BSON_ERROR; } i = ( int )( b->cur - start ); bson_little_endian32( start, &i ); return BSON_OK; }
MONGO_EXPORT int bson_finish( bson *b ) { int i; if( b->err & BSON_NOT_UTF8 ) return BSON_ERROR; if ( ! b->finished ) { if ( bson_ensure_space( b, 1 ) == BSON_ERROR ) return BSON_ERROR; bson_append_byte( b, 0 ); if ( b->cur - b->data >= INT32_MAX ) { b->err = BSON_SIZE_OVERFLOW; return BSON_ERROR; } i = ( int )( b->cur - b->data ); bson_little_endian32( b->data, &i ); b->finished = 1; } return BSON_OK; }
MONGO_EXPORT int bson_finish( bson *b ) { int i; if( b->err & BSON_NOT_UTF8 ) return BSON_ERROR; if ( ! b->finished ) { bson_fatal_msg(!b->stackPos, "Subobject not finished before bson_finish()."); if ( bson_ensure_space( b, 1 ) == BSON_ERROR ) return BSON_ERROR; bson_append_byte( b, 0 ); if ( _bson_position(b) >= INT32_MAX ) { b->err = BSON_SIZE_OVERFLOW; return BSON_ERROR; } i = ( int ) _bson_position(b); bson_little_endian32( b->data, &i ); b->finished = 1; } return BSON_OK; }
int mongo_read_response( mongo *conn, mongo_reply **reply ) { mongo_header head; /* header from network */ mongo_reply_fields fields; /* header from network */ mongo_reply *out; /* native endian */ unsigned int len; int res; mongo_read_socket( conn, &head, sizeof( head ) ); mongo_read_socket( conn, &fields, sizeof( fields ) ); bson_little_endian32( &len, &head.len ); if ( len < sizeof( head )+sizeof( fields ) || len > 64*1024*1024 ) return MONGO_READ_SIZE_ERROR; /* most likely corruption */ out = ( mongo_reply * )bson_malloc( len ); out->head.len = len; bson_little_endian32( &out->head.id, &head.id ); bson_little_endian32( &out->head.responseTo, &head.responseTo ); bson_little_endian32( &out->head.op, &head.op ); bson_little_endian32( &out->fields.flag, &fields.flag ); bson_little_endian64( &out->fields.cursorID, &fields.cursorID ); bson_little_endian32( &out->fields.start, &fields.start ); bson_little_endian32( &out->fields.num, &fields.num ); res = mongo_read_socket( conn, &out->objs, len-sizeof( head )-sizeof( fields ) ); if( res != MONGO_OK ) { bson_free( out ); return res; } *reply = out; return MONGO_OK; }
MONGO_EXPORT int bson_iterator_timestamp_time( const bson_iterator *i ) { int time; bson_little_endian32( &time, bson_iterator_value( i ) + 4 ); return time; }
static void bson_append32_as_int( bson *b, int data ) { bson_little_endian32( b->cur, &data ); b->cur += 4; }
void bson_append32( bson *b, const void *data ) { bson_little_endian32( b->cur, data ); b->cur += 4; }
bson_timestamp_t bson_iterator_timestamp( const bson_iterator *i ) { bson_timestamp_t ts; bson_little_endian32( &( ts.i ), bson_iterator_value( i ) ); bson_little_endian32( &( ts.t ), bson_iterator_value( i ) + 4 ); return ts; }
int bson_iterator_int_raw( const bson_iterator *i ) { int out; bson_little_endian32( &out, bson_iterator_value( i ) ); return out; }
char *mongo_data_append32( char *start , const void *data ) { bson_little_endian32( start , data ); return start + 4; }
MONGO_EXPORT int bson_iterator_timestamp_increment( const bson_iterator *i ) { int increment; bson_little_endian32( &increment, bson_iterator_value( i ) ); return increment; }
static void bson_append32( bson *b, const void *data ) { check_mongo_object( (void*)b ); bson_little_endian32( b->cur, data ); b->cur += 4; }
MONGO_EXPORT int bson_iterator_timestamp_increment( const bson_iterator *i ) { int increment; check_mongo_object( (void*)i ); bson_little_endian32( &increment, bson_iterator_value( i ) ); return increment; }