mongoc_uri_t *uri = mongoc_uri_new ("mongodb://localhost:27017/");
mongoc_uri_set_option_as_bool (uri, MONGOC_URI_TLS, true);
mongoc_client_t *client = mongoc_client_new_from_uri (uri);

mongoc_uri_t *uri = mongoc_uri_new ("mongodb://localhost:27017/");
mongoc_uri_set_option_as_bool (uri, MONGOC_URI_TLS, true);
mongoc_uri_set_option_as_utf8 (uri, MONGOC_URI_TLSCERTIFICATEKEYFILE, "/path/to/client-certificate.pem");
mongoc_client_t *client = mongoc_client_new_from_uri (uri);

$ openssl version

cmake -DOPENSSL_ROOT_DIR=/absolute/path/to/openssl

/* Don't try to compile this file on its own. It's meant to be #included


   by example code */
/* Insert some sample data */
bool
insert_data (mongoc_collection_t *collection)
{


   mongoc_bulk_operation_t *bulk;


   enum N { ndocs = 4 };


   bson_t *docs[ndocs];


   bson_error_t error;


   int i = 0;


   bool ret;


   bulk = mongoc_collection_create_bulk_operation_with_opts (collection, NULL);


   docs[0] = BCON_NEW ("x", BCON_DOUBLE (1.0), "tags", "[", "dog", "cat", "]");


   docs[1] = BCON_NEW ("x", BCON_DOUBLE (2.0), "tags", "[", "cat", "]");


   docs[2] = BCON_NEW (


      "x", BCON_DOUBLE (2.0), "tags", "[", "mouse", "cat", "dog", "]");


   docs[3] = BCON_NEW ("x", BCON_DOUBLE (3.0), "tags", "[", "]");


   for (i = 0; i < ndocs; i++) {


      mongoc_bulk_operation_insert (bulk, docs[i]);


      bson_destroy (docs[i]);


      docs[i] = NULL;


   }


   ret = mongoc_bulk_operation_execute (bulk, NULL, &error);


   if (!ret) {


      fprintf (stderr, "Error inserting data: %s\n", error.message);


   }


   mongoc_bulk_operation_destroy (bulk);


   return ret;
}
/* A helper which we'll use a lot later on */
void
print_res (const bson_t *reply)
{


   char *str;


   BSON_ASSERT (reply);


   str = bson_as_canonical_extended_json (reply, NULL);


   printf ("%s\n", str);


   bson_free (str);
}

bool
explain (mongoc_collection_t *collection)
{


   bson_t *command;


   bson_t reply;


   bson_error_t error;


   bool res;


   command = BCON_NEW ("explain",


                       "{",


                       "find",


                       BCON_UTF8 (COLLECTION_NAME),


                       "filter",


                       "{",


                       "x",


                       BCON_INT32 (1),


                       "}",


                       "}");


   res = mongoc_collection_command_simple (


      collection, command, NULL, &reply, &error);


   if (!res) {


      fprintf (stderr, "Error with explain: %s\n", error.message);


      goto cleanup;


   }


   /* Do something with the reply */


   print_res (&reply);
cleanup:


   bson_destroy (&reply);


   bson_destroy (command);


   return res;
}

/*


 * Copyright 2016 MongoDB, 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.


 */
#include <mongoc/mongoc.h>
#include <stdio.h>
const char *COLLECTION_NAME = "things";
#include "../doc-common-insert.c"
#include "explain.c"
int
main (int argc, char *argv[])
{


   mongoc_database_t *database = NULL;


   mongoc_client_t *client = NULL;


   mongoc_collection_t *collection = NULL;


   mongoc_uri_t *uri = NULL;


   bson_error_t error;


   char *host_and_port;


   int res = 0;


   if (argc < 2 || argc > 3) {


      fprintf (stderr,


               "usage: %s MONGOD-1-CONNECTION-STRING "


               "[MONGOD-2-HOST-NAME:MONGOD-2-PORT]\n",


               argv[0]);


      fprintf (stderr,


               "MONGOD-1-CONNECTION-STRING can be "


               "of the following forms:\n");


      fprintf (stderr, "localhost\t\t\t\tlocal machine\n");


      fprintf (stderr, "localhost:27018\t\t\t\tlocal machine on port 27018\n");


      fprintf (stderr,


               "mongodb://user:pass@localhost:27017\t"


               "local machine on port 27017, and authenticate with username "


               "user and password pass\n");


      return EXIT_FAILURE;


   }


   mongoc_init ();


   if (strncmp (argv[1], "mongodb://", 10) == 0) {


      host_and_port = bson_strdup (argv[1]);


   } else {


      host_and_port = bson_strdup_printf ("mongodb://%s", argv[1]);


   }


   uri = mongoc_uri_new_with_error (host_and_port, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               host_and_port,


               error.message);


      res = EXIT_FAILURE;


      goto cleanup;


   }


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      res = EXIT_FAILURE;


      goto cleanup;


   }


   mongoc_client_set_error_api (client, 2);


   database = mongoc_client_get_database (client, "test");


   collection = mongoc_database_get_collection (database, COLLECTION_NAME);


   printf ("Inserting data\n");


   if (!insert_data (collection)) {


      res = EXIT_FAILURE;


      goto cleanup;


   }


   printf ("explain\n");


   if (!explain (collection)) {


      res = EXIT_FAILURE;


      goto cleanup;


   }
cleanup:


   if (collection) {


      mongoc_collection_destroy (collection);


   }


   if (database) {


      mongoc_database_destroy (database);


   }


   if (client) {


      mongoc_client_destroy (client);


   }


   if (uri) {


      mongoc_uri_destroy (uri);


   }


   bson_free (host_and_port);


   mongoc_cleanup ();


   return res;
}

$ mongod

$ mkdir /tmp/db2
$ mongod --dbpath /tmp/db2 --port 27018 # second instance

$ cd examples/common_operations/$ gcc -Wall -o example common-operations.c $(pkg-config --cflags --libs libmongoc-1.0)$ ./example localhost:27017 localhost:27018
Inserting data
explain
{


   "executionStats" : {


      "allPlansExecution" : [],


      "executionStages" : {


         "advanced" : 19,


         "direction" : "forward" ,


         "docsExamined" : 76,


         "executionTimeMillisEstimate" : 0,


         "filter" : {


            "x" : {


               "$eq" : 1


            }


         },


         "invalidates" : 0,


         "isEOF" : 1,


         "nReturned" : 19,


         "needTime" : 58,


         "needYield" : 0,


         "restoreState" : 0,


         "saveState" : 0,


         "stage" : "COLLSCAN" ,


         "works" : 78


      },


      "executionSuccess" : true,


      "executionTimeMillis" : 0,


      "nReturned" : 19,


      "totalDocsExamined" : 76,


      "totalKeysExamined" : 0


   },


   "ok" : 1,


   "queryPlanner" : {


      "indexFilterSet" : false,


      "namespace" : "test.things",


      "parsedQuery" : {


         "x" : {


            "$eq" : 1


         }


      },


      "plannerVersion" : 1,


      "rejectedPlans" : [],


      "winningPlan" : {


         "direction" : "forward" ,


         "filter" : {


            "x" : {


               "$eq" : 1


            }


         },


         "stage" : "COLLSCAN"


      }


   },


   "serverInfo" : {


      "gitVersion" : "05552b562c7a0b3143a729aaa0838e558dc49b25" ,


      "host" : "MacBook-Pro-57.local",


      "port" : 27017,


      "version" : "3.2.6"


   }
}

#include <bson/bson.h>
#include <mongoc/mongoc.h>
int
main (int argc, char *argv[])
{


   mongoc_client_t *client;


   mongoc_init ();


   /* Create our MongoDB Client */


   client = mongoc_client_new (


      "mongodb://host01:27017,host02:27017,host03:27017/?replicaSet=myreplset");


   /* Do some work */


   /* TODO */


   /* Clean up */


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return 0;
}

It is recommended to use a seed list of members of the replica set to allow the driver to connect to any node.

#include <bson/bson.h>
#include <mongoc/mongoc.h>
int
main (int argc, char *argv[])
{


   mongoc_client_t *client;


   mongoc_init ();


   /* Create our MongoDB Client */


   client = mongoc_client_new ("mongodb://myshard01:27017/");


   /* Do something with client ... */


   /* Free the client */


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return 0;
}

mongoc_uri_t *uri = mongoc_uri_new ("mongodb://[::1]:27017");

mongoc_uri_t *uri = mongoc_uri_new ("mongodb://%2Ftmp%2Fmongodb-27017.sock");

mongoc_uri_t *uri = mongoc_uri_new ("mongodb://user:pass@%2Ftmp%2Fmongodb-27017.sock");

$ mongod --port 27017 --tlsMode requireTLS --tlsCertificateKeyFile server.pem --tlsCAFile ca.pem

mongoc_client_t *client = NULL;
client = mongoc_client_new ("mongodb://localhost:27017/?tls=true");

mongoc_client_t *client = NULL;
mongoc_uri_t *uri = mongoc_uri_new ("mongodb://localhost:27017/?tls=true");
mongoc_uri_set_option_as_utf8 (uri, MONGOC_URI_TLSCERTIFICATEKEYFILE, "client.pem");
client = mongoc_client_new_from_uri (uri);

mongoc_client_t *client = NULL;
client = mongoc_client_new ("mongodb://localhost:27017/?compressors=snappy,zlib,zstd");

mongoc_client_t *client = mongoc_client_new (


   "mongodb://hostA,hostB/?replicaSet=my_rs");

mongoc_uri_t *uri = mongoc_uri_new (


   "mongodb://hostA,hostB/?replicaSet=my_rs");
mongoc_client_pool_t *pool = mongoc_client_pool_new (uri);

mongoc_client_t *client = mongoc_client_pool_pop (pool);
/* use the client for operations ... */
mongoc_client_pool_push (pool, client);

mongoc_uri_t *uri = mongoc_uri_new (


   "mongodb://hostA,hostB/?replicaSet=my_rs&waitQueueTimeoutMS=1000");
mongoc_client_pool_t *pool = mongoc_client_pool_new (uri);
mongoc_client_t *client = mongoc_client_pool_pop (pool);
if (client) {


   /* use the client for operations ... */


   mongoc_client_pool_push (pool, client);
} else {


   /* take appropriate action for a timeout */
}

static void
print_all_documents (mongoc_collection_t *collection)
{


   mongoc_cursor_t *cursor;


   const bson_t *doc;


   bson_error_t error;


   bson_t query = BSON_INITIALIZER;


   char *str;


   cursor = mongoc_collection_find_with_opts (collection, query, NULL, NULL);


   while (mongoc_cursor_next (cursor, &doc)) {


      str = bson_as_canonical_extended_json (doc, NULL);


      printf ("%s\n", str);


      bson_free (str);


   }


   if (mongoc_cursor_error (cursor, &error)) {


      fprintf (stderr, "Failed to iterate all documents: %s\n", error.message);


   }


   mongoc_cursor_destroy (cursor);
}

#include <bson/bson.h>
#include <mongoc/mongoc.h>
#include <stdio.h>
#include <stdlib.h>
#ifdef _WIN32
#define sleep(_n) Sleep ((_n) *1000)
#endif
static void
print_bson (const bson_t *b)
{


   char *str;


   str = bson_as_canonical_extended_json (b, NULL);


   fprintf (stdout, "%s\n", str);


   bson_free (str);
}
static mongoc_cursor_t *
query_collection (mongoc_collection_t *collection, uint32_t last_time)
{


   mongoc_cursor_t *cursor;


   bson_t query;


   bson_t gt;


   bson_t opts;


   BSON_ASSERT (collection);


   bson_init (&query);


   BSON_APPEND_DOCUMENT_BEGIN (&query, "ts", &gt);


   BSON_APPEND_TIMESTAMP (&gt, "$gt", last_time, 0);


   bson_append_document_end (&query, &gt);


   bson_init (&opts);


   BSON_APPEND_BOOL (&opts, "tailable", true);


   BSON_APPEND_BOOL (&opts, "awaitData", true);


   cursor = mongoc_collection_find_with_opts (collection, &query, &opts, NULL);


   bson_destroy (&query);


   bson_destroy (&opts);


   return cursor;
}
static void
tail_collection (mongoc_collection_t *collection)
{


   mongoc_cursor_t *cursor;


   uint32_t last_time;


   const bson_t *doc;


   bson_error_t error;


   bson_iter_t iter;


   BSON_ASSERT (collection);


   last_time = (uint32_t) time (NULL);


   while (true) {


      cursor = query_collection (collection, last_time);


      while (!mongoc_cursor_error (cursor, &error) &&


             mongoc_cursor_more (cursor)) {


         if (mongoc_cursor_next (cursor, &doc)) {


            if (bson_iter_init_find (&iter, doc, "ts") &&


                BSON_ITER_HOLDS_TIMESTAMP (&iter)) {


               bson_iter_timestamp (&iter, &last_time, NULL);


            }


            print_bson (doc);


         }


      }


      if (mongoc_cursor_error (cursor, &error)) {


         if (error.domain == MONGOC_ERROR_SERVER) {


            fprintf (stderr, "%s\n", error.message);


            exit (1);


         }


      }


      mongoc_cursor_destroy (cursor);


      sleep (1);


   }
}
int
main (int argc, char *argv[])
{


   mongoc_collection_t *collection;


   mongoc_client_t *client;


   mongoc_uri_t *uri;


   bson_error_t error;


   if (argc != 2) {


      fprintf (stderr, "usage: %s MONGO_URI\n", argv[0]);


      return EXIT_FAILURE;


   }


   mongoc_init ();


   uri = mongoc_uri_new_with_error (argv[1], &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               argv[1],


               error.message);


      return EXIT_FAILURE;


   }


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      return EXIT_FAILURE;


   }


   mongoc_client_set_error_api (client, 2);


   collection = mongoc_client_get_collection (client, "local", "oplog.rs");


   tail_collection (collection);


   mongoc_collection_destroy (collection);


   mongoc_uri_destroy (uri);


   mongoc_client_destroy (client);


   return EXIT_SUCCESS;
}

$ gcc -Wall -o mongoc-tail mongoc-tail.c $(pkg-config --cflags --libs libmongoc-1.0)
$ ./mongoc-tail mongodb://example.com/?replicaSet=myReplSet
{


    "h" : -8458503739429355503,


    "ns" : "test.test",


    "o" : {


        "_id" : {


            "$oid" : "5372ab0a25164be923d10d50"


        }


    },


    "op" : "i",


    "ts" : {


        "$timestamp" : {


            "i" : 1,


            "t" : 1400023818


        }


    },


    "v" : 2
}

mongoc_cursor_set_max_await_time_ms().

mongoc_bulk_operation_t *bulk =


   mongoc_collection_create_bulk_operation_with_opts (collection, NULL);

#include <assert.h>
#include <mongoc/mongoc.h>
#include <stdio.h>
static void
bulk1 (mongoc_collection_t *collection)
{


   mongoc_bulk_operation_t *bulk;


   bson_error_t error;


   bson_t *doc;


   bson_t reply;


   char *str;


   bool ret;


   int i;


   bulk = mongoc_collection_create_bulk_operation_with_opts (collection, NULL);


   for (i = 0; i < 10000; i++) {


      doc = BCON_NEW ("i", BCON_INT32 (i));


      mongoc_bulk_operation_insert (bulk, doc);


      bson_destroy (doc);


   }


   ret = mongoc_bulk_operation_execute (bulk, &reply, &error);


   str = bson_as_canonical_extended_json (&reply, NULL);


   printf ("%s\n", str);


   bson_free (str);


   if (!ret) {


      fprintf (stderr, "Error: %s\n", error.message);


   }


   bson_destroy (&reply);


   mongoc_bulk_operation_destroy (bulk);
}
int
main (void)
{


   mongoc_client_t *client;


   mongoc_collection_t *collection;


   const char *uri_string = "mongodb://localhost/?appname=bulk1-example";


   mongoc_uri_t *uri;


   bson_error_t error;


   mongoc_init ();


   uri = mongoc_uri_new_with_error (uri_string, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               uri_string,


               error.message);


      return EXIT_FAILURE;


   }


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      return EXIT_FAILURE;


   }


   mongoc_client_set_error_api (client, 2);


   collection = mongoc_client_get_collection (client, "test", "test");


   bulk1 (collection);


   mongoc_uri_destroy (uri);


   mongoc_collection_destroy (collection);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return EXIT_SUCCESS;
}

{"nInserted"   : 10000,


 "nMatched"    : 0,


 "nModified"   : 0,


 "nRemoved"    : 0,


 "nUpserted"   : 0,


 "writeErrors" : []


 "writeConcernErrors" : [] }

#include <assert.h>
#include <mongoc/mongoc.h>
#include <stdio.h>
static void
bulk2 (mongoc_collection_t *collection)
{


   mongoc_bulk_operation_t *bulk;


   bson_error_t error;


   bson_t *query;


   bson_t *doc;


   bson_t *opts;


   bson_t reply;


   char *str;


   bool ret;


   int i;


   bulk = mongoc_collection_create_bulk_operation_with_opts (collection, NULL);


   /* Remove everything */


   query = bson_new ();


   mongoc_bulk_operation_remove (bulk, query);


   bson_destroy (query);


   /* Add a few documents */


   for (i = 1; i < 4; i++) {


      doc = BCON_NEW ("_id", BCON_INT32 (i));


      mongoc_bulk_operation_insert (bulk, doc);


      bson_destroy (doc);


   }


   /* {_id: 1} => {$set: {foo: "bar"}} */


   query = BCON_NEW ("_id", BCON_INT32 (1));


   doc = BCON_NEW ("$set", "{", "foo", BCON_UTF8 ("bar"), "}");


   mongoc_bulk_operation_update_many_with_opts (bulk, query, doc, NULL, &error);


   bson_destroy (query);


   bson_destroy (doc);


   /* {_id: 4} => {'$inc': {'j': 1}} (upsert) */


   opts = BCON_NEW ("upsert", BCON_BOOL (true));


   query = BCON_NEW ("_id", BCON_INT32 (4));


   doc = BCON_NEW ("$inc", "{", "j", BCON_INT32 (1), "}");


   mongoc_bulk_operation_update_many_with_opts (bulk, query, doc, opts, &error);


   bson_destroy (query);


   bson_destroy (doc);


   bson_destroy (opts);


   /* replace {j:1} with {j:2} */


   query = BCON_NEW ("j", BCON_INT32 (1));


   doc = BCON_NEW ("j", BCON_INT32 (2));


   mongoc_bulk_operation_replace_one_with_opts (bulk, query, doc, NULL, &error);


   bson_destroy (query);


   bson_destroy (doc);


   ret = mongoc_bulk_operation_execute (bulk, &reply, &error);


   str = bson_as_canonical_extended_json (&reply, NULL);


   printf ("%s\n", str);


   bson_free (str);


   if (!ret) {


      printf ("Error: %s\n", error.message);


   }


   bson_destroy (&reply);


   mongoc_bulk_operation_destroy (bulk);
}
int
main (void)
{


   mongoc_client_t *client;


   mongoc_collection_t *collection;


   const char *uri_string = "mongodb://localhost/?appname=bulk2-example";


   mongoc_uri_t *uri;


   bson_error_t error;


   mongoc_init ();


   uri = mongoc_uri_new_with_error (uri_string, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               uri_string,


               error.message);


      return EXIT_FAILURE;


   }


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      return EXIT_FAILURE;


   }


   mongoc_client_set_error_api (client, 2);


   collection = mongoc_client_get_collection (client, "test", "test");


   bulk2 (collection);


   mongoc_uri_destroy (uri);


   mongoc_collection_destroy (collection);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return EXIT_SUCCESS;
}

{ "nInserted"   : 3,


  "nMatched"    : 2,


  "nModified"   : 2,


  "nRemoved"    : 10000,


  "nUpserted"   : 1,


  "upserted"    : [{"index" : 5, "_id" : 4}],


  "writeErrors" : []


  "writeConcernErrors" : [] }

#include <assert.h>
#include <mongoc/mongoc.h>
#include <stdio.h>
static void
bulk3 (mongoc_collection_t *collection)
{


   bson_t opts = BSON_INITIALIZER;


   mongoc_bulk_operation_t *bulk;


   bson_error_t error;


   bson_t *query;


   bson_t *doc;


   bson_t reply;


   char *str;


   bool ret;


   /* false indicates unordered */


   BSON_APPEND_BOOL (&opts, "ordered", false);


   bulk = mongoc_collection_create_bulk_operation_with_opts (collection, &opts);


   bson_destroy (&opts);


   /* Add a document */


   doc = BCON_NEW ("_id", BCON_INT32 (1));


   mongoc_bulk_operation_insert (bulk, doc);


   bson_destroy (doc);


   /* remove {_id: 2} */


   query = BCON_NEW ("_id", BCON_INT32 (2));


   mongoc_bulk_operation_remove_one (bulk, query);


   bson_destroy (query);


   /* insert {_id: 3} */


   doc = BCON_NEW ("_id", BCON_INT32 (3));


   mongoc_bulk_operation_insert (bulk, doc);


   bson_destroy (doc);


   /* replace {_id:4} {'i': 1} */


   query = BCON_NEW ("_id", BCON_INT32 (4));


   doc = BCON_NEW ("i", BCON_INT32 (1));


   mongoc_bulk_operation_replace_one (bulk, query, doc, false);


   bson_destroy (query);


   bson_destroy (doc);


   ret = mongoc_bulk_operation_execute (bulk, &reply, &error);


   str = bson_as_canonical_extended_json (&reply, NULL);


   printf ("%s\n", str);


   bson_free (str);


   if (!ret) {


      printf ("Error: %s\n", error.message);


   }


   bson_destroy (&reply);


   mongoc_bulk_operation_destroy (bulk);


   bson_destroy (&opts);
}
int
main (void)
{


   mongoc_client_t *client;


   mongoc_collection_t *collection;


   const char *uri_string = "mongodb://localhost/?appname=bulk3-example";


   mongoc_uri_t *uri;


   bson_error_t error;


   mongoc_init ();


   uri = mongoc_uri_new_with_error (uri_string, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               uri_string,


               error.message);


      return EXIT_FAILURE;


   }


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      return EXIT_FAILURE;


   }


   mongoc_client_set_error_api (client, 2);


   collection = mongoc_client_get_collection (client, "test", "test");


   bulk3 (collection);


   mongoc_uri_destroy (uri);


   mongoc_collection_destroy (collection);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return EXIT_SUCCESS;
}

{ "nInserted"    : 0,


  "nMatched"     : 1,


  "nModified"    : 1,


  "nRemoved"     : 1,


  "nUpserted"    : 0,


  "writeErrors"  : [


    { "index"  : 0,


      "code"   : 11000,


      "errmsg" : "E11000 duplicate key error index: test.test.$_id_ dup key: { : 1 }" },


    { "index"  : 2,


      "code"   : 11000,


      "errmsg" : "E11000 duplicate key error index: test.test.$_id_ dup key: { : 3 }" } ],


  "writeConcernErrors" : [] }
Error: E11000 duplicate key error index: test.test.$_id_ dup key: { : 1 }

#include <assert.h>
#include <mongoc/mongoc.h>
#include <stdio.h>
static void
bulk5_fail (mongoc_collection_t *collection)
{


   mongoc_bulk_operation_t *bulk;


   bson_error_t error;


   bson_t *doc;


   bson_t reply;


   char *str;


   bool ret;


   bulk = mongoc_collection_create_bulk_operation_with_opts (collection, NULL);


   /* Two inserts */


   doc = BCON_NEW ("_id", BCON_INT32 (31));


   mongoc_bulk_operation_insert (bulk, doc);


   bson_destroy (doc);


   doc = BCON_NEW ("_id", BCON_INT32 (32));


   mongoc_bulk_operation_insert (bulk, doc);


   bson_destroy (doc);


   /* The above documents do not comply to the schema validation rules


    * we created previously, so this will result in an error */


   ret = mongoc_bulk_operation_execute (bulk, &reply, &error);


   str = bson_as_canonical_extended_json (&reply, NULL);


   printf ("%s\n", str);


   bson_free (str);


   if (!ret) {


      printf ("Error: %s\n", error.message);


   }


   bson_destroy (&reply);


   mongoc_bulk_operation_destroy (bulk);
}
static void
bulk5_success (mongoc_collection_t *collection)
{


   mongoc_bulk_operation_t *bulk;


   bson_error_t error;


   bson_t *doc;


   bson_t reply;


   char *str;


   bool ret;


   bulk = mongoc_collection_create_bulk_operation_with_opts (collection, NULL);


   /* Allow this document to bypass document validation.


    * NOTE: When authentication is enabled, the authenticated user must have


    * either the "dbadmin" or "restore" roles to bypass document validation */


   mongoc_bulk_operation_set_bypass_document_validation (bulk, true);


   /* Two inserts */


   doc = BCON_NEW ("_id", BCON_INT32 (31));


   mongoc_bulk_operation_insert (bulk, doc);


   bson_destroy (doc);


   doc = BCON_NEW ("_id", BCON_INT32 (32));


   mongoc_bulk_operation_insert (bulk, doc);


   bson_destroy (doc);


   ret = mongoc_bulk_operation_execute (bulk, &reply, &error);


   str = bson_as_canonical_extended_json (&reply, NULL);


   printf ("%s\n", str);


   bson_free (str);


   if (!ret) {


      printf ("Error: %s\n", error.message);


   }


   bson_destroy (&reply);


   mongoc_bulk_operation_destroy (bulk);
}
int
main (void)
{


   bson_t *options;


   bson_error_t error;


   mongoc_client_t *client;


   mongoc_collection_t *collection;


   mongoc_database_t *database;


   const char *uri_string = "mongodb://localhost/?appname=bulk5-example";


   mongoc_uri_t *uri;


   mongoc_init ();


   uri = mongoc_uri_new_with_error (uri_string, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               uri_string,


               error.message);


      return EXIT_FAILURE;


   }


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      return EXIT_FAILURE;


   }


   mongoc_client_set_error_api (client, 2);


   database = mongoc_client_get_database (client, "testasdf");


   /* Create schema validator */


   options = BCON_NEW (


      "validator", "{", "number", "{", "$gte", BCON_INT32 (5), "}", "}");


   collection =


      mongoc_database_create_collection (database, "collname", options, &error);


   if (collection) {


      bulk5_fail (collection);


      bulk5_success (collection);


      mongoc_collection_destroy (collection);


   } else {


      fprintf (stderr, "Couldn't create collection: '%s'\n", error.message);


   }


   bson_free (options);


   mongoc_uri_destroy (uri);


   mongoc_database_destroy (database);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return EXIT_SUCCESS;
}

{ "nInserted" : 0,


  "nMatched" : 0,


  "nModified" : 0,


  "nRemoved" : 0,


  "nUpserted" : 0,


  "writeErrors" : [


    { "index" : 0,


      "code" : 121,


      "errmsg" : "Document failed validation" } ] }
Error: Document failed validation
{ "nInserted" : 2,


  "nMatched" : 0,


  "nModified" : 0,


  "nRemoved" : 0,


  "nUpserted" : 0,


  "writeErrors" : [] }

#include <assert.h>
#include <mongoc/mongoc.h>
#include <stdio.h>
static void
bulk4 (mongoc_collection_t *collection)
{


   bson_t opts = BSON_INITIALIZER;


   mongoc_write_concern_t *wc;


   mongoc_bulk_operation_t *bulk;


   bson_error_t error;


   bson_t *doc;


   bson_t reply;


   char *str;


   bool ret;


   wc = mongoc_write_concern_new ();


   mongoc_write_concern_set_w (wc, 4);


   mongoc_write_concern_set_wtimeout_int64 (wc, 100); /* milliseconds */


   mongoc_write_concern_append (wc, &opts);


   bulk = mongoc_collection_create_bulk_operation_with_opts (collection, &opts);


   /* Two inserts */


   doc = BCON_NEW ("_id", BCON_INT32 (10));


   mongoc_bulk_operation_insert (bulk, doc);


   bson_destroy (doc);


   doc = BCON_NEW ("_id", BCON_INT32 (11));


   mongoc_bulk_operation_insert (bulk, doc);


   bson_destroy (doc);


   ret = mongoc_bulk_operation_execute (bulk, &reply, &error);


   str = bson_as_canonical_extended_json (&reply, NULL);


   printf ("%s\n", str);


   bson_free (str);


   if (!ret) {


      printf ("Error: %s\n", error.message);


   }


   bson_destroy (&reply);


   mongoc_bulk_operation_destroy (bulk);


   mongoc_write_concern_destroy (wc);


   bson_destroy (&opts);
}
int
main (void)
{


   mongoc_client_t *client;


   mongoc_collection_t *collection;


   const char *uri_string = "mongodb://localhost/?appname=bulk4-example";


   mongoc_uri_t *uri;


   bson_error_t error;


   mongoc_init ();


   uri = mongoc_uri_new_with_error (uri_string, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               uri_string,


               error.message);


      return EXIT_FAILURE;


   }


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      return EXIT_FAILURE;


   }


   mongoc_client_set_error_api (client, 2);


   collection = mongoc_client_get_collection (client, "test", "test");


   bulk4 (collection);


   mongoc_uri_destroy (uri);


   mongoc_collection_destroy (collection);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return EXIT_SUCCESS;
}

{ "nInserted"    : 2,


  "nMatched"     : 0,


  "nModified"    : 0,


  "nRemoved"     : 0,


  "nUpserted"    : 0,


  "writeErrors"  : [],


  "writeConcernErrors" : [


    { "code"   : 64,


      "errmsg" : "waiting for replication timed out" }
] }
Error: waiting for replication timed out

#include <mongoc/mongoc.h>
#include <stdio.h>
static void
bulk_collation (mongoc_collection_t *collection)
{


   mongoc_bulk_operation_t *bulk;


   bson_t *opts;


   bson_t *doc;


   bson_t *selector;


   bson_t *update;


   bson_error_t error;


   bson_t reply;


   char *str;


   uint32_t ret;


   /* insert {_id: "one"} and {_id: "One"} */


   bulk = mongoc_collection_create_bulk_operation_with_opts (collection, NULL);


   doc = BCON_NEW ("_id", BCON_UTF8 ("one"));


   mongoc_bulk_operation_insert (bulk, doc);


   bson_destroy (doc);


   doc = BCON_NEW ("_id", BCON_UTF8 ("One"));


   mongoc_bulk_operation_insert (bulk, doc);


   bson_destroy (doc);


   /* "One" normally sorts before "one"; make "one" come first */


   opts = BCON_NEW ("collation",


                    "{",


                    "locale",


                    BCON_UTF8 ("en_US"),


                    "caseFirst",


                    BCON_UTF8 ("lower"),


                    "}");


   /* set x=1 on the document with _id "One", which now sorts after "one" */


   update = BCON_NEW ("$set", "{", "x", BCON_INT64 (1), "}");


   selector = BCON_NEW ("_id", "{", "$gt", BCON_UTF8 ("one"), "}");


   mongoc_bulk_operation_update_one_with_opts (


      bulk, selector, update, opts, &error);


   ret = mongoc_bulk_operation_execute (bulk, &reply, &error);


   str = bson_as_canonical_extended_json (&reply, NULL);


   printf ("%s\n", str);


   bson_free (str);


   if (!ret) {


      printf ("Error: %s\n", error.message);


   }


   bson_destroy (&reply);


   bson_destroy (update);


   bson_destroy (selector);


   bson_destroy (opts);


   mongoc_bulk_operation_destroy (bulk);
}
int
main (void)
{


   mongoc_client_t *client;


   mongoc_collection_t *collection;


   const char *uri_string = "mongodb://localhost/?appname=bulk-collation";


   mongoc_uri_t *uri;


   bson_error_t error;


   mongoc_init ();


   uri = mongoc_uri_new_with_error (uri_string, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               uri_string,


               error.message);


      return EXIT_FAILURE;


   }


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      return EXIT_FAILURE;


   }


   mongoc_client_set_error_api (client, 2);


   collection = mongoc_client_get_collection (client, "db", "collection");


   bulk_collation (collection);


   mongoc_uri_destroy (uri);


   mongoc_collection_destroy (collection);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return EXIT_SUCCESS;
}

{ "nInserted" : 2,


   "nMatched" : 1,


   "nModified" : 1,


   "nRemoved" : 0,


   "nUpserted" : 0,


   "writeErrors" : [  ]
}

#include <mongoc/mongoc.h>
#include <stdio.h>
static void
bulk6 (mongoc_collection_t *collection)
{


   bson_t opts = BSON_INITIALIZER;


   mongoc_write_concern_t *wc;


   mongoc_bulk_operation_t *bulk;


   bson_error_t error;


   bson_t *doc;


   bson_t *selector;


   bson_t reply;


   char *str;


   bool ret;


   wc = mongoc_write_concern_new ();


   mongoc_write_concern_set_w (wc, 0);


   mongoc_write_concern_append (wc, &opts);


   bulk = mongoc_collection_create_bulk_operation_with_opts (collection, &opts);


   doc = BCON_NEW ("_id", BCON_INT32 (10));


   mongoc_bulk_operation_insert (bulk, doc);


   bson_destroy (doc);


   selector = BCON_NEW ("_id", BCON_INT32 (11));


   mongoc_bulk_operation_remove_one (bulk, selector);


   bson_destroy (selector);


   ret = mongoc_bulk_operation_execute (bulk, &reply, &error);


   str = bson_as_canonical_extended_json (&reply, NULL);


   printf ("%s\n", str);


   bson_free (str);


   if (!ret) {


      printf ("Error: %s\n", error.message);


   }


   bson_destroy (&reply);


   mongoc_bulk_operation_destroy (bulk);


   mongoc_write_concern_destroy (wc);


   bson_destroy (&opts);
}
int
main (void)
{


   mongoc_client_t *client;


   mongoc_collection_t *collection;


   const char *uri_string = "mongodb://localhost/?appname=bulk6-example";


   mongoc_uri_t *uri;


   bson_error_t error;


   mongoc_init ();


   uri = mongoc_uri_new_with_error (uri_string, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               uri_string,


               error.message);


      return EXIT_FAILURE;


   }


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      return EXIT_FAILURE;


   }


   mongoc_client_set_error_api (client, 2);


   collection = mongoc_client_get_collection (client, "test", "test");


   bulk6 (collection);


   mongoc_uri_destroy (uri);


   mongoc_collection_destroy (collection);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return EXIT_SUCCESS;
}

{ }

$ mongoimport --drop -d test -c zipcodes zips.json

$ mongo test
connecting to: test
> db.zipcodes.count()
29467
> db.zipcodes.findOne()
{


      "_id" : "35004",


      "city" : "ACMAR",


      "loc" : [


              -86.51557,


              33.584132


      ],


      "pop" : 6055,


      "state" : "AL"
}

{


  "_id" : "35004",


  "city" : "Acmar",


  "state" : "AL",


  "pop" : 6055,


  "loc" : [-86.51557, 33.584132]
}

#include <mongoc/mongoc.h>
#include <stdio.h>
static void
print_pipeline (mongoc_collection_t *collection)
{


   mongoc_cursor_t *cursor;


   bson_error_t error;


   const bson_t *doc;


   bson_t *pipeline;


   char *str;


   pipeline = BCON_NEW ("pipeline",


                        "[",


                        "{",


                        "$group",


                        "{",


                        "_id",


                        "$state",


                        "total_pop",


                        "{",


                        "$sum",


                        "$pop",


                        "}",


                        "}",


                        "}",


                        "{",


                        "$match",


                        "{",


                        "total_pop",


                        "{",


                        "$gte",


                        BCON_INT32 (10000000),


                        "}",


                        "}",


                        "}",


                        "]");


   cursor = mongoc_collection_aggregate (


      collection, MONGOC_QUERY_NONE, pipeline, NULL, NULL);


   while (mongoc_cursor_next (cursor, &doc)) {


      str = bson_as_canonical_extended_json (doc, NULL);


      printf ("%s\n", str);


      bson_free (str);


   }


   if (mongoc_cursor_error (cursor, &error)) {


      fprintf (stderr, "Cursor Failure: %s\n", error.message);


   }


   mongoc_cursor_destroy (cursor);


   bson_destroy (pipeline);
}
int
main (void)
{


   mongoc_client_t *client;


   mongoc_collection_t *collection;


   const char *uri_string =


      "mongodb://localhost:27017/?appname=aggregation-example";


   mongoc_uri_t *uri;


   bson_error_t error;


   mongoc_init ();


   uri = mongoc_uri_new_with_error (uri_string, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               uri_string,


               error.message);


      return EXIT_FAILURE;


   }


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      return EXIT_FAILURE;


   }


   mongoc_client_set_error_api (client, 2);


   collection = mongoc_client_get_collection (client, "test", "zipcodes");


   print_pipeline (collection);


   mongoc_uri_destroy (uri);


   mongoc_collection_destroy (collection);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return EXIT_SUCCESS;
}

{ "_id" : "PA", "total_pop" : 11881643 }
{ "_id" : "OH", "total_pop" : 10847115 }
{ "_id" : "NY", "total_pop" : 17990455 }
{ "_id" : "FL", "total_pop" : 12937284 }
{ "_id" : "TX", "total_pop" : 16986510 }
{ "_id" : "IL", "total_pop" : 11430472 }
{ "_id" : "CA", "total_pop" : 29760021 }

{ "_id" : "WA", "total_pop" : 4866692 }

pipeline = BCON_NEW ("pipeline", "[",


   "{", "$group", "{", "_id", "{", "state", "$state", "city", "$city", "}", "pop", "{", "$sum", "$pop", "}", "}", "}",


   "{", "$group", "{", "_id", "$_id.state", "avg_city_pop", "{", "$avg", "$pop", "}", "}", "}",


   "{", "$sort", "{", "avg_city_pop", BCON_INT32 (-1), "}", "}",


   "{", "$limit", BCON_INT32 (3) "}",
"]");

{ "_id" : "DC", "avg_city_pop" : 303450.0 }
{ "_id" : "FL", "avg_city_pop" : 27942.29805615551 }
{ "_id" : "CA", "avg_city_pop" : 27735.341099720412 }

{ "_id" : { "state" : "WY", "city" : "Smoot" }, "pop" : 414 }

{ "_id" : "FL", "avg_city_pop" : 27942.29805615551 }

/* Don't try to compile this file on its own. It's meant to be #included


   by example code */
/* Insert some sample data */
bool
insert_data (mongoc_collection_t *collection)
{


   mongoc_bulk_operation_t *bulk;


   enum N { ndocs = 4 };


   bson_t *docs[ndocs];


   bson_error_t error;


   int i = 0;


   bool ret;


   bulk = mongoc_collection_create_bulk_operation_with_opts (collection, NULL);


   docs[0] = BCON_NEW ("x", BCON_DOUBLE (1.0), "tags", "[", "dog", "cat", "]");


   docs[1] = BCON_NEW ("x", BCON_DOUBLE (2.0), "tags", "[", "cat", "]");


   docs[2] = BCON_NEW (


      "x", BCON_DOUBLE (2.0), "tags", "[", "mouse", "cat", "dog", "]");


   docs[3] = BCON_NEW ("x", BCON_DOUBLE (3.0), "tags", "[", "]");


   for (i = 0; i < ndocs; i++) {


      mongoc_bulk_operation_insert (bulk, docs[i]);


      bson_destroy (docs[i]);


      docs[i] = NULL;


   }


   ret = mongoc_bulk_operation_execute (bulk, NULL, &error);


   if (!ret) {


      fprintf (stderr, "Error inserting data: %s\n", error.message);


   }


   mongoc_bulk_operation_destroy (bulk);


   return ret;
}
/* A helper which we'll use a lot later on */
void
print_res (const bson_t *reply)
{


   char *str;


   BSON_ASSERT (reply);


   str = bson_as_canonical_extended_json (reply, NULL);


   printf ("%s\n", str);


   bson_free (str);
}

bool
distinct (mongoc_database_t *database)
{


   bson_t *command;


   bson_t reply;


   bson_error_t error;


   bool res;


   bson_iter_t iter;


   bson_iter_t array_iter;


   double val;


   command = BCON_NEW ("distinct",


                       BCON_UTF8 (COLLECTION_NAME),


                       "key",


                       BCON_UTF8 ("x"),


                       "query",


                       "{",


                       "x",


                       "{",


                       "$gt",


                       BCON_DOUBLE (1.0),


                       "}",


                       "}");


   res =


      mongoc_database_command_simple (database, command, NULL, &reply, &error);


   if (!res) {


      fprintf (stderr, "Error with distinct: %s\n", error.message);


      goto cleanup;


   }


   /* Do something with reply (in this case iterate through the values) */


   if (!(bson_iter_init_find (&iter, &reply, "values") &&


         BSON_ITER_HOLDS_ARRAY (&iter) &&


         bson_iter_recurse (&iter, &array_iter))) {


      fprintf (stderr, "Couldn't extract \"values\" field from response\n");


      goto cleanup;


   }


   while (bson_iter_next (&array_iter)) {


      if (BSON_ITER_HOLDS_DOUBLE (&array_iter)) {


         val = bson_iter_double (&array_iter);


         printf ("Next double: %f\n", val);


      }


   }
cleanup:


   /* cleanup */


   bson_destroy (command);


   bson_destroy (&reply);


   return res;
}

const char *const COLLECTION_NAME = "things";
/* Our map function just emits a single (key, 1) pair for each tag


   in the array: */
const char *const MAPPER = "function () {"


                           "this.tags.forEach(function(z) {"


                           "emit(z, 1);"


                           "});"


                           "}";
/* The reduce function sums over all of the emitted values for a


   given key: */
const char *const REDUCER = "function (key, values) {"


                            "var total = 0;"


                            "for (var i = 0; i < values.length; i++) {"


                            "total += values[i];"


                            "}"


                            "return total;"


                            "}";
/* Note We can't just return values.length as the reduce function


   might be called iteratively on the results of other reduce


   steps. */

bool
map_reduce_basic (mongoc_database_t *database)
{


   bson_t reply;


   bson_t *command;


   bool res;


   bson_error_t error;


   mongoc_cursor_t *cursor;


   const bson_t *doc;


   bool query_done = false;


   const char *out_collection_name = "outCollection";


   mongoc_collection_t *out_collection;


   /* Empty find query */


   bson_t find_query = BSON_INITIALIZER;


   /* Construct the mapReduce command */


   /* Other arguments can also be specified here, like "query" or


      "limit" and so on */


   command = BCON_NEW ("mapReduce",


                       BCON_UTF8 (COLLECTION_NAME),


                       "map",


                       BCON_CODE (MAPPER),


                       "reduce",


                       BCON_CODE (REDUCER),


                       "out",


                       BCON_UTF8 (out_collection_name));


   res =


      mongoc_database_command_simple (database, command, NULL, &reply, &error);


   if (!res) {


      fprintf (stderr, "MapReduce failed: %s\n", error.message);


      goto cleanup;


   }


   /* Do something with the reply (it doesn't contain the mapReduce results) */


   print_res (&reply);


   /* Now we'll query outCollection to see what the results are */


   out_collection =


      mongoc_database_get_collection (database, out_collection_name);


   cursor = mongoc_collection_find_with_opts (


      out_collection, &find_query, NULL, NULL);


   query_done = true;


   /* Do something with the results */


   while (mongoc_cursor_next (cursor, &doc)) {


      print_res (doc);


   }


   if (mongoc_cursor_error (cursor, &error)) {


      fprintf (stderr, "ERROR: %s\n", error.message);


      res = false;


      goto cleanup;


   }
cleanup:


   /* cleanup */


   if (query_done) {


      mongoc_cursor_destroy (cursor);


      mongoc_collection_destroy (out_collection);


   }


   bson_destroy (&reply);


   bson_destroy (command);


   return res;
}

bool
map_reduce_advanced (mongoc_database_t *database)
{


   bson_t *command;


   bson_error_t error;


   bool res = true;


   mongoc_cursor_t *cursor;


   mongoc_read_prefs_t *read_pref;


   const bson_t *doc;


   /* Construct the mapReduce command */


   /* Other arguments can also be specified here, like "query" or "limit"


      and so on */


   /* Read the results inline from a secondary replica */


   command = BCON_NEW ("mapReduce",


                       BCON_UTF8 (COLLECTION_NAME),


                       "map",


                       BCON_CODE (MAPPER),


                       "reduce",


                       BCON_CODE (REDUCER),


                       "out",


                       "{",


                       "inline",


                       "1",


                       "}");


   read_pref = mongoc_read_prefs_new (MONGOC_READ_SECONDARY);


   cursor = mongoc_database_command (


      database, MONGOC_QUERY_NONE, 0, 0, 0, command, NULL, read_pref);


   /* Do something with the results */


   while (mongoc_cursor_next (cursor, &doc)) {


      print_res (doc);


   }


   if (mongoc_cursor_error (cursor, &error)) {


      fprintf (stderr, "ERROR: %s\n", error.message);


      res = false;


   }


   mongoc_cursor_destroy (cursor);


   mongoc_read_prefs_destroy (read_pref);


   bson_destroy (command);


   return res;
}

/*


 * Copyright 2016 MongoDB, 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.


 */
#include <mongoc/mongoc.h>
#include <stdio.h>
#include "constants.c"
#include "../doc-common-insert.c"
#include "distinct.c"
#include "map-reduce-basic.c"
#include "map-reduce-advanced.c"
int
main (int argc, char *argv[])
{


   mongoc_database_t *database = NULL;


   mongoc_client_t *client = NULL;


   mongoc_collection_t *collection = NULL;


   mongoc_uri_t *uri = NULL;


   bson_error_t error;


   char *host_and_port = NULL;


   int exit_code = EXIT_FAILURE;


   if (argc != 2) {


      fprintf (stderr, "usage: %s CONNECTION-STRING\n", argv[0]);


      fprintf (stderr,


               "the connection string can be of the following forms:\n");


      fprintf (stderr, "localhost\t\t\t\tlocal machine\n");


      fprintf (stderr, "localhost:27018\t\t\t\tlocal machine on port 27018\n");


      fprintf (stderr,


               "mongodb://user:pass@localhost:27017\t"


               "local machine on port 27017, and authenticate with username "


               "user and password pass\n");


      return exit_code;


   }


   mongoc_init ();


   if (strncmp (argv[1], "mongodb://", 10) == 0) {


      host_and_port = bson_strdup (argv[1]);


   } else {


      host_and_port = bson_strdup_printf ("mongodb://%s", argv[1]);


   }


   uri = mongoc_uri_new_with_error (host_and_port, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               host_and_port,


               error.message);


      goto cleanup;


   }


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      goto cleanup;


   }


   mongoc_client_set_error_api (client, 2);


   database = mongoc_client_get_database (client, "test");


   collection = mongoc_database_get_collection (database, COLLECTION_NAME);


   printf ("Inserting data\n");


   if (!insert_data (collection)) {


      goto cleanup;


   }


   printf ("distinct\n");


   if (!distinct (database)) {


      goto cleanup;


   }


   printf ("map reduce\n");


   if (!map_reduce_basic (database)) {


      goto cleanup;


   }


   printf ("more complicated map reduce\n");


   if (!map_reduce_advanced (database)) {


      goto cleanup;


   }


   


   exit_code = EXIT_SUCCESS;
cleanup:


   if (collection) {


      mongoc_collection_destroy (collection);


   }


   if (database) {


      mongoc_database_destroy (database);


   }


   if (client) {


      mongoc_client_destroy (client);


   }


   if (uri) {


      mongoc_uri_destroy (uri);


   }


   if (host_and_port) {


      bson_free (host_and_port);


   }


   mongoc_cleanup ();


   return exit_code;
}

$ mongod

$ cd examples/basic_aggregation/
$ gcc -Wall -o agg-example basic-aggregation.c $(pkg-config --cflags --libs libmongoc-1.0)
$ ./agg-example localhost
Inserting data
distinct
Next double: 2.000000
Next double: 3.000000
map reduce
{ "result" : "outCollection", "timeMillis" : 155, "counts" : { "input" : 84, "emit" : 126, "reduce" : 3, "output" : 3 }, "ok" : 1 }
{ "_id" : "cat", "value" : 63 }
{ "_id" : "dog", "value" : 42 }
{ "_id" : "mouse", "value" : 21 }
more complicated map reduce
{ "results" : [ { "_id" : "cat", "value" : 63 }, { "_id" : "dog", "value" : 42 }, { "_id" : "mouse", "value" : 21 } ], "timeMillis" : 14, "counts" : { "input" : 84, "emit" : 126, "reduce" : 3, "output" : 3 }, "ok" : 1 }

C:\mongo-c-driver\lib\bson-static-1.0.lib
C:\mongo-c-driver\lib\mongoc-static-1.0.lib
ws2_32.lib
Secur32.lib
Crypt32.lib
BCrypt.lib

#define BSON_STATIC
#define MONGOC_STATIC
#include <mongoc/mongoc.h>

/* gcc example-create-indexes.c -o example-create-indexes $(pkg-config --cflags


 * --libs libmongoc-1.0) */
/* ./example-create-indexes [CONNECTION_STRING [COLLECTION_NAME]] */
#include <mongoc/mongoc.h>
#include <stdio.h>
#include <stdlib.h>
int
main (int argc, char *argv[])
{


   mongoc_client_t *client;


   const char *uri_string =


      "mongodb://127.0.0.1/?appname=create-indexes-example";


   mongoc_uri_t *uri;


   mongoc_database_t *db;


   const char *collection_name = "test";


   bson_t keys;


   char *index_name;


   bson_t *create_indexes;


   bson_t reply;


   char *reply_str;


   bson_error_t error;


   bool r;


   mongoc_init ();


   if (argc > 1) {


      uri_string = argv[1];


   }


   if (argc > 2) {


      collection_name = argv[2];


   }


   uri = mongoc_uri_new_with_error (uri_string, &error);


   if (!uri) {


      fprintf (stderr,


               "failed to parse URI: %s\n"


               "error message:       %s\n",


               uri_string,


               error.message);


      return EXIT_FAILURE;


   }


   client = mongoc_client_new_from_uri (uri);


   if (!client) {


      return EXIT_FAILURE;


   }


   mongoc_client_set_error_api (client, 2);


   db = mongoc_client_get_database (client, "test");


   /* ascending index on field "x" */


   bson_init (&keys);


   BSON_APPEND_INT32 (&keys, "x", 1);


   index_name = mongoc_collection_keys_to_index_string (&keys);


   create_indexes = BCON_NEW ("createIndexes",


                              BCON_UTF8 (collection_name),


                              "indexes",


                              "[",


                              "{",


                              "key",


                              BCON_DOCUMENT (&keys),


                              "name",


                              BCON_UTF8 (index_name),


                              "}",


                              "]");


   r = mongoc_database_write_command_with_opts (


      db, create_indexes, NULL /* opts */, &reply, &error);


   reply_str = bson_as_json (&reply, NULL);


   printf ("%s\n", reply_str);


   if (!r) {


      fprintf (stderr, "Error in createIndexes: %s\n", error.message);


   }


   bson_free (index_name);


   bson_free (reply_str);


   bson_destroy (&reply);


   bson_destroy (create_indexes);


   mongoc_database_destroy (db);


   mongoc_uri_destroy (uri);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return r ? EXIT_SUCCESS : EXIT_FAILURE;
}

add-auto-load-safe-path /path/to/mongo-c-driver

source path/to/mongo-c-driver/.gdbinit

(gdb) printbson bson
ALLOC [0x555556cd7310 + 0] (len=475)
{


    'bool' : true,


    'int32' : NumberInt("42"),


    'int64' : NumberLong("3000000042"),


    'string' : "Stŕìñg",


    'objectId' : ObjectID("5A1442F3122D331C3C6757E1"),


    'utcDateTime' : UTCDateTime(1511277299031),


    'arrayOfInts' : [


        '0' : NumberInt("1"),


        '1' : NumberInt("2")


    ],


    'embeddedDocument' : {


        'arrayOfStrings' : [


            '0' : "one",


            '1' : "two"


        ],


        'double' : 2.718280,


        'notherDoc' : {


            'true' : NumberInt("1"),


            'false' : false


        }


    },


    'binary' : Binary("02", "3031343532333637"),


    'regex' : Regex("@[a-z]+@", "im"),


    'null' : null,


    'js' : JavaScript("print foo"),


    'jsws' : JavaScript("print foo") with scope: {


        'f' : NumberInt("42"),


        'a' : [


            '0' : 3.141593,


            '1' : 2.718282


        ]


    },


    'timestamp' : Timestamp(4294967295, 4294967295),


    'double' : 3.141593
}

(lldb) print b
(bson_t) $0 = {"x": 1, "y": 2}

(lldb) bson --verbose b
len=19
flags=INLINE|STATIC
{


  "x": 1,


  "y": 2
}
(lldb) bson --raw b
'\x13\x00\x00\x00\x10x\x00\x01\x00\x00\x00\x10y\x00\x02\x00\x00\x00\x00'

python -m pip install pymongo

command script import /path/to/mongo-c-driver/lldb_bson.py

$ cd mongo-c-driver
$ mkdir cmake-build && cd cmake-build
$ cmake -DENABLE_AUTOMATIC_INIT_AND_CLEANUP=OFF -DENABLE_MONGOC=OFF ..
$ cmake --build . --target install

$ cd libmongocrypt
$ mkdir cmake-build && cd cmake-build
$ cmake -DENABLE_SHARED_BSON=ON ..
$ cmake --build . --target install

$ cd mongo-c-driver
$ mkdir cmake-build && cd cmake-build
$ cmake -DENABLE_AUTOMATIC_INIT_AND_CLEANUP=OFF -DENABLE_MONGOC=ON -DENABLE_CLIENT_SIDE_ENCRYPTION=ON ..
$ cmake --build . --target install

bson_t *extra = BCON_NEW ("mongocryptdSpawnPath", "/path/to/mongocryptd");
mongoc_auto_encryption_opts_set_extra (opts, extra);

bson_t *extra = BCON_NEW ("mongocryptdSpawnArgs",


   "[", "--logpath=/path/to/mongocryptd.log", "--logappend", "]");
mongoc_auto_encryption_opts_set_extra (opts, extra);

bson_t *extra = BCON_NEW ("mongocryptdBypassSpawn",


   BCON_BOOL(true), "mongocryptdURI", "mongodb://localhost:27020");
mongoc_auto_encryption_opts_set_extra (opts, extra);

#include <mongoc/mongoc.h>
#include <stdio.h>
#include <stdlib.h>
#include "client-side-encryption-helpers.h"
/* Helper method to create a new data key in the key vault, a schema to use that


 * key, and writes the schema to a file for later use. */
static bool
create_schema_file (bson_t *kms_providers,


                    const char *keyvault_db,


                    const char *keyvault_coll,


                    mongoc_client_t *keyvault_client,


                    bson_error_t *error)
{


   mongoc_client_encryption_t *client_encryption = NULL;


   mongoc_client_encryption_opts_t *client_encryption_opts = NULL;


   mongoc_client_encryption_datakey_opts_t *datakey_opts = NULL;


   bson_value_t datakey_id = {0};


   char *keyaltnames[] = {"mongoc_encryption_example_1"};


   bson_t *schema = NULL;


   char *schema_string = NULL;


   size_t schema_string_len;


   FILE *outfile = NULL;


   bool ret = false;


   client_encryption_opts = mongoc_client_encryption_opts_new ();


   mongoc_client_encryption_opts_set_kms_providers (client_encryption_opts,


                                                    kms_providers);


   mongoc_client_encryption_opts_set_keyvault_namespace (


      client_encryption_opts, keyvault_db, keyvault_coll);


   mongoc_client_encryption_opts_set_keyvault_client (client_encryption_opts,


                                                      keyvault_client);


   client_encryption =


      mongoc_client_encryption_new (client_encryption_opts, error);


   if (!client_encryption) {


      goto fail;


   }


   /* Create a new data key and json schema for the encryptedField.


    * https://dochub.mongodb.org/core/client-side-field-level-encryption-automatic-encryption-rules


    */


   datakey_opts = mongoc_client_encryption_datakey_opts_new ();


   mongoc_client_encryption_datakey_opts_set_keyaltnames (


      datakey_opts, keyaltnames, 1);


   if (!mongoc_client_encryption_create_datakey (


          client_encryption, "local", datakey_opts, &datakey_id, error)) {


      goto fail;


   }


   /* Create a schema describing that "encryptedField" is a string encrypted


    * with the newly created data key using deterministic encryption. */


   schema = BCON_NEW ("properties",


                      "{",


                      "encryptedField",


                      "{",


                      "encrypt",


                      "{",


                      "keyId",


                      "[",


                      BCON_BIN (datakey_id.value.v_binary.subtype,


                                datakey_id.value.v_binary.data,


                                datakey_id.value.v_binary.data_len),


                      "]",


                      "bsonType",


                      "string",


                      "algorithm",


                      MONGOC_AEAD_AES_256_CBC_HMAC_SHA_512_DETERMINISTIC,


                      "}",


                      "}",


                      "}",


                      "bsonType",


                      "object");


   /* Use canonical JSON so that other drivers and tools will be


    * able to parse the MongoDB extended JSON file. */


   schema_string = bson_as_canonical_extended_json (schema, &schema_string_len);


   outfile = fopen ("jsonSchema.json", "w");


   if (0 == fwrite (schema_string, sizeof (char), schema_string_len, outfile)) {


      fprintf (stderr, "failed to write to file\n");


      goto fail;


   }


   ret = true;
fail:


   mongoc_client_encryption_destroy (client_encryption);


   mongoc_client_encryption_datakey_opts_destroy (datakey_opts);


   mongoc_client_encryption_opts_destroy (client_encryption_opts);


   bson_free (schema_string);


   bson_destroy (schema);


   bson_value_destroy (&datakey_id);


   if (outfile) {


      fclose (outfile);


   }


   return ret;
}
/* This example demonstrates how to use automatic encryption with a client-side


 * schema map using the enterprise version of MongoDB */
int
main (void)
{
/* The collection used to store the encryption data keys. */
#define KEYVAULT_DB "encryption"
#define KEYVAULT_COLL "__libmongocTestKeyVault"
/* The collection used to store the encrypted documents in this example. */
#define ENCRYPTED_DB "test"
#define ENCRYPTED_COLL "coll"


   int exit_status = EXIT_FAILURE;


   bool ret;


   uint8_t *local_masterkey = NULL;


   uint32_t local_masterkey_len;


   bson_t *kms_providers = NULL;


   bson_error_t error = {0};


   bson_t *index_keys = NULL;


   char *index_name = NULL;


   bson_t *create_index_cmd = NULL;


   bson_json_reader_t *reader = NULL;


   bson_t schema = BSON_INITIALIZER;


   bson_t *schema_map = NULL;


   /* The MongoClient used to access the key vault (keyvault_namespace). */


   mongoc_client_t *keyvault_client = NULL;


   mongoc_collection_t *keyvault_coll = NULL;


   mongoc_auto_encryption_opts_t *auto_encryption_opts = NULL;


   mongoc_client_t *client = NULL;


   mongoc_collection_t *coll = NULL;


   bson_t *to_insert = NULL;


   mongoc_client_t *unencrypted_client = NULL;


   mongoc_collection_t *unencrypted_coll = NULL;


   mongoc_init ();


   /* Configure the master key. This must be the same master key that was used


    * to create the encryption key. */


   local_masterkey =


      hex_to_bin (getenv ("LOCAL_MASTERKEY"), &local_masterkey_len);


   if (!local_masterkey || local_masterkey_len != 96) {


      fprintf (stderr,


               "Specify LOCAL_MASTERKEY environment variable as a "


               "secure random 96 byte hex value.\n");


      goto fail;


   }


   kms_providers = BCON_NEW ("local",


                             "{",


                             "key",


                             BCON_BIN (0, local_masterkey, local_masterkey_len),


                             "}");


   /* Set up the key vault for this example. */


   keyvault_client = mongoc_client_new (


      "mongodb://localhost/?appname=client-side-encryption-keyvault");


   keyvault_coll = mongoc_client_get_collection (


      keyvault_client, KEYVAULT_DB, KEYVAULT_COLL);


   mongoc_collection_drop (keyvault_coll, NULL);


   /* Create a unique index to ensure that two data keys cannot share the same


    * keyAltName. This is recommended practice for the key vault. */


   index_keys = BCON_NEW ("keyAltNames", BCON_INT32 (1));


   index_name = mongoc_collection_keys_to_index_string (index_keys);


   create_index_cmd = BCON_NEW ("createIndexes",


                                KEYVAULT_COLL,


                                "indexes",


                                "[",


                                "{",


                                "key",


                                BCON_DOCUMENT (index_keys),


                                "name",


                                index_name,


                                "unique",


                                BCON_BOOL (true),


                                "partialFilterExpression",


                                "{",


                                "keyAltNames",


                                "{",


                                "$exists",


                                BCON_BOOL (true),


                                "}",


                                "}",


                                "}",


                                "]");


   ret = mongoc_client_command_simple (keyvault_client,


                                       KEYVAULT_DB,


                                       create_index_cmd,


                                       NULL /* read prefs */,


                                       NULL /* reply */,


                                       &error);


   if (!ret) {


      goto fail;


   }


   /* Create a new data key and a schema using it for encryption. Save the


    * schema to the file jsonSchema.json */


   ret = create_schema_file (


      kms_providers, KEYVAULT_DB, KEYVAULT_COLL, keyvault_client, &error);


   if (!ret) {


      goto fail;


   }


   /* Load the JSON Schema and construct the local schema_map option. */


   reader = bson_json_reader_new_from_file ("jsonSchema.json", &error);


   if (!reader) {


      goto fail;


   }


   bson_json_reader_read (reader, &schema, &error);


   /* Construct the schema map, mapping the namespace of the collection to the


    * schema describing encryption. */


   schema_map =


      BCON_NEW (ENCRYPTED_DB "." ENCRYPTED_COLL, BCON_DOCUMENT (&schema));


   auto_encryption_opts = mongoc_auto_encryption_opts_new ();


   mongoc_auto_encryption_opts_set_keyvault_client (auto_encryption_opts,


                                                    keyvault_client);


   mongoc_auto_encryption_opts_set_keyvault_namespace (


      auto_encryption_opts, KEYVAULT_DB, KEYVAULT_COLL);


   mongoc_auto_encryption_opts_set_kms_providers (auto_encryption_opts,


                                                  kms_providers);


   mongoc_auto_encryption_opts_set_schema_map (auto_encryption_opts,


                                               schema_map);


   client =


      mongoc_client_new ("mongodb://localhost/?appname=client-side-encryption");


   /* Enable automatic encryption. It will determine that encryption is


    * necessary from the schema map instead of relying on the server to provide


    * a schema. */


   ret = mongoc_client_enable_auto_encryption (


      client, auto_encryption_opts, &error);


   if (!ret) {


      goto fail;


   }


   coll = mongoc_client_get_collection (client, ENCRYPTED_DB, ENCRYPTED_COLL);


   /* Clear old data */


   mongoc_collection_drop (coll, NULL);


   to_insert = BCON_NEW ("encryptedField", "123456789");


   ret = mongoc_collection_insert_one (


      coll, to_insert, NULL /* opts */, NULL /* reply */, &error);


   if (!ret) {


      goto fail;


   }


   printf ("decrypted document: ");


   if (!print_one_document (coll, &error)) {


      goto fail;


   }


   printf ("\n");


   unencrypted_client = mongoc_client_new (


      "mongodb://localhost/?appname=client-side-encryption-unencrypted");


   unencrypted_coll = mongoc_client_get_collection (


      unencrypted_client, ENCRYPTED_DB, ENCRYPTED_COLL);


   printf ("encrypted document: ");


   if (!print_one_document (unencrypted_coll, &error)) {


      goto fail;


   }


   printf ("\n");


   exit_status = EXIT_SUCCESS;
fail:


   if (error.code) {


      fprintf (stderr, "error: %s\n", error.message);


   }


   bson_free (local_masterkey);


   bson_destroy (kms_providers);


   mongoc_collection_destroy (keyvault_coll);


   bson_destroy (index_keys);


   bson_free (index_name);


   bson_destroy (create_index_cmd);


   bson_json_reader_destroy (reader);


   mongoc_auto_encryption_opts_destroy (auto_encryption_opts);


   mongoc_collection_destroy (coll);


   mongoc_client_destroy (client);


   bson_destroy (to_insert);


   mongoc_collection_destroy (unencrypted_coll);


   mongoc_client_destroy (unencrypted_client);


   mongoc_client_destroy (keyvault_client);


   bson_destroy (&schema);


   bson_destroy (schema_map);


   mongoc_cleanup ();


   return exit_status;
}

#include <mongoc/mongoc.h>
#include <stdio.h>
#include <stdlib.h>
#include "client-side-encryption-helpers.h"
/* Helper method to create and return a JSON schema to use for encryption.
The caller will use the returned schema for server-side encryption validation.
*/
static bson_t *
create_schema (bson_t *kms_providers,


               const char *keyvault_db,


               const char *keyvault_coll,


               mongoc_client_t *keyvault_client,


               bson_error_t *error)
{


   mongoc_client_encryption_t *client_encryption = NULL;


   mongoc_client_encryption_opts_t *client_encryption_opts = NULL;


   mongoc_client_encryption_datakey_opts_t *datakey_opts = NULL;


   bson_value_t datakey_id = {0};


   char *keyaltnames[] = {"mongoc_encryption_example_2"};


   bson_t *schema = NULL;


   client_encryption_opts = mongoc_client_encryption_opts_new ();


   mongoc_client_encryption_opts_set_kms_providers (client_encryption_opts,


                                                    kms_providers);


   mongoc_client_encryption_opts_set_keyvault_namespace (


      client_encryption_opts, keyvault_db, keyvault_coll);


   mongoc_client_encryption_opts_set_keyvault_client (client_encryption_opts,


                                                      keyvault_client);


   client_encryption =


      mongoc_client_encryption_new (client_encryption_opts, error);


   if (!client_encryption) {


      goto fail;


   }


   /* Create a new data key and json schema for the encryptedField.


    * https://dochub.mongodb.org/core/client-side-field-level-encryption-automatic-encryption-rules


    */


   datakey_opts = mongoc_client_encryption_datakey_opts_new ();


   mongoc_client_encryption_datakey_opts_set_keyaltnames (


      datakey_opts, keyaltnames, 1);


   if (!mongoc_client_encryption_create_datakey (


          client_encryption, "local", datakey_opts, &datakey_id, error)) {


      goto fail;


   }


   /* Create a schema describing that "encryptedField" is a string encrypted


    * with the newly created data key using deterministic encryption. */


   schema = BCON_NEW ("properties",


                      "{",


                      "encryptedField",


                      "{",


                      "encrypt",


                      "{",


                      "keyId",


                      "[",


                      BCON_BIN (datakey_id.value.v_binary.subtype,


                                datakey_id.value.v_binary.data,


                                datakey_id.value.v_binary.data_len),


                      "]",


                      "bsonType",


                      "string",


                      "algorithm",


                      MONGOC_AEAD_AES_256_CBC_HMAC_SHA_512_DETERMINISTIC,


                      "}",


                      "}",


                      "}",


                      "bsonType",


                      "object");
fail:


   mongoc_client_encryption_destroy (client_encryption);


   mongoc_client_encryption_datakey_opts_destroy (datakey_opts);


   mongoc_client_encryption_opts_destroy (client_encryption_opts);


   bson_value_destroy (&datakey_id);


   return schema;
}
/* This example demonstrates how to use automatic encryption with a server-side


 * schema using the enterprise version of MongoDB */
int
main (void)
{
/* The collection used to store the encryption data keys. */
#define KEYVAULT_DB "encryption"
#define KEYVAULT_COLL "__libmongocTestKeyVault"
/* The collection used to store the encrypted documents in this example. */
#define ENCRYPTED_DB "test"
#define ENCRYPTED_COLL "coll"


   int exit_status = EXIT_FAILURE;


   bool ret;


   uint8_t *local_masterkey = NULL;


   uint32_t local_masterkey_len;


   bson_t *kms_providers = NULL;


   bson_error_t error = {0};


   bson_t *index_keys = NULL;


   char *index_name = NULL;


   bson_t *create_index_cmd = NULL;


   bson_json_reader_t *reader = NULL;


   bson_t *schema = NULL;


   /* The MongoClient used to access the key vault (keyvault_namespace). */


   mongoc_client_t *keyvault_client = NULL;


   mongoc_collection_t *keyvault_coll = NULL;


   mongoc_auto_encryption_opts_t *auto_encryption_opts = NULL;


   mongoc_client_t *client = NULL;


   mongoc_collection_t *coll = NULL;


   bson_t *to_insert = NULL;


   mongoc_client_t *unencrypted_client = NULL;


   mongoc_collection_t *unencrypted_coll = NULL;


   bson_t *create_cmd = NULL;


   bson_t *create_cmd_opts = NULL;


   mongoc_write_concern_t *wc = NULL;


   mongoc_init ();


   /* Configure the master key. This must be the same master key that was used


    * to create


    * the encryption key. */


   local_masterkey =


      hex_to_bin (getenv ("LOCAL_MASTERKEY"), &local_masterkey_len);


   if (!local_masterkey || local_masterkey_len != 96) {


      fprintf (stderr,


               "Specify LOCAL_MASTERKEY environment variable as a "


               "secure random 96 byte hex value.\n");


      goto fail;


   }


   kms_providers = BCON_NEW ("local",


                             "{",


                             "key",


                             BCON_BIN (0, local_masterkey, local_masterkey_len),


                             "}");


   /* Set up the key vault for this example. */


   keyvault_client = mongoc_client_new (


      "mongodb://localhost/?appname=client-side-encryption-keyvault");


   keyvault_coll = mongoc_client_get_collection (


      keyvault_client, KEYVAULT_DB, KEYVAULT_COLL);


   mongoc_collection_drop (keyvault_coll, NULL);


   /* Create a unique index to ensure that two data keys cannot share the same


    * keyAltName. This is recommended practice for the key vault. */


   index_keys = BCON_NEW ("keyAltNames", BCON_INT32 (1));


   index_name = mongoc_collection_keys_to_index_string (index_keys);


   create_index_cmd = BCON_NEW ("createIndexes",


                                KEYVAULT_COLL,


                                "indexes",


                                "[",


                                "{",


                                "key",


                                BCON_DOCUMENT (index_keys),


                                "name",


                                index_name,


                                "unique",


                                BCON_BOOL (true),


                                "partialFilterExpression",


                                "{",


                                "keyAltNames",


                                "{",


                                "$exists",


                                BCON_BOOL (true),


                                "}",


                                "}",


                                "}",


                                "]");


   ret = mongoc_client_command_simple (keyvault_client,


                                       KEYVAULT_DB,


                                       create_index_cmd,


                                       NULL /* read prefs */,


                                       NULL /* reply */,


                                       &error);


   if (!ret) {


      goto fail;


   }


   auto_encryption_opts = mongoc_auto_encryption_opts_new ();


   mongoc_auto_encryption_opts_set_keyvault_client (auto_encryption_opts,


                                                    keyvault_client);


   mongoc_auto_encryption_opts_set_keyvault_namespace (


      auto_encryption_opts, KEYVAULT_DB, KEYVAULT_COLL);


   mongoc_auto_encryption_opts_set_kms_providers (auto_encryption_opts,


                                                  kms_providers);


   schema = create_schema (


      kms_providers, KEYVAULT_DB, KEYVAULT_COLL, keyvault_client, &error);


   if (!schema) {


      goto fail;


   }


   client =


      mongoc_client_new ("mongodb://localhost/?appname=client-side-encryption");


   ret = mongoc_client_enable_auto_encryption (


      client, auto_encryption_opts, &error);


   if (!ret) {


      goto fail;


   }


   coll = mongoc_client_get_collection (client, ENCRYPTED_DB, ENCRYPTED_COLL);


   /* Clear old data */


   mongoc_collection_drop (coll, NULL);


   /* Create the collection with the encryption JSON Schema. */


   create_cmd = BCON_NEW ("create",


                          ENCRYPTED_COLL,


                          "validator",


                          "{",


                          "$jsonSchema",


                          BCON_DOCUMENT (schema),


                          "}");


   wc = mongoc_write_concern_new ();


   mongoc_write_concern_set_wmajority (wc, 0);


   create_cmd_opts = bson_new ();


   mongoc_write_concern_append (wc, create_cmd_opts);


   ret = mongoc_client_command_with_opts (client,


                                          ENCRYPTED_DB,


                                          create_cmd,


                                          NULL /* read prefs */,


                                          create_cmd_opts,


                                          NULL /* reply */,


                                          &error);


   if (!ret) {


      goto fail;


   }


   to_insert = BCON_NEW ("encryptedField", "123456789");


   ret = mongoc_collection_insert_one (


      coll, to_insert, NULL /* opts */, NULL /* reply */, &error);


   if (!ret) {


      goto fail;


   }


   printf ("decrypted document: ");


   if (!print_one_document (coll, &error)) {


      goto fail;


   }


   printf ("\n");


   unencrypted_client = mongoc_client_new (


      "mongodb://localhost/?appname=client-side-encryption-unencrypted");


   unencrypted_coll = mongoc_client_get_collection (


      unencrypted_client, ENCRYPTED_DB, ENCRYPTED_COLL);


   printf ("encrypted document: ");


   if (!print_one_document (unencrypted_coll, &error)) {


      goto fail;


   }


   printf ("\n");


   /* Expect a server-side error if inserting with the unencrypted collection.


    */


   ret = mongoc_collection_insert_one (


      unencrypted_coll, to_insert, NULL /* opts */, NULL /* reply */, &error);


   if (!ret) {


      printf ("insert with unencrypted collection failed: %s\n", error.message);


      memset (&error, 0, sizeof (error));


   }


   exit_status = EXIT_SUCCESS;
fail:


   if (error.code) {


      fprintf (stderr, "error: %s\n", error.message);


   }


   bson_free (local_masterkey);


   bson_destroy (kms_providers);


   mongoc_collection_destroy (keyvault_coll);


   bson_destroy (index_keys);


   bson_free (index_name);


   bson_destroy (create_index_cmd);


   bson_json_reader_destroy (reader);


   mongoc_auto_encryption_opts_destroy (auto_encryption_opts);


   mongoc_collection_destroy (coll);


   mongoc_client_destroy (client);


   bson_destroy (to_insert);


   mongoc_collection_destroy (unencrypted_coll);


   mongoc_client_destroy (unencrypted_client);


   mongoc_client_destroy (keyvault_client);


   bson_destroy (schema);


   bson_destroy (create_cmd);


   bson_destroy (create_cmd_opts);


   mongoc_write_concern_destroy (wc);


   mongoc_cleanup ();


   return exit_status;
}

#include <mongoc/mongoc.h>
#include <stdio.h>
#include <stdlib.h>
#include "client-side-encryption-helpers.h"
/* This example demonstrates how to use explicit encryption and decryption using


 * the community version of MongoDB */
int
main (void)
{
/* The collection used to store the encryption data keys. */
#define KEYVAULT_DB "encryption"
#define KEYVAULT_COLL "__libmongocTestKeyVault"
/* The collection used to store the encrypted documents in this example. */
#define ENCRYPTED_DB "test"
#define ENCRYPTED_COLL "coll"


   int exit_status = EXIT_FAILURE;


   bool ret;


   uint8_t *local_masterkey = NULL;


   uint32_t local_masterkey_len;


   bson_t *kms_providers = NULL;


   bson_error_t error = {0};


   bson_t *index_keys = NULL;


   char *index_name = NULL;


   bson_t *create_index_cmd = NULL;


   bson_t *schema = NULL;


   mongoc_client_t *client = NULL;


   mongoc_collection_t *coll = NULL;


   mongoc_collection_t *keyvault_coll = NULL;


   bson_t *to_insert = NULL;


   bson_t *create_cmd = NULL;


   bson_t *create_cmd_opts = NULL;


   mongoc_write_concern_t *wc = NULL;


   mongoc_client_encryption_t *client_encryption = NULL;


   mongoc_client_encryption_opts_t *client_encryption_opts = NULL;


   mongoc_client_encryption_datakey_opts_t *datakey_opts = NULL;


   char *keyaltnames[] = {"mongoc_encryption_example_3"};


   bson_value_t datakey_id = {0};


   bson_value_t encrypted_field = {0};


   bson_value_t to_encrypt = {0};


   mongoc_client_encryption_encrypt_opts_t *encrypt_opts = NULL;


   bson_value_t decrypted = {0};


   mongoc_init ();


   /* Configure the master key. This must be the same master key that was used


    * to create the encryption key. */


   local_masterkey =


      hex_to_bin (getenv ("LOCAL_MASTERKEY"), &local_masterkey_len);


   if (!local_masterkey || local_masterkey_len != 96) {


      fprintf (stderr,


               "Specify LOCAL_MASTERKEY environment variable as a "


               "secure random 96 byte hex value.\n");


      goto fail;


   }


   kms_providers = BCON_NEW ("local",


                             "{",


                             "key",


                             BCON_BIN (0, local_masterkey, local_masterkey_len),


                             "}");


   /* The mongoc_client_t used to read/write application data. */


   client =


      mongoc_client_new ("mongodb://localhost/?appname=client-side-encryption");


   coll = mongoc_client_get_collection (client, ENCRYPTED_DB, ENCRYPTED_COLL);


   /* Clear old data */


   mongoc_collection_drop (coll, NULL);


   /* Set up the key vault for this example. */


   keyvault_coll =


      mongoc_client_get_collection (client, KEYVAULT_DB, KEYVAULT_COLL);


   mongoc_collection_drop (keyvault_coll, NULL);


   /* Create a unique index to ensure that two data keys cannot share the same


    * keyAltName. This is recommended practice for the key vault. */


   index_keys = BCON_NEW ("keyAltNames", BCON_INT32 (1));


   index_name = mongoc_collection_keys_to_index_string (index_keys);


   create_index_cmd = BCON_NEW ("createIndexes",


                                KEYVAULT_COLL,


                                "indexes",


                                "[",


                                "{",


                                "key",


                                BCON_DOCUMENT (index_keys),


                                "name",


                                index_name,


                                "unique",


                                BCON_BOOL (true),


                                "partialFilterExpression",


                                "{",


                                "keyAltNames",


                                "{",


                                "$exists",


                                BCON_BOOL (true),


                                "}",


                                "}",


                                "}",


                                "]");


   ret = mongoc_client_command_simple (client,


                                       KEYVAULT_DB,


                                       create_index_cmd,


                                       NULL /* read prefs */,


                                       NULL /* reply */,


                                       &error);


   if (!ret) {


      goto fail;


   }


   client_encryption_opts = mongoc_client_encryption_opts_new ();


   mongoc_client_encryption_opts_set_kms_providers (client_encryption_opts,


                                                    kms_providers);


   mongoc_client_encryption_opts_set_keyvault_namespace (


      client_encryption_opts, KEYVAULT_DB, KEYVAULT_COLL);


   /* Set a mongoc_client_t to use for reading/writing to the key vault. This


    * can be the same mongoc_client_t used by the main application. */


   mongoc_client_encryption_opts_set_keyvault_client (client_encryption_opts,


                                                      client);


   client_encryption =


      mongoc_client_encryption_new (client_encryption_opts, &error);


   if (!client_encryption) {


      goto fail;


   }


   /* Create a new data key for the encryptedField.


    * https://dochub.mongodb.org/core/client-side-field-level-encryption-automatic-encryption-rules


    */


   datakey_opts = mongoc_client_encryption_datakey_opts_new ();


   mongoc_client_encryption_datakey_opts_set_keyaltnames (


      datakey_opts, keyaltnames, 1);


   if (!mongoc_client_encryption_create_datakey (


          client_encryption, "local", datakey_opts, &datakey_id, &error)) {


      goto fail;


   }


   /* Explicitly encrypt a field */


   encrypt_opts = mongoc_client_encryption_encrypt_opts_new ();


   mongoc_client_encryption_encrypt_opts_set_algorithm (


      encrypt_opts, MONGOC_AEAD_AES_256_CBC_HMAC_SHA_512_DETERMINISTIC);


   mongoc_client_encryption_encrypt_opts_set_keyid (encrypt_opts, &datakey_id);


   to_encrypt.value_type = BSON_TYPE_UTF8;


   to_encrypt.value.v_utf8.str = "123456789";


   to_encrypt.value.v_utf8.len = strlen (to_encrypt.value.v_utf8.str);


   ret = mongoc_client_encryption_encrypt (


      client_encryption, &to_encrypt, encrypt_opts, &encrypted_field, &error);


   if (!ret) {


      goto fail;


   }


   to_insert = bson_new ();


   BSON_APPEND_VALUE (to_insert, "encryptedField", &encrypted_field);


   ret = mongoc_collection_insert_one (


      coll, to_insert, NULL /* opts */, NULL /* reply */, &error);


   if (!ret) {


      goto fail;


   }


   printf ("encrypted document: ");


   if (!print_one_document (coll, &error)) {


      goto fail;


   }


   printf ("\n");


   /* Explicitly decrypt a field */


   ret = mongoc_client_encryption_decrypt (


      client_encryption, &encrypted_field, &decrypted, &error);


   if (!ret) {


      goto fail;


   }


   printf ("decrypted value: %s\n", decrypted.value.v_utf8.str);


   exit_status = EXIT_SUCCESS;
fail:


   if (error.code) {


      fprintf (stderr, "error: %s\n", error.message);


   }


   bson_free (local_masterkey);


   bson_destroy (kms_providers);


   mongoc_collection_destroy (keyvault_coll);


   bson_destroy (index_keys);


   bson_free (index_name);


   bson_destroy (create_index_cmd);


   mongoc_collection_destroy (coll);


   mongoc_client_destroy (client);


   bson_destroy (to_insert);


   bson_destroy (schema);


   bson_destroy (create_cmd);


   bson_destroy (create_cmd_opts);


   mongoc_write_concern_destroy (wc);


   mongoc_client_encryption_destroy (client_encryption);


   mongoc_client_encryption_datakey_opts_destroy (datakey_opts);


   mongoc_client_encryption_opts_destroy (client_encryption_opts);


   bson_value_destroy (&encrypted_field);


   mongoc_client_encryption_encrypt_opts_destroy (encrypt_opts);


   bson_value_destroy (&decrypted);


   bson_value_destroy (&datakey_id);


   mongoc_cleanup ();


   return exit_status;
}

#include <mongoc/mongoc.h>
#include <stdio.h>
#include <stdlib.h>
#include "client-side-encryption-helpers.h"
/* This example demonstrates how to set up automatic decryption without


 * automatic encryption using the community version of MongoDB */
int
main (void)
{
/* The collection used to store the encryption data keys. */
#define KEYVAULT_DB "encryption"
#define KEYVAULT_COLL "__libmongocTestKeyVault"
/* The collection used to store the encrypted documents in this example. */
#define ENCRYPTED_DB "test"
#define ENCRYPTED_COLL "coll"


   int exit_status = EXIT_FAILURE;


   bool ret;


   uint8_t *local_masterkey = NULL;


   uint32_t local_masterkey_len;


   bson_t *kms_providers = NULL;


   bson_error_t error = {0};


   bson_t *index_keys = NULL;


   char *index_name = NULL;


   bson_t *create_index_cmd = NULL;


   bson_t *schema = NULL;


   mongoc_client_t *client = NULL;


   mongoc_collection_t *coll = NULL;


   mongoc_collection_t *keyvault_coll = NULL;


   bson_t *to_insert = NULL;


   bson_t *create_cmd = NULL;


   bson_t *create_cmd_opts = NULL;


   mongoc_write_concern_t *wc = NULL;


   mongoc_client_encryption_t *client_encryption = NULL;


   mongoc_client_encryption_opts_t *client_encryption_opts = NULL;


   mongoc_client_encryption_datakey_opts_t *datakey_opts = NULL;


   char *keyaltnames[] = {"mongoc_encryption_example_4"};


   bson_value_t datakey_id = {0};


   bson_value_t encrypted_field = {0};


   bson_value_t to_encrypt = {0};


   mongoc_client_encryption_encrypt_opts_t *encrypt_opts = NULL;


   bson_value_t decrypted = {0};


   mongoc_auto_encryption_opts_t *auto_encryption_opts = NULL;


   mongoc_client_t *unencrypted_client = NULL;


   mongoc_collection_t *unencrypted_coll = NULL;


   mongoc_init ();


   /* Configure the master key. This must be the same master key that was used


    * to create the encryption key. */


   local_masterkey =


      hex_to_bin (getenv ("LOCAL_MASTERKEY"), &local_masterkey_len);


   if (!local_masterkey || local_masterkey_len != 96) {


      fprintf (stderr,


               "Specify LOCAL_MASTERKEY environment variable as a "


               "secure random 96 byte hex value.\n");


      goto fail;


   }


   kms_providers = BCON_NEW ("local",


                             "{",


                             "key",


                             BCON_BIN (0, local_masterkey, local_masterkey_len),


                             "}");


   client =


      mongoc_client_new ("mongodb://localhost/?appname=client-side-encryption");


   auto_encryption_opts = mongoc_auto_encryption_opts_new ();


   mongoc_auto_encryption_opts_set_keyvault_namespace (


      auto_encryption_opts, KEYVAULT_DB, KEYVAULT_COLL);


   mongoc_auto_encryption_opts_set_kms_providers (auto_encryption_opts,


                                                  kms_providers);


   /* Setting bypass_auto_encryption to true disables automatic encryption but


    * keeps the automatic decryption behavior. bypass_auto_encryption will also


    * disable spawning mongocryptd */


   mongoc_auto_encryption_opts_set_bypass_auto_encryption (auto_encryption_opts,


                                                           true);


   /* Once bypass_auto_encryption is set, community users can enable auto


    * encryption on the client. This will, in fact, only perform automatic


    * decryption. */


   ret = mongoc_client_enable_auto_encryption (


      client, auto_encryption_opts, &error);


   if (!ret) {


      goto fail;


   }


   /* Now that automatic decryption is on, we can test it by inserting a


    * document with an explicitly encrypted value into the collection. When we


    * look up the document later, it should be automatically decrypted for us.


    */


   coll = mongoc_client_get_collection (client, ENCRYPTED_DB, ENCRYPTED_COLL);


   /* Clear old data */


   mongoc_collection_drop (coll, NULL);


   /* Set up the key vault for this example. */


   keyvault_coll =


      mongoc_client_get_collection (client, KEYVAULT_DB, KEYVAULT_COLL);


   mongoc_collection_drop (keyvault_coll, NULL);


   /* Create a unique index to ensure that two data keys cannot share the same


    * keyAltName. This is recommended practice for the key vault. */


   index_keys = BCON_NEW ("keyAltNames", BCON_INT32 (1));


   index_name = mongoc_collection_keys_to_index_string (index_keys);


   create_index_cmd = BCON_NEW ("createIndexes",


                                KEYVAULT_COLL,


                                "indexes",


                                "[",


                                "{",


                                "key",


                                BCON_DOCUMENT (index_keys),


                                "name",


                                index_name,


                                "unique",


                                BCON_BOOL (true),


                                "partialFilterExpression",


                                "{",


                                "keyAltNames",


                                "{",


                                "$exists",


                                BCON_BOOL (true),


                                "}",


                                "}",


                                "}",


                                "]");


   ret = mongoc_client_command_simple (client,


                                       KEYVAULT_DB,


                                       create_index_cmd,


                                       NULL /* read prefs */,


                                       NULL /* reply */,


                                       &error);


   if (!ret) {


      goto fail;


   }


   client_encryption_opts = mongoc_client_encryption_opts_new ();


   mongoc_client_encryption_opts_set_kms_providers (client_encryption_opts,


                                                    kms_providers);


   mongoc_client_encryption_opts_set_keyvault_namespace (


      client_encryption_opts, KEYVAULT_DB, KEYVAULT_COLL);


   /* The key vault client is used for reading to/from the key vault. This can


    * be the same mongoc_client_t used by the application. */


   mongoc_client_encryption_opts_set_keyvault_client (client_encryption_opts,


                                                      client);


   client_encryption =


      mongoc_client_encryption_new (client_encryption_opts, &error);


   if (!client_encryption) {


      goto fail;


   }


   /* Create a new data key for the encryptedField.


    * https://dochub.mongodb.org/core/client-side-field-level-encryption-automatic-encryption-rules


    */


   datakey_opts = mongoc_client_encryption_datakey_opts_new ();


   mongoc_client_encryption_datakey_opts_set_keyaltnames (


      datakey_opts, keyaltnames, 1);


   ret = mongoc_client_encryption_create_datakey (


      client_encryption, "local", datakey_opts, &datakey_id, &error);


   if (!ret) {


      goto fail;


   }


   /* Explicitly encrypt a field. */


   encrypt_opts = mongoc_client_encryption_encrypt_opts_new ();


   mongoc_client_encryption_encrypt_opts_set_algorithm (


      encrypt_opts, MONGOC_AEAD_AES_256_CBC_HMAC_SHA_512_DETERMINISTIC);


   mongoc_client_encryption_encrypt_opts_set_keyaltname (


      encrypt_opts, "mongoc_encryption_example_4");


   to_encrypt.value_type = BSON_TYPE_UTF8;


   to_encrypt.value.v_utf8.str = "123456789";


   to_encrypt.value.v_utf8.len = strlen (to_encrypt.value.v_utf8.str);


   ret = mongoc_client_encryption_encrypt (


      client_encryption, &to_encrypt, encrypt_opts, &encrypted_field, &error);


   if (!ret) {


      goto fail;


   }


   to_insert = bson_new ();


   BSON_APPEND_VALUE (to_insert, "encryptedField", &encrypted_field);


   ret = mongoc_collection_insert_one (


      coll, to_insert, NULL /* opts */, NULL /* reply */, &error);


   if (!ret) {


      goto fail;


   }


   /* When we retrieve the document, any encrypted fields will get automatically


    * decrypted by the driver. */


   printf ("decrypted document: ");


   if (!print_one_document (coll, &error)) {


      goto fail;


   }


   printf ("\n");


   unencrypted_client =


      mongoc_client_new ("mongodb://localhost/?appname=client-side-encryption");


   unencrypted_coll = mongoc_client_get_collection (


      unencrypted_client, ENCRYPTED_DB, ENCRYPTED_COLL);


   printf ("encrypted document: ");


   if (!print_one_document (unencrypted_coll, &error)) {


      goto fail;


   }


   printf ("\n");


   exit_status = EXIT_SUCCESS;
fail:


   if (error.code) {


      fprintf (stderr, "error: %s\n", error.message);


   }


   bson_free (local_masterkey);


   bson_destroy (kms_providers);


   mongoc_collection_destroy (keyvault_coll);


   bson_destroy (index_keys);


   bson_free (index_name);


   bson_destroy (create_index_cmd);


   mongoc_collection_destroy (coll);


   mongoc_client_destroy (client);


   bson_destroy (to_insert);


   bson_destroy (schema);


   bson_destroy (create_cmd);


   bson_destroy (create_cmd_opts);


   mongoc_write_concern_destroy (wc);


   mongoc_client_encryption_destroy (client_encryption);


   mongoc_client_encryption_datakey_opts_destroy (datakey_opts);


   mongoc_client_encryption_opts_destroy (client_encryption_opts);


   bson_value_destroy (&encrypted_field);


   mongoc_client_encryption_encrypt_opts_destroy (encrypt_opts);


   bson_value_destroy (&decrypted);


   bson_value_destroy (&datakey_id);


   mongoc_collection_destroy (unencrypted_coll);


   mongoc_client_destroy (unencrypted_client);


   mongoc_auto_encryption_opts_destroy (auto_encryption_opts);


   mongoc_cleanup ();


   return exit_status;
}