bson_ext 1.5.1 → 1.5.2

data/ext/cmongo/c-driver/src/bson.h

@@ -1,229 +0,0 @@
-/* bson.h */
-
-/*    Copyright 2009, 2010 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 "platform_hacks.h"
-#include <time.h>
-
-MONGO_EXTERN_C_START
-
-typedef enum {
-    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, /* deprecated */
-    bson_code=13,
-    bson_symbol=14,
-    bson_codewscope=15,
-    bson_int = 16,
-    bson_timestamp = 17,
-    bson_long = 18
-} bson_type;
-
-typedef int bson_bool_t;
-
-typedef struct {
-    char * data;
-    bson_bool_t owned;
-} bson;
-
-typedef struct {
-    const char * cur;
-    bson_bool_t first;
-} bson_iterator;
-
-typedef struct {
-    char * buf;
-    char * cur;
-    int bufSize;
-    bson_bool_t finished;
-    int stack[32];
-    int stackPos;
-} bson_buffer;
-
-#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; /* increment */
-  int t; /* time in seconds */
-} bson_timestamp_t;
-
-/* ----------------------------
-   READING
-   ------------------------------ */
-
-bson * bson_empty(bson * obj); /* returns pointer to static empty bson object */
-void bson_copy(bson* out, const bson* in); /* puts data in new buffer. NOOP if out==NULL */
-bson * bson_from_buffer(bson * b, bson_buffer * buf);
-bson * bson_init( bson * b , char * data , bson_bool_t mine );
-int bson_size(const bson * b );
-void bson_destroy( bson * b );
-
-void bson_print( bson * b );
-void bson_print_raw( const char * bson , int depth );
-
-/* advances iterator to named field */
-/* returns bson_eoo (which is false) if field not found */
-bson_type bson_find(bson_iterator* it, const bson* obj, const char* name);
-
-void bson_iterator_init( bson_iterator * i , const char * bson );
-
-/* more returns true for eoo. best to loop with bson_iterator_next(&it) */
-bson_bool_t bson_iterator_more( const bson_iterator * i );
-bson_type bson_iterator_next( bson_iterator * i );
-
-bson_type bson_iterator_type( const bson_iterator * i );
-const char * bson_iterator_key( const bson_iterator * i );
-const char * bson_iterator_value( const bson_iterator * i );
-
-/* these convert to the right type (return 0 if non-numeric) */
-double bson_iterator_double( const bson_iterator * i );
-int bson_iterator_int( const bson_iterator * i );
-int64_t bson_iterator_long( const bson_iterator * i );
-
-/* return the bson timestamp as a whole or in parts */
-bson_timestamp_t bson_iterator_timestamp( const bson_iterator * i );
-
-/* false: boolean false, 0 in any type, or null */
-/* true: anything else (even empty strings and objects) */
-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 );
-bson_oid_t* bson_iterator_oid( const bson_iterator * i );
-
-/* these can also be used with bson_code and bson_symbol*/
-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 */
-const char * bson_iterator_code(const bson_iterator * i);
-
-/* calls bson_empty on scope if not a bson_codewscope */
-void bson_iterator_code_scope(const bson_iterator * i, bson * scope);
-
-/* both of these only work with bson_date */
-bson_date_t bson_iterator_date(const bson_iterator * i);
-time_t bson_iterator_time_t(const bson_iterator * i);
-
-int bson_iterator_bin_len( const bson_iterator * i );
-char bson_iterator_bin_type( const bson_iterator * i );
-const char * bson_iterator_bin_data( const bson_iterator * i );
-
-const char * bson_iterator_regex( const bson_iterator * i );
-const char * bson_iterator_regex_opts( const bson_iterator * i );
-
-/* these work with bson_object and bson_array */
-void bson_iterator_subobject(const bson_iterator * i, bson * sub);
-void bson_iterator_subiterator(const bson_iterator * i, bson_iterator * sub);
-
-/* str must be at least 24 hex chars + null byte */
-void bson_oid_from_string(bson_oid_t* oid, const char* str);
-void bson_oid_to_string(const bson_oid_t* oid, char* str);
-void bson_oid_gen(bson_oid_t* oid);
-
-time_t bson_oid_generated_time(bson_oid_t* oid); /* Gives the time the OID was created */
-
-/* ----------------------------
-   BUILDING
-   ------------------------------ */
-
-bson_buffer * bson_buffer_init( bson_buffer * b );
-bson_buffer * bson_ensure_space( bson_buffer * b , const int bytesNeeded );
-
-/**
- * @return the raw data.  you either should free this OR call bson_destroy not both
- */
-char * bson_buffer_finish( bson_buffer * b );
-void bson_buffer_destroy( bson_buffer * b );
-
-bson_buffer * bson_append_oid( bson_buffer * b , const char * name , const bson_oid_t* oid );
-bson_buffer * bson_append_new_oid( bson_buffer * b , const char * name );
-bson_buffer * bson_append_int( bson_buffer * b , const char * name , const int i );
-bson_buffer * bson_append_long( bson_buffer * b , const char * name , const int64_t i );
-bson_buffer * bson_append_double( bson_buffer * b , const char * name , const double d );
-bson_buffer * bson_append_string( bson_buffer * b , const char * name , const char * str );
-bson_buffer * bson_append_string_n( bson_buffer * b, const char * name, const char * str , int len);
-bson_buffer * bson_append_symbol( bson_buffer * b , const char * name , const char * str );
-bson_buffer * bson_append_symbol_n( bson_buffer * b , const char * name , const char * str , int len );
-bson_buffer * bson_append_code( bson_buffer * b , const char * name , const char * str );
-bson_buffer * bson_append_code_n( bson_buffer * b , const char * name , const char * str , int len );
-bson_buffer * bson_append_code_w_scope( bson_buffer * b , const char * name , const char * code , const bson * scope);
-bson_buffer * bson_append_code_w_scope_n( bson_buffer * b , const char * name , const char * code , int size , const bson * scope);
-bson_buffer * bson_append_binary( bson_buffer * b, const char * name, char type, const char * str, int len );
-bson_buffer * bson_append_bool( bson_buffer * b , const char * name , const bson_bool_t v );
-bson_buffer * bson_append_null( bson_buffer * b , const char * name );
-bson_buffer * bson_append_undefined( bson_buffer * b , const char * name );
-bson_buffer * bson_append_regex( bson_buffer * b , const char * name , const char * pattern, const char * opts );
-bson_buffer * bson_append_bson( bson_buffer * b , const char * name , const bson* bson);
-bson_buffer * bson_append_element( bson_buffer * b, const char * name_or_null, const bson_iterator* elem);
-bson_buffer * bson_append_timestamp( bson_buffer * b, const char * name, bson_timestamp_t * ts );
-
-/* these both append a bson_date */
-bson_buffer * bson_append_date(bson_buffer * b, const char * name, bson_date_t millis);
-bson_buffer * bson_append_time_t(bson_buffer * b, const char * name, time_t secs);
-
-bson_buffer * bson_append_start_object( bson_buffer * b , const char * name );
-bson_buffer * bson_append_start_array( bson_buffer * b , const char * name );
-bson_buffer * bson_append_finish_object( bson_buffer * b );
-
-void bson_numstr(char* str, int i);
-void bson_incnumstr(char* str);
-
-
-/* ------------------------------
-   ERROR HANDLING - also used in mongo code
-   ------------------------------ */
-
-void * bson_malloc(int size); /* checks return value */
-void * bson_realloc(void * ptr, int size); /* checks return value */
-
-/* bson_err_handlers shouldn't return!!! */
-typedef void(*bson_err_handler)(const char* errmsg);
-
-/* returns old handler or NULL */
-/* default handler prints error then exits with failure*/
-bson_err_handler set_bson_err_handler(bson_err_handler func);
-
-/* does nothing is ok != 0 */
-void bson_fatal( int ok );
-void bson_fatal_msg( int ok, const char* msg );
-
-MONGO_EXTERN_C_END
-#endif

data/ext/cmongo/c-driver/src/gridfs.c

@@ -1,799 +0,0 @@
-/*--------------------------------------------------------------------*/
-/* gridfs.c                                                           */
-/* Author: Christopher Triolo                                         */
-/*--------------------------------------------------------------------*/
-
-#include "gridfs.h"
-#include "mongo.h"
-#include "bson.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <assert.h>
-#define TRUE 1
-#define FALSE 0
-
-
-/*--------------------------------------------------------------------*/
-
-static bson * chunk_new(bson_oid_t id, int chunkNumber,
-    const char * data, int len)
-
-{
-  bson * b;
-  bson_buffer buf;
-
-  b = (bson *)bson_malloc(sizeof(bson));
-  if (b == NULL) return NULL;
-
-  bson_buffer_init(&buf);
-  bson_append_oid(&buf, "files_id", &id);
-  bson_append_int(&buf, "n", chunkNumber);
-  bson_append_binary(&buf, "data", 2, data, len);
-  bson_from_buffer(b, &buf);
-  return  b;
-}
-
-/*--------------------------------------------------------------------*/
-
-static void chunk_free(bson * oChunk)
-
-{
-  bson_destroy(oChunk);
-  free(oChunk);
-}
-
-/*--------------------------------------------------------------------*/
-
-int gridfs_init(mongo_connection * client, const char * dbname,
-    const char * prefix, gridfs* gfs)
-{
-  int options;
-  bson_buffer bb;
-  bson b;
-  bson out;
-  bson_bool_t success;
-
-  gfs->client = client;
-
-  /* Allocate space to own the dbname */
-  gfs->dbname = (const char *)bson_malloc(strlen(dbname)+1);
-  if (gfs->dbname == NULL) {
-    return FALSE;
-  }
-  strcpy((char*)gfs->dbname, dbname);
-
-  /* Allocate space to own the prefix */
-  if (prefix == NULL) prefix = "fs";
-  gfs->prefix = (const char *)bson_malloc(strlen(prefix)+1);
-  if (gfs->prefix == NULL) {
-    free((char*)gfs->dbname);
-    return FALSE;
-  }
-  strcpy((char *)gfs->prefix, prefix);
-
-  /* Allocate space to own files_ns */
-  gfs->files_ns =
-    (const char *) bson_malloc (strlen(prefix)+strlen(dbname)+strlen(".files")+2);
-  if (gfs->files_ns == NULL) {
-    free((char*)gfs->dbname);
-    free((char*)gfs->prefix);
-    return FALSE;
-  }
-  strcpy((char*)gfs->files_ns, dbname);
-  strcat((char*)gfs->files_ns, ".");
-  strcat((char*)gfs->files_ns, prefix);
-  strcat((char*)gfs->files_ns, ".files");
-
-  /* Allocate space to own chunks_ns */
-  gfs->chunks_ns = (const char *) bson_malloc(strlen(prefix) + strlen(dbname)
-              + strlen(".chunks") + 2);
-  if (gfs->chunks_ns == NULL) {
-    free((char*)gfs->dbname);
-    free((char*)gfs->prefix);
-    free((char*)gfs->files_ns);
-    return FALSE;
-  }
-  strcpy((char*)gfs->chunks_ns, dbname);
-  strcat((char*)gfs->chunks_ns, ".");
-  strcat((char*)gfs->chunks_ns, prefix);
-  strcat((char*)gfs->chunks_ns, ".chunks");
-
-  bson_buffer_init(&bb);
-  bson_append_int(&bb, "filename", 1);
-  bson_from_buffer(&b, &bb);
-  options = 0;
-  success = mongo_create_index(gfs->client, gfs->files_ns, &b, options, &out);
-  bson_destroy(&b);
-  if (!success) {
-    free((char*)gfs->dbname);
-    free((char*)gfs->prefix);
-    free((char*)gfs->files_ns);
-    free((char*)gfs->chunks_ns);
-    return FALSE;
-  }
-
-  bson_buffer_init(&bb);
-  bson_append_int(&bb, "files_id", 1);
-  bson_append_int(&bb, "n", 1);
-  bson_from_buffer(&b, &bb);
-  options = MONGO_INDEX_UNIQUE;
-  success = mongo_create_index(gfs->client, gfs->chunks_ns, &b, options, &out);
-  bson_destroy(&b);
-  if (!success) {
-    free((char*)gfs->dbname);
-    free((char*)gfs->prefix);
-    free((char*)gfs->files_ns);
-    free((char*)gfs->chunks_ns);
-    return FALSE;
-  }
-
-  return TRUE;
-}
-
-/*--------------------------------------------------------------------*/
-
-void gridfs_destroy(gridfs* gfs)
-
-{
-  if (gfs == NULL) return;
-  if (gfs->dbname) free((char*)gfs->dbname);
-  if (gfs->prefix) free((char*)gfs->prefix);
-  if (gfs->files_ns) free((char*)gfs->files_ns);
-  if (gfs->chunks_ns) free((char*)gfs->chunks_ns);
-}
-
-/*--------------------------------------------------------------------*/
-
-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_long(&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;
-}
-
-/*--------------------------------------------------------------------*/
-
-bson gridfs_store_buffer( gridfs* gfs, const char* data,
-        gridfs_offset length, const char* remotename,
-        const char * contenttype)
-
-{
-  char const * const end = data + length;
-  bson_oid_t id;
-  int chunkNumber = 0;
-  int chunkLen;
-  bson * oChunk;
-
-  /* Large files Assertion */
-  assert(length <= 0xffffffff);
-
-  /* Generate and append an oid*/
-  bson_oid_gen(&id);
-
-  /* Insert the file's data chunk by chunk */
-  while (data < end) {
-    chunkLen = DEFAULT_CHUNK_SIZE < (unsigned int)(end - data) ?
-      DEFAULT_CHUNK_SIZE : (unsigned int)(end - data);
-    oChunk = chunk_new( id, chunkNumber, data, chunkLen );
-    mongo_insert(gfs->client, gfs->chunks_ns, oChunk);
-    chunk_free(oChunk);
-    chunkNumber++;
-    data += chunkLen;
-  }
-
-  /* Inserts file's metadata */
-  return gridfs_insert_file(gfs, remotename, id, length, contenttype);
-}
-
-/*--------------------------------------------------------------------*/
-
-void gridfile_writer_init( gridfile* gfile, gridfs* gfs,
-    const char* remote_name, const char* content_type )
-{
-    gfile->gfs = gfs;
-
-    bson_oid_gen( &(gfile->id) );
-    gfile->chunk_num = 0;
-    gfile->length = 0;
-    gfile->pending_len = 0;
-    gfile->pending_data = NULL;
-
-    gfile->remote_name = (const char *)bson_malloc( strlen( remote_name ) + 1 );
-    strcpy( (char *)gfile->remote_name, remote_name );
-
-    gfile->content_type = (const char *)bson_malloc( strlen( content_type ) );
-    strcpy( (char *)gfile->content_type, content_type );
-}
-
-/*--------------------------------------------------------------------*/
-
-void gridfile_write_buffer( gridfile* gfile, const char* data, gridfs_offset length )
-{
-
-  int bytes_left = 0;
-  int data_partial_len = 0;
-  int chunks_to_write = 0;
-  char* buffer;
-  bson* oChunk;
-  gridfs_offset to_write = length + gfile->pending_len;
-
-  if ( to_write < DEFAULT_CHUNK_SIZE ) { /* Less than one chunk to write */
-    if( gfile->pending_data ) {
-      gfile->pending_data = (char *)bson_realloc((void *)gfile->pending_data, gfile->pending_len + to_write);
-      memcpy( gfile->pending_data + gfile->pending_len, data, length );
-    } else if (to_write > 0) {
-      gfile->pending_data = (char *)bson_malloc(to_write);
-      memcpy( gfile->pending_data, data, length );
-    }
-    gfile->pending_len += length;
-
-  } else { /* At least one chunk of data to write */
-
-    /* If there's a pending chunk to be written, we need to combine
-     * the buffer provided up to DEFAULT_CHUNK_SIZE.
-     */
-    if ( gfile->pending_len > 0 ) {
-      chunks_to_write = to_write / DEFAULT_CHUNK_SIZE;
-      bytes_left = to_write % DEFAULT_CHUNK_SIZE;
-
-      data_partial_len = DEFAULT_CHUNK_SIZE - gfile->pending_len;
-      buffer = (char *)bson_malloc( DEFAULT_CHUNK_SIZE );
-      memcpy(buffer, gfile->pending_data, gfile->pending_len);
-      memcpy(buffer + gfile->pending_len, data, data_partial_len);
-
-      oChunk = chunk_new(gfile->id, gfile->chunk_num, buffer, DEFAULT_CHUNK_SIZE);
-      mongo_insert(gfile->gfs->client, gfile->gfs->chunks_ns, oChunk);
-      chunk_free(oChunk);
-      gfile->chunk_num++;
-      gfile->length += DEFAULT_CHUNK_SIZE;
-      data += data_partial_len;
-
-      chunks_to_write--;
-
-      free(buffer);
-    }
-
-    while( chunks_to_write > 0 ) {
-      oChunk = chunk_new(gfile->id, gfile->chunk_num, data, DEFAULT_CHUNK_SIZE);
-      mongo_insert(gfile->gfs->client, gfile->gfs->chunks_ns, oChunk);
-      chunk_free(oChunk);
-      gfile->chunk_num++;
-      chunks_to_write--;
-      gfile->length += DEFAULT_CHUNK_SIZE;
-      data += DEFAULT_CHUNK_SIZE;
-    }
-
-    free(gfile->pending_data);
-
-    /* If there are any leftover bytes, store them as pending data. */
-    if( bytes_left == 0 )
-      gfile->pending_data = NULL;
-    else {
-      gfile->pending_data = (char *)bson_malloc( bytes_left );
-      memcpy( gfile->pending_data, data, bytes_left );
-    }
-
-    gfile->pending_len = bytes_left;
-  }
-}
-
-/*--------------------------------------------------------------------*/
-
-bson gridfile_writer_done( gridfile* gfile )
-{
-
-  /* write any remaining pending chunk data.
-   * pending data will always take up less than one chunk
-   */
-  bson* oChunk;
-  if( gfile->pending_data )
-  {
-    oChunk = chunk_new(gfile->id, gfile->chunk_num, gfile->pending_data, gfile->pending_len);
-    mongo_insert(gfile->gfs->client, gfile->gfs->chunks_ns, oChunk);
-    chunk_free(oChunk);
-    free(gfile->pending_data);
-    gfile->length += gfile->pending_len;
-  }
-
-  /* insert into files collection */
-  return gridfs_insert_file(gfile->gfs, gfile->remote_name, gfile->id,
-      gfile->length, gfile->content_type);
-}
-
-/*--------------------------------------------------------------------*/
-
-bson gridfs_store_file(gridfs* gfs, const char* filename,
-      const char* remotename, const char* contenttype)
-{
-  char buffer[DEFAULT_CHUNK_SIZE];
-  FILE * fd;
-  bson_oid_t id;
-  int chunkNumber = 0;
-  gridfs_offset length = 0;
-  gridfs_offset chunkLen = 0;
-  bson* oChunk;
-
-  /* Open the file and the correct stream */
-  if (strcmp(filename, "-") == 0) fd = stdin;
-  else fd = fopen(filename, "rb");
-  assert(fd != NULL); /* No such file */
-
-  /* Generate and append an oid*/
-  bson_oid_gen(&id);
-
-  /* Insert the file chunk by chunk */
-  chunkLen = fread(buffer, 1, DEFAULT_CHUNK_SIZE, fd);
-  do {
-    oChunk = chunk_new( id, chunkNumber, buffer, chunkLen );
-    mongo_insert(gfs->client, gfs->chunks_ns, oChunk);
-    chunk_free(oChunk);
-    length += chunkLen;
-    chunkNumber++;
-    chunkLen = fread(buffer, 1, DEFAULT_CHUNK_SIZE, fd);
-  } while (chunkLen != 0);
-
-  /* Close the file stream */
-  if (fd != stdin) fclose(fd);
-
-  /* Large files Assertion */
-  /* assert(length <= 0xffffffff); */
-
-  /* Optional Remote Name */
-  if (remotename == NULL || *remotename == '\0') {
-    remotename = filename; }
-
-  /* Inserts file's metadata */
-  return gridfs_insert_file(gfs, remotename, id, length, contenttype);
-}
-
-/*--------------------------------------------------------------------*/
-
-void gridfs_remove_filename(gridfs* gfs, const char* filename )
-
-{
-  bson query;
-  bson_buffer buf;
-  mongo_cursor* files;
-  bson file;
-  bson_iterator it;
-  bson_oid_t id;
-  bson b;
-
-  bson_buffer_init(&buf);
-  bson_append_string(&buf, "filename", filename);
-  bson_from_buffer(&query, &buf);
-  files = mongo_find(gfs->client, gfs->files_ns, &query, NULL, 0, 0, 0);
-  bson_destroy(&query);
-
-  /* Remove each file and it's chunks from files named filename */
-  while (mongo_cursor_next(files)) {
-    file = files->current;
-    bson_find(&it, &file, "_id");
-    id = *bson_iterator_oid(&it);
-
-    /* Remove the file with the specified id */
-    bson_buffer_init(&buf);
-    bson_append_oid(&buf, "_id", &id);
-    bson_from_buffer(&b, &buf);
-    mongo_remove( gfs->client, gfs->files_ns, &b);
-    bson_destroy(&b);
-
-    /* Remove all chunks from the file with the specified id */
-    bson_buffer_init(&buf);
-    bson_append_oid(&buf, "files_id", &id);
-    bson_from_buffer(&b, &buf);
-    mongo_remove( gfs->client, gfs->chunks_ns, &b);
-    bson_destroy(&b);
-  }
-
-}
-
-/*--------------------------------------------------------------------*/
-
-int gridfs_find_query(gridfs* gfs, bson* query,
-         gridfile* gfile )
-
-{
-  bson_buffer date_buffer;
-  bson uploadDate;
-  bson_buffer buf;
-  bson finalQuery;
-  bson out;
-  int i;
-
-  bson_buffer_init(&date_buffer);
-  bson_append_int(&date_buffer, "uploadDate", -1);
-  bson_from_buffer(&uploadDate, &date_buffer);
-  bson_buffer_init(&buf);
-  bson_append_bson(&buf, "query", query);
-  bson_append_bson(&buf, "orderby", &uploadDate);
-  bson_from_buffer(&finalQuery, &buf);
-
-
-  i = (mongo_find_one(gfs->client, gfs->files_ns,
-         &finalQuery, NULL, &out));
-  bson_destroy(&uploadDate);
-  bson_destroy(&finalQuery);
-  if (!i)
-    return FALSE;
-  else {
-    gridfile_init(gfs, &out, gfile);
-    bson_destroy(&out);
-    return TRUE;
-  }
-}
-
-/*--------------------------------------------------------------------*/
-
-int gridfs_find_filename(gridfs* gfs, const char* filename,
-       gridfile* gfile)
-
-{
-  bson query;
-  bson_buffer buf;
-  int i;
-
-  bson_buffer_init(&buf);
-  bson_append_string(&buf, "filename", filename);
-  bson_from_buffer(&query, &buf) ;
-  i = gridfs_find_query(gfs, &query, gfile);
-  bson_destroy(&query);
-  return i;
-}
-
-/*--------------------------------------------------------------------*/
-
-int gridfile_init(gridfs* gfs, bson* meta, gridfile* gfile)
-
-{
-  gfile->gfs = gfs;
-  gfile->pos = 0;
-  gfile->meta = (bson*)bson_malloc(sizeof(bson));
-  if (gfile->meta == NULL) return FALSE;
-  bson_copy(gfile->meta, meta);
-  return TRUE;
-}
-
-/*--------------------------------------------------------------------*/
-
-void gridfile_destroy(gridfile* gfile)
-
-{
-  bson_destroy(gfile->meta);
-  free(gfile->meta);
-}
-
-/*--------------------------------------------------------------------*/
-
-bson_bool_t gridfile_exists(gridfile* gfile)
-
-{
-  return (bson_bool_t)(gfile != NULL || gfile->meta == NULL);
-}
-
-/*--------------------------------------------------------------------*/
-
-const char* gridfile_get_filename(gridfile* gfile)
-
-{
-  bson_iterator it;
-
-  bson_find(&it, gfile->meta, "filename");
-  return bson_iterator_string(&it);
-}
-
-/*--------------------------------------------------------------------*/
-
-int gridfile_get_chunksize(gridfile* gfile)
-
-{
-  bson_iterator it;
-
-  bson_find(&it, gfile->meta, "chunkSize");
-  return bson_iterator_int(&it);
-}
-
-/*--------------------------------------------------------------------*/
-
-gridfs_offset gridfile_get_contentlength(gridfile* gfile)
-
-{
-  bson_iterator it;
-
-  bson_find(&it, gfile->meta, "length");
-
-  if( bson_iterator_type( &it ) == bson_int )
-    return (gridfs_offset)bson_iterator_int( &it );
-  else
-    return (gridfs_offset)bson_iterator_long( &it );
-}
-
-/*--------------------------------------------------------------------*/
-
-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;
-}
-
-/*--------------------------------------------------------------------*/
-
-bson_date_t gridfile_get_uploaddate(gridfile* gfile)
-
-{
-  bson_iterator it;
-
-  bson_find(&it, gfile->meta, "uploadDate");
-  return bson_iterator_date( &it );
-}
-
-/*--------------------------------------------------------------------*/
-
-const char* gridfile_get_md5(gridfile* gfile)
-
-{
-  bson_iterator it;
-
-  bson_find(&it, gfile->meta, "md5");
-  return bson_iterator_string( &it );
-}
-
-/*--------------------------------------------------------------------*/
-
-const char* gridfile_get_field(gridfile* gfile, const char* name)
-
-{
-  bson_iterator it;
-
-  bson_find(&it, gfile->meta, name);
-  return bson_iterator_value( &it );
-}
-
-/*--------------------------------------------------------------------*/
-
-bson_bool_t gridfile_get_boolean(gridfile* gfile, const char* name)
-{
-  bson_iterator it;
-
-  bson_find(&it, gfile->meta, name);
-  return bson_iterator_bool( &it );
-}
-
-/*--------------------------------------------------------------------*/
-bson gridfile_get_metadata(gridfile* gfile)
-
-{
-  bson sub;
-  bson_iterator it;
-
-  if (bson_find(&it, gfile->meta, "metadata")) {
-    bson_iterator_subobject( &it, &sub );
-    return sub;
-  }
-  else {
-    bson_empty(&sub);
-    return sub;
-  }
-}
-
-/*--------------------------------------------------------------------*/
-
-int gridfile_get_numchunks(gridfile* gfile)
-
-{
-  bson_iterator it;
-  gridfs_offset length;
-  gridfs_offset chunkSize;
-  double numchunks;
-
-  bson_find(&it, gfile->meta, "length");
-
-  if( bson_iterator_type( &it ) == bson_int )
-    length = (gridfs_offset)bson_iterator_int( &it );
-  else
-    length = (gridfs_offset)bson_iterator_long( &it );
-
-  bson_find(&it, gfile->meta, "chunkSize");
-  chunkSize = bson_iterator_int(&it);
-  numchunks = ((double)length/(double)chunkSize);
-  return (numchunks - (int)numchunks > 0)
-    ? (int)(numchunks+1)
-    : (int)(numchunks);
-}
-
-/*--------------------------------------------------------------------*/
-
-bson gridfile_get_chunk(gridfile* gfile, int n)
-
-{
-  bson query;
-  bson out;
-  bson_buffer buf;
-  bson_iterator it;
-  bson_oid_t id;
-
-  bson_buffer_init(&buf);
-  bson_find(&it, gfile->meta, "_id");
-  id = *bson_iterator_oid(&it);
-  bson_append_oid(&buf, "files_id", &id);
-  bson_append_int(&buf, "n", n);
-  bson_from_buffer(&query, &buf);
-
-  assert(mongo_find_one(gfile->gfs->client,
-      gfile->gfs->chunks_ns,
-      &query, NULL, &out));
-  return out;
-}
-
-/*--------------------------------------------------------------------*/
-
-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_find(&it, gfile->meta, "_id");
-  id = *bson_iterator_oid(&it);
-
-  bson_buffer_init(&query_buf);
-  bson_append_oid(&query_buf, "files_id", &id);
-  if (size == 1) {
-    bson_append_int(&query_buf, "n", start);
-  } else {
-    bson_buffer_init(&gte_buf);
-    bson_append_int(&gte_buf, "$gte", start);
-    bson_from_buffer(&gte_bson, &gte_buf);
-    bson_append_bson(&query_buf, "n", &gte_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);
-}
-
-/*--------------------------------------------------------------------*/
-
-gridfs_offset gridfile_write_file(gridfile* gfile, FILE *stream)
-
-{
-  int i;
-  size_t len;
-  bson chunk;
-  bson_iterator it;
-  const char* data;
-  const int num = gridfile_get_numchunks( gfile );
-
-  for ( i=0; i<num; i++ ){
-    chunk = gridfile_get_chunk( gfile, i );
-    bson_find( &it, &chunk, "data" );
-    len = bson_iterator_bin_len( &it );
-    data = bson_iterator_bin_data( &it );
-    fwrite( data , sizeof(char), len, stream );
-  }
-
-  return gridfile_get_contentlength(gfile);
-}
-
-/*--------------------------------------------------------------------*/
-
-gridfs_offset gridfile_read(gridfile* gfile, gridfs_offset size, char* buf)
-
-{
-  mongo_cursor* chunks;
-  bson chunk;
-
-  int first_chunk;
-  int last_chunk;
-  int total_chunks;
-  gridfs_offset chunksize;
-  gridfs_offset contentlength;
-  gridfs_offset bytes_left;
-  int i;
-  bson_iterator it;
-  gridfs_offset chunk_len;
-  const char * chunk_data;
-
-  contentlength = gridfile_get_contentlength(gfile);
-  chunksize = gridfile_get_chunksize(gfile);
-  size = (contentlength - gfile->pos < size)
-    ? contentlength - gfile->pos
-    : size;
-  bytes_left = size;
-
-  first_chunk = (gfile->pos)/chunksize;
-  last_chunk = (gfile->pos+size-1)/chunksize;
-  total_chunks = last_chunk - first_chunk + 1;
-  chunks = gridfile_get_chunks(gfile, first_chunk, total_chunks);
-
-  for (i = 0; i < total_chunks; i++) {
-    mongo_cursor_next(chunks);
-    chunk = chunks->current;
-    bson_find(&it, &chunk, "data");
-    chunk_len = bson_iterator_bin_len( &it );
-    chunk_data = bson_iterator_bin_data( &it );
-    if (i == 0) {
-      chunk_data += (gfile->pos)%chunksize;
-      chunk_len -= (gfile->pos)%chunksize;
-    }
-    if (bytes_left > chunk_len) {
-      memcpy(buf, chunk_data, chunk_len);
-      bytes_left -= chunk_len;
-      buf += chunk_len;
-    } else {
-      memcpy(buf, chunk_data, bytes_left);
-    }
-  }
-
-  mongo_cursor_destroy(chunks);
-  gfile->pos = gfile->pos + size;
-
-  return size;
-}
-
-/*--------------------------------------------------------------------*/
-
-gridfs_offset gridfile_seek(gridfile* gfile, gridfs_offset offset)
-
-{
-  gridfs_offset length;
-
-  length = gridfile_get_contentlength(gfile);
-  gfile->pos = length < offset ? length : offset;
-  return gfile->pos;
-}