bson_ext 1.3.1 → 1.4.0

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

@@ -0,0 +1,229 @@
+/* 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

@@ -0,0 +1,799 @@
+/*--------------------------------------------------------------------*/
+/* 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;
+}