bson.h

Go to the documentation of this file.

/*    Copyright 2009-2012 10gen Inc.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

#ifndef BSON_H_
#define BSON_H_
#include <time.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <stdarg.h>

#include "common_decimal.h"

#if defined(__GNUC__) || defined(__xlC__)
    #define SDB_EXPORT
#else
    #ifdef SDB_STATIC_BUILD
        #define SDB_EXPORT
    #elif defined(SDB_DLL_BUILD)
        #define SDB_EXPORT __declspec(dllexport)
    #else
        #define SDB_EXPORT __declspec(dllimport)
    #endif
#endif

#ifdef __cplusplus
#define SDB_EXTERN_C_START extern "C" {
#define SDB_EXTERN_C_END }
#else
#define SDB_EXTERN_C_START
#define SDB_EXTERN_C_END
#endif

//#if defined(SDB_HAVE_STDINT) || __STDC_VERSION__ >= 199901L
#include <stdint.h>
//#elif defined(SDB_HAVE_UNISTD)
//#include <unistd.h>
//#elif defined(SDB_USE__INT64)
//typedef __int64 int64_t;
//typedef unsigned __int64 uint64_t;
//#elif defined(SDB_USE_LONG_LONG_INT)
//typedef long long int int64_t;
//typedef unsigned long long int uint64_t;
//#else
//#error Must compile with c99 or define SDB_HAVE_STDINT, SDB_HAVE_UNISTD, SDB_USE__INT64, or SDB_USE_LONG_LONG_INT.
//#endif

//#ifdef SDB_BIG_ENDIAN
//#define bson_little_endian64(out, in) ( bson_swap_endian64(out, in) )
//#define bson_little_endian32(out, in) ( bson_swap_endian32(out, in) )
//#define bson_big_endian64(out, in) ( memcpy(out, in, 8) )
//#define bson_big_endian32(out, in) ( memcpy(out, in, 4) )
//#else
#define bson_little_endian64(out, in) ( memcpy(out, in, 8) )
#define bson_little_endian32(out, in) ( memcpy(out, in, 4) )
#define bson_little_endian16(out, in) ( memcpy(out, in, 2) )
#define bson_big_endian64(out, in) ( bson_swap_endian64(out, in) )
#define bson_big_endian32(out, in) ( bson_swap_endian32(out, in) )
#define bson_big_endian16(out, in) ( bson_swap_endian16(out, in) )
//#endif

SDB_EXTERN_C_START

#define BSON_OK 0
#define BSON_ERROR -1

enum bson_error_t {
    BSON_SIZE_OVERFLOW = 1 
};


enum bson_validity_t {
    BSON_VALID = 0,                 
    BSON_NOT_UTF8 = ( 1<<1 ),       
    BSON_FIELD_HAS_DOT = ( 1<<2 ),  
    BSON_FIELD_INIT_DOLLAR = ( 1<<3 ), 
    BSON_ALREADY_FINISHED = ( 1<<4 )  
};

enum bson_binary_subtype_t {
    BSON_BIN_BINARY = 0, 
    BSON_BIN_FUNC = 1, 
    BSON_BIN_BINARY_OLD = 2, 
    BSON_BIN_UUID = 3, 
    BSON_BIN_MD5 = 5, 
    BSON_BIN_USER = 128 
};

typedef enum {
    BSON_MINKEY = -1, 
    BSON_EOO = 0, 
    BSON_DOUBLE = 1, 
    BSON_STRING = 2, 
    BSON_OBJECT = 3, 
    BSON_ARRAY = 4, 
    BSON_BINDATA = 5, 
    BSON_UNDEFINED = 6, 
    BSON_OID = 7, 
    BSON_BOOL = 8, 
    BSON_DATE = 9, 
    BSON_NULL = 10, 
    BSON_REGEX = 11, 
    BSON_DBREF = 12, 
    BSON_CODE = 13, 
    BSON_SYMBOL = 14, 
    BSON_CODEWSCOPE = 15, 
    BSON_INT = 16, 
    BSON_TIMESTAMP = 17, 
    BSON_LONG = 18, 
    BSON_DECIMAL = 100, 
    BSON_MAXKEY = 127 
} bson_type;

typedef int bson_bool_t;

typedef struct {
    const char *cur;
    bson_bool_t first;
} bson_iterator;

#define BSON_MAX_STACK_SIZE 32
typedef struct {
    char *data;    
    char *cur;     
    int dataSize;  
    bson_bool_t finished; 
    int stack[BSON_MAX_STACK_SIZE];        
    char stackType[BSON_MAX_STACK_SIZE];        
    int stackPos;         
    int err; 
    char *errstr; 
    int ownmem; 
} bson;

#pragma pack(1)
typedef union {
    char bytes[12];
    int ints[3];
} bson_oid_t;
#pragma pack()

typedef int64_t bson_date_t; /* milliseconds since epoch UTC */

typedef struct {
    int i; 
    int t; 
} bson_timestamp_t;

/* ----------------------------
   READING
   ------------------------------ */

SDB_EXPORT bson* bson_create( void );

SDB_EXPORT void  bson_dispose(bson* b);

SDB_EXPORT int bson_size( const bson *b );

SDB_EXPORT int bson_buffer_size( const bson *b );

SDB_EXPORT void bson_print( const bson *b );

SDB_EXPORT int bson_sprint_iterator ( char **pbuf, int *left, bson_iterator *i,
                                      char delChar ) ;

SDB_EXPORT int bson_sprint( char *buffer, int bufsize, const bson *b );

SDB_EXPORT int bson_sprint_length_iterator ( bson_iterator *i ) ;

SDB_EXPORT int bson_sprint_length( const bson *b );

SDB_EXPORT const char *bson_data( const bson *b );

//SDB_EXPORT void bson_print_raw( const char *bson , int depth );

SDB_EXPORT int bson_sprint_raw ( char **pbuf, int *left, const char *data, int isobj );

SDB_EXPORT int bson_sprint_length_raw( const char *data, int isobj );

SDB_EXPORT bson_type bson_find( bson_iterator *it, const bson *obj, const char *name );

SDB_EXPORT bson_iterator* bson_iterator_create( void );

SDB_EXPORT void bson_iterator_dispose(bson_iterator*);
SDB_EXPORT void bson_iterator_init( bson_iterator *i , const bson *b );

SDB_EXPORT void bson_iterator_from_buffer( bson_iterator *i, const char *buffer );

/* more returns true for eoo. best to loop with bson_iterator_next(&it) */
SDB_EXPORT bson_bool_t bson_iterator_more( const bson_iterator *i );

SDB_EXPORT bson_type bson_iterator_next( bson_iterator *i );

SDB_EXPORT bson_type bson_iterator_type( const bson_iterator *i );

SDB_EXPORT const char *bson_iterator_key( const bson_iterator *i );

SDB_EXPORT const char *bson_iterator_value( const bson_iterator *i );

/* these convert to the right type (return 0 if non-numeric) */
SDB_EXPORT double bson_iterator_double( const bson_iterator *i );

SDB_EXPORT int bson_iterator_int( const bson_iterator *i );

SDB_EXPORT int64_t bson_iterator_long( const bson_iterator *i );

SDB_EXPORT int bson_iterator_decimal_scale( const bson_iterator *i, 
                                            int *sign, int *scale ) ;

SDB_EXPORT int bson_iterator_decimal_typemod( const bson_iterator *i, 
                                              int *typemod ) ;

SDB_EXPORT int bson_iterator_decimal_weight( const bson_iterator *i, 
                                             int *weight ) ;

SDB_EXPORT int bson_iterator_decimal_size( const bson_iterator *i, 
                                           int *size ) ;

SDB_EXPORT int bson_iterator_decimal( const bson_iterator *i, 
                                      bson_decimal *decimal ) ;


/* return the bson timestamp as a whole or in parts */
SDB_EXPORT bson_timestamp_t bson_iterator_timestamp( const bson_iterator *i );
SDB_EXPORT int bson_iterator_timestamp_time( const bson_iterator *i );
SDB_EXPORT int bson_iterator_timestamp_increment( const bson_iterator *i );

/* false: boolean false, 0 in any type, or null */
/* true: anything else (even empty strings and objects) */
SDB_EXPORT bson_bool_t bson_iterator_bool( const bson_iterator *i );

/* these assume you are using the right type */
double bson_iterator_double_raw( const bson_iterator *i );

int bson_iterator_int_raw( const bson_iterator *i );

int64_t bson_iterator_long_raw( const bson_iterator *i );

bson_bool_t bson_iterator_bool_raw( const bson_iterator *i );

SDB_EXPORT bson_oid_t *bson_iterator_oid( const bson_iterator *i );

/* these can also be used with bson_code and bson_symbol*/
SDB_EXPORT const char *bson_iterator_string( const bson_iterator *i );

int bson_iterator_string_len( const bson_iterator *i );

/* works with bson_code, bson_codewscope, and BSON_STRING */
/* returns NULL for everything else */
SDB_EXPORT const char *bson_iterator_code( const bson_iterator *i );

/* calls bson_empty on scope if not a bson_codewscope */
SDB_EXPORT void bson_iterator_code_scope( const bson_iterator *i, bson *scope );

/* both of these only work with bson_date */
SDB_EXPORT bson_date_t bson_iterator_date( const bson_iterator *i );

SDB_EXPORT time_t bson_iterator_time_t( const bson_iterator *i );

SDB_EXPORT int bson_iterator_bin_len( const bson_iterator *i );

SDB_EXPORT char bson_iterator_bin_type( const bson_iterator *i );

SDB_EXPORT const char *bson_iterator_bin_data( const bson_iterator *i );

SDB_EXPORT const char *bson_iterator_regex( const bson_iterator *i );

SDB_EXPORT const char *bson_iterator_regex_opts( const bson_iterator *i );

SDB_EXPORT const char *bson_iterator_dbref( const bson_iterator *i );

SDB_EXPORT bson_oid_t *bson_iterator_dbref_oid( const bson_iterator *i );

/* these work with BSON_OBJECT and BSON_ARRAY */
SDB_EXPORT void bson_iterator_subobject( const bson_iterator *i, bson *sub );

SDB_EXPORT void bson_iterator_subiterator( const bson_iterator *i, bson_iterator *sub );

/* str must be at least 24 hex chars + null byte */
SDB_EXPORT void bson_oid_from_string( bson_oid_t *oid, const char *str );

SDB_EXPORT void bson_oid_to_string( const bson_oid_t *oid, char *str );

SDB_EXPORT void bson_oid_gen( bson_oid_t *oid );

SDB_EXPORT void bson_set_oid_fuzz( int ( *func )( void ) );

SDB_EXPORT void bson_set_oid_inc( int ( *func )( void ) );

SDB_EXPORT time_t bson_oid_generated_time( bson_oid_t *oid ); /* Gives the time the OID was created */

/* ----------------------------
   BUILDING
   ------------------------------ */

SDB_EXPORT void bson_init( bson *b );

int bson_init_data( bson *b , const char *data );

int bson_init_finished_data( bson *b, const char *data ) ;

SDB_EXPORT void bson_init_size( bson *b, int size );

int bson_ensure_space( bson *b, const int bytesNeeded );

SDB_EXPORT int bson_finish( bson *b );

SDB_EXPORT void bson_destroy( bson *b );

/* returns pointer to static empty bson object */
SDB_EXPORT bson *bson_empty( bson *obj );

SDB_EXPORT bson_bool_t bson_is_empty( bson *obj );

SDB_EXPORT int bson_copy( bson *out, const bson *in ); /* puts data in new buffer. NOOP if out==NULL */

SDB_EXPORT int bson_init_by_reset( bson *obj );

SDB_EXPORT int bson_append_oid( bson *b, const char *name, const bson_oid_t *oid );

SDB_EXPORT int bson_append_new_oid( bson *b, const char *name );

SDB_EXPORT int bson_append_int( bson *b, const char *name, const int i );

SDB_EXPORT int bson_append_long( bson *b, const char *name, const int64_t i );

SDB_EXPORT int bson_append_decimal( bson *b, const char *name, 
                                    const bson_decimal *decimal ) ;

SDB_EXPORT int bson_append_decimal2( bson *b, const char *name, 
                                     const char *value, int precision, 
                                     int scale ) ;
SDB_EXPORT int bson_append_decimal3( bson *b, const char *name, 
                                     const char *value ) ;

SDB_EXPORT int bson_append_double( bson *b, const char *name, const double d );

SDB_EXPORT int bson_append_string( bson *b, const char *name, const char *str );

SDB_EXPORT int bson_append_string_n( bson *b, const char *name, const char *str, int len );

SDB_EXPORT int bson_append_symbol( bson *b, const char *name, const char *str );

SDB_EXPORT int bson_append_symbol_n( bson *b, const char *name, const char *str, int len );

SDB_EXPORT int bson_append_code( bson *b, const char *name, const char *str );

SDB_EXPORT int bson_append_code_n( bson *b, const char *name, const char *str, int len );

SDB_EXPORT int bson_append_code_w_scope( bson *b, const char *name, const char *code, const bson *scope );

SDB_EXPORT int bson_append_code_w_scope_n( bson *b, const char *name, const char *code, int size, const bson *scope );

SDB_EXPORT int bson_append_binary( bson *b, const char *name, char type, const char *str, int len );

SDB_EXPORT int bson_append_bool( bson *b, const char *name, const bson_bool_t v );

SDB_EXPORT int bson_append_null( bson *b, const char *name );

SDB_EXPORT int bson_append_undefined( bson *b, const char *name );

SDB_EXPORT int bson_append_regex( bson *b, const char *name, const char *pattern, const char *opts );

SDB_EXPORT int bson_append_minkey( bson *b, const char *name ) ;

SDB_EXPORT int bson_append_maxkey( bson *b, const char *name ) ;

SDB_EXPORT int bson_append_bson( bson *b, const char *name, const bson *bson );

SDB_EXPORT int bson_append_array( bson *b, const char *name, const bson *bson );

SDB_EXPORT int bson_append_element( bson *b, const char *name_or_null, const bson_iterator *elem );

SDB_EXPORT int bson_append_elements( bson *dst, const bson *src );

SDB_EXPORT int bson_append_timestamp( bson *b, const char *name, bson_timestamp_t *ts );

SDB_EXPORT int bson_append_timestamp2( bson *b, const char *name, int time, int increment );

/* these both append a bson_date */
SDB_EXPORT int bson_append_date( bson *b, const char *name, bson_date_t millis );

SDB_EXPORT int bson_append_time_t( bson *b, const char *name, time_t secs );

SDB_EXPORT int bson_append_start_object( bson *b, const char *name );

SDB_EXPORT int bson_append_start_array( bson *b, const char *name );

SDB_EXPORT int bson_append_finish_object( bson *b );

SDB_EXPORT int bson_append_finish_array( bson *b );

void bson_numstr( char *str, int i );

void bson_incnumstr( char *str );

/* Error handling and standard library function over-riding. */
/* -------------------------------------------------------- */

/* bson_err_handlers shouldn't return!!! */
typedef void( *bson_err_handler )( const char *errmsg );

typedef int (*bson_printf_func)( const char *, ... );
typedef int (*bson_fprintf_func)( FILE *, const char *, ... );
typedef int (*bson_sprintf_func)( char *, const char *, ... );

typedef void* (*bson_malloc_func_p)( size_t ) ;
typedef void* (*bson_realloc_func_p)( void*, size_t ) ;
typedef void  (*bson_free_func_p)( void* ) ;

void bson_set_malloc_func( bson_malloc_func_p func ) ;
void bson_set_realloc_func( bson_realloc_func_p func ) ;
void bson_set_free_func( bson_free_func_p func ) ;

extern bson_printf_func bson_printf;
extern bson_fprintf_func bson_fprintf;
extern bson_sprintf_func bson_sprintf;
extern bson_printf_func bson_errprintf;

SDB_EXPORT void bson_free( void *ptr );

SDB_EXPORT void *bson_malloc( int size );

void *bson_realloc( void *ptr, int size );

SDB_EXPORT bson_err_handler set_bson_err_handler( bson_err_handler func );

/* does nothing if ok != 0 */
void bson_fatal( int ok );

void bson_fatal_msg( int ok, const char *msg );

void bson_builder_error( bson *b );

SDB_EXPORT double bson_int64_to_double( int64_t i64 );

SDB_EXPORT void bson_swap_endian32( void *outp, const void *inp );
SDB_EXPORT void bson_swap_endian64( void *outp, const void *inp );

SDB_EXPORT bson_bool_t bson_is_inf( double d, int *pSign ) ;

SDB_EXPORT void bson_set_js_compatibility(int compatible);

SDB_EXPORT int bson_get_js_compatibility();

SDB_EXTERN_C_END
#endif