{% endblock %}
libbson-1.6.1/doc/mongoc-theme/static/ 0000775 0000000 0000000 00000000000 13057346540 0017574 5 ustar 00root root 0000000 0000000 libbson-1.6.1/doc/mongoc-theme/static/mongoc.css_t 0000664 0000000 0000000 00000023467 13057346540 0022127 0 ustar 00root root 0000000 0000000 /*
* mongoc.css_t
* ~~~~~~~~~~~~~~
*
* Sphinx stylesheet -- MongoDB C Driver theme.
*
* Adapted from Sphinx Readable Theme, Copyright 2013 by Ignacy Sokolowski
* https://github.com/ignacysokolowski/sphinx-readable-theme
*
* Copyright (c) 2017 MongoDB, Inc.
*
* MIT LICENSE
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
{% set page_width = '940px' %}
@import url('basic.css');
/* -- page layout --------------------------------------------------------- */
body {
font-family: sans-serif;
font-size: 18px;
margin: 0;
padding: 0;
}
div.document {
margin: 10px auto 0 auto;
max-width: {{ page_width }};
}
div.documentwrapper {
float: left;
width: 100%;
}
div.bodywrapper {
margin: 0 0 0 {{ theme_sidebarwidth|toint }}px;
}
/* make room for the big table */
div.bodywrapper#errors {
margin: 0;
}
div.body {
background-color: #ffffff;
color: #3e4349;
padding: 0 30px 30px 30px;
}
div.footer {
color: #555;
font-size: 14px;
margin: 20px auto 30px auto;
padding: 1em;
max-width: 880px;
}
div.footer a {
text-decoration: underline;
}
div.related {
padding: 10px 0;
width: auto;
}
/* on wide windows, show the sidebar and hide the home link */
div.related li.nav-item-0 {
display: none;
}
div.related ul {
padding: 0;
padding-left: 0 !important;
margin: 0 !important;
}
div.sphinxsidebar {
float: left;
font-size: 14px;
line-height: 1.5em;
margin-left: -100%;
width: {{ theme_sidebarwidth|toint }}px;
}
div.sphinxsidebarwrapper {
font-size: 14px;
line-height: 1.5em;
padding: 10px 0;
}
div.sphinxsidebar h3,
div.sphinxsidebar h4 {
color: #333;
font-size: 24px;
font-weight: normal;
margin: 0 0 5px 0;
padding: 0;
}
div.sphinxsidebarwrapper h3:first-of-type {
margin-bottom: 44px;
}
div.sphinxsidebar h4 {
font-size: 1.1em;
}
div.sphinxsidebar h3 a {
color: #333;
}
div.sphinxsidebar p {
color: #888;
}
div.sphinxsidebar p.searchtip {
line-height: 1.4em;
}
div.sphinxsidebar ul {
color: #000;
margin: 10px 0 20px;
padding: 0;
}
div.sphinxsidebar ul li.current > a {
font-weight: bold;
}
div.sphinxsidebar a {
color: #444;
}
div.sphinxsidebar a:hover {
color: #d00;
}
div.sphinxsidebar input {
border: 1px solid #ccc;
font-family: sans-serif;
font-size: 1em;
}
div.footer-nav {
clear: both;
}
div.footer a.footer-nav-button {
display: block;
font-size: 18px;
margin: 0.5em 0;
text-decoration: none;
}
a.footer-nav-button-prev {
float: left;
}
a.footer-nav-button-next {
float: right;
}
div.colophon {
clear: both;
text-align: center;
padding: 2em;
}
/* -- body styles --------------------------------------------------------- */
a {
color: #900;
text-decoration: none;
}
a:visited {
color: #700;
}
a:hover {
color: #d00;
text-decoration: underline;
}
hr {
border: 1px solid #b1b4b6;
}
div.body h1,
div.body h2,
div.body h3,
div.body h4,
div.body h5,
div.body h6 { font-weight: normal; }
div.body h1,
div.body h2,
div.body h3,
div.body h4 { color: #212224; }
div.body h5 { color: #000; }
div.body h6 { color: #777; }
div.body h1 { margin: 0 0 10px 0; }
div.body h2,
div.body h3 { margin: 30px 0px 10px 0px; }
div.body h4,
div.body h5,
div.body h6 { margin: 20px 0px 10px 0px; }
div.body h1 { padding: 0 0 10px 0; }
div.body h2,
div.body h3 { padding: 10px 0 10px 0; }
div.body h4 { padding: 10px 0 10px 0; }
div.body h5,
div.body h6 { padding: 10px 0 0 0; }
div.body h1,
div.body h2,
div.body h3 { border-bottom: 1px solid #ddd; }
div.body h4 { border-bottom: 1px solid #e5e5e5; }
div.body h1 { font-size: 230%; }
div.body h2 { font-size: 180%; }
div.body h3 { font-size: 130%; }
div.body h4 { font-size: 110%; }
div.body h5 { font-size: 105%; }
div.body h6 { font-size: 100%; }
a.headerlink {
color: #c60f0f;
font-size: 0.8em;
padding: 0 4px 0 4px;
text-decoration: none;
}
a.headerlink:hover {
background-color: #c60f0f;
color: #fff;
}
div.body ul {
list-style: disc;
margin: 1em 0;
padding-left: 1.3em;
}
div.body ul ul, div.body ol ul {
margin: .2em 0;
padding-left: 1.2em;
}
div.body ul li {
padding: 2px 0;
}
div.body ul.search li {
padding: 5px 0 5px 20px;
}
div.body ol {
counter-reset: li;
margin-left: 0;
padding-left: 0;
}
div.body ol ol {
margin: .2em 0;
}
div.body ol > li {
list-style: none;
margin: 0 0 0 1.9em;
padding: 2px 1px;
position: relative;
}
div.body ol > li:before {
content: counter(li) ".";
counter-increment: li;
top: -2px;
left: -1.9em;
width: 1.9em;
padding: 4px 0;
position: absolute;
text-align: left;
}
div.body p,
div.body dd,
div.body li {
line-height: 1.4em;
}
div.admonition p.admonition-title + p {
display: inline;
}
div.highlight {
background-color: #fff;
}
div.important, div.note {
background-color: #eee;
border: 1px solid #ccc;
}
div.attention, div.caution, div.hint, div.seealso, div.tip {
background-color: #fef9e9;
border: 1px solid #fbe091;
}
div.topic {
background-color: #eee;
}
div.danger, div.error, div.warning {
background-color: #ffe4e4;
border: 1px solid #f66;
}
p.admonition-title {
display: inline;
}
p.admonition-title:after {
content: ':';
}
pre {
background-color: #f5f5f5;
border: 1px solid #C6C9CB;
color: #222;
font-size: 0.75em;
line-height: 1.5em;
margin: 1.5em 0 1.5em 0;
padding: 10px;
box-shadow: 1px 1px 1px #d8d8d8;
-webkit-box-shadow: 1px 1px 1px #d8d8d8;
-moz-box-shadow: 1px 1px 1px #d8d8d8;
}
pre, tt, code {
font-family: 'Consolas', 'Menlo', 'Deja Vu Sans Mono', 'Bitstream Vera Sans Mono', monospace;
}
tt, code {
background-color: #ecf0f3;
font-size: 0.85em;
}
tt.descname, code.descname {
font-size: 0.95em;
}
tt.xref, a tt, code.xref, a code {
font-weight: normal;
}
span.pre {
padding: 0 2px;
}
/* Table-of-contents lists (UL) on home page should look like section headers */
{% set toc_selector = 'div.bodywrapper#index div.toctree-wrapper > ul' %}
{{ toc_selector }} {
margin: 0;
}
{{ toc_selector }} {
padding: 0;
margin: 20px 0 0 0;
}
{{ toc_selector }} > li.toctree-l1 {
list-style: none;
margin: 20px 0 10px;
}
{{ toc_selector }} li.toctree-l1 > a {
width: 100%;
display: block;
padding: 17px 0;
margin-bottom: 17px;
border-bottom: 1px solid #ddd;
font-size: 180%;
font-weight: normal;
color: black;
}
{{ toc_selector }} li.toctree-l1 > a:hover {
text-decoration: none;
color: #d00;
}
{{ toc_selector }} li.toctree-l1 ul {
padding-left: 20px;
}
dl.class, dl.function {
margin-bottom: 50px;
}
dl.function > dt,
dl.attribute > dt,
dl.classmethod > dt,
dl.method > dt,
dl.class > dt,
dl.exception > dt {
background-color: #f5f5f5;
margin: 25px 0 10px 0;
padding: 1px 10px;
}
table.docutils {
width: 100%;
}
table.docutils.footnote {
width: auto;
}
table.docutils thead,
table.docutils tfoot {
background: #f5f5f5;
}
table.docutils thead tr th {
color: #000;
font-weight: normal;
padding: 7px 5px;
vertical-align: middle;
}
table.docutils tbody tr th,
table.docutils tbody tr td {
border-bottom: 0;
border-top: solid 1px #ddd;
padding: 7px 5px;
vertical-align: top;
}
table.docutils tbody tr:last-child th,
table.docutils tbody tr:last-child td {
border-bottom: solid 1px #ddd;
}
table.docutils thead tr td p,
table.docutils tfoot tr td p,
table.docutils tbody tr td p,
table.docutils thead tr td ul,
table.docutils tfoot tr td ul,
table.docutils tbody tr td ul,
table.docutils thead tr td ol,
table.docutils tfoot tr td ol,
table.docutils tbody tr td ol {
margin: 0 0 .5em;
}
table.docutils thead tr td p.last,
table.docutils tfoot tr td p.last,
table.docutils tbody tr td p.last,
table.docutils thead tr td ul.last,
table.docutils tfoot tr td ul.last,
table.docutils tbody tr td ul.last,
table.docutils thead tr td ol.last,
table.docutils tfoot tr td ol.last,
table.docutils tbody tr td ol.last {
margin-bottom: 0;
}
.viewcode-back {
font-family: Arial, sans-serif;
}
div.viewcode-block:target {
background-color: #fef9e9;
border-top: 1px solid #fbe091;
border-bottom: 1px solid #fbe091;
}
a.symbol span {
font-family: monospace;
}
div.code-block-caption {
font-size: inherit;
padding: 0 0 1em 0;
}
@media screen and (max-width: 870px) {
div.document {
width: auto;
margin: 0;
}
div.bodywrapper {
margin: 0;
}
div.body {
min-height: 0;
padding: 0 20px 30px 20px;
}
/* hide side bar and reveal home page link */
div.sphinxsidebar, div.colophon {
display: none;
}
div.related li.nav-item-0 {
display: inline;
}
}
libbson-1.6.1/doc/mongoc-theme/static/pygments.css 0000664 0000000 0000000 00000010305 13057346540 0022153 0 ustar 00root root 0000000 0000000 .highlight .hll { background-color: #ffffcc }
.highlight { background: #f8f8f8; }
.highlight .c { color: #888 } /* Comment */
.highlight .err { color: #a40000; border: 1px solid #ef2929 } /* Error */
.highlight .g { color: #000000 } /* Generic */
.highlight .k { color: #004461; font-weight: bold } /* Keyword */
.highlight .l { color: #000000 } /* Literal */
.highlight .n { color: #000000 } /* Name */
.highlight .o { color: #582800 } /* Operator */
.highlight .x { color: #000000 } /* Other */
.highlight .p { color: #000000; font-weight: bold } /* Punctuation */
.highlight .cm { color: #8f5902; font-style: italic } /* Comment.Multiline */
.highlight .cp { color: #8f5902 } /* Comment.Preproc */
.highlight .c1 { color: #8f5902; font-style: italic } /* Comment.Single */
.highlight .cs { color: #8f5902; font-style: italic } /* Comment.Special */
.highlight .gd { color: #a40000 } /* Generic.Deleted */
.highlight .ge { color: #000000; font-style: italic } /* Generic.Emph */
.highlight .gr { color: #ef2929 } /* Generic.Error */
.highlight .gh { color: #000080; font-weight: bold } /* Generic.Heading */
.highlight .gi { color: #00A000 } /* Generic.Inserted */
.highlight .go { color: #888888 } /* Generic.Output */
.highlight .gp { color: #745334 } /* Generic.Prompt */
.highlight .gs { color: #000000; font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */
.highlight .gt { color: #a40000; font-weight: bold } /* Generic.Traceback */
.highlight .kc { color: #004461; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #004461; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #004461; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #004461; font-weight: bold } /* Keyword.Pseudo */
.highlight .kr { color: #004461; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #004461; font-weight: bold } /* Keyword.Type */
.highlight .ld { color: #000000 } /* Literal.Date */
.highlight .m { color: #990000 } /* Literal.Number */
.highlight .s { color: #3b7c03 } /* Literal.String */
.highlight .na { color: #c4a000 } /* Name.Attribute */
.highlight .nb { color: #004461 } /* Name.Builtin */
.highlight .nc { color: #000000 } /* Name.Class */
.highlight .no { color: #000000 } /* Name.Constant */
.highlight .nd { color: #888888 } /* Name.Decorator */
.highlight .ni { color: #ce5c00 } /* Name.Entity */
.highlight .ne { color: #cc0000; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #000000 } /* Name.Function */
.highlight .nl { color: #f57900 } /* Name.Label */
.highlight .nn { color: #000000 } /* Name.Namespace */
.highlight .nx { color: #000000 } /* Name.Other */
.highlight .py { color: #000000 } /* Name.Property */
.highlight .nt { color: #004461; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #000000 } /* Name.Variable */
.highlight .ow { color: #004461; font-weight: bold } /* Operator.Word */
.highlight .w { color: #f8f8f8; text-decoration: underline } /* Text.Whitespace */
.highlight .mf { color: #990000 } /* Literal.Number.Float */
.highlight .mh { color: #990000 } /* Literal.Number.Hex */
.highlight .mi { color: #990000 } /* Literal.Number.Integer */
.highlight .mo { color: #990000 } /* Literal.Number.Oct */
.highlight .sb { color: #4e9a06 } /* Literal.String.Backtick */
.highlight .sc { color: #4e9a06 } /* Literal.String.Char */
.highlight .sd { color: #8f5902 } /* Literal.String.Doc */
.highlight .s2 { color: #4e9a06 } /* Literal.String.Double */
.highlight .se { color: #4e9a06 } /* Literal.String.Escape */
.highlight .sh { color: #4e9a06 } /* Literal.String.Heredoc */
.highlight .si { color: #4e9a06 } /* Literal.String.Interpol */
.highlight .sx { color: #4e9a06 } /* Literal.String.Other */
.highlight .sr { color: #4e9a06 } /* Literal.String.Regex */
.highlight .s1 { color: #4e9a06 } /* Literal.String.Single */
.highlight .ss { color: #4e9a06 } /* Literal.String.Symbol */
.highlight .bp { color: #3465a4 } /* Name.Builtin.Pseudo */
.highlight .vc { color: #000000 } /* Name.Variable.Class */
.highlight .vg { color: #000000 } /* Name.Variable.Global */
.highlight .vi { color: #000000 } /* Name.Variable.Instance */
.highlight .il { color: #990000 } /* Literal.Number.Integer.Long */
libbson-1.6.1/doc/mongoc-theme/theme.conf 0000664 0000000 0000000 00000000110 13057346540 0020246 0 ustar 00root root 0000000 0000000 [theme]
inherit = basic
stylesheet = mongoc.css
pygments_style = sphinx
libbson-1.6.1/doc/mongoc/ 0000775 0000000 0000000 00000000000 13057346540 0015205 5 ustar 00root root 0000000 0000000 libbson-1.6.1/doc/mongoc/__init__.py 0000664 0000000 0000000 00000002536 13057346540 0017324 0 ustar 00root root 0000000 0000000 from docutils.nodes import literal, Text
from docutils.parsers.rst import roles
from sphinx.roles import XRefRole
class SymbolRole(XRefRole):
def __call__(self, *args, **kwargs):
nodes, messages = XRefRole.__call__(self, *args, **kwargs)
for node in nodes:
attrs = node.attributes
target = attrs['reftarget']
parens = ''
if target.endswith('()'):
# Function call, :symbol:`mongoc_init()`
target = target[:-2]
parens = '()'
if ':' in target:
# E.g., 'bson:bson_t' has domain 'bson', target 'bson_t'
attrs['domain'], name = target.split(':', 1)
attrs['reftarget'] = name
assert isinstance(node.children[0].children[0], Text)
node.children[0].children[0] = Text(name + parens,
name + parens)
else:
attrs['reftarget'] = target
attrs['reftype'] = 'doc'
attrs['classes'].append('symbol')
return nodes, messages
def setup(app):
roles.register_local_role(
'symbol', SymbolRole(warn_dangling=True, innernodeclass=literal))
return {
'version': '1.0',
'parallel_read_safe': True,
'parallel_write_safe': True,
}
libbson-1.6.1/doc/oid.rst 0000664 0000000 0000000 00000004703 13057346540 0015234 0 ustar 00root root 0000000 0000000 :man_page: bson_oid
ObjectIDs
=========
Libbson provides a simple way to generate ObjectIDs. It can be used in a single-threaded or multi-threaded manner depending on your requirements.
The :symbol:`bson_oid_t` structure represents an ``ObjectI`` in MongoDB. It is a 96-bit identifier that includes various information about the system generating the OID.
Composition
-----------
* 4 bytes : The UNIX timestamp in big-endian format.
* 3 bytes : The first 3 bytes of ``MD5(hostname)``.
* 2 bytes : The ``pid_t`` of the current process. Alternatively the task-id if configured.
* 3 bytes : A 24-bit monotonic counter incrementing from ``rand()`` in big-endian.
Sorting ObjectIDs
-----------------
The typical way to sort in C is using ``qsort()``. Therefore, Libbson provides a ``qsort()`` compatible callback function named :symbol:`bson_oid_compare()`. It returns ``less than 1``, ``greater than 1``, or ``0`` depending on the equality of two :symbol:`bson_oid_t` structures.
Comparing Object IDs
--------------------
If you simply want to compare two :symbol:`bson_oid_t` structures for equality, use :symbol:`bson_oid_equal()`.
Generating
----------
To generate a :symbol:`bson_oid_t`, you may use the following.
.. code-block:: c
bson_oid_t oid;
bson_oid_init (&oid, NULL);
Parsing ObjectID Strings
------------------------
You can also parse a string contianing a :symbol:`bson_oid_t`. The input string *MUST* be 24 characters or more in length.
.. code-block:: c
bson_oid_t oid;
bson_oid_init_from_string (&oid, "123456789012345678901234");
If you need to parse may :symbol:`bson_oid_t` in a tight loop and can guarantee the data is safe, you might consider using the inline variant. It will be inlined into your code and reduce the need for a foreign function call.
.. code-block:: c
bson_oid_t oid;
bson_oid_init_from_string_unsafe (&oid, "123456789012345678901234");
Hashing ObjectIDs
-----------------
If you need to store items in a hashtable, you may want to use the :symbol:`bson_oid_t` as the key. Libbson provides a hash function for just this purpose. It is based on DJB hash.
.. code-block:: c
unsigned hash;
hash = bson_oid_hash (oid);
Fetching ObjectID Creation Time
-------------------------------
You can easily fetch the time that a :symbol:`bson_oid_t` was generated using :symbol:`bson_oid_get_time_t()`.
.. code-block:: c
time_t t;
t = bson_oid_get_time_t (oid);
printf ("The OID was generated at %u\n", (unsigned) t);
libbson-1.6.1/doc/parsing.rst 0000664 0000000 0000000 00000007346 13057346540 0016132 0 ustar 00root root 0000000 0000000 :man_page: bson_parsing
Parsing and Iterating BSON Documents
====================================
Parsing
-------
BSON documents are lazily parsed as necessary. To begin parsing a BSON document, use one of the provided Libbson functions to create a new :symbol:`bson_t` from existing data such as :symbol:`bson_new_from_data()`. This will make a copy of the data so that additional mutations may occur to the BSON document.
.. tip:
If you only want to parse a BSON document and have no need to mutate it, you may use :symbol:`bson_init_static()` to avoid making a copy of the data.
.. code-block:: c
bson_t *b;
b = bson_new_from_data (my_data, my_data_len);
if (!b) {
fprintf (stderr, "The specified length embedded in did not match "
"\n");
return;
}
bson_destroy (b);
Only two checks are performed when creating a new :symbol:`bson_t` from an existing buffer. First, the document must begin with the buffer length, matching what was expected by the caller. Second, the document must end with the expected trailing ``\0`` byte.
To parse the document further we use a :symbol:`bson_iter_t` to iterate the elements within the document. Let's print all of the field names in the document.
.. code-block:: c
bson_t *b;
bson_iter_t iter;
if ((b = bson_new_from_data (my_data, my_data_len))) {
if (bson_iter_init (&iter, b)) {
while (bson_iter_next (&iter)) {
printf ("Found element key: \"%s\"\n", bson_iter_key (&iter));
}
}
bson_destroy (b);
}
Converting a document to JSON uses a :symbol:`bson_iter_t` and :symbol:`bson_visitor_t` to iterate all fields of a BSON document recursively and generate a UTF-8 encoded JSON string.
.. code-block:: c
bson_t *b;
char *json;
if ((b = bson_new_from_data (my_data, my_data_len))) {
if ((json = bson_as_json (b, NULL))) {
printf ("%s\n", json);
bson_free (json);
}
bson_destroy (b);
}
Recursing into Sub-Documents
----------------------------
Libbson provides convenient sub-iterators to dive down into a sub-document or sub-array. Below is an example that will dive into a sub-document named "foo" and print it's field names.
.. code-block:: c
bson_iter_t iter;
bson_iter_t *child;
char *json;
if (bson_iter_init_find (&iter, doc, "foo") &&
BSON_ITER_HOLDS_DOCUMENT (&iter) && bson_iter_recurse (&iter, &child)) {
while (bson_iter_next (&child)) {
printf ("Found sub-key of \"foo\" named \"%s\"\n",
bson_iter_key (&child));
}
}
Finding Fields using Dot Notation
---------------------------------
Using the :symbol:`bson_iter_recurse()` function exemplified above, :symbol:`bson_iter_find_descendant()` can find a field for you using the MongoDB style path notation such as "foo.bar.0.baz".
Let's create a document like ``{"foo": {"bar": [{"baz: 1}]}}`` and locate the ``"baz"`` field.
.. code-block:: c
bson_t *b;
bson_iter_t iter;
bson_iter_t baz;
b =
BCON_NEW ("foo", "{", "bar", "[", "{", "baz", BCON_INT32 (1), "}", "]", "}");
if (bson_iter_init (&iter, b) &&
bson_iter_find_descendant (&iter, "foo.bar.0.baz", &baz) &&
BSON_ITER_HOLDS_INT32 (&baz)) {
printf ("baz = %d\n", bson_iter_int32 (&baz));
}
bson_destroy (b);
Validating a BSON Document
--------------------------
If all you want to do is validate that a BSON document is valid, you can use :symbol:`bson_validate()`.
.. code-block:: c
size_t err_offset;
if (!bson_validate (doc, BSON_VALIDATE_NONE, &err_offset)) {
fprintf (stderr,
"The document failed to validate at offset: %u\n",
(unsigned) err_offset);
}
See the :symbol:`bson_validate()` documentation for more information and examples.
libbson-1.6.1/doc/performance.rst 0000664 0000000 0000000 00000001755 13057346540 0016766 0 ustar 00root root 0000000 0000000 :man_page: bson_performance
Performance Notes
=================
.. _performance_array_element_key_building:
Array Element Key Building
--------------------------
When writing marshaling layers between higher level languages and Libbson, you will eventually need to build keys for array elements. Each element in a BSON array has a monotonic string key like ``"0"``, ``"1"``, etc. Using ``snprintf()`` and others tend to be rather slow on most ``libc`` implementations. Therefore, Libbson provides :symbol:`bson_uint32_to_string()` to improve this. Using this function allows an internal fast path to be used for numbers less than 1000 which is the vast majority of arrays. If the key is larger than that, a fallback of ``snprintf()`` will be used.
.. code-block:: c
char str[16];
const char *key;
uint32_t i;
for (i = 0; i < 10; i++) {
bson_uint32_to_string (i, &key, str, sizeof str);
printf ("Key: %s\n", key);
}
For more information, see :symbol:`bson_uint32_to_string()`.
libbson-1.6.1/doc/streaming-bson.rst 0000664 0000000 0000000 00000005267 13057346540 0017417 0 ustar 00root root 0000000 0000000 :man_page: bson_streaming_bson
Streaming BSON
==============
:symbol:`bson_reader_t` provides a streaming reader which can be initialized with a filedescriptor or memory region. :symbol:`bson_writer_t` provides a streaming writer which can be initialized with a memory region. (Streaming BSON to a file descriptor is not yet supported.)
Reading from a BSON Stream
--------------------------
:symbol:`bson_reader_t` provides a convenient API to read sequential BSON documents from a file-descriptor or memory buffer. The :symbol:`bson_reader_read()` function will read forward in the underlying stream and returna :symbol:`bson_t` that can be inspected and iterated upon.
.. code-block:: c
#include
#include
int
main (int argc, char *argv[])
{
bson_reader_t *reader;
const bson_t *doc;
bson_error_t error;
bool eof;
reader = bson_reader_new_from_file ("mycollection.bson", &error);
if (!reader) {
fprintf (stderr, "Failed to open file.\n");
return 1;
}
while ((doc = bson_reader_read (reader, &eof))) {
char *str = bson_as_json (doc, NULL);
printf ("%s\n", str);
bson_free (str);
}
if (!eof) {
fprintf (stderr,
"corrupted bson document found at %u\n",
(unsigned) bson_reader_tell (reader));
}
bson_reader_destroy (reader);
return 0;
}
See :symbol:`bson_reader_new_from_fd()`, :symbol:`bson_reader_new_from_file()`, and :symbol:`bson_reader_new_from_data()` for more information.
Writing a sequence of BSON Documents
------------------------------------
:symbol:`bson_writer_t` provides a convenient API to write a sequence of BSON documents to a memory buffer that can grow with ``realloc()``. The :symbol:`bson_writer_begin()` and :symbol:`bson_writer_end()` functions will manage the underlying buffer while building the sequence of documents.
This could also be useful if you want to write to a network packet while serializing the documents from a higher level language, (but do so just after the packets header).
.. code-block:: c
#include
#include
#include
int
main (int argc, char *argv[])
{
bson_writer_t *writer;
bson_t *doc;
uint8_t *buf = NULL;
size_t buflen = 0;
bool r;
int i;
writer = bson_writer_new (&buf, &buflen, 0, bson_realloc_ctx, NULL);
for (i = 0; i < 10000; i++) {
r = bson_writer_begin (writer, &doc);
assert (r);
r = BSON_APPEND_INT32 (doc, "i", i);
assert (r);
bson_writer_end (writer);
}
bson_free (buf);
return 0;
}
See :symbol:`bson_writer_new()` for more information.
libbson-1.6.1/doc/taglist.py 0000775 0000000 0000000 00000011125 13057346540 0015747 0 ustar 00root root 0000000 0000000 """
Adapted from the sphinxcontrib.taglist extension, Copyright 2007-2009 by the
Sphinx team.
MIT LICENSE
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
"""
from docutils import nodes, utils
from sphinx.environment import NoUri
from sphinx.util.compat import Directive
def get_tags(s):
return list(filter(lambda x: x,
map(lambda x: x.strip(),
s.split(' ')
)
)
)
def tag_role(name, rawtext, text, lineno, inliner, options=None, content=[]):
status = utils.unescape(text.strip().replace(' ', '_'))
return [], []
class taglist(nodes.General, nodes.Element):
def __init__(self, *a, **b):
super(taglist, self).__init__(*a, **b)
self.tags = []
class TaglistDirective(Directive):
has_content = True
option_spec = {
'tags': str,
}
def run(self):
tl = taglist('')
tl.tags = get_tags(self.options.get('tags', ''))
section = nodes.section(ids=['taglist'])
title = nodes.Text(self.content[0] or "See Also:")
section += nodes.title(title, title)
text = nodes.paragraph()
text += [nodes.Text(":tag:`%s`"%t) for t in tl.tags ]
self.state.nested_parse(text, 0, section)
section += [tl]
return [section]
def process_tags(app, doctree):
# collect all tags in the environment
# this is not done in the directive itself because it some transformations
# must have already been run, e.g. substitutions
env = app.builder.env
if not hasattr(env, 'tags_all_tags'):
env.tags_all_tags = []
for node in doctree.traverse(taglist):
env.tags_all_tags.append({'docname': env.docname, 'tags': node.tags})
def process_taglist_nodes(app, doctree, fromdocname):
# Replace all taglist nodes with a list of the collected tags.
# Augment each tag with a backlink to the original location.
env = app.builder.env
if not hasattr(env, 'tags_all_tags'):
env.tags_all_tags = []
for node in doctree.traverse(taglist):
content = []
for tag_info in env.tags_all_tags:
tags = tag_info['tags']
if not set(tags).intersection(node.tags):
continue
if fromdocname == tag_info['docname']:
continue
# (Recursively) resolve references in the tag content
para = nodes.paragraph(classes=['tag-source'])
refnode = nodes.reference('', '', internal=True)
try:
refnode['refuri'] = app.builder.get_relative_uri(
fromdocname, tag_info['docname'])
except NoUri:
# ignore if no URI can be determined, e.g. for LaTeX output
pass
# Create a reference
refnode.append(nodes.Text(tag_info['docname']))
para += refnode
content.append(para)
node.replace_self(content)
def purge_tags(app, env, docname):
if not hasattr(env, 'tags_all_tags'):
return
env.tags_all_tags = [tag for tag in env.tags_all_tags
if tag['docname'] != docname]
def visit_tag_node(self, node):
pass
def depart_tag_node(self, node):
pass
def setup(app):
app.add_config_value('taglist_css', {}, 'env')
app.add_config_value('taglist_tags', {}, 'env')
app.add_role('tag', tag_role)
app.add_node(taglist)
app.add_directive('taglist', TaglistDirective)
app.connect('doctree-read', process_tags)
app.connect('doctree-resolved', process_taglist_nodes)
app.connect('env-purge-doc', purge_tags)
libbson-1.6.1/doc/threading.rst 0000664 0000000 0000000 00000001004 13057346540 0016415 0 ustar 00root root 0000000 0000000 :man_page: bson_threading
Threading
=========
Libbson's data structures are *NOT* thread-safe. You are responsible for accessing and mutating these structures from one thread at a time.
Libbson requires POSIX threads (pthreads) on all UNIX-like platforms. On Windows, the native threading interface is used. Libbson uses your system's threading library to safely generate unique :doc:`ObjectIds `, and to provide a fallback implementation for atomic operations on platforms without built-in atomics.
libbson-1.6.1/doc/tutorial.rst 0000664 0000000 0000000 00000000204 13057346540 0016314 0 ustar 00root root 0000000 0000000 :man_page: bson_tutorial
Tutorial
========
.. toctree::
:titlesonly:
:maxdepth: 1
creating
errors
oid
parsing
utf8
libbson-1.6.1/doc/utf8.rst 0000664 0000000 0000000 00000001743 13057346540 0015350 0 ustar 00root root 0000000 0000000 :man_page: bson_utf8
UTF-8
=====
Encoding
--------
Libbson expects that you are always working with UTF-8 encoded text. Anything else is **invalid API use**.
If you should need to walk through UTF-8 sequences, you can use the various UTF-8 helper functions distributed with Libbson.
Validating a UTF-8 Sequence
---------------------------
To validate the string contained in ``my_string``, use the following. You may pass ``-1`` for the string length if you know the string is NULL-terminated.
.. code-block:: c
if (!bson_utf8_validate (my_string, -1, false)) {
printf ("Validation failed.\n");
}
If ``my_string`` has NULL bytes within the string, you must provide the string length. Use the following format. Notice the ``true`` at the end indicationg ``\0`` is allowed.
.. code-block:: c
if (!bson_utf8_validate (my_string, my_string_len, true)) {
printf ("Validation failed.\n");
}
For more information see the API reference for :symbol:`bson_utf8_validate()`.
libbson-1.6.1/doc/version.rst 0000664 0000000 0000000 00000002105 13057346540 0016140 0 ustar 00root root 0000000 0000000 :man_page: bson_version
Libbson Versioning
==================
Versioning Macros and Functions
Macros
------
The following preprocessor macros can be used to perform various checks based on the version of the library you are compiling against. This may be useful if you only want to enable a feature on a certain version of the library.
Synopsis
--------
.. code-block:: c
#define BSON_CHECK_VERSION(major, minor, micro)
#define BSON_MAJOR_VERSION (1)
#define BSON_MINOR_VERSION (4)
#define BSON_MICRO_VERSION (1)
#define BSON_VERSION_S "1.4.1"
#define BSON_VERSION_HEX \
(BSON_MAJOR_VERSION << 24 | BSON_MINOR_VERSION << 16 | \
BSON_MICRO_VERSION << 8)
Only compile a block on Libbson 1.1.0 and newer.
.. code-block:: c
#if BSON_CHECK_VERSION(1, 1, 0)
static void
do_something (void)
{
}
#endif
.. only:: html
Functions
---------
.. toctree::
:titlesonly:
:maxdepth: 1
bson_check_version
bson_get_major_version
bson_get_micro_version
bson_get_minor_version
bson_get_version
libbson-1.6.1/examples/ 0000775 0000000 0000000 00000000000 13057346540 0014774 5 ustar 00root root 0000000 0000000 libbson-1.6.1/examples/Makefile.am 0000664 0000000 0000000 00000003272 13057346540 0017034 0 ustar 00root root 0000000 0000000 EXAMPLELDFLAGS = $(COVERAGE_LDFLAGS)
EXAMPLE_CFLAGS = \
-I$(top_srcdir)/src/bson \
-I$(top_builddir)/src/bson
EXAMPLE_STREAMING_CFLAGS = $(EXAMPLE_CFLAGS) \
$(SOCKET_CFLAGS)
EXAMPLE_STREAMING_LDFLAGS = $(SOCKET_LDFLAGS)
noinst_PROGRAMS += bson-to-json
bson_to_json_SOURCES = examples/bson-to-json.c
bson_to_json_CPPFLAGS = $(EXAMPLE_CFLAGS)
bson_to_json_LDFLAGS = $(EXAMPLELDFLAGS)
bson_to_json_LDADD = libbson-1.0.la
noinst_PROGRAMS += bson-validate
bson_validate_SOURCES = examples/bson-validate.c
bson_validate_CPPFLAGS = $(EXAMPLE_CFLAGS)
bson_validate_LDFLAGS = $(EXAMPLELDFLAGS)
bson_validate_LDADD = libbson-1.0.la
noinst_PROGRAMS += bcon-speed
bcon_speed_SOURCES = examples/bcon-speed.c
bcon_speed_CPPFLAGS = $(EXAMPLE_CFLAGS)
bcon_speed_LDFLAGS = $(EXAMPLELDFLAGS)
bcon_speed_LDADD = libbson-1.0.la
noinst_PROGRAMS += bcon-col-view
bcon_col_view_SOURCES = examples/bcon-col-view.c
bcon_col_view_CPPFLAGS = $(EXAMPLE_CFLAGS)
bcon_col_view_LDFLAGS = $(EXAMPLELDFLAGS)
bcon_col_view_LDADD = libbson-1.0.la
noinst_PROGRAMS += json-to-bson
json_to_bson_SOURCES = examples/json-to-bson.c
json_to_bson_CPPFLAGS = $(EXAMPLE_CFLAGS)
json_to_bson_LDFLAGS = $(EXAMPLELDFLAGS)
json_to_bson_LDADD = libbson-1.0.la
noinst_PROGRAMS += bson-metrics
bson_metrics_SOURCES = examples/bson-metrics.c
bson_metrics_CPPFLAGS = $(EXAMPLE_CFLAGS)
bson_metrics_LDFLAGS = $(EXAMPLELDFLAGS)
bson_metrics_LDADD = -lm libbson-1.0.la
noinst_PROGRAMS += bson-streaming-reader
bson_streaming_reader_SOURCES = examples/bson-streaming-reader.c
bson_streaming_reader_CPPFLAGS = $(EXAMPLE_STREAMING_CFLAGS)
bson_streaming_reader_LDFLAGS = $(EXAMPLELDFLAGS)
bson_streaming_reader_LDADD = $(EXAMPLE_STREAMING_LDFLAGS) libbson-1.0.la
libbson-1.6.1/examples/bcon-col-view.c 0000664 0000000 0000000 00000004224 13057346540 0017606 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 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
#include
#define QUERY(...) ELE_QUERY, __VA_ARGS__, NULL
#define SORT(...) ELE_SORT, __VA_ARGS__, NULL
#define LIMIT(var) ELE_LIMIT, (var)
#define COL_VIEW_CREATE(...) col_view_create ("", __VA_ARGS__, ELE_END)
typedef enum ele {
ELE_SORT,
ELE_LIMIT,
ELE_QUERY,
ELE_END,
} ele_t;
bson_t *
col_view_create (const char *stub, ...)
{
bson_t *bson;
va_list ap;
ele_t type;
int keep_going = 1;
bcon_append_ctx_t ctx;
bcon_append_ctx_init (&ctx);
va_start (ap, stub);
bson = bson_new ();
while (keep_going) {
type = va_arg (ap, ele_t);
switch (type) {
case ELE_SORT:
BCON_APPEND_CTX (bson, &ctx, "sort", "{");
bcon_append_ctx_va (bson, &ctx, &ap);
BCON_APPEND_CTX (bson, &ctx, "}");
break;
case ELE_LIMIT: {
int i = va_arg (ap, int);
BCON_APPEND_CTX (bson, &ctx, "limit", BCON_INT32 (i));
break;
}
case ELE_QUERY:
BCON_APPEND_CTX (bson, &ctx, "query", "{");
bcon_append_ctx_va (bson, &ctx, &ap);
BCON_APPEND_CTX (bson, &ctx, "}");
break;
case ELE_END:
keep_going = 0;
break;
default:
assert (0);
break;
}
}
va_end (ap);
return bson;
}
int
main (int argc, char *argv[])
{
bson_t *bson;
char *json;
bson = COL_VIEW_CREATE (
SORT ("a", BCON_INT32 (1)), QUERY ("hello", "world"), LIMIT (10));
json = bson_as_json (bson, NULL);
printf ("%s\n", json);
bson_free (json);
bson_destroy (bson);
return 0;
}
libbson-1.6.1/examples/bcon-speed.c 0000664 0000000 0000000 00000004770 13057346540 0017167 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013-2014 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
#include
#include
#include
/*
* This is a test for comparing the performance of BCON to regular
* bson_append*() function calls.
*
* Maybe run the following a few times to get an idea of the performance
* implications of using BCON. Generally, it's fast enough to be very
* useful and result in easier to read BSON code.
*
* time ./bcon-speed 100000 y
* time ./bcon-speed 100000 n
*/
int
main (int argc, char *argv[])
{
int i;
int n;
int bcon;
bson_t bson, foo, bar, baz;
bson_init (&bson);
if (argc != 3) {
fprintf (stderr,
"usage: bcon-speed NUM_ITERATIONS [y|n]\n"
"\n"
" y = perform speed tests with bcon\n"
" n = perform speed tests with bson_append\n"
"\n");
return EXIT_FAILURE;
}
assert (argc == 3);
n = atoi (argv[1]);
bcon = (argv[2][0] == 'y') ? 1 : 0;
for (i = 0; i < n; i++) {
if (bcon) {
BCON_APPEND (&bson,
"foo",
"{",
"bar",
"{",
"baz",
"[",
BCON_INT32 (1),
BCON_INT32 (2),
BCON_INT32 (3),
"]",
"}",
"}");
} else {
bson_append_document_begin (&bson, "foo", -1, &foo);
bson_append_document_begin (&foo, "bar", -1, &bar);
bson_append_array_begin (&bar, "baz", -1, &baz);
bson_append_int32 (&baz, "0", -1, 1);
bson_append_int32 (&baz, "1", -1, 2);
bson_append_int32 (&baz, "2", -1, 3);
bson_append_array_end (&bar, &baz);
bson_append_document_end (&foo, &bar);
bson_append_document_end (&bson, &foo);
}
bson_reinit (&bson);
}
bson_destroy (&bson);
return 0;
}
libbson-1.6.1/examples/bson-metrics.c 0000664 0000000 0000000 00000023764 13057346540 0017561 0 ustar 00root root 0000000 0000000 /*
* Copyright 2014 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.
*/
/*
* This program will scan each BSON document contained in the provided files
* and print metrics to STDOUT.
*/
#include
#include
#include
#define MAX_RECURSION 100
static double
dtimeofday (void)
{
struct timeval timeval;
bson_gettimeofday (&timeval);
return (timeval.tv_sec + timeval.tv_usec * 0.000001);
}
typedef struct {
uint64_t count;
char *description;
} bson_type_metrics_t;
typedef struct {
uint64_t doc_count;
uint64_t element_count;
uint64_t doc_size_max;
uint64_t key_size_tally;
uint64_t utf8_size_tally;
uint32_t depth;
bson_type_metrics_t bson_type_metrics[256];
} bson_metrics_state_t;
static bson_metrics_state_t initial_state = {
0L,
0L,
0L,
0L,
0L,
0L,
{{/* BSON_TYPE_EOD = 0x00 */ 0L, "End of document"},
{/* BSON_TYPE_DOUBLE = 0x01 */ 0L, "Floating point"},
{/* BSON_TYPE_UTF8 = 0x02 */ 0L, "UTF-8 string"},
{/* BSON_TYPE_DOCUMENT = 0x03 */ 0L, "Embedded document"},
{/* BSON_TYPE_ARRAY = 0x04 */ 0L, "Array"},
{/* BSON_TYPE_BINARY = 0x05 */ 0L, "Binary data"},
{/* BSON_TYPE_UNDEFINED = 0x06 */ 0L, "Undefined - Deprecated"},
{/* BSON_TYPE_OID = 0x07 */ 0L, "ObjectId"},
{/* BSON_TYPE_BOOL = 0x08 */ 0L, "Boolean"},
{/* BSON_TYPE_DATE_TIME = 0x09 */ 0L, "UTC datetime"},
{/* BSON_TYPE_NULL = 0x0A */ 0L, "Null value"},
{/* BSON_TYPE_REGEX = 0x0B */ 0L, "Regular expression"},
{/* BSON_TYPE_DBPOINTER = 0x0C */ 0L, "DBPointer - Deprecated"},
{/* BSON_TYPE_CODE = 0x0D */ 0L, "JavaScript code"},
{/* BSON_TYPE_SYMBOL = 0x0E */ 0L, "Symbol - Deprecated"},
{/* BSON_TYPE_CODEWSCOPE = 0x0F */ 0L, "JavaScript code w/ scope"},
{/* BSON_TYPE_INT32 = 0x10 */ 0L, "32-bit Integer"},
{/* BSON_TYPE_TIMESTAMP = 0x11 */ 0L, "Timestamp"},
{/* BSON_TYPE_INT64 = 0x12 */ 0L, "64-bit Integer"},
{0L, NULL}}};
static bson_metrics_state_t state;
static int
compar_bson_type_metrics (const void *a, const void *b)
{
return (((bson_type_metrics_t *) b)->count -
((bson_type_metrics_t *) a)->count);
}
/*
* Forward declarations.
*/
static bool
bson_metrics_visit_array (const bson_iter_t *iter,
const char *key,
const bson_t *v_array,
void *data);
static bool
bson_metrics_visit_document (const bson_iter_t *iter,
const char *key,
const bson_t *v_document,
void *data);
static bool
bson_metrics_visit_utf8 (const bson_iter_t *iter,
const char *key,
size_t v_utf8_len,
const char *v_utf8,
void *data)
{
bson_metrics_state_t *state = data;
state->utf8_size_tally += v_utf8_len;
return false;
}
static bool
bson_metrics_visit_before (const bson_iter_t *iter, const char *key, void *data)
{
bson_metrics_state_t *state = data;
bson_type_t btype;
++state->element_count;
state->key_size_tally += strlen (key); /* TODO - filter out array keys(?) */
btype = bson_iter_type (iter);
++state->bson_type_metrics[btype].count;
return false;
}
static const bson_visitor_t bson_metrics_visitors = {
bson_metrics_visit_before,
NULL, /* visit_after */
NULL, /* visit_corrupt */
NULL, /* visit_double */
bson_metrics_visit_utf8,
bson_metrics_visit_document,
bson_metrics_visit_array,
NULL, /* visit_binary */
NULL, /* visit_undefined */
NULL, /* visit_oid */
NULL, /* visit_bool */
NULL, /* visit_date_time */
NULL, /* visit_null */
NULL, /* visit_regex */
NULL, /* visit_dbpointer */
NULL, /* visit_code */
NULL, /* visit_symbol */
NULL, /* visit_codewscope */
NULL, /* visit_int32 */
NULL, /* visit_timestamp */
NULL, /* visit_int64 */
NULL, /* visit_maxkey */
NULL, /* visit_minkey */
};
static bool
bson_metrics_visit_document (const bson_iter_t *iter,
const char *key,
const bson_t *v_document,
void *data)
{
bson_metrics_state_t *state = data;
bson_iter_t child;
if (state->depth >= MAX_RECURSION) {
fprintf (stderr, "Invalid document, max recursion reached.\n");
return true;
}
if (bson_iter_init (&child, v_document)) {
state->depth++;
bson_iter_visit_all (&child, &bson_metrics_visitors, data);
state->depth--;
}
return false;
}
static bool
bson_metrics_visit_array (const bson_iter_t *iter,
const char *key,
const bson_t *v_array,
void *data)
{
bson_metrics_state_t *state = data;
bson_iter_t child;
if (state->depth >= MAX_RECURSION) {
fprintf (stderr, "Invalid document, max recursion reached.\n");
return true;
}
if (bson_iter_init (&child, v_array)) {
state->depth++;
bson_iter_visit_all (&child, &bson_metrics_visitors, data);
state->depth--;
}
return false;
}
static void
bson_metrics (const bson_t *bson, size_t *length, void *data)
{
bson_iter_t iter;
bson_metrics_state_t *state = data;
++state->doc_count;
if (bson_iter_init (&iter, bson)) {
bson_iter_visit_all (&iter, &bson_metrics_visitors, data);
}
}
int
main (int argc, char *argv[])
{
bson_reader_t *reader;
const bson_t *b;
bson_error_t error;
const char *filename;
int i, j;
double dtime_before, dtime_after, dtime_delta;
uint64_t aggregate_count;
off_t mark;
/*
* Print program usage if no arguments are provided.
*/
if (argc == 1) {
fprintf (stderr, "usage: %s FILE...\n", argv[0]);
return 1;
}
/*
* Process command line arguments expecting each to be a filename.
*/
printf ("[");
for (i = 1; i < argc; i++) {
if (i > 1)
printf (",");
filename = argv[i];
/*
* Initialize a new reader for this file descriptor.
*/
if (!(reader = bson_reader_new_from_file (filename, &error))) {
fprintf (
stderr, "Failed to open \"%s\": %s\n", filename, error.message);
continue;
}
state = initial_state;
dtime_before = dtimeofday ();
mark = 0;
while ((b = bson_reader_read (reader, NULL))) {
off_t pos = bson_reader_tell (reader);
state.doc_size_max = BSON_MAX (pos - mark, state.doc_size_max);
mark = pos;
bson_metrics (b, NULL, &state);
}
dtime_after = dtimeofday ();
dtime_delta = BSON_MAX (dtime_after - dtime_before, 0.000001);
state.bson_type_metrics[BSON_TYPE_MAXKEY].description = "Max key";
state.bson_type_metrics[BSON_TYPE_MINKEY].description = "Min key";
aggregate_count = state.bson_type_metrics[BSON_TYPE_DOCUMENT].count +
state.bson_type_metrics[BSON_TYPE_ARRAY].count;
qsort (state.bson_type_metrics,
256,
sizeof (bson_type_metrics_t),
compar_bson_type_metrics);
printf ("\n {\n");
printf (" \"file\": \"%s\",\n", filename);
printf (" \"secs\": %.2f,\n", dtime_delta);
printf (" \"docs_per_sec\": %" PRIu64 ",\n",
(uint64_t) round (state.doc_count / dtime_delta));
printf (" \"docs\": %" PRIu64 ",\n", state.doc_count);
printf (" \"elements\": %" PRIu64 ",\n", state.element_count);
printf (" \"elements_per_doc\": %" PRIu64 ",\n",
(uint64_t) round ((double) state.element_count /
(double) BSON_MAX (state.doc_count, 1)));
printf (" \"aggregates\": %" PRIu64 ",\n", aggregate_count);
printf (" \"aggregates_per_doc\": %" PRIu64 ",\n",
(uint64_t) round ((double) aggregate_count /
(double) BSON_MAX (state.doc_count, 1)));
printf (" \"degree\": %" PRIu64 ",\n",
(uint64_t) round (
(double) state.element_count /
((double) BSON_MAX (state.doc_count + aggregate_count, 1))));
printf (" \"doc_size_max\": %" PRIu64 ",\n", state.doc_size_max);
printf (" \"doc_size_average\": %" PRIu64 ",\n",
(uint64_t) round ((double) bson_reader_tell (reader) /
(double) BSON_MAX (state.doc_count, 1)));
printf (" \"key_size_average\": %" PRIu64 ",\n",
(uint64_t) round ((double) state.key_size_tally /
(double) BSON_MAX (state.element_count, 1)));
printf (" \"string_size_average\": %" PRIu64 ",\n",
(uint64_t) round (
(double) state.utf8_size_tally /
(double) BSON_MAX (
state.bson_type_metrics[BSON_TYPE_UTF8].count, 1)));
printf (" \"percent_by_type\": {\n");
for (j = 0; state.bson_type_metrics[j].count > 0; j++) {
bson_type_metrics_t bson_type_metrics = state.bson_type_metrics[j];
printf (" \"%s\": %" PRIu64 ",\n",
bson_type_metrics.description,
(uint64_t) round ((double) bson_type_metrics.count * 100.0 /
(double) BSON_MAX (state.element_count, 1)));
}
printf (" }\n");
printf (" }");
/*
* Cleanup after our reader, which closes the file descriptor.
*/
bson_reader_destroy (reader);
}
printf ("\n]\n");
return 0;
}
libbson-1.6.1/examples/bson-streaming-reader.c 0000664 0000000 0000000 00000011721 13057346540 0021332 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 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
#include
#include
#include
#include
#ifdef _WIN32
#include
#include
#else
#include
#include
#include
#include
#endif
#define DEFAULT_PORT "5000"
#define DEFAULT_HOST "localhost"
/*
* bson-streaming-remote-open --
*
* Makes a connection to the specified host and port over TCP. This
* abstracts away most of the socket details required to make a
* connection.
*
* Parameters:
* @hostname: The name of the host to connect to, or NULL.
* @port: The port number of the server on the host, or NULL.
*
* Returns:
* A valid file descriptor ready for reading on success.
* -1 on failure.
*/
int
bson_streaming_remote_open (const char *hostname, const char *port)
{
int error, sock;
struct addrinfo hints, *ptr, *server_list;
/*
* Look up the host's address information, hinting that we'd like to use a
* TCP/IP connection.
*/
memset (&hints, 0, sizeof hints);
hints.ai_family = PF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
error =
getaddrinfo ((!hostname || !strlen (hostname)) ? DEFAULT_HOST : hostname,
(!port || !strlen (port)) ? DEFAULT_PORT : port,
&hints,
&server_list);
if (error) {
fprintf (stderr,
"bson-streaming-remote-open: Failed to get server info: %s\n",
gai_strerror (error));
return -1;
}
/*
* Iterate through the results of getaddrinfo, attempting to connect to the
* first possible result.
*/
for (ptr = server_list; ptr != NULL; ptr = ptr->ai_next) {
sock = socket (ptr->ai_family, ptr->ai_socktype, ptr->ai_protocol);
if (sock < 0) {
perror ("bson-streaming-remote-open: socket creation failed");
continue;
}
if (connect (sock, ptr->ai_addr, ptr->ai_addrlen) < 0) {
close (sock);
perror ("bson-streaming-remote-open: connect failure");
continue;
}
/*
* Connection success.
*/
break;
}
if (ptr == NULL) {
fprintf (stderr,
"bson-streaming-remote-open: failed to connect to server\n");
return -1;
}
freeaddrinfo (server_list);
return sock;
}
/*
* main --
*
* Connects to a server and reads BSON from it. This program takes the
* following command line options:
*
* -h Print this help and exit.
* -s SERVER_NAME Specify the host name of the server.
* -p PORT_NUM Specify the port number to connect to on the server.
*/
int
main (int argc, char *argv[])
{
bson_reader_t *reader;
char *hostname = NULL;
char *json;
char *port = NULL;
const bson_t *document;
int fd;
int opt;
opterr = 1;
/*
* Parse command line arguments.
*/
while ((opt = getopt (argc, argv, "hs:p:")) != -1) {
switch (opt) {
case 'h':
fprintf (
stdout, "Usage: %s [-s SERVER_NAME] [-p PORT_NUM]\n", argv[0]);
free (hostname);
free (port);
return EXIT_SUCCESS;
case 'p':
free (port);
port = (char *) malloc (strlen (optarg) + 1);
strcpy (port, optarg);
break;
case 's':
free (hostname);
hostname = (char *) malloc (strlen (optarg) + 1);
strcpy (hostname, optarg);
break;
default:
fprintf (stderr, "Unknown option: %s\n", optarg);
}
}
/*
* Open a file descriptor on the remote and read in BSON documents, one by
* one. As an example of processing, this prints the incoming documents as
* JSON onto STDOUT.
*/
fd = bson_streaming_remote_open (hostname, port);
if (fd == -1) {
free (hostname);
free (port);
return EXIT_FAILURE;
}
reader = bson_reader_new_from_fd (fd, true);
while ((document = bson_reader_read (reader, NULL))) {
json = bson_as_json (document, NULL);
fprintf (stdout, "%s\n", json);
bson_free (json);
}
/*
* Destroy the reader, which performs cleanup. The ``true'' argument passed
* to bson_reader_new_from_fd tells libbson to close the file descriptor on
* destruction.
*/
bson_reader_destroy (reader);
free (hostname);
free (port);
return EXIT_SUCCESS;
}
libbson-1.6.1/examples/bson-to-json.c 0000664 0000000 0000000 00000003675 13057346540 0017503 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 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.
*/
/*
* This program will print each BSON document contained in the provided files
* as a JSON string to STDOUT.
*/
#include
#include
int
main (int argc, char *argv[])
{
bson_reader_t *reader;
const bson_t *b;
bson_error_t error;
const char *filename;
char *str;
int i;
/*
* Print program usage if no arguments are provided.
*/
if (argc == 1) {
fprintf (stderr, "usage: %s [FILE | -]...\nUse - for STDIN.\n", argv[0]);
return 1;
}
/*
* Process command line arguments expecting each to be a filename.
*/
for (i = 1; i < argc; i++) {
filename = argv[i];
if (strcmp (filename, "-") == 0) {
reader = bson_reader_new_from_fd (STDIN_FILENO, false);
} else {
if (!(reader = bson_reader_new_from_file (filename, &error))) {
fprintf (
stderr, "Failed to open \"%s\": %s\n", filename, error.message);
continue;
}
}
/*
* Convert each incoming document to JSON and print to stdout.
*/
while ((b = bson_reader_read (reader, NULL))) {
str = bson_as_json (b, NULL);
fprintf (stdout, "%s\n", str);
bson_free (str);
}
/*
* Cleanup after our reader, which closes the file descriptor.
*/
bson_reader_destroy (reader);
}
return 0;
}
libbson-1.6.1/examples/bson-validate.c 0000664 0000000 0000000 00000004757 13057346540 0017705 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 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.
*/
/*
* This program will validate each BSON document contained in the files provide
* as arguments to the program. Each document from each file is read in
* sequence until a bad BSON document is found or there are no more documents
* to read.
*
* Try running it with:
*
* ./bson-validate tests/binary/overflow2.bson
* ./bson-validate tests/binary/trailingnull.bson
*/
#include
#include
#include
int
main (int argc, char *argv[])
{
bson_reader_t *reader;
const bson_t *b;
bson_error_t error;
const char *filename;
size_t offset;
int docnum;
int i;
/*
* Print program usage if no arguments are provided.
*/
if (argc == 1) {
fprintf (stderr, "usage: %s FILE...\n", argv[0]);
return 1;
}
/*
* Process command line arguments expecting each to be a filename.
*/
for (i = 1; i < argc; i++) {
filename = argv[i];
docnum = 0;
/*
* Initialize a new reader for this file descriptor.
*/
if (!(reader = bson_reader_new_from_file (filename, &error))) {
fprintf (
stderr, "Failed to open \"%s\": %s\n", filename, error.message);
continue;
}
/*
* Convert each incoming document to JSON and print to stdout.
*/
while ((b = bson_reader_read (reader, NULL))) {
docnum++;
if (!bson_validate (
b,
(BSON_VALIDATE_UTF8 | BSON_VALIDATE_UTF8_ALLOW_NULL),
&offset)) {
fprintf (stderr,
"Document %u in \"%s\" is invalid at offset %u.\n",
docnum,
filename,
(int) offset);
bson_reader_destroy (reader);
return 1;
}
}
/*
* Cleanup after our reader, which closes the file descriptor.
*/
bson_reader_destroy (reader);
}
return 0;
}
libbson-1.6.1/examples/json-to-bson.c 0000664 0000000 0000000 00000004347 13057346540 0017500 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 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.
*/
/*
* This program will print each JSON document contained in the provided files
* as a BSON string to STDOUT.
*/
#include
#include
#include
int
main (int argc, char *argv[])
{
bson_json_reader_t *reader;
bson_error_t error;
const char *filename;
bson_t doc = BSON_INITIALIZER;
int i;
int b;
/*
* Print program usage if no arguments are provided.
*/
if (argc == 1) {
fprintf (stderr, "usage: %s FILE...\n", argv[0]);
return 1;
}
/*
* Process command line arguments expecting each to be a filename.
*/
for (i = 1; i < argc; i++) {
filename = argv[i];
/*
* Open the filename provided in command line arguments.
*/
if (0 == strcmp (filename, "-")) {
reader = bson_json_reader_new_from_fd (STDIN_FILENO, false);
} else {
if (!(reader = bson_json_reader_new_from_file (filename, &error))) {
fprintf (
stderr, "Failed to open \"%s\": %s\n", filename, error.message);
continue;
}
}
/*
* Convert each incoming document to BSON and print to stdout.
*/
while ((b = bson_json_reader_read (reader, &doc, &error))) {
if (b < 0) {
fprintf (stderr, "Error in json parsing:\n%s\n", error.message);
abort ();
}
if (fwrite (bson_get_data (&doc), 1, doc.len, stdout) != doc.len) {
fprintf (stderr, "Failed to write to stdout, exiting.\n");
exit (1);
}
bson_reinit (&doc);
}
bson_json_reader_destroy (reader);
bson_destroy (&doc);
}
return 0;
}
libbson-1.6.1/src/ 0000775 0000000 0000000 00000000000 13057346540 0013745 5 ustar 00root root 0000000 0000000 libbson-1.6.1/src/Makefile.am 0000664 0000000 0000000 00000000622 13057346540 0016001 0 ustar 00root root 0000000 0000000 lib_LTLIBRARIES += libbson-1.0.la
libbson_1_0_la_SOURCES =
libbson_1_0_la_LIBADD = \
libbson.la \
-lm
libbson_1_0_la_LDFLAGS = \
$(OPTIMIZE_LDFLAGS) \
$(COVERAGE_LDFLAGS) \
-no-undefined \
-rpath $(libdir)
include src/bson/Makefile.am
include src/jsonsl/Makefile.am
pkgconfigdir = $(libdir)/pkgconfig
pkgconfig_DATA = $(top_builddir)/src/libbson-1.0.pc
EXTRA_DIST += \
src/libbson-1.0.pc.in
libbson-1.6.1/src/bson/ 0000775 0000000 0000000 00000000000 13057346540 0014706 5 ustar 00root root 0000000 0000000 libbson-1.6.1/src/bson/.gitignore 0000664 0000000 0000000 00000000065 13057346540 0016677 0 ustar 00root root 0000000 0000000 bson-config.h
bson-stdint.h
bson-version.h
.dirstamp
libbson-1.6.1/src/bson/Makefile.am 0000664 0000000 0000000 00000004264 13057346540 0016750 0 ustar 00root root 0000000 0000000 noinst_LTLIBRARIES += libbson.la
headerdir = $(prefix)/include/libbson-@BSON_API_VERSION@
header_DATA = \
$(INST_H_FILES) \
src/bson/bson-config.h
INST_H_FILES = \
src/bson/bcon.h \
src/bson/bson.h \
src/bson/bson-atomic.h \
src/bson/bson-clock.h \
src/bson/bson-compat.h \
src/bson/bson-context.h \
src/bson/bson-decimal128.h \
src/bson/bson-endian.h \
src/bson/bson-error.h \
src/bson/bson-iter.h \
src/bson/bson-json.h \
src/bson/bson-keys.h \
src/bson/bson-macros.h \
src/bson/bson-md5.h \
src/bson/bson-memory.h \
src/bson/bson-oid.h \
src/bson/bson-reader.h \
src/bson/bson-string.h \
src/bson/bson-types.h \
src/bson/bson-utf8.h \
src/bson/bson-value.h \
src/bson/bson-version.h \
src/bson/bson-version-functions.h \
src/bson/bson-writer.h
if OS_WIN32
INST_H_FILES += src/bson/bson-stdint-win32.h
else
INST_H_FILES += src/bson/bson-stdint.h
endif
NOINST_H_FILES = \
src/bson/b64_ntop.h \
src/bson/b64_pton.h \
src/bson/bson-private.h \
src/bson/bson-iso8601-private.h \
src/bson/bson-context-private.h \
src/bson/bson-thread-private.h \
src/bson/bson-timegm-private.h
libbson_la_CPPFLAGS = \
-DBSON_COMPILATION \
-I$(top_srcdir)/src \
-I$(top_srcdir)/src/bson \
-I$(top_srcdir)/src/jsonsl \
-I$(top_builddir)/src/bson
libbson_la_CFLAGS = \
$(MAINTAINER_CFLAGS) \
$(OPTIMIZE_CFLAGS) \
$(COVERAGE_CFLAGS) \
$(PTHREAD_CFLAGS) \
-fvisibility=hidden
libbson_la_SOURCES = \
$(INST_H_FILES) \
$(NOINST_H_FILES) \
src/bson/bcon.c \
src/bson/bson.c \
src/bson/bson-atomic.c \
src/bson/bson-clock.c \
src/bson/bson-context.c \
src/bson/bson-decimal128.c \
src/bson/bson-error.c \
src/bson/bson-iter.c \
src/bson/bson-iso8601.c \
src/bson/bson-json.c \
src/bson/bson-keys.c \
src/bson/bson-md5.c \
src/bson/bson-memory.c \
src/bson/bson-oid.c \
src/bson/bson-reader.c \
src/bson/bson-string.c \
src/bson/bson-timegm.c \
src/bson/bson-utf8.c \
src/bson/bson-value.c \
src/bson/bson-version-functions.c \
src/bson/bson-writer.c
libbson_la_LIBADD =
if !OS_WIN32
libbson_la_LIBADD += $(PTHREAD_LIBS)
else
libbson_la_LIBADD += -lws2_32
endif
EXTRA_DIST += \
src/bson/bson-config.h.in \
src/bson/bson-version.h.in
DISTCLEANFILES += \
src/bson/bson-stdint.h
libbson-1.6.1/src/bson/b64_ntop.h 0000664 0000000 0000000 00000016507 13057346540 0016523 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 1996, 1998 by Internet Software Consortium.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
* ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
* CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
* ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
* SOFTWARE.
*/
/*
* Portions Copyright (c) 1995 by International Business Machines, Inc.
*
* International Business Machines, Inc. (hereinafter called IBM) grants
* permission under its copyrights to use, copy, modify, and distribute this
* Software with or without fee, provided that the above copyright notice and
* all paragraphs of this notice appear in all copies, and that the name of IBM
* not be used in connection with the marketing of any product incorporating
* the Software or modifications thereof, without specific, written prior
* permission.
*
* To the extent it has a right to do so, IBM grants an immunity from suit
* under its patents, if any, for the use, sale or manufacture of products to
* the extent that such products are used for performing Domain Name System
* dynamic updates in TCP/IP networks by means of the Software. No immunity is
* granted for any product per se or for any other function of any product.
*
* THE SOFTWARE IS PROVIDED "AS IS", AND IBM DISCLAIMS ALL WARRANTIES,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE. IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL,
* DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER ARISING
* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE, EVEN
* IF IBM IS APPRISED OF THE POSSIBILITY OF SUCH DAMAGES.
*/
#include "bson-compat.h"
#include "bson-macros.h"
#include "bson-types.h"
#define Assert(Cond) \
if (!(Cond)) \
abort ()
static const char Base64[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
static const char Pad64 = '=';
/* (From RFC1521 and draft-ietf-dnssec-secext-03.txt)
* The following encoding technique is taken from RFC 1521 by Borenstein
* and Freed. It is reproduced here in a slightly edited form for
* convenience.
*
* A 65-character subset of US-ASCII is used, enabling 6 bits to be
* represented per printable character. (The extra 65th character, "=",
* is used to signify a special processing function.)
*
* The encoding process represents 24-bit groups of input bits as output
* strings of 4 encoded characters. Proceeding from left to right, a
* 24-bit input group is formed by concatenating 3 8-bit input groups.
* These 24 bits are then treated as 4 concatenated 6-bit groups, each
* of which is translated into a single digit in the base64 alphabet.
*
* Each 6-bit group is used as an index into an array of 64 printable
* characters. The character referenced by the index is placed in the
* output string.
*
* Table 1: The Base64 Alphabet
*
* Value Encoding Value Encoding Value Encoding Value Encoding
* 0 A 17 R 34 i 51 z
* 1 B 18 S 35 j 52 0
* 2 C 19 T 36 k 53 1
* 3 D 20 U 37 l 54 2
* 4 E 21 V 38 m 55 3
* 5 F 22 W 39 n 56 4
* 6 G 23 X 40 o 57 5
* 7 H 24 Y 41 p 58 6
* 8 I 25 Z 42 q 59 7
* 9 J 26 a 43 r 60 8
* 10 K 27 b 44 s 61 9
* 11 L 28 c 45 t 62 +
* 12 M 29 d 46 u 63 /
* 13 N 30 e 47 v
* 14 O 31 f 48 w (pad) =
* 15 P 32 g 49 x
* 16 Q 33 h 50 y
*
* Special processing is performed if fewer than 24 bits are available
* at the end of the data being encoded. A full encoding quantum is
* always completed at the end of a quantity. When fewer than 24 input
* bits are available in an input group, zero bits are added (on the
* right) to form an integral number of 6-bit groups. Padding at the
* end of the data is performed using the '=' character.
*
* Since all base64 input is an integral number of octets, only the
* following cases can arise:
*
* (1) the final quantum of encoding input is an integral
* multiple of 24 bits; here, the final unit of encoded
* output will be an integral multiple of 4 characters
* with no "=" padding,
* (2) the final quantum of encoding input is exactly 8 bits;
* here, the final unit of encoded output will be two
* characters followed by two "=" padding characters, or
* (3) the final quantum of encoding input is exactly 16 bits;
* here, the final unit of encoded output will be three
* characters followed by one "=" padding character.
*/
static ssize_t
b64_ntop (uint8_t const *src, size_t srclength, char *target, size_t targsize)
{
size_t datalength = 0;
uint8_t input[3];
uint8_t output[4];
size_t i;
while (2 < srclength) {
input[0] = *src++;
input[1] = *src++;
input[2] = *src++;
srclength -= 3;
output[0] = input[0] >> 2;
output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
output[3] = input[2] & 0x3f;
Assert (output[0] < 64);
Assert (output[1] < 64);
Assert (output[2] < 64);
Assert (output[3] < 64);
if (datalength + 4 > targsize) {
return -1;
}
target[datalength++] = Base64[output[0]];
target[datalength++] = Base64[output[1]];
target[datalength++] = Base64[output[2]];
target[datalength++] = Base64[output[3]];
}
/* Now we worry about padding. */
if (0 != srclength) {
/* Get what's left. */
input[0] = input[1] = input[2] = '\0';
for (i = 0; i < srclength; i++) {
input[i] = *src++;
}
output[0] = input[0] >> 2;
output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
Assert (output[0] < 64);
Assert (output[1] < 64);
Assert (output[2] < 64);
if (datalength + 4 > targsize) {
return -1;
}
target[datalength++] = Base64[output[0]];
target[datalength++] = Base64[output[1]];
if (srclength == 1) {
target[datalength++] = Pad64;
} else {
target[datalength++] = Base64[output[2]];
}
target[datalength++] = Pad64;
}
if (datalength >= targsize) {
return -1;
}
target[datalength] = '\0'; /* Returned value doesn't count \0. */
return datalength;
}
libbson-1.6.1/src/bson/b64_pton.h 0000664 0000000 0000000 00000030066 13057346540 0016517 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 1996, 1998 by Internet Software Consortium.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
* ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
* CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
* ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
* SOFTWARE.
*/
/*
* Portions Copyright (c) 1995 by International Business Machines, Inc.
*
* International Business Machines, Inc. (hereinafter called IBM) grants
* permission under its copyrights to use, copy, modify, and distribute this
* Software with or without fee, provided that the above copyright notice and
* all paragraphs of this notice appear in all copies, and that the name of IBM
* not be used in connection with the marketing of any product incorporating
* the Software or modifications thereof, without specific, written prior
* permission.
*
* To the extent it has a right to do so, IBM grants an immunity from suit
* under its patents, if any, for the use, sale or manufacture of products to
* the extent that such products are used for performing Domain Name System
* dynamic updates in TCP/IP networks by means of the Software. No immunity is
* granted for any product per se or for any other function of any product.
*
* THE SOFTWARE IS PROVIDED "AS IS", AND IBM DISCLAIMS ALL WARRANTIES,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE. IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL,
* DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER ARISING
* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE, EVEN
* IF IBM IS APPRISED OF THE POSSIBILITY OF SUCH DAMAGES.
*/
#include "bson-compat.h"
#define Assert(Cond) \
if (!(Cond)) \
abort ()
static const char Base64[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
static const char Pad64 = '=';
/* (From RFC1521 and draft-ietf-dnssec-secext-03.txt)
The following encoding technique is taken from RFC 1521 by Borenstein
and Freed. It is reproduced here in a slightly edited form for
convenience.
A 65-character subset of US-ASCII is used, enabling 6 bits to be
represented per printable character. (The extra 65th character, "=",
is used to signify a special processing function.)
The encoding process represents 24-bit groups of input bits as output
strings of 4 encoded characters. Proceeding from left to right, a
24-bit input group is formed by concatenating 3 8-bit input groups.
These 24 bits are then treated as 4 concatenated 6-bit groups, each
of which is translated into a single digit in the base64 alphabet.
Each 6-bit group is used as an index into an array of 64 printable
characters. The character referenced by the index is placed in the
output string.
Table 1: The Base64 Alphabet
Value Encoding Value Encoding Value Encoding Value Encoding
0 A 17 R 34 i 51 z
1 B 18 S 35 j 52 0
2 C 19 T 36 k 53 1
3 D 20 U 37 l 54 2
4 E 21 V 38 m 55 3
5 F 22 W 39 n 56 4
6 G 23 X 40 o 57 5
7 H 24 Y 41 p 58 6
8 I 25 Z 42 q 59 7
9 J 26 a 43 r 60 8
10 K 27 b 44 s 61 9
11 L 28 c 45 t 62 +
12 M 29 d 46 u 63 /
13 N 30 e 47 v
14 O 31 f 48 w (pad) =
15 P 32 g 49 x
16 Q 33 h 50 y
Special processing is performed if fewer than 24 bits are available
at the end of the data being encoded. A full encoding quantum is
always completed at the end of a quantity. When fewer than 24 input
bits are available in an input group, zero bits are added (on the
right) to form an integral number of 6-bit groups. Padding at the
end of the data is performed using the '=' character.
Since all base64 input is an integral number of octets, only the
following cases can arise:
(1) the final quantum of encoding input is an integral
multiple of 24 bits; here, the final unit of encoded
output will be an integral multiple of 4 characters
with no "=" padding,
(2) the final quantum of encoding input is exactly 8 bits;
here, the final unit of encoded output will be two
characters followed by two "=" padding characters, or
(3) the final quantum of encoding input is exactly 16 bits;
here, the final unit of encoded output will be three
characters followed by one "=" padding character.
*/
/* skips all whitespace anywhere.
converts characters, four at a time, starting at (or after)
src from base - 64 numbers into three 8 bit bytes in the target area.
it returns the number of data bytes stored at the target, or -1 on error.
*/
static int b64rmap_initialized = 0;
static uint8_t b64rmap[256];
static const uint8_t b64rmap_special = 0xf0;
static const uint8_t b64rmap_end = 0xfd;
static const uint8_t b64rmap_space = 0xfe;
static const uint8_t b64rmap_invalid = 0xff;
/**
* Initializing the reverse map is not thread safe.
* Which is fine for NSD. For now...
**/
static void
b64_initialize_rmap ()
{
int i;
unsigned char ch;
/* Null: end of string, stop parsing */
b64rmap[0] = b64rmap_end;
for (i = 1; i < 256; ++i) {
ch = (unsigned char) i;
/* Whitespaces */
if (isspace (ch))
b64rmap[i] = b64rmap_space;
/* Padding: stop parsing */
else if (ch == Pad64)
b64rmap[i] = b64rmap_end;
/* Non-base64 char */
else
b64rmap[i] = b64rmap_invalid;
}
/* Fill reverse mapping for base64 chars */
for (i = 0; Base64[i] != '\0'; ++i)
b64rmap[(uint8_t) Base64[i]] = i;
b64rmap_initialized = 1;
}
static int
b64_pton_do (char const *src, uint8_t *target, size_t targsize)
{
int tarindex, state, ch;
uint8_t ofs;
state = 0;
tarindex = 0;
while (1) {
ch = *src++;
ofs = b64rmap[ch];
if (ofs >= b64rmap_special) {
/* Ignore whitespaces */
if (ofs == b64rmap_space)
continue;
/* End of base64 characters */
if (ofs == b64rmap_end)
break;
/* A non-base64 character. */
return (-1);
}
switch (state) {
case 0:
if ((size_t) tarindex >= targsize)
return (-1);
target[tarindex] = ofs << 2;
state = 1;
break;
case 1:
if ((size_t) tarindex + 1 >= targsize)
return (-1);
target[tarindex] |= ofs >> 4;
target[tarindex + 1] = (ofs & 0x0f) << 4;
tarindex++;
state = 2;
break;
case 2:
if ((size_t) tarindex + 1 >= targsize)
return (-1);
target[tarindex] |= ofs >> 2;
target[tarindex + 1] = (ofs & 0x03) << 6;
tarindex++;
state = 3;
break;
case 3:
if ((size_t) tarindex >= targsize)
return (-1);
target[tarindex] |= ofs;
tarindex++;
state = 0;
break;
default:
abort ();
}
}
/*
* We are done decoding Base-64 chars. Let's see if we ended
* on a byte boundary, and/or with erroneous trailing characters.
*/
if (ch == Pad64) { /* We got a pad char. */
ch = *src++; /* Skip it, get next. */
switch (state) {
case 0: /* Invalid = in first position */
case 1: /* Invalid = in second position */
return (-1);
case 2: /* Valid, means one byte of info */
/* Skip any number of spaces. */
for ((void) NULL; ch != '\0'; ch = *src++)
if (b64rmap[ch] != b64rmap_space)
break;
/* Make sure there is another trailing = sign. */
if (ch != Pad64)
return (-1);
ch = *src++; /* Skip the = */
/* Fall through to "single trailing =" case. */
/* FALLTHROUGH */
case 3: /* Valid, means two bytes of info */
/*
* We know this char is an =. Is there anything but
* whitespace after it?
*/
for ((void) NULL; ch != '\0'; ch = *src++)
if (b64rmap[ch] != b64rmap_space)
return (-1);
/*
* Now make sure for cases 2 and 3 that the "extra"
* bits that slopped past the last full byte were
* zeros. If we don't check them, they become a
* subliminal channel.
*/
if (target[tarindex] != 0)
return (-1);
default:
break;
}
} else {
/*
* We ended by seeing the end of the string. Make sure we
* have no partial bytes lying around.
*/
if (state != 0)
return (-1);
}
return (tarindex);
}
static int
b64_pton_len (char const *src)
{
int tarindex, state, ch;
uint8_t ofs;
state = 0;
tarindex = 0;
while (1) {
ch = *src++;
ofs = b64rmap[ch];
if (ofs >= b64rmap_special) {
/* Ignore whitespaces */
if (ofs == b64rmap_space)
continue;
/* End of base64 characters */
if (ofs == b64rmap_end)
break;
/* A non-base64 character. */
return (-1);
}
switch (state) {
case 0:
state = 1;
break;
case 1:
tarindex++;
state = 2;
break;
case 2:
tarindex++;
state = 3;
break;
case 3:
tarindex++;
state = 0;
break;
default:
abort ();
}
}
/*
* We are done decoding Base-64 chars. Let's see if we ended
* on a byte boundary, and/or with erroneous trailing characters.
*/
if (ch == Pad64) { /* We got a pad char. */
ch = *src++; /* Skip it, get next. */
switch (state) {
case 0: /* Invalid = in first position */
case 1: /* Invalid = in second position */
return (-1);
case 2: /* Valid, means one byte of info */
/* Skip any number of spaces. */
for ((void) NULL; ch != '\0'; ch = *src++)
if (b64rmap[ch] != b64rmap_space)
break;
/* Make sure there is another trailing = sign. */
if (ch != Pad64)
return (-1);
ch = *src++; /* Skip the = */
/* Fall through to "single trailing =" case. */
/* FALLTHROUGH */
case 3: /* Valid, means two bytes of info */
/*
* We know this char is an =. Is there anything but
* whitespace after it?
*/
for ((void) NULL; ch != '\0'; ch = *src++)
if (b64rmap[ch] != b64rmap_space)
return (-1);
default:
break;
}
} else {
/*
* We ended by seeing the end of the string. Make sure we
* have no partial bytes lying around.
*/
if (state != 0)
return (-1);
}
return (tarindex);
}
static int
b64_pton (char const *src, uint8_t *target, size_t targsize)
{
if (!b64rmap_initialized)
b64_initialize_rmap ();
if (target)
return b64_pton_do (src, target, targsize);
else
return b64_pton_len (src);
}
libbson-1.6.1/src/bson/bcon.c 0000664 0000000 0000000 00000064375 13057346540 0016012 0 ustar 00root root 0000000 0000000 /*
* @file bcon.c
* @brief BCON (BSON C Object Notation) Implementation
*/
/* Copyright 2009-2013 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
#include "bcon.h"
#include "bson-config.h"
/* These stack manipulation macros are used to manage append recursion in
* bcon_append_ctx_va(). They take care of some awkward dereference rules (the
* real bson object isn't in the stack, but accessed by pointer) and add in run
* time asserts to make sure we don't blow the stack in either direction */
#define STACK_ELE(_delta, _name) (ctx->stack[(_delta) + ctx->n]._name)
#define STACK_BSON(_delta) \
(((_delta) + ctx->n) == 0 ? bson : &STACK_ELE (_delta, bson))
#define STACK_ITER(_delta) \
(((_delta) + ctx->n) == 0 ? &root_iter : &STACK_ELE (_delta, iter))
#define STACK_BSON_PARENT STACK_BSON (-1)
#define STACK_BSON_CHILD STACK_BSON (0)
#define STACK_ITER_PARENT STACK_ITER (-1)
#define STACK_ITER_CHILD STACK_ITER (0)
#define STACK_I STACK_ELE (0, i)
#define STACK_IS_ARRAY STACK_ELE (0, is_array)
#define STACK_PUSH_ARRAY(statement) \
do { \
assert (ctx->n < (BCON_STACK_MAX - 1)); \
ctx->n++; \
STACK_I = 0; \
STACK_IS_ARRAY = 1; \
statement; \
} while (0)
#define STACK_PUSH_DOC(statement) \
do { \
assert (ctx->n < (BCON_STACK_MAX - 1)); \
ctx->n++; \
STACK_IS_ARRAY = 0; \
statement; \
} while (0)
#define STACK_POP_ARRAY(statement) \
do { \
assert (STACK_IS_ARRAY); \
assert (ctx->n != 0); \
statement; \
ctx->n--; \
} while (0)
#define STACK_POP_DOC(statement) \
do { \
assert (!STACK_IS_ARRAY); \
assert (ctx->n != 0); \
statement; \
ctx->n--; \
} while (0)
/* This is a landing pad union for all of the types we can process with bcon.
* We need actual storage for this to capture the return value of va_arg, which
* takes multiple calls to get everything we need for some complex types */
typedef union bcon_append {
char *UTF8;
double DOUBLE;
bson_t *DOCUMENT;
bson_t *ARRAY;
bson_t *BCON;
struct {
bson_subtype_t subtype;
uint8_t *binary;
uint32_t length;
} BIN;
bson_oid_t *OID;
bool BOOL;
int64_t DATE_TIME;
struct {
char *regex;
char *flags;
} REGEX;
struct {
char *collection;
bson_oid_t *oid;
} DBPOINTER;
const char *CODE;
char *SYMBOL;
struct {
const char *js;
bson_t *scope;
} CODEWSCOPE;
int32_t INT32;
struct {
uint32_t timestamp;
uint32_t increment;
} TIMESTAMP;
int64_t INT64;
bson_decimal128_t *DECIMAL128;
const bson_iter_t *ITER;
} bcon_append_t;
/* same as bcon_append_t. Some extra symbols and varying types that handle the
* differences between bson_append and bson_iter */
typedef union bcon_extract {
bson_type_t TYPE;
bson_iter_t *ITER;
const char *key;
const char **UTF8;
double *DOUBLE;
bson_t *DOCUMENT;
bson_t *ARRAY;
struct {
bson_subtype_t *subtype;
const uint8_t **binary;
uint32_t *length;
} BIN;
const bson_oid_t **OID;
bool *BOOL;
int64_t *DATE_TIME;
struct {
const char **regex;
const char **flags;
} REGEX;
struct {
const char **collection;
const bson_oid_t **oid;
} DBPOINTER;
const char **CODE;
const char **SYMBOL;
struct {
const char **js;
bson_t *scope;
} CODEWSCOPE;
int32_t *INT32;
struct {
uint32_t *timestamp;
uint32_t *increment;
} TIMESTAMP;
int64_t *INT64;
bson_decimal128_t *DECIMAL128;
} bcon_extract_t;
static const char *gBconMagic = "BCON_MAGIC";
static const char *gBconeMagic = "BCONE_MAGIC";
const char *
bson_bcon_magic (void)
{
return gBconMagic;
}
const char *
bson_bcone_magic (void)
{
return gBconeMagic;
}
static void
_noop (void)
{
}
/* appends val to the passed bson object. Meant to be a super simple dispatch
* table */
static void
_bcon_append_single (bson_t *bson,
bcon_type_t type,
const char *key,
bcon_append_t *val)
{
switch ((int) type) {
case BCON_TYPE_UTF8:
bson_append_utf8 (bson, key, -1, val->UTF8, -1);
break;
case BCON_TYPE_DOUBLE:
bson_append_double (bson, key, -1, val->DOUBLE);
break;
case BCON_TYPE_BIN: {
bson_append_binary (
bson, key, -1, val->BIN.subtype, val->BIN.binary, val->BIN.length);
break;
}
case BCON_TYPE_UNDEFINED:
bson_append_undefined (bson, key, -1);
break;
case BCON_TYPE_OID:
bson_append_oid (bson, key, -1, val->OID);
break;
case BCON_TYPE_BOOL:
bson_append_bool (bson, key, -1, (bool) val->BOOL);
break;
case BCON_TYPE_DATE_TIME:
bson_append_date_time (bson, key, -1, val->DATE_TIME);
break;
case BCON_TYPE_NULL:
bson_append_null (bson, key, -1);
break;
case BCON_TYPE_REGEX: {
bson_append_regex (bson, key, -1, val->REGEX.regex, val->REGEX.flags);
break;
}
case BCON_TYPE_DBPOINTER: {
bson_append_dbpointer (
bson, key, -1, val->DBPOINTER.collection, val->DBPOINTER.oid);
break;
}
case BCON_TYPE_CODE:
bson_append_code (bson, key, -1, val->CODE);
break;
case BCON_TYPE_SYMBOL:
bson_append_symbol (bson, key, -1, val->SYMBOL, -1);
break;
case BCON_TYPE_CODEWSCOPE:
bson_append_code_with_scope (
bson, key, -1, val->CODEWSCOPE.js, val->CODEWSCOPE.scope);
break;
case BCON_TYPE_INT32:
bson_append_int32 (bson, key, -1, val->INT32);
break;
case BCON_TYPE_TIMESTAMP: {
bson_append_timestamp (
bson, key, -1, val->TIMESTAMP.timestamp, val->TIMESTAMP.increment);
break;
}
case BCON_TYPE_INT64:
bson_append_int64 (bson, key, -1, val->INT64);
break;
case BCON_TYPE_DECIMAL128:
bson_append_decimal128 (bson, key, -1, val->DECIMAL128);
break;
case BCON_TYPE_MAXKEY:
bson_append_maxkey (bson, key, -1);
break;
case BCON_TYPE_MINKEY:
bson_append_minkey (bson, key, -1);
break;
case BCON_TYPE_ARRAY: {
bson_append_array (bson, key, -1, val->ARRAY);
break;
}
case BCON_TYPE_DOCUMENT: {
bson_append_document (bson, key, -1, val->DOCUMENT);
break;
}
case BCON_TYPE_ITER:
bson_append_iter (bson, key, -1, val->ITER);
break;
default:
assert (0);
break;
}
}
#define CHECK_TYPE(_type) \
do { \
if (bson_iter_type (iter) != (_type)) { \
return false; \
} \
} while (0)
/* extracts the value under the iterator and writes it to val. returns false
* if the iterator type doesn't match the token type.
*
* There are two magic tokens:
*
* BCONE_SKIP -
* Let's us verify that a key has a type, without caring about its value.
* This allows for wider declarative BSON verification
*
* BCONE_ITER -
* Returns the underlying iterator. This could allow for more complicated,
* procedural verification (if a parameter could have multiple types).
* */
static bool
_bcon_extract_single (const bson_iter_t *iter,
bcon_type_t type,
bcon_extract_t *val)
{
switch ((int) type) {
case BCON_TYPE_UTF8:
CHECK_TYPE (BSON_TYPE_UTF8);
*val->UTF8 = bson_iter_utf8 (iter, NULL);
break;
case BCON_TYPE_DOUBLE:
CHECK_TYPE (BSON_TYPE_DOUBLE);
*val->DOUBLE = bson_iter_double (iter);
break;
case BCON_TYPE_BIN:
CHECK_TYPE (BSON_TYPE_BINARY);
bson_iter_binary (
iter, val->BIN.subtype, val->BIN.length, val->BIN.binary);
break;
case BCON_TYPE_UNDEFINED:
CHECK_TYPE (BSON_TYPE_UNDEFINED);
break;
case BCON_TYPE_OID:
CHECK_TYPE (BSON_TYPE_OID);
*val->OID = bson_iter_oid (iter);
break;
case BCON_TYPE_BOOL:
CHECK_TYPE (BSON_TYPE_BOOL);
*val->BOOL = bson_iter_bool (iter);
break;
case BCON_TYPE_DATE_TIME:
CHECK_TYPE (BSON_TYPE_DATE_TIME);
*val->DATE_TIME = bson_iter_date_time (iter);
break;
case BCON_TYPE_NULL:
CHECK_TYPE (BSON_TYPE_NULL);
break;
case BCON_TYPE_REGEX:
CHECK_TYPE (BSON_TYPE_REGEX);
*val->REGEX.regex = bson_iter_regex (iter, val->REGEX.flags);
break;
case BCON_TYPE_DBPOINTER:
CHECK_TYPE (BSON_TYPE_DBPOINTER);
bson_iter_dbpointer (
iter, NULL, val->DBPOINTER.collection, val->DBPOINTER.oid);
break;
case BCON_TYPE_CODE:
CHECK_TYPE (BSON_TYPE_CODE);
*val->CODE = bson_iter_code (iter, NULL);
break;
case BCON_TYPE_SYMBOL:
CHECK_TYPE (BSON_TYPE_SYMBOL);
*val->SYMBOL = bson_iter_symbol (iter, NULL);
break;
case BCON_TYPE_CODEWSCOPE: {
const uint8_t *buf;
uint32_t len;
CHECK_TYPE (BSON_TYPE_CODEWSCOPE);
*val->CODEWSCOPE.js = bson_iter_codewscope (iter, NULL, &len, &buf);
bson_init_static (val->CODEWSCOPE.scope, buf, len);
break;
}
case BCON_TYPE_INT32:
CHECK_TYPE (BSON_TYPE_INT32);
*val->INT32 = bson_iter_int32 (iter);
break;
case BCON_TYPE_TIMESTAMP:
CHECK_TYPE (BSON_TYPE_TIMESTAMP);
bson_iter_timestamp (
iter, val->TIMESTAMP.timestamp, val->TIMESTAMP.increment);
break;
case BCON_TYPE_INT64:
CHECK_TYPE (BSON_TYPE_INT64);
*val->INT64 = bson_iter_int64 (iter);
break;
case BCON_TYPE_DECIMAL128:
CHECK_TYPE (BSON_TYPE_DECIMAL128);
bson_iter_decimal128 (iter, val->DECIMAL128);
break;
case BCON_TYPE_MAXKEY:
CHECK_TYPE (BSON_TYPE_MAXKEY);
break;
case BCON_TYPE_MINKEY:
CHECK_TYPE (BSON_TYPE_MINKEY);
break;
case BCON_TYPE_ARRAY: {
const uint8_t *buf;
uint32_t len;
CHECK_TYPE (BSON_TYPE_ARRAY);
bson_iter_array (iter, &len, &buf);
bson_init_static (val->ARRAY, buf, len);
break;
}
case BCON_TYPE_DOCUMENT: {
const uint8_t *buf;
uint32_t len;
CHECK_TYPE (BSON_TYPE_DOCUMENT);
bson_iter_document (iter, &len, &buf);
bson_init_static (val->DOCUMENT, buf, len);
break;
}
case BCON_TYPE_SKIP:
CHECK_TYPE (val->TYPE);
break;
case BCON_TYPE_ITER:
memcpy (val->ITER, iter, sizeof *iter);
break;
default:
assert (0);
break;
}
return true;
}
/* Consumes ap, storing output values into u and returning the type of the
* captured token.
*
* The basic workflow goes like this:
*
* 1. Look at the current arg. It will be a char *
* a. If it's a NULL, we're done processing.
* b. If it's BCON_MAGIC (a symbol with storage in this module)
* I. The next token is the type
* II. The type specifies how many args to eat and their types
* c. Otherwise it's either recursion related or a raw string
* I. If the first byte is '{', '}', '[', or ']' pass back an
* appropriate recursion token
* II. If not, just call it a UTF8 token and pass that back
*/
static bcon_type_t
_bcon_append_tokenize (va_list *ap, bcon_append_t *u)
{
char *mark;
bcon_type_t type;
mark = va_arg (*ap, char *);
assert (mark != BCONE_MAGIC);
if (mark == NULL) {
type = BCON_TYPE_END;
} else if (mark == BCON_MAGIC) {
type = va_arg (*ap, bcon_type_t);
switch ((int) type) {
case BCON_TYPE_UTF8:
u->UTF8 = va_arg (*ap, char *);
break;
case BCON_TYPE_DOUBLE:
u->DOUBLE = va_arg (*ap, double);
break;
case BCON_TYPE_DOCUMENT:
u->DOCUMENT = va_arg (*ap, bson_t *);
break;
case BCON_TYPE_ARRAY:
u->ARRAY = va_arg (*ap, bson_t *);
break;
case BCON_TYPE_BIN:
u->BIN.subtype = va_arg (*ap, bson_subtype_t);
u->BIN.binary = va_arg (*ap, uint8_t *);
u->BIN.length = va_arg (*ap, uint32_t);
break;
case BCON_TYPE_UNDEFINED:
break;
case BCON_TYPE_OID:
u->OID = va_arg (*ap, bson_oid_t *);
break;
case BCON_TYPE_BOOL:
u->BOOL = va_arg (*ap, int);
break;
case BCON_TYPE_DATE_TIME:
u->DATE_TIME = va_arg (*ap, int64_t);
break;
case BCON_TYPE_NULL:
break;
case BCON_TYPE_REGEX:
u->REGEX.regex = va_arg (*ap, char *);
u->REGEX.flags = va_arg (*ap, char *);
break;
case BCON_TYPE_DBPOINTER:
u->DBPOINTER.collection = va_arg (*ap, char *);
u->DBPOINTER.oid = va_arg (*ap, bson_oid_t *);
break;
case BCON_TYPE_CODE:
u->CODE = va_arg (*ap, char *);
break;
case BCON_TYPE_SYMBOL:
u->SYMBOL = va_arg (*ap, char *);
break;
case BCON_TYPE_CODEWSCOPE:
u->CODEWSCOPE.js = va_arg (*ap, char *);
u->CODEWSCOPE.scope = va_arg (*ap, bson_t *);
break;
case BCON_TYPE_INT32:
u->INT32 = va_arg (*ap, int32_t);
break;
case BCON_TYPE_TIMESTAMP:
u->TIMESTAMP.timestamp = va_arg (*ap, uint32_t);
u->TIMESTAMP.increment = va_arg (*ap, uint32_t);
break;
case BCON_TYPE_INT64:
u->INT64 = va_arg (*ap, int64_t);
break;
case BCON_TYPE_DECIMAL128:
u->DECIMAL128 = va_arg (*ap, bson_decimal128_t *);
break;
case BCON_TYPE_MAXKEY:
break;
case BCON_TYPE_MINKEY:
break;
case BCON_TYPE_BCON:
u->BCON = va_arg (*ap, bson_t *);
break;
case BCON_TYPE_ITER:
u->ITER = va_arg (*ap, const bson_iter_t *);
break;
default:
assert (0);
break;
}
} else {
switch (mark[0]) {
case '{':
type = BCON_TYPE_DOC_START;
break;
case '}':
type = BCON_TYPE_DOC_END;
break;
case '[':
type = BCON_TYPE_ARRAY_START;
break;
case ']':
type = BCON_TYPE_ARRAY_END;
break;
default:
type = BCON_TYPE_UTF8;
u->UTF8 = mark;
break;
}
}
return type;
}
/* Consumes ap, storing output values into u and returning the type of the
* captured token.
*
* The basic workflow goes like this:
*
* 1. Look at the current arg. It will be a char *
* a. If it's a NULL, we're done processing.
* b. If it's BCONE_MAGIC (a symbol with storage in this module)
* I. The next token is the type
* II. The type specifies how many args to eat and their types
* c. Otherwise it's either recursion related or a raw string
* I. If the first byte is '{', '}', '[', or ']' pass back an
* appropriate recursion token
* II. If not, just call it a UTF8 token and pass that back
*/
static bcon_type_t
_bcon_extract_tokenize (va_list *ap, bcon_extract_t *u)
{
char *mark;
bcon_type_t type;
mark = va_arg (*ap, char *);
assert (mark != BCON_MAGIC);
if (mark == NULL) {
type = BCON_TYPE_END;
} else if (mark == BCONE_MAGIC) {
type = va_arg (*ap, bcon_type_t);
switch ((int) type) {
case BCON_TYPE_UTF8:
u->UTF8 = va_arg (*ap, const char **);
break;
case BCON_TYPE_DOUBLE:
u->DOUBLE = va_arg (*ap, double *);
break;
case BCON_TYPE_DOCUMENT:
u->DOCUMENT = va_arg (*ap, bson_t *);
break;
case BCON_TYPE_ARRAY:
u->ARRAY = va_arg (*ap, bson_t *);
break;
case BCON_TYPE_BIN:
u->BIN.subtype = va_arg (*ap, bson_subtype_t *);
u->BIN.binary = va_arg (*ap, const uint8_t **);
u->BIN.length = va_arg (*ap, uint32_t *);
break;
case BCON_TYPE_UNDEFINED:
break;
case BCON_TYPE_OID:
u->OID = va_arg (*ap, const bson_oid_t **);
break;
case BCON_TYPE_BOOL:
u->BOOL = va_arg (*ap, bool *);
break;
case BCON_TYPE_DATE_TIME:
u->DATE_TIME = va_arg (*ap, int64_t *);
break;
case BCON_TYPE_NULL:
break;
case BCON_TYPE_REGEX:
u->REGEX.regex = va_arg (*ap, const char **);
u->REGEX.flags = va_arg (*ap, const char **);
break;
case BCON_TYPE_DBPOINTER:
u->DBPOINTER.collection = va_arg (*ap, const char **);
u->DBPOINTER.oid = va_arg (*ap, const bson_oid_t **);
break;
case BCON_TYPE_CODE:
u->CODE = va_arg (*ap, const char **);
break;
case BCON_TYPE_SYMBOL:
u->SYMBOL = va_arg (*ap, const char **);
break;
case BCON_TYPE_CODEWSCOPE:
u->CODEWSCOPE.js = va_arg (*ap, const char **);
u->CODEWSCOPE.scope = va_arg (*ap, bson_t *);
break;
case BCON_TYPE_INT32:
u->INT32 = va_arg (*ap, int32_t *);
break;
case BCON_TYPE_TIMESTAMP:
u->TIMESTAMP.timestamp = va_arg (*ap, uint32_t *);
u->TIMESTAMP.increment = va_arg (*ap, uint32_t *);
break;
case BCON_TYPE_INT64:
u->INT64 = va_arg (*ap, int64_t *);
break;
case BCON_TYPE_DECIMAL128:
u->DECIMAL128 = va_arg (*ap, bson_decimal128_t *);
break;
case BCON_TYPE_MAXKEY:
break;
case BCON_TYPE_MINKEY:
break;
case BCON_TYPE_SKIP:
u->TYPE = va_arg (*ap, bson_type_t);
break;
case BCON_TYPE_ITER:
u->ITER = va_arg (*ap, bson_iter_t *);
break;
default:
assert (0);
break;
}
} else {
switch (mark[0]) {
case '{':
type = BCON_TYPE_DOC_START;
break;
case '}':
type = BCON_TYPE_DOC_END;
break;
case '[':
type = BCON_TYPE_ARRAY_START;
break;
case ']':
type = BCON_TYPE_ARRAY_END;
break;
default:
type = BCON_TYPE_RAW;
u->key = mark;
break;
}
}
return type;
}
/* This trivial utility function is useful for concatenating a bson object onto
* the end of another, ignoring the keys from the source bson object and
* continuing to use and increment the keys from the source. It's only useful
* when called from bcon_append_ctx_va */
static void
_bson_concat_array (bson_t *dest, const bson_t *src, bcon_append_ctx_t *ctx)
{
bson_iter_t iter;
const char *key;
char i_str[16];
bool r;
r = bson_iter_init (&iter, src);
if (!r) {
fprintf (stderr, "Invalid BSON document, possible memory coruption.\n");
return;
}
STACK_I--;
while (bson_iter_next (&iter)) {
bson_uint32_to_string (STACK_I, &key, i_str, sizeof i_str);
STACK_I++;
bson_append_iter (dest, key, -1, &iter);
}
}
/* Append_ctx_va consumes the va_list until NULL is found, appending into bson
* as tokens are found. It can receive or return an in-progress bson object
* via the ctx param. It can also operate on the middle of a va_list, and so
* can be wrapped inside of another varargs function.
*
* Note that passing in a va_list that isn't perferectly formatted for BCON
* ingestion will almost certainly result in undefined behavior
*
* The workflow relies on the passed ctx object, which holds a stack of bson
* objects, along with metadata (if the emedded layer is an array, and which
* element it is on if so). We iterate, generating tokens from the va_list,
* until we reach an END token. If any errors occur, we just blow up (the
* var_args stuff is already incredibly fragile to mistakes, and we have no way
* of introspecting, so just don't screw it up).
*
* There are also a few STACK_* macros in here which manimpulate ctx that are
* defined up top.
* */
void
bcon_append_ctx_va (bson_t *bson, bcon_append_ctx_t *ctx, va_list *ap)
{
bcon_type_t type;
const char *key;
char i_str[16];
bcon_append_t u = {0};
while (1) {
if (STACK_IS_ARRAY) {
bson_uint32_to_string (STACK_I, &key, i_str, sizeof i_str);
STACK_I++;
} else {
type = _bcon_append_tokenize (ap, &u);
if (type == BCON_TYPE_END) {
return;
}
if (type == BCON_TYPE_DOC_END) {
STACK_POP_DOC (
bson_append_document_end (STACK_BSON_PARENT, STACK_BSON_CHILD));
continue;
}
if (type == BCON_TYPE_BCON) {
bson_concat (STACK_BSON_CHILD, u.BCON);
continue;
}
assert (type == BCON_TYPE_UTF8);
key = u.UTF8;
}
type = _bcon_append_tokenize (ap, &u);
assert (type != BCON_TYPE_END);
switch ((int) type) {
case BCON_TYPE_BCON:
assert (STACK_IS_ARRAY);
_bson_concat_array (STACK_BSON_CHILD, u.BCON, ctx);
break;
case BCON_TYPE_DOC_START:
STACK_PUSH_DOC (bson_append_document_begin (
STACK_BSON_PARENT, key, -1, STACK_BSON_CHILD));
break;
case BCON_TYPE_DOC_END:
STACK_POP_DOC (
bson_append_document_end (STACK_BSON_PARENT, STACK_BSON_CHILD));
break;
case BCON_TYPE_ARRAY_START:
STACK_PUSH_ARRAY (bson_append_array_begin (
STACK_BSON_PARENT, key, -1, STACK_BSON_CHILD));
break;
case BCON_TYPE_ARRAY_END:
STACK_POP_ARRAY (
bson_append_array_end (STACK_BSON_PARENT, STACK_BSON_CHILD));
break;
default:
_bcon_append_single (STACK_BSON_CHILD, type, key, &u);
break;
}
}
}
/* extract_ctx_va consumes the va_list until NULL is found, extracting values
* as tokens are found. It can receive or return an in-progress bson object
* via the ctx param. It can also operate on the middle of a va_list, and so
* can be wrapped inside of another varargs function.
*
* Note that passing in a va_list that isn't perferectly formatted for BCON
* ingestion will almost certainly result in undefined behavior
*
* The workflow relies on the passed ctx object, which holds a stack of iterator
* objects, along with metadata (if the emedded layer is an array, and which
* element it is on if so). We iterate, generating tokens from the va_list,
* until we reach an END token. If any errors occur, we just blow up (the
* var_args stuff is already incredibly fragile to mistakes, and we have no way
* of introspecting, so just don't screw it up).
*
* There are also a few STACK_* macros in here which manimpulate ctx that are
* defined up top.
*
* The function returns true if all tokens could be successfully matched, false
* otherwise.
* */
bool
bcon_extract_ctx_va (bson_t *bson, bcon_extract_ctx_t *ctx, va_list *ap)
{
bcon_type_t type;
const char *key;
bson_iter_t root_iter;
bson_iter_t current_iter;
char i_str[16];
bcon_extract_t u = {0};
bson_iter_init (&root_iter, bson);
while (1) {
if (STACK_IS_ARRAY) {
bson_uint32_to_string (STACK_I, &key, i_str, sizeof i_str);
STACK_I++;
} else {
type = _bcon_extract_tokenize (ap, &u);
if (type == BCON_TYPE_END) {
return true;
}
if (type == BCON_TYPE_DOC_END) {
STACK_POP_DOC (_noop ());
continue;
}
assert (type == BCON_TYPE_RAW);
key = u.key;
}
type = _bcon_extract_tokenize (ap, &u);
assert (type != BCON_TYPE_END);
if (type == BCON_TYPE_DOC_END) {
STACK_POP_DOC (_noop ());
} else if (type == BCON_TYPE_ARRAY_END) {
STACK_POP_ARRAY (_noop ());
} else {
memcpy (¤t_iter, STACK_ITER_CHILD, sizeof current_iter);
if (!bson_iter_find (¤t_iter, key)) {
return false;
}
switch ((int) type) {
case BCON_TYPE_DOC_START:
if (bson_iter_type (¤t_iter) != BSON_TYPE_DOCUMENT) {
return false;
}
STACK_PUSH_DOC (
bson_iter_recurse (¤t_iter, STACK_ITER_CHILD));
break;
case BCON_TYPE_ARRAY_START:
if (bson_iter_type (¤t_iter) != BSON_TYPE_ARRAY) {
return false;
}
STACK_PUSH_ARRAY (
bson_iter_recurse (¤t_iter, STACK_ITER_CHILD));
break;
default:
if (!_bcon_extract_single (¤t_iter, type, &u)) {
return false;
}
break;
}
}
}
}
void
bcon_extract_ctx_init (bcon_extract_ctx_t *ctx)
{
ctx->n = 0;
ctx->stack[0].is_array = false;
}
bool
bcon_extract (bson_t *bson, ...)
{
va_list ap;
bcon_extract_ctx_t ctx;
bool r;
bcon_extract_ctx_init (&ctx);
va_start (ap, bson);
r = bcon_extract_ctx_va (bson, &ctx, &ap);
va_end (ap);
return r;
}
void
bcon_append (bson_t *bson, ...)
{
va_list ap;
bcon_append_ctx_t ctx;
bcon_append_ctx_init (&ctx);
va_start (ap, bson);
bcon_append_ctx_va (bson, &ctx, &ap);
va_end (ap);
}
void
bcon_append_ctx (bson_t *bson, bcon_append_ctx_t *ctx, ...)
{
va_list ap;
va_start (ap, ctx);
bcon_append_ctx_va (bson, ctx, &ap);
va_end (ap);
}
void
bcon_extract_ctx (bson_t *bson, bcon_extract_ctx_t *ctx, ...)
{
va_list ap;
va_start (ap, ctx);
bcon_extract_ctx_va (bson, ctx, &ap);
va_end (ap);
}
void
bcon_append_ctx_init (bcon_append_ctx_t *ctx)
{
ctx->n = 0;
ctx->stack[0].is_array = 0;
}
bson_t *
bcon_new (void *unused, ...)
{
va_list ap;
bcon_append_ctx_t ctx;
bson_t *bson;
bcon_append_ctx_init (&ctx);
bson = bson_new ();
va_start (ap, unused);
bcon_append_ctx_va (bson, &ctx, &ap);
va_end (ap);
return bson;
}
libbson-1.6.1/src/bson/bcon.h 0000664 0000000 0000000 00000025273 13057346540 0016011 0 ustar 00root root 0000000 0000000 /*
* @file bcon.h
* @brief BCON (BSON C Object Notation) Declarations
*/
/* Copyright 2009-2013 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.
*/
#ifndef BCON_H_
#define BCON_H_
#include "bson.h"
BSON_BEGIN_DECLS
#define BCON_STACK_MAX 100
#define BCON_ENSURE_DECLARE(fun, type) \
static BSON_INLINE type bcon_ensure_##fun (type _t) \
{ \
return _t; \
}
#define BCON_ENSURE(fun, val) bcon_ensure_##fun (val)
#define BCON_ENSURE_STORAGE(fun, val) bcon_ensure_##fun (&(val))
BCON_ENSURE_DECLARE (const_char_ptr, const char *)
BCON_ENSURE_DECLARE (const_char_ptr_ptr, const char **)
BCON_ENSURE_DECLARE (double, double)
BCON_ENSURE_DECLARE (double_ptr, double *)
BCON_ENSURE_DECLARE (const_bson_ptr, const bson_t *)
BCON_ENSURE_DECLARE (bson_ptr, bson_t *)
BCON_ENSURE_DECLARE (subtype, bson_subtype_t)
BCON_ENSURE_DECLARE (subtype_ptr, bson_subtype_t *)
BCON_ENSURE_DECLARE (const_uint8_ptr, const uint8_t *)
BCON_ENSURE_DECLARE (const_uint8_ptr_ptr, const uint8_t **)
BCON_ENSURE_DECLARE (uint32, uint32_t)
BCON_ENSURE_DECLARE (uint32_ptr, uint32_t *)
BCON_ENSURE_DECLARE (const_oid_ptr, const bson_oid_t *)
BCON_ENSURE_DECLARE (const_oid_ptr_ptr, const bson_oid_t **)
BCON_ENSURE_DECLARE (int32, int32_t)
BCON_ENSURE_DECLARE (int32_ptr, int32_t *)
BCON_ENSURE_DECLARE (int64, int64_t)
BCON_ENSURE_DECLARE (int64_ptr, int64_t *)
BCON_ENSURE_DECLARE (const_decimal128_ptr, const bson_decimal128_t *)
BCON_ENSURE_DECLARE (bool, bool)
BCON_ENSURE_DECLARE (bool_ptr, bool *)
BCON_ENSURE_DECLARE (bson_type, bson_type_t)
BCON_ENSURE_DECLARE (bson_iter_ptr, bson_iter_t *)
BCON_ENSURE_DECLARE (const_bson_iter_ptr, const bson_iter_t *)
#define BCON_UTF8(_val) \
BCON_MAGIC, BCON_TYPE_UTF8, BCON_ENSURE (const_char_ptr, (_val))
#define BCON_DOUBLE(_val) \
BCON_MAGIC, BCON_TYPE_DOUBLE, BCON_ENSURE (double, (_val))
#define BCON_DOCUMENT(_val) \
BCON_MAGIC, BCON_TYPE_DOCUMENT, BCON_ENSURE (const_bson_ptr, (_val))
#define BCON_ARRAY(_val) \
BCON_MAGIC, BCON_TYPE_ARRAY, BCON_ENSURE (const_bson_ptr, (_val))
#define BCON_BIN(_subtype, _binary, _length) \
BCON_MAGIC, BCON_TYPE_BIN, BCON_ENSURE (subtype, (_subtype)), \
BCON_ENSURE (const_uint8_ptr, (_binary)), \
BCON_ENSURE (uint32, (_length))
#define BCON_UNDEFINED BCON_MAGIC, BCON_TYPE_UNDEFINED
#define BCON_OID(_val) \
BCON_MAGIC, BCON_TYPE_OID, BCON_ENSURE (const_oid_ptr, (_val))
#define BCON_BOOL(_val) BCON_MAGIC, BCON_TYPE_BOOL, BCON_ENSURE (bool, (_val))
#define BCON_DATE_TIME(_val) \
BCON_MAGIC, BCON_TYPE_DATE_TIME, BCON_ENSURE (int64, (_val))
#define BCON_NULL BCON_MAGIC, BCON_TYPE_NULL
#define BCON_REGEX(_regex, _flags) \
BCON_MAGIC, BCON_TYPE_REGEX, BCON_ENSURE (const_char_ptr, (_regex)), \
BCON_ENSURE (const_char_ptr, (_flags))
#define BCON_DBPOINTER(_collection, _oid) \
BCON_MAGIC, BCON_TYPE_DBPOINTER, \
BCON_ENSURE (const_char_ptr, (_collection)), \
BCON_ENSURE (const_oid_ptr, (_oid))
#define BCON_CODE(_val) \
BCON_MAGIC, BCON_TYPE_CODE, BCON_ENSURE (const_char_ptr, (_val))
#define BCON_SYMBOL(_val) \
BCON_MAGIC, BCON_TYPE_SYMBOL, BCON_ENSURE (const_char_ptr, (_val))
#define BCON_CODEWSCOPE(_js, _scope) \
BCON_MAGIC, BCON_TYPE_CODEWSCOPE, BCON_ENSURE (const_char_ptr, (_js)), \
BCON_ENSURE (const_bson_ptr, (_scope))
#define BCON_INT32(_val) \
BCON_MAGIC, BCON_TYPE_INT32, BCON_ENSURE (int32, (_val))
#define BCON_TIMESTAMP(_timestamp, _increment) \
BCON_MAGIC, BCON_TYPE_TIMESTAMP, BCON_ENSURE (int32, (_timestamp)), \
BCON_ENSURE (int32, (_increment))
#define BCON_INT64(_val) \
BCON_MAGIC, BCON_TYPE_INT64, BCON_ENSURE (int64, (_val))
#define BCON_DECIMAL128(_val) \
BCON_MAGIC, BCON_TYPE_DECIMAL128, BCON_ENSURE (const_decimal128_ptr, (_val))
#define BCON_MAXKEY BCON_MAGIC, BCON_TYPE_MAXKEY
#define BCON_MINKEY BCON_MAGIC, BCON_TYPE_MINKEY
#define BCON(_val) \
BCON_MAGIC, BCON_TYPE_BCON, BCON_ENSURE (const_bson_ptr, (_val))
#define BCON_ITER(_val) \
BCON_MAGIC, BCON_TYPE_ITER, BCON_ENSURE (const_bson_iter_ptr, (_val))
#define BCONE_UTF8(_val) \
BCONE_MAGIC, BCON_TYPE_UTF8, BCON_ENSURE_STORAGE (const_char_ptr_ptr, (_val))
#define BCONE_DOUBLE(_val) \
BCONE_MAGIC, BCON_TYPE_DOUBLE, BCON_ENSURE_STORAGE (double_ptr, (_val))
#define BCONE_DOCUMENT(_val) \
BCONE_MAGIC, BCON_TYPE_DOCUMENT, BCON_ENSURE_STORAGE (bson_ptr, (_val))
#define BCONE_ARRAY(_val) \
BCONE_MAGIC, BCON_TYPE_ARRAY, BCON_ENSURE_STORAGE (bson_ptr, (_val))
#define BCONE_BIN(subtype, binary, length) \
BCONE_MAGIC, BCON_TYPE_BIN, BCON_ENSURE_STORAGE (subtype_ptr, (subtype)), \
BCON_ENSURE_STORAGE (const_uint8_ptr_ptr, (binary)), \
BCON_ENSURE_STORAGE (uint32_ptr, (length))
#define BCONE_UNDEFINED BCONE_MAGIC, BCON_TYPE_UNDEFINED
#define BCONE_OID(_val) \
BCONE_MAGIC, BCON_TYPE_OID, BCON_ENSURE_STORAGE (const_oid_ptr_ptr, (_val))
#define BCONE_BOOL(_val) \
BCONE_MAGIC, BCON_TYPE_BOOL, BCON_ENSURE_STORAGE (bool_ptr, (_val))
#define BCONE_DATE_TIME(_val) \
BCONE_MAGIC, BCON_TYPE_DATE_TIME, BCON_ENSURE_STORAGE (int64_ptr, (_val))
#define BCONE_NULL BCONE_MAGIC, BCON_TYPE_NULL
#define BCONE_REGEX(_regex, _flags) \
BCONE_MAGIC, BCON_TYPE_REGEX, \
BCON_ENSURE_STORAGE (const_char_ptr_ptr, (_regex)), \
BCON_ENSURE_STORAGE (const_char_ptr_ptr, (_flags))
#define BCONE_DBPOINTER(_collection, _oid) \
BCONE_MAGIC, BCON_TYPE_DBPOINTER, \
BCON_ENSURE_STORAGE (const_char_ptr_ptr, (_collection)), \
BCON_ENSURE_STORAGE (const_oid_ptr_ptr, (_oid))
#define BCONE_CODE(_val) \
BCONE_MAGIC, BCON_TYPE_CODE, BCON_ENSURE_STORAGE (const_char_ptr_ptr, (_val))
#define BCONE_SYMBOL(_val) \
BCONE_MAGIC, BCON_TYPE_SYMBOL, \
BCON_ENSURE_STORAGE (const_char_ptr_ptr, (_val))
#define BCONE_CODEWSCOPE(_js, _scope) \
BCONE_MAGIC, BCON_TYPE_CODEWSCOPE, \
BCON_ENSURE_STORAGE (const_char_ptr_ptr, (_js)), \
BCON_ENSURE_STORAGE (bson_ptr, (_scope))
#define BCONE_INT32(_val) \
BCONE_MAGIC, BCON_TYPE_INT32, BCON_ENSURE_STORAGE (int32_ptr, (_val))
#define BCONE_TIMESTAMP(_timestamp, _increment) \
BCONE_MAGIC, BCON_TYPE_TIMESTAMP, \
BCON_ENSURE_STORAGE (int32_ptr, (_timestamp)), \
BCON_ENSURE_STORAGE (int32_ptr, (_increment))
#define BCONE_INT64(_val) \
BCONE_MAGIC, BCON_TYPE_INT64, BCON_ENSURE_STORAGE (int64_ptr, (_val))
#define BCONE_DECIMAL128(_val) \
BCONE_MAGIC, BCON_TYPE_DECIMAL128, \
BCON_ENSURE_STORAGE (const_decimal128_ptr, (_val))
#define BCONE_MAXKEY BCONE_MAGIC, BCON_TYPE_MAXKEY
#define BCONE_MINKEY BCONE_MAGIC, BCON_TYPE_MINKEY
#define BCONE_SKIP(_val) \
BCONE_MAGIC, BCON_TYPE_SKIP, BCON_ENSURE (bson_type, (_val))
#define BCONE_ITER(_val) \
BCONE_MAGIC, BCON_TYPE_ITER, BCON_ENSURE_STORAGE (bson_iter_ptr, (_val))
#define BCON_MAGIC bson_bcon_magic ()
#define BCONE_MAGIC bson_bcone_magic ()
typedef enum {
BCON_TYPE_UTF8,
BCON_TYPE_DOUBLE,
BCON_TYPE_DOCUMENT,
BCON_TYPE_ARRAY,
BCON_TYPE_BIN,
BCON_TYPE_UNDEFINED,
BCON_TYPE_OID,
BCON_TYPE_BOOL,
BCON_TYPE_DATE_TIME,
BCON_TYPE_NULL,
BCON_TYPE_REGEX,
BCON_TYPE_DBPOINTER,
BCON_TYPE_CODE,
BCON_TYPE_SYMBOL,
BCON_TYPE_CODEWSCOPE,
BCON_TYPE_INT32,
BCON_TYPE_TIMESTAMP,
BCON_TYPE_INT64,
BCON_TYPE_DECIMAL128,
BCON_TYPE_MAXKEY,
BCON_TYPE_MINKEY,
BCON_TYPE_BCON,
BCON_TYPE_ARRAY_START,
BCON_TYPE_ARRAY_END,
BCON_TYPE_DOC_START,
BCON_TYPE_DOC_END,
BCON_TYPE_END,
BCON_TYPE_RAW,
BCON_TYPE_SKIP,
BCON_TYPE_ITER,
BCON_TYPE_ERROR,
} bcon_type_t;
typedef struct bcon_append_ctx_frame {
int i;
bool is_array;
bson_t bson;
} bcon_append_ctx_frame_t;
typedef struct bcon_extract_ctx_frame {
int i;
bool is_array;
bson_iter_t iter;
} bcon_extract_ctx_frame_t;
typedef struct _bcon_append_ctx_t {
bcon_append_ctx_frame_t stack[BCON_STACK_MAX];
int n;
} bcon_append_ctx_t;
typedef struct _bcon_extract_ctx_t {
bcon_extract_ctx_frame_t stack[BCON_STACK_MAX];
int n;
} bcon_extract_ctx_t;
BSON_EXPORT (void)
bcon_append (bson_t *bson, ...) BSON_GNUC_NULL_TERMINATED;
BSON_EXPORT (void)
bcon_append_ctx (bson_t *bson,
bcon_append_ctx_t *ctx,
...) BSON_GNUC_NULL_TERMINATED;
BSON_EXPORT (void)
bcon_append_ctx_va (bson_t *bson, bcon_append_ctx_t *ctx, va_list *va);
BSON_EXPORT (void)
bcon_append_ctx_init (bcon_append_ctx_t *ctx);
BSON_EXPORT (void)
bcon_extract_ctx_init (bcon_extract_ctx_t *ctx);
BSON_EXPORT (void)
bcon_extract_ctx (bson_t *bson,
bcon_extract_ctx_t *ctx,
...) BSON_GNUC_NULL_TERMINATED;
BSON_EXPORT (bool)
bcon_extract_ctx_va (bson_t *bson, bcon_extract_ctx_t *ctx, va_list *ap);
BSON_EXPORT (bool)
bcon_extract (bson_t *bson, ...) BSON_GNUC_NULL_TERMINATED;
BSON_EXPORT (bool)
bcon_extract_va (bson_t *bson,
bcon_extract_ctx_t *ctx,
...) BSON_GNUC_NULL_TERMINATED;
BSON_EXPORT (bson_t *)
bcon_new (void *unused, ...) BSON_GNUC_NULL_TERMINATED;
/**
* The bcon_..() functions are all declared with __attribute__((sentinel)).
*
* From GCC manual for "sentinel": "A valid NULL in this context is defined as
* zero with any pointer type. If your system defines the NULL macro with an
* integer type then you need to add an explicit cast."
* Case in point: GCC on Solaris (at least)
*/
#define BCON_APPEND(_bson, ...) \
bcon_append ((_bson), __VA_ARGS__, (void *) NULL)
#define BCON_APPEND_CTX(_bson, _ctx, ...) \
bcon_append_ctx ((_bson), (_ctx), __VA_ARGS__, (void *) NULL)
#define BCON_EXTRACT(_bson, ...) \
bcon_extract ((_bson), __VA_ARGS__, (void *) NULL)
#define BCON_EXTRACT_CTX(_bson, _ctx, ...) \
bcon_extract ((_bson), (_ctx), __VA_ARGS__, (void *) NULL)
#define BCON_NEW(...) bcon_new (NULL, __VA_ARGS__, (void *) NULL)
BSON_EXPORT (const char *)
bson_bcon_magic (void) BSON_GNUC_CONST;
BSON_EXPORT (const char *)
bson_bcone_magic (void) BSON_GNUC_CONST;
BSON_END_DECLS
#endif
libbson-1.6.1/src/bson/bson-atomic.c 0000664 0000000 0000000 00000003225 13057346540 0017267 0 ustar 00root root 0000000 0000000 /*
* Copyright 2014 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 "bson-atomic.h"
/*
* We should only ever hit these on non-Windows systems, for which we require
* pthread support. Therefore, we will avoid making a threading portability
* for threads here and just use pthreads directly.
*/
#ifdef __BSON_NEED_BARRIER
#include
static pthread_mutex_t gBarrier = PTHREAD_MUTEX_INITIALIZER;
void
bson_memory_barrier (void)
{
pthread_mutex_lock (&gBarrier);
pthread_mutex_unlock (&gBarrier);
}
#endif
#ifdef __BSON_NEED_ATOMIC_32
#include
static pthread_mutex_t gSync32 = PTHREAD_MUTEX_INITIALIZER;
int32_t
bson_atomic_int_add (volatile int32_t *p, int32_t n)
{
int ret;
pthread_mutex_lock (&gSync32);
*p += n;
ret = *p;
pthread_mutex_unlock (&gSync32);
return ret;
}
#endif
#ifdef __BSON_NEED_ATOMIC_64
#include
static pthread_mutex_t gSync64 = PTHREAD_MUTEX_INITIALIZER;
int64_t
bson_atomic_int64_add (volatile int64_t *p, int64_t n)
{
int64_t ret;
pthread_mutex_lock (&gSync64);
*p += n;
ret = *p;
pthread_mutex_unlock (&gSync64);
return ret;
}
#endif
libbson-1.6.1/src/bson/bson-atomic.h 0000664 0000000 0000000 00000005424 13057346540 0017277 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013-2014 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.
*/
#ifndef BSON_ATOMIC_H
#define BSON_ATOMIC_H
#include "bson-config.h"
#include "bson-compat.h"
#include "bson-macros.h"
BSON_BEGIN_DECLS
#if defined(__sun) && defined(__SVR4)
/* Solaris */
#include
#define bson_atomic_int_add(p, v) \
atomic_add_32_nv ((volatile uint32_t *) p, (v))
#define bson_atomic_int64_add(p, v) \
atomic_add_64_nv ((volatile uint64_t *) p, (v))
#elif defined(_WIN32)
/* MSVC/MinGW */
#define bson_atomic_int_add(p, v) \
(InterlockedExchangeAdd ((volatile LONG *) (p), (LONG) (v)) + (LONG) (v))
#define bson_atomic_int64_add(p, v) \
(InterlockedExchangeAdd64 ((volatile LONGLONG *) (p), (LONGLONG) (v)) + \
(LONGLONG) (v))
#else
#ifdef BSON_HAVE_ATOMIC_32_ADD_AND_FETCH
#define bson_atomic_int_add(p, v) __sync_add_and_fetch ((p), (v))
#else
#define __BSON_NEED_ATOMIC_32
#endif
#ifdef BSON_HAVE_ATOMIC_64_ADD_AND_FETCH
#if BSON_GNUC_IS_VERSION(4, 1)
/*
* GCC 4.1 on i386 can generate buggy 64-bit atomic increment.
* So we will work around with a fallback.
*
* https://gcc.gnu.org/bugzilla/show_bug.cgi?id=40693
*/
#define __BSON_NEED_ATOMIC_64
#else
#define bson_atomic_int64_add(p, v) \
__sync_add_and_fetch ((volatile int64_t *) (p), (int64_t) (v))
#endif
#else
#define __BSON_NEED_ATOMIC_64
#endif
#endif
#ifdef __BSON_NEED_ATOMIC_32
BSON_EXPORT (int32_t)
bson_atomic_int_add (volatile int32_t *p, int32_t n);
#endif
#ifdef __BSON_NEED_ATOMIC_64
BSON_EXPORT (int64_t)
bson_atomic_int64_add (volatile int64_t *p, int64_t n);
#endif
#if defined(_WIN32)
#define bson_memory_barrier() MemoryBarrier ()
#elif defined(__GNUC__)
#if BSON_GNUC_CHECK_VERSION(4, 1)
#define bson_memory_barrier() __sync_synchronize ()
#else
#warning "GCC Pre-4.1 discovered, using inline assembly for memory barrier."
#define bson_memory_barrier() __asm__ volatile("" ::: "memory")
#endif
#elif defined(__SUNPRO_C)
#include
#define bson_memory_barrier() __machine_rw_barrier ()
#elif defined(__xlC__)
#define bson_memory_barrier() __sync ()
#else
#define __BSON_NEED_BARRIER 1
#warning "Unknown compiler, using lock for compiler barrier."
BSON_EXPORT (void)
bson_memory_barrier (void);
#endif
BSON_END_DECLS
#endif /* BSON_ATOMIC_H */
libbson-1.6.1/src/bson/bson-clock.c 0000664 0000000 0000000 00000007440 13057346540 0017111 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 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.
*/
#ifdef __APPLE__
#include
#include
#include
#include
#endif
#include "bson-config.h"
#include "bson-compat.h"
#if defined(BSON_HAVE_CLOCK_GETTIME)
#include
#include
#endif
#include "bson-clock.h"
/*
*--------------------------------------------------------------------------
*
* bson_gettimeofday --
*
* A wrapper around gettimeofday() with fallback support for Windows.
*
* Returns:
* 0 if successful.
*
* Side effects:
* @tv is set.
*
*--------------------------------------------------------------------------
*/
int
bson_gettimeofday (struct timeval *tv) /* OUT */
{
#if defined(_WIN32)
#if defined(_MSC_VER)
#define DELTA_EPOCH_IN_MICROSEC 11644473600000000Ui64
#else
#define DELTA_EPOCH_IN_MICROSEC 11644473600000000ULL
#endif
FILETIME ft;
uint64_t tmp = 0;
/*
* The const value is shamelessy stolen from
* http://www.boost.org/doc/libs/1_55_0/boost/chrono/detail/inlined/win/chrono.hpp
*
* File times are the number of 100 nanosecond intervals elapsed since
* 12:00 am Jan 1, 1601 UTC. I haven't check the math particularly hard
*
* ... good luck
*/
if (tv) {
GetSystemTimeAsFileTime (&ft);
/* pull out of the filetime into a 64 bit uint */
tmp |= ft.dwHighDateTime;
tmp <<= 32;
tmp |= ft.dwLowDateTime;
/* convert from 100's of nanosecs to microsecs */
tmp /= 10;
/* adjust to unix epoch */
tmp -= DELTA_EPOCH_IN_MICROSEC;
tv->tv_sec = (long) (tmp / 1000000UL);
tv->tv_usec = (long) (tmp % 1000000UL);
}
return 0;
#else
return gettimeofday (tv, NULL);
#endif
}
/*
*--------------------------------------------------------------------------
*
* bson_get_monotonic_time --
*
* Returns the monotonic system time, if available. A best effort is
* made to use the monotonic clock. However, some systems may not
* support such a feature.
*
* Returns:
* The monotonic clock in microseconds.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
int64_t
bson_get_monotonic_time (void)
{
#if defined(BSON_HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC)
struct timespec ts;
clock_gettime (CLOCK_MONOTONIC, &ts);
return ((ts.tv_sec * 1000000UL) + (ts.tv_nsec / 1000UL));
#elif defined(__APPLE__)
static mach_timebase_info_data_t info = {0};
static double ratio = 0.0;
if (!info.denom) {
/* the value from mach_absolute_time () * info.numer / info.denom
* is in nano seconds. So we have to divid by 1000.0 to get micro
* seconds*/
mach_timebase_info (&info);
ratio = (double) info.numer / (double) info.denom / 1000.0;
}
return mach_absolute_time () * ratio;
#elif defined(_WIN32)
/* Despite it's name, this is in milliseconds! */
int64_t ticks = GetTickCount64 ();
return (ticks * 1000L);
#elif defined(__hpux__)
int64_t nanosec = gethrtime ();
return (nanosec / 1000UL);
#else
#warning "Monotonic clock is not yet supported on your platform."
struct timeval tv;
bson_gettimeofday (&tv);
return (tv.tv_sec * 1000000UL) + tv.tv_usec;
#endif
}
libbson-1.6.1/src/bson/bson-clock.h 0000664 0000000 0000000 00000001757 13057346540 0017123 0 ustar 00root root 0000000 0000000 /*
* Copyright 2014 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.
*/
#ifndef BSON_CLOCK_H
#define BSON_CLOCK_H
#if !defined(BSON_INSIDE) && !defined(BSON_COMPILATION)
#error "Only can be included directly."
#endif
#include "bson-compat.h"
#include "bson-macros.h"
#include "bson-types.h"
BSON_BEGIN_DECLS
BSON_EXPORT (int64_t)
bson_get_monotonic_time (void);
BSON_EXPORT (int)
bson_gettimeofday (struct timeval *tv);
BSON_END_DECLS
#endif /* BSON_CLOCK_H */
libbson-1.6.1/src/bson/bson-compat.h 0000664 0000000 0000000 00000006674 13057346540 0017316 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 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.
*/
#ifndef BSON_COMPAT_H
#define BSON_COMPAT_H
#if !defined(BSON_INSIDE) && !defined(BSON_COMPILATION)
#error "Only can be included directly."
#endif
#if defined(__MINGW32__)
#if defined(__USE_MINGW_ANSI_STDIO)
#if __USE_MINGW_ANSI_STDIO < 1
#error "__USE_MINGW_ANSI_STDIO > 0 is required for correct PRI* macros"
#endif
#else
#define __USE_MINGW_ANSI_STDIO 1
#endif
#endif
#include "bson-config.h"
#include "bson-macros.h"
#ifdef BSON_OS_WIN32
#if defined(_WIN32_WINNT) && (_WIN32_WINNT < 0x0600)
#undef _WIN32_WINNT
#endif
#ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x0600
#endif
#ifndef NOMINMAX
#define NOMINMAX
#endif
#include
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#include
#undef WIN32_LEAN_AND_MEAN
#else
#include
#endif
#include
#include
#endif
#ifdef BSON_OS_UNIX
#include
#include
#endif
#include "bson-macros.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
BSON_BEGIN_DECLS
#ifdef _MSC_VER
#include "bson-stdint-win32.h"
#ifndef __cplusplus
/* benign redefinition of type */
#pragma warning(disable : 4142)
#ifndef _SSIZE_T_DEFINED
#define _SSIZE_T_DEFINED
typedef SSIZE_T ssize_t;
#endif
typedef SIZE_T size_t;
#pragma warning(default : 4142)
#else
/*
* MSVC++ does not include ssize_t, just size_t.
* So we need to synthesize that as well.
*/
#pragma warning(disable : 4142)
#ifndef _SSIZE_T_DEFINED
#define _SSIZE_T_DEFINED
typedef SSIZE_T ssize_t;
#endif
#pragma warning(default : 4142)
#endif
#define PRIi32 "d"
#define PRId32 "d"
#define PRIu32 "u"
#define PRIi64 "I64i"
#define PRId64 "I64i"
#define PRIu64 "I64u"
#else
#include "bson-stdint.h"
#include
#endif
#if defined(__MINGW32__) && !defined(INIT_ONCE_STATIC_INIT)
#define INIT_ONCE_STATIC_INIT RTL_RUN_ONCE_INIT
typedef RTL_RUN_ONCE INIT_ONCE;
#endif
#ifdef BSON_HAVE_STDBOOL_H
#include
#elif !defined(__bool_true_false_are_defined)
#ifndef __cplusplus
typedef signed char bool;
#define false 0
#define true 1
#endif
#define __bool_true_false_are_defined 1
#endif
#if defined(__GNUC__)
#if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1)
#define bson_sync_synchronize() __sync_synchronize ()
#elif defined(__i386__) || defined(__i486__) || defined(__i586__) || \
defined(__i686__) || defined(__x86_64__)
#define bson_sync_synchronize() asm volatile("mfence" ::: "memory")
#else
#define bson_sync_synchronize() asm volatile("sync" ::: "memory")
#endif
#elif defined(_MSC_VER)
#define bson_sync_synchronize() MemoryBarrier ()
#endif
#if !defined(va_copy) && defined(__va_copy)
#define va_copy(dst, src) __va_copy (dst, src)
#endif
#if !defined(va_copy)
#define va_copy(dst, src) ((dst) = (src))
#endif
BSON_END_DECLS
#endif /* BSON_COMPAT_H */
libbson-1.6.1/src/bson/bson-config.h.in 0000664 0000000 0000000 00000005517 13057346540 0017700 0 ustar 00root root 0000000 0000000 #ifndef BSON_CONFIG_H
#define BSON_CONFIG_H
/*
* Define to 1234 for Little Endian, 4321 for Big Endian.
*/
#define BSON_BYTE_ORDER @BSON_BYTE_ORDER@
/*
* Define to 1 if you have stdbool.h
*/
#define BSON_HAVE_STDBOOL_H @BSON_HAVE_STDBOOL_H@
#if BSON_HAVE_STDBOOL_H != 1
# undef BSON_HAVE_STDBOOL_H
#endif
/*
* Define to 1 for POSIX-like systems, 2 for Windows.
*/
#define BSON_OS @BSON_OS@
/*
* Define to 1 if we have access to GCC 32-bit atomic builtins.
* While this requires GCC 4.1+ in most cases, it is also architecture
* dependent. For example, some PPC or ARM systems may not have it even
* if it is a recent GCC version.
*/
#define BSON_HAVE_ATOMIC_32_ADD_AND_FETCH @BSON_HAVE_ATOMIC_32_ADD_AND_FETCH@
#if BSON_HAVE_ATOMIC_32_ADD_AND_FETCH != 1
# undef BSON_HAVE_ATOMIC_32_ADD_AND_FETCH
#endif
/*
* Similarly, define to 1 if we have access to GCC 64-bit atomic builtins.
*/
#define BSON_HAVE_ATOMIC_64_ADD_AND_FETCH @BSON_HAVE_ATOMIC_64_ADD_AND_FETCH@
#if BSON_HAVE_ATOMIC_64_ADD_AND_FETCH != 1
# undef BSON_HAVE_ATOMIC_64_ADD_AND_FETCH
#endif
/*
* Define to 1 if your system requires {} around PTHREAD_ONCE_INIT.
* This is typically just Solaris 8-10.
*/
#define BSON_PTHREAD_ONCE_INIT_NEEDS_BRACES @BSON_PTHREAD_ONCE_INIT_NEEDS_BRACES@
#if BSON_PTHREAD_ONCE_INIT_NEEDS_BRACES != 1
# undef BSON_PTHREAD_ONCE_INIT_NEEDS_BRACES
#endif
/*
* Define to 1 if you have clock_gettime() available.
*/
#define BSON_HAVE_CLOCK_GETTIME @BSON_HAVE_CLOCK_GETTIME@
#if BSON_HAVE_CLOCK_GETTIME != 1
# undef BSON_HAVE_CLOCK_GETTIME
#endif
/*
* Define to 1 if you have strnlen available on your platform.
*/
#define BSON_HAVE_STRNLEN @BSON_HAVE_STRNLEN@
#if BSON_HAVE_STRNLEN != 1
# undef BSON_HAVE_STRNLEN
#endif
/*
* Define to 1 if you have snprintf available on your platform.
*/
#define BSON_HAVE_SNPRINTF @BSON_HAVE_SNPRINTF@
#if BSON_HAVE_SNPRINTF != 1
# undef BSON_HAVE_SNPRINTF
#endif
/*
* Define to 1 if you have reallocf available on your platform.
*/
#define BSON_HAVE_REALLOCF @BSON_HAVE_REALLOCF@
#if BSON_HAVE_REALLOCF != 1
# undef BSON_HAVE_REALLOCF
#endif
/*
* Define to 1 if you have _set_output_format (VS2013 and older).
*/
#define BSON_NEEDS_SET_OUTPUT_FORMAT @BSON_NEEDS_SET_OUTPUT_FORMAT@
#if BSON_NEEDS_SET_OUTPUT_FORMAT != 1
# undef BSON_NEEDS_SET_OUTPUT_FORMAT
#endif
/*
* Define to 1 if you have struct timespec available on your platform.
*/
#define BSON_HAVE_TIMESPEC @BSON_HAVE_TIMESPEC@
#if BSON_HAVE_TIMESPEC != 1
# undef BSON_HAVE_TIMESPEC
#endif
/*
* Define to 1 if you want extra aligned types in libbson
*/
#define BSON_EXTRA_ALIGN @BSON_EXTRA_ALIGN@
#if BSON_EXTRA_ALIGN != 1
# undef BSON_EXTRA_ALIGN
#endif
/*
* Define to 1 if you have SYS_gettid syscall
*/
#define BSON_HAVE_SYSCALL_TID @BSON_HAVE_SYSCALL_TID@
#if BSON_HAVE_SYSCALL_TID != 1
# undef BSON_HAVE_SYSCALL_TID
#endif
#endif /* BSON_CONFIG_H */
libbson-1.6.1/src/bson/bson-context-private.h 0000664 0000000 0000000 00000002321 13057346540 0021150 0 ustar 00root root 0000000 0000000 /*
* Copyright 2014 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.
*/
#ifndef BSON_CONTEXT_PRIVATE_H
#define BSON_CONTEXT_PRIVATE_H
#include "bson-context.h"
#include "bson-thread-private.h"
BSON_BEGIN_DECLS
struct _bson_context_t {
bson_context_flags_t flags : 7;
bool pidbe_once : 1;
uint8_t pidbe[2];
uint8_t md5[3];
int32_t seq32;
int64_t seq64;
void (*oid_get_host) (bson_context_t *context, bson_oid_t *oid);
void (*oid_get_pid) (bson_context_t *context, bson_oid_t *oid);
void (*oid_get_seq32) (bson_context_t *context, bson_oid_t *oid);
void (*oid_get_seq64) (bson_context_t *context, bson_oid_t *oid);
};
BSON_END_DECLS
#endif /* BSON_CONTEXT_PRIVATE_H */
libbson-1.6.1/src/bson/bson-context.c 0000664 0000000 0000000 00000030011 13057346540 0017470 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 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 "bson-compat.h"
#include
#include
#include
#include
#include
#include "bson-atomic.h"
#include "bson-clock.h"
#include "bson-context.h"
#include "bson-context-private.h"
#include "bson-md5.h"
#include "bson-memory.h"
#include "bson-thread-private.h"
#ifdef BSON_HAVE_SYSCALL_TID
#include
#endif
#ifndef HOST_NAME_MAX
#define HOST_NAME_MAX 256
#endif
/*
* Globals.
*/
static bson_context_t gContextDefault;
#ifdef BSON_HAVE_SYSCALL_TID
static uint16_t
gettid (void)
{
return syscall (SYS_gettid);
}
#endif
/*
*--------------------------------------------------------------------------
*
* _bson_context_get_oid_host --
*
* Retrieves the first three bytes of MD5(hostname) and assigns them
* to the host portion of oid.
*
* Returns:
* None.
*
* Side effects:
* @oid is modified.
*
*--------------------------------------------------------------------------
*/
static void
_bson_context_get_oid_host (bson_context_t *context, /* IN */
bson_oid_t *oid) /* OUT */
{
uint8_t *bytes = (uint8_t *) oid;
uint8_t digest[16];
bson_md5_t md5;
char hostname[HOST_NAME_MAX];
BSON_ASSERT (context);
BSON_ASSERT (oid);
gethostname (hostname, sizeof hostname);
hostname[HOST_NAME_MAX - 1] = '\0';
bson_md5_init (&md5);
bson_md5_append (
&md5, (const uint8_t *) hostname, (uint32_t) strlen (hostname));
bson_md5_finish (&md5, &digest[0]);
bytes[4] = digest[0];
bytes[5] = digest[1];
bytes[6] = digest[2];
}
/*
*--------------------------------------------------------------------------
*
* _bson_context_get_oid_host_cached --
*
* Fetch the cached copy of the MD5(hostname).
*
* Returns:
* None.
*
* Side effects:
* @oid is modified.
*
*--------------------------------------------------------------------------
*/
static void
_bson_context_get_oid_host_cached (bson_context_t *context, /* IN */
bson_oid_t *oid) /* OUT */
{
BSON_ASSERT (context);
BSON_ASSERT (oid);
oid->bytes[4] = context->md5[0];
oid->bytes[5] = context->md5[1];
oid->bytes[6] = context->md5[2];
}
static BSON_INLINE uint16_t
_bson_getpid (void)
{
uint16_t pid;
#ifdef BSON_OS_WIN32
DWORD real_pid;
real_pid = GetCurrentProcessId ();
pid = (real_pid & 0xFFFF) ^ ((real_pid >> 16) & 0xFFFF);
#else
pid = getpid ();
#endif
return pid;
}
/*
*--------------------------------------------------------------------------
*
* _bson_context_get_oid_pid --
*
* Initialize the pid field of @oid.
*
* The pid field is 2 bytes, big-endian for memcmp().
*
* Returns:
* None.
*
* Side effects:
* @oid is modified.
*
*--------------------------------------------------------------------------
*/
static void
_bson_context_get_oid_pid (bson_context_t *context, /* IN */
bson_oid_t *oid) /* OUT */
{
uint16_t pid = _bson_getpid ();
uint8_t *bytes = (uint8_t *) &pid;
BSON_ASSERT (context);
BSON_ASSERT (oid);
pid = BSON_UINT16_TO_BE (pid);
oid->bytes[7] = bytes[0];
oid->bytes[8] = bytes[1];
}
/*
*--------------------------------------------------------------------------
*
* _bson_context_get_oid_pid_cached --
*
* Fetch the cached copy of the current pid.
* This helps avoid multiple calls to getpid() which is slower
* on some systems.
*
* Returns:
* None.
*
* Side effects:
* @oid is modified.
*
*--------------------------------------------------------------------------
*/
static void
_bson_context_get_oid_pid_cached (bson_context_t *context, /* IN */
bson_oid_t *oid) /* OUT */
{
oid->bytes[7] = context->pidbe[0];
oid->bytes[8] = context->pidbe[1];
}
/*
*--------------------------------------------------------------------------
*
* _bson_context_get_oid_seq32 --
*
* 32-bit sequence generator, non-thread-safe version.
*
* Returns:
* None.
*
* Side effects:
* @oid is modified.
*
*--------------------------------------------------------------------------
*/
static void
_bson_context_get_oid_seq32 (bson_context_t *context, /* IN */
bson_oid_t *oid) /* OUT */
{
uint32_t seq = context->seq32++;
seq = BSON_UINT32_TO_BE (seq);
memcpy (&oid->bytes[9], ((uint8_t *) &seq) + 1, 3);
}
/*
*--------------------------------------------------------------------------
*
* _bson_context_get_oid_seq32_threadsafe --
*
* Thread-safe version of 32-bit sequence generator.
*
* Returns:
* None.
*
* Side effects:
* @oid is modified.
*
*--------------------------------------------------------------------------
*/
static void
_bson_context_get_oid_seq32_threadsafe (bson_context_t *context, /* IN */
bson_oid_t *oid) /* OUT */
{
int32_t seq = bson_atomic_int_add (&context->seq32, 1);
seq = BSON_UINT32_TO_BE (seq);
memcpy (&oid->bytes[9], ((uint8_t *) &seq) + 1, 3);
}
/*
*--------------------------------------------------------------------------
*
* _bson_context_get_oid_seq64 --
*
* 64-bit oid sequence generator, non-thread-safe version.
*
* Returns:
* None.
*
* Side effects:
* @oid is modified.
*
*--------------------------------------------------------------------------
*/
static void
_bson_context_get_oid_seq64 (bson_context_t *context, /* IN */
bson_oid_t *oid) /* OUT */
{
uint64_t seq;
BSON_ASSERT (context);
BSON_ASSERT (oid);
seq = BSON_UINT64_TO_BE (context->seq64++);
memcpy (&oid->bytes[4], &seq, sizeof (seq));
}
/*
*--------------------------------------------------------------------------
*
* _bson_context_get_oid_seq64_threadsafe --
*
* Thread-safe 64-bit sequence generator.
*
* Returns:
* None.
*
* Side effects:
* @oid is modified.
*
*--------------------------------------------------------------------------
*/
static void
_bson_context_get_oid_seq64_threadsafe (bson_context_t *context, /* IN */
bson_oid_t *oid) /* OUT */
{
int64_t seq = bson_atomic_int64_add (&context->seq64, 1);
seq = BSON_UINT64_TO_BE (seq);
memcpy (&oid->bytes[4], &seq, sizeof (seq));
}
static void
_bson_context_init (bson_context_t *context, /* IN */
bson_context_flags_t flags) /* IN */
{
struct timeval tv;
uint16_t pid;
unsigned int seed[3];
unsigned int real_seed;
bson_oid_t oid;
context->flags = flags;
context->oid_get_host = _bson_context_get_oid_host_cached;
context->oid_get_pid = _bson_context_get_oid_pid_cached;
context->oid_get_seq32 = _bson_context_get_oid_seq32;
context->oid_get_seq64 = _bson_context_get_oid_seq64;
/*
* Generate a seed for our the random starting position of our increment
* bytes. We mask off the last nibble so that the last digit of the OID will
* start at zero. Just to be nice.
*
* The seed itself is made up of the current time in seconds, milliseconds,
* and pid xored together. I welcome better solutions if at all necessary.
*/
bson_gettimeofday (&tv);
seed[0] = (unsigned int) tv.tv_sec;
seed[1] = (unsigned int) tv.tv_usec;
seed[2] = _bson_getpid ();
real_seed = seed[0] ^ seed[1] ^ seed[2];
#ifdef BSON_OS_WIN32
/* ms's runtime is multithreaded by default, so no rand_r */
srand (real_seed);
context->seq32 = rand () & 0x007FFFF0;
#else
context->seq32 = rand_r (&real_seed) & 0x007FFFF0;
#endif
if ((flags & BSON_CONTEXT_DISABLE_HOST_CACHE)) {
context->oid_get_host = _bson_context_get_oid_host;
} else {
_bson_context_get_oid_host (context, &oid);
context->md5[0] = oid.bytes[4];
context->md5[1] = oid.bytes[5];
context->md5[2] = oid.bytes[6];
}
if ((flags & BSON_CONTEXT_THREAD_SAFE)) {
context->oid_get_seq32 = _bson_context_get_oid_seq32_threadsafe;
context->oid_get_seq64 = _bson_context_get_oid_seq64_threadsafe;
}
if ((flags & BSON_CONTEXT_DISABLE_PID_CACHE)) {
context->oid_get_pid = _bson_context_get_oid_pid;
} else {
pid = BSON_UINT16_TO_BE (_bson_getpid ());
#ifdef BSON_HAVE_SYSCALL_TID
if ((flags & BSON_CONTEXT_USE_TASK_ID)) {
int32_t tid;
if ((tid = gettid ())) {
pid = BSON_UINT16_TO_BE (tid);
}
}
#endif
memcpy (&context->pidbe[0], &pid, 2);
}
}
/*
*--------------------------------------------------------------------------
*
* bson_context_new --
*
* Initializes a new context with the flags specified.
*
* In most cases, you want to call this with @flags set to
* BSON_CONTEXT_NONE.
*
* If you are running on Linux, %BSON_CONTEXT_USE_TASK_ID can result
* in a healthy speedup for multi-threaded scenarios.
*
* If you absolutely must have a single context for your application
* and use more than one thread, then %BSON_CONTEXT_THREAD_SAFE should
* be bitwise-or'd with your flags. This requires synchronization
* between threads.
*
* If you expect your hostname to change often, you may consider
* specifying %BSON_CONTEXT_DISABLE_HOST_CACHE so that gethostname()
* is called for every OID generated. This is much slower.
*
* If you expect your pid to change without notice, such as from an
* unexpected call to fork(), then specify
* %BSON_CONTEXT_DISABLE_PID_CACHE.
*
* Returns:
* A newly allocated bson_context_t that should be freed with
* bson_context_destroy().
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
bson_context_t *
bson_context_new (bson_context_flags_t flags)
{
bson_context_t *context;
context = bson_malloc0 (sizeof *context);
_bson_context_init (context, flags);
return context;
}
/*
*--------------------------------------------------------------------------
*
* bson_context_destroy --
*
* Cleans up a bson_context_t and releases any associated resources.
* This should be called when you are done using @context.
*
* Returns:
* None.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
void
bson_context_destroy (bson_context_t *context) /* IN */
{
if (context != &gContextDefault) {
memset (context, 0, sizeof *context);
bson_free (context);
}
}
static BSON_ONCE_FUN (_bson_context_init_default)
{
_bson_context_init (
&gContextDefault,
(BSON_CONTEXT_THREAD_SAFE | BSON_CONTEXT_DISABLE_PID_CACHE));
BSON_ONCE_RETURN;
}
/*
*--------------------------------------------------------------------------
*
* bson_context_get_default --
*
* Fetches the default, thread-safe implementation of #bson_context_t.
* If you need faster generation, it is recommended you create your
* own #bson_context_t with bson_context_new().
*
* Returns:
* A shared instance to the default #bson_context_t. This should not
* be modified or freed.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
bson_context_t *
bson_context_get_default (void)
{
static bson_once_t once = BSON_ONCE_INIT;
bson_once (&once, _bson_context_init_default);
return &gContextDefault;
}
libbson-1.6.1/src/bson/bson-context.h 0000664 0000000 0000000 00000002115 13057346540 0017501 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 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.
*/
#ifndef BSON_CONTEXT_H
#define BSON_CONTEXT_H
#if !defined(BSON_INSIDE) && !defined(BSON_COMPILATION)
#error "Only can be included directly."
#endif
#include "bson-macros.h"
#include "bson-types.h"
BSON_BEGIN_DECLS
BSON_EXPORT (bson_context_t *)
bson_context_new (bson_context_flags_t flags);
BSON_EXPORT (void)
bson_context_destroy (bson_context_t *context);
BSON_EXPORT (bson_context_t *)
bson_context_get_default (void) BSON_GNUC_CONST;
BSON_END_DECLS
#endif /* BSON_CONTEXT_H */
libbson-1.6.1/src/bson/bson-decimal128.c 0000664 0000000 0000000 00000053211 13057346540 0017644 0 ustar 00root root 0000000 0000000
/*
* Copyright 2015 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
#include
#include
#include
#include "bson-decimal128.h"
#include "bson-types.h"
#include "bson-macros.h"
#include "bson-string.h"
#define BSON_DECIMAL128_EXPONENT_MAX 6111
#define BSON_DECIMAL128_EXPONENT_MIN -6176
#define BSON_DECIMAL128_EXPONENT_BIAS 6176
#define BSON_DECIMAL128_MAX_DIGITS 34
#define BSON_DECIMAL128_SET_NAN(dec) \
do { \
(dec).high = 0x7c00000000000000ull; \
(dec).low = 0; \
} while (0);
#define BSON_DECIMAL128_SET_INF(dec, isneg) \
do { \
(dec).high = 0x7800000000000000ull + 0x8000000000000000ull * (isneg); \
(dec).low = 0; \
} while (0);
/**
* _bson_uint128_t:
*
* This struct represents a 128 bit integer.
*/
typedef struct {
uint32_t parts[4]; /* 32-bit words stored high to low. */
} _bson_uint128_t;
/**
*------------------------------------------------------------------------------
*
* _bson_uint128_divide1B --
*
* This function divides a #_bson_uint128_t by 1000000000 (1 billion) and
* computes the quotient and remainder.
*
* The remainder will contain 9 decimal digits for conversion to string.
*
* @value The #_bson_uint128_t operand.
* @quotient A pointer to store the #_bson_uint128_t quotient.
* @rem A pointer to store the #uint64_t remainder.
*
* Returns:
* The quotient at @quotient and the remainder at @rem.
*
* Side effects:
* None.
*
*------------------------------------------------------------------------------
*/
static void
_bson_uint128_divide1B (_bson_uint128_t value, /* IN */
_bson_uint128_t *quotient, /* OUT */
uint32_t *rem) /* OUT */
{
const uint32_t DIVISOR = 1000 * 1000 * 1000;
uint64_t _rem = 0;
int i = 0;
if (!value.parts[0] && !value.parts[1] && !value.parts[2] &&
!value.parts[3]) {
*quotient = value;
*rem = 0;
return;
}
for (i = 0; i <= 3; i++) {
_rem <<= 32; /* Adjust remainder to match value of next dividend */
_rem += value.parts[i]; /* Add the divided to _rem */
value.parts[i] = (uint32_t) (_rem / DIVISOR);
_rem %= DIVISOR; /* Store the remainder */
}
*quotient = value;
*rem = _rem;
}
/**
*------------------------------------------------------------------------------
*
* bson_decimal128_to_string --
*
* This function converts a BID formatted decimal128 value to string,
* accepting a &bson_decimal128_t as @dec. The string is stored at @str.
*
* @dec : The BID formatted decimal to convert.
* @str : The output decimal128 string. At least %BSON_DECIMAL128_STRING
*characters.
*
* Returns:
* None.
*
* Side effects:
* None.
*
*------------------------------------------------------------------------------
*/
void
bson_decimal128_to_string (const bson_decimal128_t *dec, /* IN */
char *str) /* OUT */
{
uint32_t COMBINATION_MASK = 0x1f; /* Extract least significant 5 bits */
uint32_t EXPONENT_MASK = 0x3fff; /* Extract least significant 14 bits */
uint32_t COMBINATION_INFINITY = 30; /* Value of combination field for Inf */
uint32_t COMBINATION_NAN = 31; /* Value of combination field for NaN */
uint32_t EXPONENT_BIAS = 6176; /* decimal128 exponent bias */
char *str_out = str; /* output pointer in string */
char significand_str[35]; /* decoded significand digits */
/* Note: bits in this routine are referred to starting at 0, */
/* from the sign bit, towards the coefficient. */
uint32_t high; /* bits 0 - 31 */
uint32_t midh; /* bits 32 - 63 */
uint32_t midl; /* bits 64 - 95 */
uint32_t low; /* bits 96 - 127 */
uint32_t combination; /* bits 1 - 5 */
uint32_t biased_exponent; /* decoded biased exponent (14 bits) */
uint32_t significand_digits = 0; /* the number of significand digits */
uint32_t significand[36] = {0}; /* the base-10 digits in the significand */
uint32_t *significand_read = significand; /* read pointer into significand */
int32_t exponent; /* unbiased exponent */
int32_t scientific_exponent; /* the exponent if scientific notation is
* used */
bool is_zero = false; /* true if the number is zero */
uint8_t significand_msb; /* the most signifcant significand bits (50-46) */
_bson_uint128_t
significand128; /* temporary storage for significand decoding */
size_t i; /* indexing variables */
int j, k;
memset (significand_str, 0, sizeof (significand_str));
if ((int64_t) dec->high < 0) { /* negative */
*(str_out++) = '-';
}
low = (uint32_t) dec->low, midl = (uint32_t) (dec->low >> 32),
midh = (uint32_t) dec->high, high = (uint32_t) (dec->high >> 32);
/* Decode combination field and exponent */
combination = (high >> 26) & COMBINATION_MASK;
if (BSON_UNLIKELY ((combination >> 3) == 3)) {
/* Check for 'special' values */
if (combination == COMBINATION_INFINITY) { /* Infinity */
strcpy (str_out, BSON_DECIMAL128_INF);
return;
} else if (combination == COMBINATION_NAN) { /* NaN */
/* str, not str_out, to erase the sign */
strcpy (str, BSON_DECIMAL128_NAN);
/* we don't care about the NaN payload. */
return;
} else {
biased_exponent = (high >> 15) & EXPONENT_MASK;
significand_msb = 0x8 + ((high >> 14) & 0x1);
}
} else {
significand_msb = (high >> 14) & 0x7;
biased_exponent = (high >> 17) & EXPONENT_MASK;
}
exponent = biased_exponent - EXPONENT_BIAS;
/* Create string of significand digits */
/* Convert the 114-bit binary number represented by */
/* (high, midh, midl, low) to at most 34 decimal */
/* digits through modulo and division. */
significand128.parts[0] = (high & 0x3fff) + ((significand_msb & 0xf) << 14);
significand128.parts[1] = midh;
significand128.parts[2] = midl;
significand128.parts[3] = low;
if (significand128.parts[0] == 0 && significand128.parts[1] == 0 &&
significand128.parts[2] == 0 && significand128.parts[3] == 0) {
is_zero = true;
} else if (significand128.parts[0] >= (1 << 17)) {
/* The significand is non-canonical or zero.
* In order to preserve compatability with the densely packed decimal
* format, the maximum value for the significand of decimal128 is
* 1e34 - 1. If the value is greater than 1e34 - 1, the IEEE 754
* standard dictates that the significand is interpreted as zero.
*/
is_zero = true;
} else {
for (k = 3; k >= 0; k--) {
uint32_t least_digits = 0;
_bson_uint128_divide1B (
significand128, &significand128, &least_digits);
/* We now have the 9 least significant digits (in base 2). */
/* Convert and output to string. */
if (!least_digits) {
continue;
}
for (j = 8; j >= 0; j--) {
significand[k * 9 + j] = least_digits % 10;
least_digits /= 10;
}
}
}
/* Output format options: */
/* Scientific - [-]d.dddE(+/-)dd or [-]dE(+/-)dd */
/* Regular - ddd.ddd */
if (is_zero) {
significand_digits = 1;
*significand_read = 0;
} else {
significand_digits = 36;
while (!(*significand_read)) {
significand_digits--;
significand_read++;
}
}
scientific_exponent = significand_digits - 1 + exponent;
/* The scientific exponent checks are dictated by the string conversion
* specification and are somewhat arbitrary cutoffs.
*
* We must check exponent > 0, because if this is the case, the number
* has trailing zeros. However, we *cannot* output these trailing zeros,
* because doing so would change the precision of the value, and would
* change stored data if the string converted number is round tripped.
*/
if (scientific_exponent < -6 || exponent > 0) {
/* Scientific format */
*(str_out++) = *(significand_read++) + '0';
significand_digits--;
if (significand_digits) {
*(str_out++) = '.';
}
for (i = 0; i < significand_digits; i++) {
*(str_out++) = *(significand_read++) + '0';
}
/* Exponent */
*(str_out++) = 'E';
bson_snprintf (str_out, 6, "%+d", scientific_exponent);
} else {
/* Regular format with no decimal place */
if (exponent >= 0) {
for (i = 0; i < significand_digits; i++) {
*(str_out++) = *(significand_read++) + '0';
}
*str_out = '\0';
} else {
int32_t radix_position = significand_digits + exponent;
if (radix_position > 0) { /* non-zero digits before radix */
for (i = 0; i < radix_position; i++) {
*(str_out++) = *(significand_read++) + '0';
}
} else { /* leading zero before radix point */
*(str_out++) = '0';
}
*(str_out++) = '.';
while (radix_position++ < 0) { /* add leading zeros after radix */
*(str_out++) = '0';
}
for (i = 0; i < significand_digits - BSON_MAX (radix_position - 1, 0);
i++) {
*(str_out++) = *(significand_read++) + '0';
}
*str_out = '\0';
}
}
}
typedef struct {
uint64_t high, low;
} _bson_uint128_6464_t;
/**
*-------------------------------------------------------------------------
*
* mul64x64 --
*
* This function multiplies two &uint64_t into a &_bson_uint128_6464_t.
*
* Returns:
* The product of @left and @right.
*
* Side Effects:
* None.
*
*-------------------------------------------------------------------------
*/
static void
_mul_64x64 (uint64_t left, /* IN */
uint64_t right, /* IN */
_bson_uint128_6464_t *product) /* OUT */
{
uint64_t left_high, left_low, right_high, right_low, product_high,
product_mid, product_mid2, product_low;
_bson_uint128_6464_t rt = {0};
if (!left && !right) {
*product = rt;
return;
}
left_high = left >> 32;
left_low = (uint32_t) left;
right_high = right >> 32;
right_low = (uint32_t) right;
product_high = left_high * right_high;
product_mid = left_high * right_low;
product_mid2 = left_low * right_high;
product_low = left_low * right_low;
product_high += product_mid >> 32;
product_mid = (uint32_t) product_mid + product_mid2 + (product_low >> 32);
product_high = product_high + (product_mid >> 32);
product_low = (product_mid << 32) + (uint32_t) product_low;
rt.high = product_high;
rt.low = product_low;
*product = rt;
}
/**
*------------------------------------------------------------------------------
*
* _dec128_tolower --
*
* This function converts the ASCII character @c to lowercase. It is locale
* insensitive (unlike the stdlib tolower).
*
* Returns:
* The lowercased character.
*/
char
_dec128_tolower (char c)
{
if (isupper (c)) {
c += 32;
}
return c;
}
/**
*------------------------------------------------------------------------------
*
* _dec128_istreq --
*
* This function compares the null-terminated *ASCII* strings @a and @b
* for case-insensitive equality.
*
* Returns:
* true if the strings are equal, false otherwise.
*/
bool
_dec128_istreq (const char *a, /* IN */
const char *b /* IN */)
{
while (*a != '\0' || *b != '\0') {
/* strings are different lengths. */
if (*a == '\0' || *b == '\0') {
return false;
}
if (_dec128_tolower (*a) != _dec128_tolower (*b)) {
return false;
}
a++;
b++;
}
return true;
}
/**
*------------------------------------------------------------------------------
*
* bson_decimal128_from_string --
*
* This function converts @string in the format [+-]ddd[.]ddd[E][+-]dddd to
* decimal128. Out of range values are converted to +/-Infinity. Invalid
* strings are converted to NaN.
*
* If more digits are provided than the available precision allows,
* round to the nearest expressable decimal128 with ties going to even will
* occur.
*
* Note: @string must be ASCII only!
*
* Returns:
* true on success, or false on failure. @dec will be NaN if @str was invalid
* The &bson_decimal128_t converted from @string at @dec.
*
* Side effects:
* None.
*
*------------------------------------------------------------------------------
*/
bool
bson_decimal128_from_string (const char *string, /* IN */
bson_decimal128_t *dec) /* OUT */
{
_bson_uint128_6464_t significand = {0};
const char *str_read = string; /* Read pointer for consuming str. */
/* Parsing state tracking */
bool is_negative = false;
bool saw_radix = false;
bool includes_sign = false; /* True if the input string contains a sign. */
bool found_nonzero = false;
size_t significant_digits = 0; /* Total number of significant digits
* (no leading or trailing zero) */
size_t ndigits_read = 0; /* Total number of significand digits read */
size_t ndigits = 0; /* Total number of digits (no leading zeros) */
size_t radix_position = 0; /* The number of the digits after radix */
size_t first_nonzero = 0; /* The index of the first non-zero in *str* */
uint16_t digits[BSON_DECIMAL128_MAX_DIGITS] = {0};
uint16_t ndigits_stored = 0; /* The number of digits in digits */
uint16_t *digits_insert = digits; /* Insertion pointer for digits */
size_t first_digit = 0; /* The index of the first non-zero digit */
size_t last_digit = 0; /* The index of the last digit */
int32_t exponent = 0;
uint64_t significand_high = 0; /* The high 17 digits of the significand */
uint64_t significand_low = 0; /* The low 17 digits of the significand */
uint16_t biased_exponent = 0; /* The biased exponent */
BSON_ASSERT (dec);
dec->high = 0;
dec->low = 0;
if (*str_read == '+' || *str_read == '-') {
is_negative = *(str_read++) == '-';
includes_sign = true;
}
/* Check for Infinity or NaN */
if (!isdigit (*str_read) && *str_read != '.') {
if (_dec128_istreq (str_read, "inf") ||
_dec128_istreq (str_read, "infinity")) {
BSON_DECIMAL128_SET_INF (*dec, is_negative);
return true;
} else if (_dec128_istreq (str_read, "nan")) {
BSON_DECIMAL128_SET_NAN (*dec);
return true;
}
BSON_DECIMAL128_SET_NAN (*dec);
return false;
}
/* Read digits */
while (isdigit (*str_read) || *str_read == '.') {
if (*str_read == '.') {
if (saw_radix) {
BSON_DECIMAL128_SET_NAN (*dec);
return false;
}
saw_radix = true;
str_read++;
continue;
}
if (ndigits_stored < 34) {
if (*str_read != '0' || found_nonzero) {
if (!found_nonzero) {
first_nonzero = ndigits_read;
}
found_nonzero = true;
*(digits_insert++) = *(str_read) - '0'; /* Only store 34 digits */
ndigits_stored++;
}
}
if (found_nonzero) {
ndigits++;
}
if (saw_radix) {
radix_position++;
}
ndigits_read++;
str_read++;
}
if (saw_radix && !ndigits_read) {
BSON_DECIMAL128_SET_NAN (*dec);
return false;
}
/* Read exponent if exists */
if (*str_read == 'e' || *str_read == 'E') {
int nread = 0;
#ifdef _MSC_VER
#define SSCANF sscanf_s
#else
#define SSCANF sscanf
#endif
int read_exponent = SSCANF (++str_read, "%d%n", &exponent, &nread);
str_read += nread;
if (!read_exponent || nread == 0) {
BSON_DECIMAL128_SET_NAN (*dec);
return false;
}
#undef SSCANF
}
if (*str_read) {
BSON_DECIMAL128_SET_NAN (*dec);
return false;
}
/* Done reading input. */
/* Find first non-zero digit in digits */
first_digit = 0;
if (!ndigits_stored) { /* value is zero */
first_digit = 0;
last_digit = 0;
digits[0] = 0;
ndigits = 1;
ndigits_stored = 1;
significant_digits = 0;
} else {
last_digit = ndigits_stored - 1;
significant_digits = ndigits;
/* Mark trailing zeros as non-significant */
while (string[first_nonzero + significant_digits - 1 + includes_sign +
saw_radix] == '0') {
significant_digits--;
}
}
/* Normalization of exponent */
/* Correct exponent based on radix position, and shift significand as needed
*/
/* to represent user input */
/* Overflow prevention */
if (exponent <= radix_position && radix_position - exponent > (1 << 14)) {
exponent = BSON_DECIMAL128_EXPONENT_MIN;
} else {
exponent -= radix_position;
}
/* Attempt to normalize the exponent */
while (exponent > BSON_DECIMAL128_EXPONENT_MAX) {
/* Shift exponent to significand and decrease */
last_digit++;
if (last_digit - first_digit > BSON_DECIMAL128_MAX_DIGITS) {
/* The exponent is too great to shift into the significand. */
if (significant_digits == 0) {
/* Value is zero, we are allowed to clamp the exponent. */
exponent = BSON_DECIMAL128_EXPONENT_MAX;
break;
}
/* Overflow is not permitted, error. */
BSON_DECIMAL128_SET_NAN (*dec);
return false;
}
exponent--;
}
while (exponent < BSON_DECIMAL128_EXPONENT_MIN || ndigits_stored < ndigits) {
/* Shift last digit */
if (last_digit == 0) {
/* underflow is not allowed, but zero clamping is */
if (significant_digits == 0) {
exponent = BSON_DECIMAL128_EXPONENT_MIN;
break;
}
BSON_DECIMAL128_SET_NAN (*dec);
return false;
}
if (ndigits_stored < ndigits) {
if (string[ndigits - 1 + includes_sign + saw_radix] - '0' != 0 &&
significant_digits != 0) {
BSON_DECIMAL128_SET_NAN (*dec);
return false;
}
ndigits--; /* adjust to match digits not stored */
} else {
if (digits[last_digit] != 0) {
/* Inexact rounding is not allowed. */
BSON_DECIMAL128_SET_NAN (*dec);
return false;
}
last_digit--; /* adjust to round */
}
if (exponent < BSON_DECIMAL128_EXPONENT_MAX) {
exponent++;
} else {
BSON_DECIMAL128_SET_NAN (*dec);
return false;
}
}
/* Round */
/* We've normalized the exponent, but might still need to round. */
if (last_digit - first_digit + 1 < significant_digits) {
uint8_t round_digit;
/* There are non-zero digits after last_digit that need rounding. */
/* We round to nearest, ties to even */
round_digit =
string[first_nonzero + last_digit + includes_sign + saw_radix + 1] -
'0';
if (round_digit != 0) {
/* Inexact (non-zero) rounding is not allowed */
BSON_DECIMAL128_SET_NAN (*dec);
return false;
}
}
/* Encode significand */
significand_high = 0, /* The high 17 digits of the significand */
significand_low = 0; /* The low 17 digits of the significand */
if (significant_digits == 0) { /* read a zero */
significand_high = 0;
significand_low = 0;
} else if (last_digit - first_digit < 17) {
int d_idx = first_digit;
significand_low = digits[d_idx++];
for (; d_idx <= last_digit; d_idx++) {
significand_low *= 10;
significand_low += digits[d_idx];
significand_high = 0;
}
} else {
int d_idx = first_digit;
significand_high = digits[d_idx++];
for (; d_idx <= last_digit - 17; d_idx++) {
significand_high *= 10;
significand_high += digits[d_idx];
}
significand_low = digits[d_idx++];
for (; d_idx <= last_digit; d_idx++) {
significand_low *= 10;
significand_low += digits[d_idx];
}
}
_mul_64x64 (significand_high, 100000000000000000ull, &significand);
significand.low += significand_low;
if (significand.low < significand_low) {
significand.high += 1;
}
biased_exponent = (exponent + (int16_t) BSON_DECIMAL128_EXPONENT_BIAS);
/* Encode combination, exponent, and significand. */
if ((significand.high >> 49) & 1) {
/* Encode '11' into bits 1 to 3 */
dec->high |= (0x3ull << 61);
dec->high |= (biased_exponent & 0x3fffull) << 47;
dec->high |= significand.high & 0x7fffffffffffull;
} else {
dec->high |= (biased_exponent & 0x3fffull) << 49;
dec->high |= significand.high & 0x1ffffffffffffull;
}
dec->low = significand.low;
/* Encode sign */
if (is_negative) {
dec->high |= 0x8000000000000000ull;
}
return true;
}
libbson-1.6.1/src/bson/bson-decimal128.h 0000664 0000000 0000000 00000002714 13057346540 0017653 0 ustar 00root root 0000000 0000000 /*
* Copyright 2015 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.
*/
#ifndef BSON_DECIMAL128_H
#define BSON_DECIMAL128_H
#if !defined(BSON_INSIDE) && !defined(BSON_COMPILATION)
#error "Only can be included directly."
#endif
#include
#include "bson-macros.h"
#include "bson-config.h"
#include "bson-types.h"
/**
* BSON_DECIMAL128_STRING:
*
* The length of a decimal128 string (with null terminator).
*
* 1 for the sign
* 35 for digits and radix
* 2 for exponent indicator and sign
* 4 for exponent digits
*/
#define BSON_DECIMAL128_STRING 43
#define BSON_DECIMAL128_INF "Infinity"
#define BSON_DECIMAL128_NAN "NaN"
BSON_BEGIN_DECLS
BSON_EXPORT (void)
bson_decimal128_to_string (const bson_decimal128_t *dec, char *str);
/* Note: @string must be ASCII characters only! */
BSON_EXPORT (bool)
bson_decimal128_from_string (const char *string, bson_decimal128_t *dec);
BSON_END_DECLS
#endif /* BSON_DECIMAL128_H */
libbson-1.6.1/src/bson/bson-endian.h 0000664 0000000 0000000 00000014470 13057346540 0017262 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 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.
*/
#ifndef BSON_ENDIAN_H
#define BSON_ENDIAN_H
#if !defined(BSON_INSIDE) && !defined(BSON_COMPILATION)
#error "Only can be included directly."
#endif
#if defined(__sun)
#include
#endif
#include "bson-config.h"
#include "bson-macros.h"
#include "bson-compat.h"
BSON_BEGIN_DECLS
#define BSON_BIG_ENDIAN 4321
#define BSON_LITTLE_ENDIAN 1234
#if defined(__sun)
#define BSON_UINT16_SWAP_LE_BE(v) BSWAP_16 ((uint16_t) v)
#define BSON_UINT32_SWAP_LE_BE(v) BSWAP_32 ((uint32_t) v)
#define BSON_UINT64_SWAP_LE_BE(v) BSWAP_64 ((uint64_t) v)
#elif defined(__clang__) && defined(__clang_major__) && \
defined(__clang_minor__) && (__clang_major__ >= 3) && \
(__clang_minor__ >= 1)
#if __has_builtin(__builtin_bswap16)
#define BSON_UINT16_SWAP_LE_BE(v) __builtin_bswap16 (v)
#endif
#if __has_builtin(__builtin_bswap32)
#define BSON_UINT32_SWAP_LE_BE(v) __builtin_bswap32 (v)
#endif
#if __has_builtin(__builtin_bswap64)
#define BSON_UINT64_SWAP_LE_BE(v) __builtin_bswap64 (v)
#endif
#elif defined(__GNUC__) && (__GNUC__ >= 4)
#if __GNUC__ > 4 || (defined(__GNUC_MINOR__) && __GNUC_MINOR__ >= 3)
#define BSON_UINT32_SWAP_LE_BE(v) __builtin_bswap32 ((uint32_t) v)
#define BSON_UINT64_SWAP_LE_BE(v) __builtin_bswap64 ((uint64_t) v)
#endif
#if __GNUC__ > 4 || (defined(__GNUC_MINOR__) && __GNUC_MINOR__ >= 8)
#define BSON_UINT16_SWAP_LE_BE(v) __builtin_bswap16 ((uint32_t) v)
#endif
#endif
#ifndef BSON_UINT16_SWAP_LE_BE
#define BSON_UINT16_SWAP_LE_BE(v) __bson_uint16_swap_slow ((uint16_t) v)
#endif
#ifndef BSON_UINT32_SWAP_LE_BE
#define BSON_UINT32_SWAP_LE_BE(v) __bson_uint32_swap_slow ((uint32_t) v)
#endif
#ifndef BSON_UINT64_SWAP_LE_BE
#define BSON_UINT64_SWAP_LE_BE(v) __bson_uint64_swap_slow ((uint64_t) v)
#endif
#if BSON_BYTE_ORDER == BSON_LITTLE_ENDIAN
#define BSON_UINT16_FROM_LE(v) ((uint16_t) v)
#define BSON_UINT16_TO_LE(v) ((uint16_t) v)
#define BSON_UINT16_FROM_BE(v) BSON_UINT16_SWAP_LE_BE (v)
#define BSON_UINT16_TO_BE(v) BSON_UINT16_SWAP_LE_BE (v)
#define BSON_UINT32_FROM_LE(v) ((uint32_t) v)
#define BSON_UINT32_TO_LE(v) ((uint32_t) v)
#define BSON_UINT32_FROM_BE(v) BSON_UINT32_SWAP_LE_BE (v)
#define BSON_UINT32_TO_BE(v) BSON_UINT32_SWAP_LE_BE (v)
#define BSON_UINT64_FROM_LE(v) ((uint64_t) v)
#define BSON_UINT64_TO_LE(v) ((uint64_t) v)
#define BSON_UINT64_FROM_BE(v) BSON_UINT64_SWAP_LE_BE (v)
#define BSON_UINT64_TO_BE(v) BSON_UINT64_SWAP_LE_BE (v)
#define BSON_DOUBLE_FROM_LE(v) ((double) v)
#define BSON_DOUBLE_TO_LE(v) ((double) v)
#elif BSON_BYTE_ORDER == BSON_BIG_ENDIAN
#define BSON_UINT16_FROM_LE(v) BSON_UINT16_SWAP_LE_BE (v)
#define BSON_UINT16_TO_LE(v) BSON_UINT16_SWAP_LE_BE (v)
#define BSON_UINT16_FROM_BE(v) ((uint16_t) v)
#define BSON_UINT16_TO_BE(v) ((uint16_t) v)
#define BSON_UINT32_FROM_LE(v) BSON_UINT32_SWAP_LE_BE (v)
#define BSON_UINT32_TO_LE(v) BSON_UINT32_SWAP_LE_BE (v)
#define BSON_UINT32_FROM_BE(v) ((uint32_t) v)
#define BSON_UINT32_TO_BE(v) ((uint32_t) v)
#define BSON_UINT64_FROM_LE(v) BSON_UINT64_SWAP_LE_BE (v)
#define BSON_UINT64_TO_LE(v) BSON_UINT64_SWAP_LE_BE (v)
#define BSON_UINT64_FROM_BE(v) ((uint64_t) v)
#define BSON_UINT64_TO_BE(v) ((uint64_t) v)
#define BSON_DOUBLE_FROM_LE(v) (__bson_double_swap_slow (v))
#define BSON_DOUBLE_TO_LE(v) (__bson_double_swap_slow (v))
#else
#error "The endianness of target architecture is unknown."
#endif
/*
*--------------------------------------------------------------------------
*
* __bson_uint16_swap_slow --
*
* Fallback endianness conversion for 16-bit integers.
*
* Returns:
* The endian swapped version.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
static BSON_INLINE uint16_t
__bson_uint16_swap_slow (uint16_t v) /* IN */
{
return ((v & 0x00FF) << 8) | ((v & 0xFF00) >> 8);
}
/*
*--------------------------------------------------------------------------
*
* __bson_uint32_swap_slow --
*
* Fallback endianness conversion for 32-bit integers.
*
* Returns:
* The endian swapped version.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
static BSON_INLINE uint32_t
__bson_uint32_swap_slow (uint32_t v) /* IN */
{
return ((v & 0x000000FFU) << 24) | ((v & 0x0000FF00U) << 8) |
((v & 0x00FF0000U) >> 8) | ((v & 0xFF000000U) >> 24);
}
/*
*--------------------------------------------------------------------------
*
* __bson_uint64_swap_slow --
*
* Fallback endianness conversion for 64-bit integers.
*
* Returns:
* The endian swapped version.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
static BSON_INLINE uint64_t
__bson_uint64_swap_slow (uint64_t v) /* IN */
{
return ((v & 0x00000000000000FFULL) << 56) |
((v & 0x000000000000FF00ULL) << 40) |
((v & 0x0000000000FF0000ULL) << 24) |
((v & 0x00000000FF000000ULL) << 8) |
((v & 0x000000FF00000000ULL) >> 8) |
((v & 0x0000FF0000000000ULL) >> 24) |
((v & 0x00FF000000000000ULL) >> 40) |
((v & 0xFF00000000000000ULL) >> 56);
}
/*
*--------------------------------------------------------------------------
*
* __bson_double_swap_slow --
*
* Fallback endianness conversion for double floating point.
*
* Returns:
* The endian swapped version.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
BSON_STATIC_ASSERT (sizeof (double) == sizeof (uint64_t));
static BSON_INLINE double
__bson_double_swap_slow (double v) /* IN */
{
uint64_t uv;
memcpy (&uv, &v, sizeof (v));
uv = BSON_UINT64_SWAP_LE_BE (uv);
memcpy (&v, &uv, sizeof (v));
return v;
}
BSON_END_DECLS
#endif /* BSON_ENDIAN_H */
libbson-1.6.1/src/bson/bson-error.c 0000664 0000000 0000000 00000006166 13057346540 0017153 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 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
#include
#include "bson-compat.h"
#include "bson-config.h"
#include "bson-error.h"
#include "bson-memory.h"
#include "bson-string.h"
#include "bson-types.h"
/*
*--------------------------------------------------------------------------
*
* bson_set_error --
*
* Initializes @error using the parameters specified.
*
* @domain is an application specific error domain which should
* describe which module initiated the error. Think of this as the
* exception type.
*
* @code is the @domain specific error code.
*
* @format is used to generate the format string. It uses vsnprintf()
* internally so the format should match what you would use there.
*
* Parameters:
* @error: A #bson_error_t.
* @domain: The error domain.
* @code: The error code.
* @format: A printf style format string.
*
* Returns:
* None.
*
* Side effects:
* @error is initialized.
*
*--------------------------------------------------------------------------
*/
void
bson_set_error (bson_error_t *error, /* OUT */
uint32_t domain, /* IN */
uint32_t code, /* IN */
const char *format, /* IN */
...) /* IN */
{
va_list args;
if (error) {
error->domain = domain;
error->code = code;
va_start (args, format);
bson_vsnprintf (error->message, sizeof error->message, format, args);
va_end (args);
error->message[sizeof error->message - 1] = '\0';
}
}
/*
*--------------------------------------------------------------------------
*
* bson_strerror_r --
*
* This is a reentrant safe macro for strerror.
*
* The resulting string may be stored in @buf.
*
* Returns:
* A pointer to a static string or @buf.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
char *
bson_strerror_r (int err_code, /* IN */
char *buf, /* IN */
size_t buflen) /* IN */
{
static const char *unknown_msg = "Unknown error";
char *ret = NULL;
#if defined(_WIN32)
if (strerror_s (buf, buflen, err_code) != 0) {
ret = buf;
}
#elif defined(__GNUC__) && defined(_GNU_SOURCE)
ret = strerror_r (err_code, buf, buflen);
#else /* XSI strerror_r */
if (strerror_r (err_code, buf, buflen) == 0) {
ret = buf;
}
#endif
if (!ret) {
bson_strncpy (buf, unknown_msg, buflen);
ret = buf;
}
return ret;
}
libbson-1.6.1/src/bson/bson-error.h 0000664 0000000 0000000 00000002136 13057346540 0017151 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 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.
*/
#ifndef BSON_ERROR_H
#define BSON_ERROR_H
#include "bson-compat.h"
#include "bson-macros.h"
#include "bson-types.h"
BSON_BEGIN_DECLS
#define BSON_ERROR_JSON 1
#define BSON_ERROR_READER 2
BSON_EXPORT (void)
bson_set_error (bson_error_t *error,
uint32_t domain,
uint32_t code,
const char *format,
...) BSON_GNUC_PRINTF (4, 5);
BSON_EXPORT (char *)
bson_strerror_r (int err_code, char *buf, size_t buflen);
BSON_END_DECLS
#endif /* BSON_ERROR_H */
libbson-1.6.1/src/bson/bson-iso8601-private.h 0000664 0000000 0000000 00000001700 13057346540 0020575 0 ustar 00root root 0000000 0000000 /*
* Copyright 2014 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.
*/
#ifndef BSON_ISO8601_PRIVATE_H
#define BSON_ISO8601_PRIVATE_H
#include "bson-compat.h"
#include "bson-macros.h"
BSON_BEGIN_DECLS
bool
_bson_iso8601_date_parse (const char *str,
int32_t len,
int64_t *out,
bson_error_t *error);
BSON_END_DECLS
#endif /* BSON_ISO8601_PRIVATE_H */
libbson-1.6.1/src/bson/bson-iso8601.c 0000664 0000000 0000000 00000017136 13057346540 0017132 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 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 "bson-compat.h"
#include "bson-macros.h"
#include "bson-error.h"
#include "bson-iso8601-private.h"
#include "bson-json.h"
#include "bson-timegm-private.h"
static bool
get_tok (const char *terminals,
const char **ptr,
int32_t *remaining,
const char **out,
int32_t *out_len)
{
const char *terminal;
bool found_terminal = false;
if (!*remaining) {
*out = "";
*out_len = 0;
}
*out = *ptr;
*out_len = -1;
for (; *remaining && !found_terminal;
(*ptr)++, (*remaining)--, (*out_len)++) {
for (terminal = terminals; *terminal; terminal++) {
if (**ptr == *terminal) {
found_terminal = true;
break;
}
}
}
if (!found_terminal) {
(*out_len)++;
}
return found_terminal;
}
static bool
digits_only (const char *str, int32_t len)
{
int i;
for (i = 0; i < len; i++) {
if (!isdigit (str[i])) {
return false;
}
}
return true;
}
static bool
parse_num (const char *str,
int32_t len,
int32_t digits,
int32_t min,
int32_t max,
int32_t *out)
{
int i;
int magnitude = 1;
int32_t value = 0;
if ((digits >= 0 && len != digits) || !digits_only (str, len)) {
return false;
}
for (i = 1; i <= len; i++, magnitude *= 10) {
value += (str[len - i] - '0') * magnitude;
}
if (value < min || value > max) {
return false;
}
*out = value;
return true;
}
bool
_bson_iso8601_date_parse (const char *str,
int32_t len,
int64_t *out,
bson_error_t *error)
{
const char *ptr;
int32_t remaining = len;
const char *year_ptr;
const char *month_ptr;
const char *day_ptr;
const char *hour_ptr;
const char *min_ptr;
const char *sec_ptr;
const char *millis_ptr;
const char *tz_ptr;
int32_t year_len = 0;
int32_t month_len = 0;
int32_t day_len = 0;
int32_t hour_len = 0;
int32_t min_len = 0;
int32_t sec_len = 0;
int32_t millis_len = 0;
int32_t tz_len = 0;
int32_t year;
int32_t month;
int32_t day;
int32_t hour;
int32_t min;
int32_t sec = 0;
int64_t millis = 0;
int32_t tz_adjustment = 0;
struct bson_tm posix_date = {0};
#define DATE_PARSE_ERR(msg) \
bson_set_error (error, \
BSON_ERROR_JSON, \
BSON_JSON_ERROR_READ_INVALID_PARAM, \
"Could not parse \"%s\" as date: " msg, \
str); \
return false
#define DEFAULT_DATE_PARSE_ERR \
DATE_PARSE_ERR ("use ISO8601 format yyyy-mm-ddThh:mm plus timezone, either" \
" \"Z\" or like \"+0500\"")
ptr = str;
/* we have to match at least yyyy-mm-ddThh:mm */
if (!(get_tok ("-", &ptr, &remaining, &year_ptr, &year_len) &&
get_tok ("-", &ptr, &remaining, &month_ptr, &month_len) &&
get_tok ("T", &ptr, &remaining, &day_ptr, &day_len) &&
get_tok (":", &ptr, &remaining, &hour_ptr, &hour_len) &&
get_tok (":+-Z", &ptr, &remaining, &min_ptr, &min_len))) {
DEFAULT_DATE_PARSE_ERR;
}
/* if the minute has a ':' at the end look for seconds */
if (min_ptr[min_len] == ':') {
if (remaining < 2) {
DATE_PARSE_ERR ("reached end of date while looking for seconds");
}
get_tok (".+-Z", &ptr, &remaining, &sec_ptr, &sec_len);
if (!sec_len) {
DATE_PARSE_ERR ("minute ends in \":\" seconds is required");
}
}
/* if we had a second and it is followed by a '.' look for milliseconds */
if (sec_len && sec_ptr[sec_len] == '.') {
if (remaining < 2) {
DATE_PARSE_ERR ("reached end of date while looking for milliseconds");
}
get_tok ("+-Z", &ptr, &remaining, &millis_ptr, &millis_len);
if (!millis_len) {
DATE_PARSE_ERR ("seconds ends in \".\", milliseconds is required");
}
}
/* backtrack by 1 to put ptr on the timezone */
ptr--;
remaining++;
get_tok ("", &ptr, &remaining, &tz_ptr, &tz_len);
if (!parse_num (year_ptr, year_len, 4, -9999, 9999, &year)) {
DATE_PARSE_ERR ("year must be an integer");
}
/* values are as in struct tm */
year -= 1900;
if (!parse_num (month_ptr, month_len, 2, 1, 12, &month)) {
DATE_PARSE_ERR ("month must be an integer");
}
/* values are as in struct tm */
month -= 1;
if (!parse_num (day_ptr, day_len, 2, 1, 31, &day)) {
DATE_PARSE_ERR ("day must be an integer");
}
if (!parse_num (hour_ptr, hour_len, 2, 0, 23, &hour)) {
DATE_PARSE_ERR ("hour must be an integer");
}
if (!parse_num (min_ptr, min_len, 2, 0, 59, &min)) {
DATE_PARSE_ERR ("minute must be an integer");
}
if (sec_len && !parse_num (sec_ptr, sec_len, 2, 0, 60, &sec)) {
DATE_PARSE_ERR ("seconds must be an integer");
}
if (tz_len > 0) {
if (tz_ptr[0] == 'Z' && tz_len == 1) {
/* valid */
} else if (tz_ptr[0] == '+' || tz_ptr[0] == '-') {
int32_t tz_hour;
int32_t tz_min;
if (tz_len != 5 || !digits_only (tz_ptr + 1, 4)) {
DATE_PARSE_ERR ("could not parse timezone");
}
if (!parse_num (tz_ptr + 1, 2, -1, -23, 23, &tz_hour)) {
DATE_PARSE_ERR ("timezone hour must be at most 23");
}
if (!parse_num (tz_ptr + 3, 2, -1, 0, 59, &tz_min)) {
DATE_PARSE_ERR ("timezone minute must be at most 59");
}
/* we inflect the meaning of a 'positive' timezone. Those are hours
* we have to substract, and vice versa */
tz_adjustment =
(tz_ptr[0] == '-' ? 1 : -1) * ((tz_min * 60) + (tz_hour * 60 * 60));
if (!(tz_adjustment > -86400 && tz_adjustment < 86400)) {
DATE_PARSE_ERR ("timezone offset must be less than 24 hours");
}
} else {
DATE_PARSE_ERR ("timezone is required");
}
}
if (millis_len > 0) {
int i;
int magnitude;
millis = 0;
if (millis_len > 3 || !digits_only (millis_ptr, millis_len)) {
DATE_PARSE_ERR ("milliseconds must be an integer");
}
for (i = 1, magnitude = 1; i <= millis_len; i++, magnitude *= 10) {
millis += (millis_ptr[millis_len - i] - '0') * magnitude;
}
if (millis_len == 1) {
millis *= 100;
} else if (millis_len == 2) {
millis *= 10;
}
if (millis < 0 || millis > 1000) {
DATE_PARSE_ERR ("milliseconds must be at least 0 and less than 1000");
}
}
posix_date.tm_sec = sec;
posix_date.tm_min = min;
posix_date.tm_hour = hour;
posix_date.tm_mday = day;
posix_date.tm_mon = month;
posix_date.tm_year = year;
posix_date.tm_wday = 0;
posix_date.tm_yday = 0;
millis = 1000 * _bson_timegm (&posix_date) + millis;
millis += tz_adjustment * 1000;
*out = millis;
return true;
}
libbson-1.6.1/src/bson/bson-iter.c 0000664 0000000 0000000 00000155604 13057346540 0016767 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013-2014 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 "bson-iter.h"
#include "bson-config.h"
#include "bson-decimal128.h"
#ifdef HAVE_STRINGS_H
#include
#endif
#define ITER_TYPE(i) ((bson_type_t) * ((i)->raw + (i)->type))
/*
*--------------------------------------------------------------------------
*
* bson_iter_init --
*
* Initializes @iter to be used to iterate @bson.
*
* Returns:
* true if bson_iter_t was initialized. otherwise false.
*
* Side effects:
* @iter is initialized.
*
*--------------------------------------------------------------------------
*/
bool
bson_iter_init (bson_iter_t *iter, /* OUT */
const bson_t *bson) /* IN */
{
BSON_ASSERT (iter);
BSON_ASSERT (bson);
if (BSON_UNLIKELY (bson->len < 5)) {
memset (iter, 0, sizeof *iter);
return false;
}
iter->raw = bson_get_data (bson);
iter->len = bson->len;
iter->off = 0;
iter->type = 0;
iter->key = 0;
iter->d1 = 0;
iter->d2 = 0;
iter->d3 = 0;
iter->d4 = 0;
iter->next_off = 4;
iter->err_off = 0;
return true;
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_recurse --
*
* Creates a new sub-iter looking at the document or array that @iter
* is currently pointing at.
*
* Returns:
* true if successful and @child was initialized.
*
* Side effects:
* @child is initialized.
*
*--------------------------------------------------------------------------
*/
bool
bson_iter_recurse (const bson_iter_t *iter, /* IN */
bson_iter_t *child) /* OUT */
{
const uint8_t *data = NULL;
uint32_t len = 0;
BSON_ASSERT (iter);
BSON_ASSERT (child);
if (ITER_TYPE (iter) == BSON_TYPE_DOCUMENT) {
bson_iter_document (iter, &len, &data);
} else if (ITER_TYPE (iter) == BSON_TYPE_ARRAY) {
bson_iter_array (iter, &len, &data);
} else {
return false;
}
child->raw = data;
child->len = len;
child->off = 0;
child->type = 0;
child->key = 0;
child->d1 = 0;
child->d2 = 0;
child->d3 = 0;
child->d4 = 0;
child->next_off = 4;
child->err_off = 0;
return true;
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_init_find --
*
* Initializes a #bson_iter_t and moves the iter to the first field
* matching @key.
*
* Returns:
* true if the field named @key was found; otherwise false.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
bool
bson_iter_init_find (bson_iter_t *iter, /* INOUT */
const bson_t *bson, /* IN */
const char *key) /* IN */
{
BSON_ASSERT (iter);
BSON_ASSERT (bson);
BSON_ASSERT (key);
return bson_iter_init (iter, bson) && bson_iter_find (iter, key);
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_init_find_case --
*
* A case-insensitive version of bson_iter_init_find().
*
* Returns:
* true if the field was found and @iter is observing that field.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
bool
bson_iter_init_find_case (bson_iter_t *iter, /* INOUT */
const bson_t *bson, /* IN */
const char *key) /* IN */
{
BSON_ASSERT (iter);
BSON_ASSERT (bson);
BSON_ASSERT (key);
return bson_iter_init (iter, bson) && bson_iter_find_case (iter, key);
}
/*
*--------------------------------------------------------------------------
*
* _bson_iter_find_with_len --
*
* Internal helper for finding an exact key.
*
* Returns:
* true if the field @key was found.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
static bool
_bson_iter_find_with_len (bson_iter_t *iter, /* INOUT */
const char *key, /* IN */
int keylen) /* IN */
{
const char *ikey;
if (keylen == 0) {
return false;
}
if (keylen < 0) {
keylen = (int) strlen (key);
}
while (bson_iter_next (iter)) {
ikey = bson_iter_key (iter);
if ((0 == strncmp (key, ikey, keylen)) && (ikey[keylen] == '\0')) {
return true;
}
}
return false;
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_find --
*
* Searches through @iter starting from the current position for a key
* matching @key. This is a case-sensitive search meaning "KEY" and
* "key" would NOT match.
*
* Returns:
* true if @key is found.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
bool
bson_iter_find (bson_iter_t *iter, /* INOUT */
const char *key) /* IN */
{
BSON_ASSERT (iter);
BSON_ASSERT (key);
return _bson_iter_find_with_len (iter, key, -1);
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_find_case --
*
* Searches through @iter starting from the current position for a key
* matching @key. This is a case-insensitive search meaning "KEY" and
* "key" would match.
*
* Returns:
* true if @key is found.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
bool
bson_iter_find_case (bson_iter_t *iter, /* INOUT */
const char *key) /* IN */
{
BSON_ASSERT (iter);
BSON_ASSERT (key);
while (bson_iter_next (iter)) {
#ifdef BSON_OS_WIN32
if (!_stricmp (key, bson_iter_key (iter))) {
#else
if (!strcasecmp (key, bson_iter_key (iter))) {
#endif
return true;
}
}
return false;
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_find_descendant --
*
* Locates a descendant using the "parent.child.key" notation. This
* operates similar to bson_iter_find() except that it can recurse
* into children documents using the dot notation.
*
* Returns:
* true if the descendant was found and @descendant was initialized.
*
* Side effects:
* @descendant may be initialized.
*
*--------------------------------------------------------------------------
*/
bool
bson_iter_find_descendant (bson_iter_t *iter, /* INOUT */
const char *dotkey, /* IN */
bson_iter_t *descendant) /* OUT */
{
bson_iter_t tmp;
const char *dot;
size_t sublen;
BSON_ASSERT (iter);
BSON_ASSERT (dotkey);
BSON_ASSERT (descendant);
if ((dot = strchr (dotkey, '.'))) {
sublen = dot - dotkey;
} else {
sublen = strlen (dotkey);
}
if (_bson_iter_find_with_len (iter, dotkey, (int) sublen)) {
if (!dot) {
*descendant = *iter;
return true;
}
if (BSON_ITER_HOLDS_DOCUMENT (iter) || BSON_ITER_HOLDS_ARRAY (iter)) {
if (bson_iter_recurse (iter, &tmp)) {
return bson_iter_find_descendant (&tmp, dot + 1, descendant);
}
}
}
return false;
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_key --
*
* Retrieves the key of the current field. The resulting key is valid
* while @iter is valid.
*
* Returns:
* A string that should not be modified or freed.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
const char *
bson_iter_key (const bson_iter_t *iter) /* IN */
{
BSON_ASSERT (iter);
return bson_iter_key_unsafe (iter);
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_type --
*
* Retrieves the type of the current field. It may be useful to check
* the type using the BSON_ITER_HOLDS_*() macros.
*
* Returns:
* A bson_type_t.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
bson_type_t
bson_iter_type (const bson_iter_t *iter) /* IN */
{
BSON_ASSERT (iter);
BSON_ASSERT (iter->raw);
BSON_ASSERT (iter->len);
return bson_iter_type_unsafe (iter);
}
/*
*--------------------------------------------------------------------------
*
* _bson_iter_next_internal --
*
* Internal function to advance @iter to the next field and retrieve
* the key and BSON type before error-checking.
*
* Return:
* true if an element was decoded, else false.
*
* Side effects:
* @key and @bson_type are set.
*
* If the return value is false:
* - @iter is invalidated: @iter->raw is NULLed
* - @unsupported is set to true if the bson type is unsupported
* - otherwise if the BSON is corrupt, @iter->err_off is nonzero
* - otherwise @bson_type is set to BSON_TYPE_EOD
*
*--------------------------------------------------------------------------
*/
static bool
_bson_iter_next_internal (bson_iter_t *iter, /* INOUT */
const char **key, /* OUT */
uint32_t *bson_type, /* OUT */
bool *unsupported) /* OUT */
{
const uint8_t *data;
uint32_t o;
unsigned int len;
BSON_ASSERT (iter);
*unsupported = false;
if (!iter->raw) {
*key = NULL;
*bson_type = BSON_TYPE_EOD;
return false;
}
data = iter->raw;
len = iter->len;
iter->off = iter->next_off;
iter->type = iter->off;
iter->key = iter->off + 1;
iter->d1 = 0;
iter->d2 = 0;
iter->d3 = 0;
iter->d4 = 0;
/* iterate from start to end of NULL-terminated key string */
for (o = iter->off + 1; o < len; o++) {
if (!data[o]) {
iter->d1 = ++o;
goto fill_data_fields;
}
}
goto mark_invalid;
fill_data_fields:
*key = bson_iter_key_unsafe (iter);
*bson_type = ITER_TYPE (iter);
switch (*bson_type) {
case BSON_TYPE_DATE_TIME:
case BSON_TYPE_DOUBLE:
case BSON_TYPE_INT64:
case BSON_TYPE_TIMESTAMP:
iter->next_off = o + 8;
break;
case BSON_TYPE_CODE:
case BSON_TYPE_SYMBOL:
case BSON_TYPE_UTF8: {
uint32_t l;
if ((o + 4) >= len) {
iter->err_off = o;
goto mark_invalid;
}
iter->d2 = o + 4;
memcpy (&l, iter->raw + iter->d1, sizeof (l));
l = BSON_UINT32_FROM_LE (l);
if (l > (len - (o + 4))) {
iter->err_off = o;
goto mark_invalid;
}
iter->next_off = o + 4 + l;
/*
* Make sure the string length includes the NUL byte.
*/
if (BSON_UNLIKELY ((l == 0) || (iter->next_off >= len))) {
iter->err_off = o;
goto mark_invalid;
}
/*
* Make sure the last byte is a NUL byte.
*/
if (BSON_UNLIKELY ((iter->raw + iter->d2)[l - 1] != '\0')) {
iter->err_off = o + 4 + l - 1;
goto mark_invalid;
}
} break;
case BSON_TYPE_BINARY: {
bson_subtype_t subtype;
uint32_t l;
if (o >= (len - 4)) {
iter->err_off = o;
goto mark_invalid;
}
iter->d2 = o + 4;
iter->d3 = o + 5;
memcpy (&l, iter->raw + iter->d1, sizeof (l));
l = BSON_UINT32_FROM_LE (l);
if (l >= (len - o)) {
iter->err_off = o;
goto mark_invalid;
}
subtype = *(iter->raw + iter->d2);
if (subtype == BSON_SUBTYPE_BINARY_DEPRECATED) {
int32_t binary_len;
if (l < 4) {
iter->err_off = o;
goto mark_invalid;
}
/* subtype 2 has a redundant length header in the data */
memcpy (&binary_len, (iter->raw + iter->d3), sizeof (binary_len));
binary_len = BSON_UINT32_FROM_LE (binary_len);
if (binary_len + 4 != l) {
iter->err_off = iter->d3;
goto mark_invalid;
}
}
iter->next_off = o + 5 + l;
} break;
case BSON_TYPE_ARRAY:
case BSON_TYPE_DOCUMENT: {
uint32_t l;
if (o >= (len - 4)) {
iter->err_off = o;
goto mark_invalid;
}
memcpy (&l, iter->raw + iter->d1, sizeof (l));
l = BSON_UINT32_FROM_LE (l);
if ((l > len) || (l > (len - o))) {
iter->err_off = o;
goto mark_invalid;
}
iter->next_off = o + l;
} break;
case BSON_TYPE_OID:
iter->next_off = o + 12;
break;
case BSON_TYPE_BOOL: {
char val;
if (iter->d1 >= len) {
iter->err_off = o;
goto mark_invalid;
}
memcpy (&val, iter->raw + iter->d1, 1);
if (val != 0x00 && val != 0x01) {
iter->err_off = o;
goto mark_invalid;
}
iter->next_off = o + 1;
} break;
case BSON_TYPE_REGEX: {
bool eor = false;
bool eoo = false;
for (; o < len; o++) {
if (!data[o]) {
iter->d2 = ++o;
eor = true;
break;
}
}
if (!eor) {
iter->err_off = iter->next_off;
goto mark_invalid;
}
for (; o < len; o++) {
if (!data[o]) {
eoo = true;
break;
}
}
if (!eoo) {
iter->err_off = iter->next_off;
goto mark_invalid;
}
iter->next_off = o + 1;
} break;
case BSON_TYPE_DBPOINTER: {
uint32_t l;
if (o >= (len - 4)) {
iter->err_off = o;
goto mark_invalid;
}
iter->d2 = o + 4;
memcpy (&l, iter->raw + iter->d1, sizeof (l));
l = BSON_UINT32_FROM_LE (l);
if ((l > len) || (l > (len - o))) {
iter->err_off = o;
goto mark_invalid;
}
if (*(iter->raw + o + l + 3)) {
/* not null terminated */
iter->err_off = o + l + 3;
goto mark_invalid;
}
iter->d3 = o + 4 + l;
iter->next_off = o + 4 + l + 12;
} break;
case BSON_TYPE_CODEWSCOPE: {
uint32_t l;
uint32_t doclen;
if ((len < 19) || (o >= (len - 14))) {
iter->err_off = o;
goto mark_invalid;
}
iter->d2 = o + 4;
iter->d3 = o + 8;
memcpy (&l, iter->raw + iter->d1, sizeof (l));
l = BSON_UINT32_FROM_LE (l);
if ((l < 14) || (l >= (len - o))) {
iter->err_off = o;
goto mark_invalid;
}
iter->next_off = o + l;
if (iter->next_off >= len) {
iter->err_off = o;
goto mark_invalid;
}
memcpy (&l, iter->raw + iter->d2, sizeof (l));
l = BSON_UINT32_FROM_LE (l);
if (l >= (len - o - 4 - 4)) {
iter->err_off = o;
goto mark_invalid;
}
if ((o + 4 + 4 + l + 4) >= iter->next_off) {
iter->err_off = o + 4;
goto mark_invalid;
}
iter->d4 = o + 4 + 4 + l;
memcpy (&doclen, iter->raw + iter->d4, sizeof (doclen));
doclen = BSON_UINT32_FROM_LE (doclen);
if ((o + 4 + 4 + l + doclen) != iter->next_off) {
iter->err_off = o + 4 + 4 + l;
goto mark_invalid;
}
} break;
case BSON_TYPE_INT32:
iter->next_off = o + 4;
break;
case BSON_TYPE_DECIMAL128:
iter->next_off = o + 16;
break;
case BSON_TYPE_MAXKEY:
case BSON_TYPE_MINKEY:
case BSON_TYPE_NULL:
case BSON_TYPE_UNDEFINED:
iter->d1 = -1;
iter->next_off = o;
break;
default:
*unsupported = true;
/* FALL THROUGH */
case BSON_TYPE_EOD:
iter->err_off = o;
goto mark_invalid;
}
/*
* Check to see if any of the field locations would overflow the
* current BSON buffer. If so, set the error location to the offset
* of where the field starts.
*/
if (iter->next_off >= len) {
iter->err_off = o;
goto mark_invalid;
}
iter->err_off = 0;
return true;
mark_invalid:
iter->raw = NULL;
iter->len = 0;
iter->next_off = 0;
return false;
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_next --
*
* Advances @iter to the next field of the underlying BSON document.
* If all fields have been exhausted, then %false is returned.
*
* It is a programming error to use @iter after this function has
* returned false.
*
* Returns:
* true if the iter was advanced to the next record.
* otherwise false and @iter should be considered invalid.
*
* Side effects:
* @iter may be invalidated.
*
*--------------------------------------------------------------------------
*/
bool
bson_iter_next (bson_iter_t *iter) /* INOUT */
{
uint32_t bson_type;
const char *key;
bool unsupported;
return _bson_iter_next_internal (iter, &key, &bson_type, &unsupported);
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_binary --
*
* Retrieves the BSON_TYPE_BINARY field. The subtype is stored in
* @subtype. The length of @binary in bytes is stored in @binary_len.
*
* @binary should not be modified or freed and is only valid while
* @iter's bson_t is valid and unmodified.
*
* Parameters:
* @iter: A bson_iter_t
* @subtype: A location for the binary subtype.
* @binary_len: A location for the length of @binary.
* @binary: A location for a pointer to the binary data.
*
* Returns:
* None.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
void
bson_iter_binary (const bson_iter_t *iter, /* IN */
bson_subtype_t *subtype, /* OUT */
uint32_t *binary_len, /* OUT */
const uint8_t **binary) /* OUT */
{
bson_subtype_t backup;
BSON_ASSERT (iter);
BSON_ASSERT (!binary || binary_len);
if (ITER_TYPE (iter) == BSON_TYPE_BINARY) {
if (!subtype) {
subtype = &backup;
}
*subtype = (bson_subtype_t) * (iter->raw + iter->d2);
if (binary) {
memcpy (binary_len, (iter->raw + iter->d1), sizeof (*binary_len));
*binary_len = BSON_UINT32_FROM_LE (*binary_len);
*binary = iter->raw + iter->d3;
if (*subtype == BSON_SUBTYPE_BINARY_DEPRECATED) {
*binary_len -= sizeof (int32_t);
*binary += sizeof (int32_t);
}
}
return;
}
if (binary) {
*binary = NULL;
}
if (binary_len) {
*binary_len = 0;
}
if (subtype) {
*subtype = BSON_SUBTYPE_BINARY;
}
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_bool --
*
* Retrieves the current field of type BSON_TYPE_BOOL.
*
* Returns:
* true or false, dependent on bson document.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
bool
bson_iter_bool (const bson_iter_t *iter) /* IN */
{
BSON_ASSERT (iter);
if (ITER_TYPE (iter) == BSON_TYPE_BOOL) {
return bson_iter_bool_unsafe (iter);
}
return false;
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_as_bool --
*
* If @iter is on a boolean field, returns the boolean. If it is on a
* non-boolean field such as int32, int64, or double, it will convert
* the value to a boolean.
*
* Zero is false, and non-zero is true.
*
* Returns:
* true or false, dependent on field type.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
bool
bson_iter_as_bool (const bson_iter_t *iter) /* IN */
{
BSON_ASSERT (iter);
switch ((int) ITER_TYPE (iter)) {
case BSON_TYPE_BOOL:
return bson_iter_bool (iter);
case BSON_TYPE_DOUBLE:
return !(bson_iter_double (iter) == 0.0);
case BSON_TYPE_INT64:
return !(bson_iter_int64 (iter) == 0);
case BSON_TYPE_INT32:
return !(bson_iter_int32 (iter) == 0);
case BSON_TYPE_UTF8:
return true;
case BSON_TYPE_NULL:
case BSON_TYPE_UNDEFINED:
return false;
default:
return true;
}
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_double --
*
* Retrieves the current field of type BSON_TYPE_DOUBLE.
*
* Returns:
* A double.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
double
bson_iter_double (const bson_iter_t *iter) /* IN */
{
BSON_ASSERT (iter);
if (ITER_TYPE (iter) == BSON_TYPE_DOUBLE) {
return bson_iter_double_unsafe (iter);
}
return 0;
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_int32 --
*
* Retrieves the value of the field of type BSON_TYPE_INT32.
*
* Returns:
* A 32-bit signed integer.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
int32_t
bson_iter_int32 (const bson_iter_t *iter) /* IN */
{
BSON_ASSERT (iter);
if (ITER_TYPE (iter) == BSON_TYPE_INT32) {
return bson_iter_int32_unsafe (iter);
}
return 0;
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_int64 --
*
* Retrieves a 64-bit signed integer for the current BSON_TYPE_INT64
* field.
*
* Returns:
* A 64-bit signed integer.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
int64_t
bson_iter_int64 (const bson_iter_t *iter) /* IN */
{
BSON_ASSERT (iter);
if (ITER_TYPE (iter) == BSON_TYPE_INT64) {
return bson_iter_int64_unsafe (iter);
}
return 0;
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_as_int64 --
*
* If @iter is not an int64 field, it will try to convert the value to
* an int64. Such field types include:
*
* - bool
* - double
* - int32
*
* Returns:
* An int64_t.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
int64_t
bson_iter_as_int64 (const bson_iter_t *iter) /* IN */
{
BSON_ASSERT (iter);
switch ((int) ITER_TYPE (iter)) {
case BSON_TYPE_BOOL:
return (int64_t) bson_iter_bool (iter);
case BSON_TYPE_DOUBLE:
return (int64_t) bson_iter_double (iter);
case BSON_TYPE_INT64:
return bson_iter_int64 (iter);
case BSON_TYPE_INT32:
return (int64_t) bson_iter_int32 (iter);
default:
return 0;
}
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_decimal128 --
*
* This function retrieves the current field of type
*%BSON_TYPE_DECIMAL128.
* The result is valid while @iter is valid, and is stored in @dec.
*
* Returns:
*
* True on success, false on failure.
*
* Side Effects:
* None.
*
*--------------------------------------------------------------------------
*/
bool
bson_iter_decimal128 (const bson_iter_t *iter, /* IN */
bson_decimal128_t *dec) /* OUT */
{
BSON_ASSERT (iter);
if (ITER_TYPE (iter) == BSON_TYPE_DECIMAL128) {
bson_iter_decimal128_unsafe (iter, dec);
return true;
}
return false;
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_oid --
*
* Retrieves the current field of type %BSON_TYPE_OID. The result is
* valid while @iter is valid.
*
* Returns:
* A bson_oid_t that should not be modified or freed.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
const bson_oid_t *
bson_iter_oid (const bson_iter_t *iter) /* IN */
{
BSON_ASSERT (iter);
if (ITER_TYPE (iter) == BSON_TYPE_OID) {
return bson_iter_oid_unsafe (iter);
}
return NULL;
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_regex --
*
* Fetches the current field from the iter which should be of type
* BSON_TYPE_REGEX.
*
* Returns:
* Regex from @iter. This should not be modified or freed.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
const char *
bson_iter_regex (const bson_iter_t *iter, /* IN */
const char **options) /* IN */
{
const char *ret = NULL;
const char *ret_options = NULL;
BSON_ASSERT (iter);
if (ITER_TYPE (iter) == BSON_TYPE_REGEX) {
ret = (const char *) (iter->raw + iter->d1);
ret_options = (const char *) (iter->raw + iter->d2);
}
if (options) {
*options = ret_options;
}
return ret;
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_utf8 --
*
* Retrieves the current field of type %BSON_TYPE_UTF8 as a UTF-8
* encoded string.
*
* Parameters:
* @iter: A bson_iter_t.
* @length: A location for the length of the string.
*
* Returns:
* A string that should not be modified or freed.
*
* Side effects:
* @length will be set to the result strings length if non-NULL.
*
*--------------------------------------------------------------------------
*/
const char *
bson_iter_utf8 (const bson_iter_t *iter, /* IN */
uint32_t *length) /* OUT */
{
BSON_ASSERT (iter);
if (ITER_TYPE (iter) == BSON_TYPE_UTF8) {
if (length) {
*length = bson_iter_utf8_len_unsafe (iter);
}
return (const char *) (iter->raw + iter->d2);
}
if (length) {
*length = 0;
}
return NULL;
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_dup_utf8 --
*
* Copies the current UTF-8 element into a newly allocated string. The
* string should be freed using bson_free() when the caller is
* finished with it.
*
* Returns:
* A newly allocated char* that should be freed with bson_free().
*
* Side effects:
* @length will be set to the result strings length if non-NULL.
*
*--------------------------------------------------------------------------
*/
char *
bson_iter_dup_utf8 (const bson_iter_t *iter, /* IN */
uint32_t *length) /* OUT */
{
uint32_t local_length = 0;
const char *str;
char *ret = NULL;
BSON_ASSERT (iter);
if ((str = bson_iter_utf8 (iter, &local_length))) {
ret = bson_malloc0 (local_length + 1);
memcpy (ret, str, local_length);
ret[local_length] = '\0';
}
if (length) {
*length = local_length;
}
return ret;
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_code --
*
* Retrieves the current field of type %BSON_TYPE_CODE. The length of
* the resulting string is stored in @length.
*
* Parameters:
* @iter: A bson_iter_t.
* @length: A location for the code length.
*
* Returns:
* A NUL-terminated string containing the code which should not be
* modified or freed.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
const char *
bson_iter_code (const bson_iter_t *iter, /* IN */
uint32_t *length) /* OUT */
{
BSON_ASSERT (iter);
if (ITER_TYPE (iter) == BSON_TYPE_CODE) {
if (length) {
*length = bson_iter_utf8_len_unsafe (iter);
}
return (const char *) (iter->raw + iter->d2);
}
if (length) {
*length = 0;
}
return NULL;
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_codewscope --
*
* Similar to bson_iter_code() but with a scope associated encoded as
* a BSON document. @scope should not be modified or freed. It is
* valid while @iter is valid.
*
* Parameters:
* @iter: A #bson_iter_t.
* @length: A location for the length of resulting string.
* @scope_len: A location for the length of @scope.
* @scope: A location for the scope encoded as BSON.
*
* Returns:
* A NUL-terminated string that should not be modified or freed.
*
* Side effects:
* @length is set to the resulting string length in bytes.
* @scope_len is set to the length of @scope in bytes.
* @scope is set to the scope documents buffer which can be
* turned into a bson document with bson_init_static().
*
*--------------------------------------------------------------------------
*/
const char *
bson_iter_codewscope (const bson_iter_t *iter, /* IN */
uint32_t *length, /* OUT */
uint32_t *scope_len, /* OUT */
const uint8_t **scope) /* OUT */
{
uint32_t len;
BSON_ASSERT (iter);
if (ITER_TYPE (iter) == BSON_TYPE_CODEWSCOPE) {
if (length) {
memcpy (&len, iter->raw + iter->d2, sizeof (len));
*length = BSON_UINT32_FROM_LE (len) - 1;
}
memcpy (&len, iter->raw + iter->d4, sizeof (len));
*scope_len = BSON_UINT32_FROM_LE (len);
*scope = iter->raw + iter->d4;
return (const char *) (iter->raw + iter->d3);
}
if (length) {
*length = 0;
}
if (scope_len) {
*scope_len = 0;
}
if (scope) {
*scope = NULL;
}
return NULL;
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_dbpointer --
*
* Retrieves a BSON_TYPE_DBPOINTER field. @collection_len will be set
* to the length of the collection name. The collection name will be
* placed into @collection. The oid will be placed into @oid.
*
* @collection and @oid should not be modified.
*
* Parameters:
* @iter: A #bson_iter_t.
* @collection_len: A location for the length of @collection.
* @collection: A location for the collection name.
* @oid: A location for the oid.
*
* Returns:
* None.
*
* Side effects:
* @collection_len is set to the length of @collection in bytes
* excluding the null byte.
* @collection is set to the collection name, including a terminating
* null byte.
* @oid is initialized with the oid.
*
*--------------------------------------------------------------------------
*/
void
bson_iter_dbpointer (const bson_iter_t *iter, /* IN */
uint32_t *collection_len, /* OUT */
const char **collection, /* OUT */
const bson_oid_t **oid) /* OUT */
{
BSON_ASSERT (iter);
if (collection) {
*collection = NULL;
}
if (oid) {
*oid = NULL;
}
if (ITER_TYPE (iter) == BSON_TYPE_DBPOINTER) {
if (collection_len) {
memcpy (
collection_len, (iter->raw + iter->d1), sizeof (*collection_len));
*collection_len = BSON_UINT32_FROM_LE (*collection_len);
if ((*collection_len) > 0) {
(*collection_len)--;
}
}
if (collection) {
*collection = (const char *) (iter->raw + iter->d2);
}
if (oid) {
*oid = (const bson_oid_t *) (iter->raw + iter->d3);
}
}
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_symbol --
*
* Retrieves the symbol of the current field of type BSON_TYPE_SYMBOL.
*
* Parameters:
* @iter: A bson_iter_t.
* @length: A location for the length of the symbol.
*
* Returns:
* A string containing the symbol as UTF-8. The value should not be
* modified or freed.
*
* Side effects:
* @length is set to the resulting strings length in bytes,
* excluding the null byte.
*
*--------------------------------------------------------------------------
*/
const char *
bson_iter_symbol (const bson_iter_t *iter, /* IN */
uint32_t *length) /* OUT */
{
const char *ret = NULL;
uint32_t ret_length = 0;
BSON_ASSERT (iter);
if (ITER_TYPE (iter) == BSON_TYPE_SYMBOL) {
ret = (const char *) (iter->raw + iter->d2);
ret_length = bson_iter_utf8_len_unsafe (iter);
}
if (length) {
*length = ret_length;
}
return ret;
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_date_time --
*
* Fetches the number of milliseconds elapsed since the UNIX epoch.
* This value can be negative as times before 1970 are valid.
*
* Returns:
* A signed 64-bit integer containing the number of milliseconds.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
int64_t
bson_iter_date_time (const bson_iter_t *iter) /* IN */
{
BSON_ASSERT (iter);
if (ITER_TYPE (iter) == BSON_TYPE_DATE_TIME) {
return bson_iter_int64_unsafe (iter);
}
return 0;
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_time_t --
*
* Retrieves the current field of type BSON_TYPE_DATE_TIME as a
* time_t.
*
* Returns:
* A #time_t of the number of seconds since UNIX epoch in UTC.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
time_t
bson_iter_time_t (const bson_iter_t *iter) /* IN */
{
BSON_ASSERT (iter);
if (ITER_TYPE (iter) == BSON_TYPE_DATE_TIME) {
return bson_iter_time_t_unsafe (iter);
}
return 0;
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_timestamp --
*
* Fetches the current field if it is a BSON_TYPE_TIMESTAMP.
*
* Parameters:
* @iter: A #bson_iter_t.
* @timestamp: a location for the timestamp.
* @increment: A location for the increment.
*
* Returns:
* None.
*
* Side effects:
* @timestamp is initialized.
* @increment is initialized.
*
*--------------------------------------------------------------------------
*/
void
bson_iter_timestamp (const bson_iter_t *iter, /* IN */
uint32_t *timestamp, /* OUT */
uint32_t *increment) /* OUT */
{
uint64_t encoded;
uint32_t ret_timestamp = 0;
uint32_t ret_increment = 0;
BSON_ASSERT (iter);
if (ITER_TYPE (iter) == BSON_TYPE_TIMESTAMP) {
memcpy (&encoded, iter->raw + iter->d1, sizeof (encoded));
encoded = BSON_UINT64_FROM_LE (encoded);
ret_timestamp = (encoded >> 32) & 0xFFFFFFFF;
ret_increment = encoded & 0xFFFFFFFF;
}
if (timestamp) {
*timestamp = ret_timestamp;
}
if (increment) {
*increment = ret_increment;
}
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_timeval --
*
* Retrieves the current field of type BSON_TYPE_DATE_TIME and stores
* it into the struct timeval provided. tv->tv_sec is set to the
* number of seconds since the UNIX epoch in UTC.
*
* Since BSON_TYPE_DATE_TIME does not support fractions of a second,
* tv->tv_usec will always be set to zero.
*
* Returns:
* None.
*
* Side effects:
* @tv is initialized.
*
*--------------------------------------------------------------------------
*/
void
bson_iter_timeval (const bson_iter_t *iter, /* IN */
struct timeval *tv) /* OUT */
{
BSON_ASSERT (iter);
if (ITER_TYPE (iter) == BSON_TYPE_DATE_TIME) {
bson_iter_timeval_unsafe (iter, tv);
return;
}
memset (tv, 0, sizeof *tv);
}
/**
* bson_iter_document:
* @iter: a bson_iter_t.
* @document_len: A location for the document length.
* @document: A location for a pointer to the document buffer.
*
*/
/*
*--------------------------------------------------------------------------
*
* bson_iter_document --
*
* Retrieves the data to the document BSON structure and stores the
* length of the document buffer in @document_len and the document
* buffer in @document.
*
* If you would like to iterate over the child contents, you might
* consider creating a bson_t on the stack such as the following. It
* allows you to call functions taking a const bson_t* only.
*
* bson_t b;
* uint32_t len;
* const uint8_t *data;
*
* bson_iter_document(iter, &len, &data);
*
* if (bson_init_static (&b, data, len)) {
* ...
* }
*
* There is no need to cleanup the bson_t structure as no data can be
* modified in the process of its use (as it is static/const).
*
* Returns:
* None.
*
* Side effects:
* @document_len is initialized.
* @document is initialized.
*
*--------------------------------------------------------------------------
*/
void
bson_iter_document (const bson_iter_t *iter, /* IN */
uint32_t *document_len, /* OUT */
const uint8_t **document) /* OUT */
{
BSON_ASSERT (iter);
BSON_ASSERT (document_len);
BSON_ASSERT (document);
*document = NULL;
*document_len = 0;
if (ITER_TYPE (iter) == BSON_TYPE_DOCUMENT) {
memcpy (document_len, (iter->raw + iter->d1), sizeof (*document_len));
*document_len = BSON_UINT32_FROM_LE (*document_len);
*document = (iter->raw + iter->d1);
}
}
/**
* bson_iter_array:
* @iter: a #bson_iter_t.
* @array_len: A location for the array length.
* @array: A location for a pointer to the array buffer.
*/
/*
*--------------------------------------------------------------------------
*
* bson_iter_array --
*
* Retrieves the data to the array BSON structure and stores the
* length of the array buffer in @array_len and the array buffer in
* @array.
*
* If you would like to iterate over the child contents, you might
* consider creating a bson_t on the stack such as the following. It
* allows you to call functions taking a const bson_t* only.
*
* bson_t b;
* uint32_t len;
* const uint8_t *data;
*
* bson_iter_array (iter, &len, &data);
*
* if (bson_init_static (&b, data, len)) {
* ...
* }
*
* There is no need to cleanup the #bson_t structure as no data can be
* modified in the process of its use.
*
* Returns:
* None.
*
* Side effects:
* @array_len is initialized.
* @array is initialized.
*
*--------------------------------------------------------------------------
*/
void
bson_iter_array (const bson_iter_t *iter, /* IN */
uint32_t *array_len, /* OUT */
const uint8_t **array) /* OUT */
{
BSON_ASSERT (iter);
BSON_ASSERT (array_len);
BSON_ASSERT (array);
*array = NULL;
*array_len = 0;
if (ITER_TYPE (iter) == BSON_TYPE_ARRAY) {
memcpy (array_len, (iter->raw + iter->d1), sizeof (*array_len));
*array_len = BSON_UINT32_FROM_LE (*array_len);
*array = (iter->raw + iter->d1);
}
}
#define VISIT_FIELD(name) visitor->visit_##name && visitor->visit_##name
#define VISIT_AFTER VISIT_FIELD (after)
#define VISIT_BEFORE VISIT_FIELD (before)
#define VISIT_CORRUPT \
if (visitor->visit_corrupt) \
visitor->visit_corrupt
#define VISIT_DOUBLE VISIT_FIELD (double)
#define VISIT_UTF8 VISIT_FIELD (utf8)
#define VISIT_DOCUMENT VISIT_FIELD (document)
#define VISIT_ARRAY VISIT_FIELD (array)
#define VISIT_BINARY VISIT_FIELD (binary)
#define VISIT_UNDEFINED VISIT_FIELD (undefined)
#define VISIT_OID VISIT_FIELD (oid)
#define VISIT_BOOL VISIT_FIELD (bool)
#define VISIT_DATE_TIME VISIT_FIELD (date_time)
#define VISIT_NULL VISIT_FIELD (null)
#define VISIT_REGEX VISIT_FIELD (regex)
#define VISIT_DBPOINTER VISIT_FIELD (dbpointer)
#define VISIT_CODE VISIT_FIELD (code)
#define VISIT_SYMBOL VISIT_FIELD (symbol)
#define VISIT_CODEWSCOPE VISIT_FIELD (codewscope)
#define VISIT_INT32 VISIT_FIELD (int32)
#define VISIT_TIMESTAMP VISIT_FIELD (timestamp)
#define VISIT_INT64 VISIT_FIELD (int64)
#define VISIT_DECIMAL128 VISIT_FIELD (decimal128)
#define VISIT_MAXKEY VISIT_FIELD (maxkey)
#define VISIT_MINKEY VISIT_FIELD (minkey)
/**
* bson_iter_visit_all:
* @iter: A #bson_iter_t.
* @visitor: A #bson_visitor_t containing the visitors.
* @data: User data for @visitor data parameters.
*
*
* Returns: true if the visitor was pre-maturely ended; otherwise false.
*/
/*
*--------------------------------------------------------------------------
*
* bson_iter_visit_all --
*
* Visits all fields forward from the current position of @iter. For
* each field found a function in @visitor will be called. Typically
* you will use this immediately after initializing a bson_iter_t.
*
* bson_iter_init (&iter, b);
* bson_iter_visit_all (&iter, my_visitor, NULL);
*
* @iter will no longer be valid after this function has executed and
* will need to be reinitialized if intending to reuse.
*
* Returns:
* true if successfully visited all fields or callback requested
* early termination, otherwise false.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
bool
bson_iter_visit_all (bson_iter_t *iter, /* INOUT */
const bson_visitor_t *visitor, /* IN */
void *data) /* IN */
{
uint32_t bson_type;
const char *key;
bool unsupported;
BSON_ASSERT (iter);
BSON_ASSERT (visitor);
while (_bson_iter_next_internal (iter, &key, &bson_type, &unsupported)) {
if (*key && !bson_utf8_validate (key, strlen (key), false)) {
iter->err_off = iter->off;
break;
}
if (VISIT_BEFORE (iter, key, data)) {
return true;
}
switch (bson_type) {
case BSON_TYPE_DOUBLE:
if (VISIT_DOUBLE (iter, key, bson_iter_double (iter), data)) {
return true;
}
break;
case BSON_TYPE_UTF8: {
uint32_t utf8_len;
const char *utf8;
utf8 = bson_iter_utf8 (iter, &utf8_len);
if (!bson_utf8_validate (utf8, utf8_len, true)) {
iter->err_off = iter->off;
return true;
}
if (VISIT_UTF8 (iter, key, utf8_len, utf8, data)) {
return true;
}
} break;
case BSON_TYPE_DOCUMENT: {
const uint8_t *docbuf = NULL;
uint32_t doclen = 0;
bson_t b;
bson_iter_document (iter, &doclen, &docbuf);
if (bson_init_static (&b, docbuf, doclen) &&
VISIT_DOCUMENT (iter, key, &b, data)) {
return true;
}
} break;
case BSON_TYPE_ARRAY: {
const uint8_t *docbuf = NULL;
uint32_t doclen = 0;
bson_t b;
bson_iter_array (iter, &doclen, &docbuf);
if (bson_init_static (&b, docbuf, doclen) &&
VISIT_ARRAY (iter, key, &b, data)) {
return true;
}
} break;
case BSON_TYPE_BINARY: {
const uint8_t *binary = NULL;
bson_subtype_t subtype = BSON_SUBTYPE_BINARY;
uint32_t binary_len = 0;
bson_iter_binary (iter, &subtype, &binary_len, &binary);
if (VISIT_BINARY (iter, key, subtype, binary_len, binary, data)) {
return true;
}
} break;
case BSON_TYPE_UNDEFINED:
if (VISIT_UNDEFINED (iter, key, data)) {
return true;
}
break;
case BSON_TYPE_OID:
if (VISIT_OID (iter, key, bson_iter_oid (iter), data)) {
return true;
}
break;
case BSON_TYPE_BOOL:
if (VISIT_BOOL (iter, key, bson_iter_bool (iter), data)) {
return true;
}
break;
case BSON_TYPE_DATE_TIME:
if (VISIT_DATE_TIME (iter, key, bson_iter_date_time (iter), data)) {
return true;
}
break;
case BSON_TYPE_NULL:
if (VISIT_NULL (iter, key, data)) {
return true;
}
break;
case BSON_TYPE_REGEX: {
const char *regex = NULL;
const char *options = NULL;
regex = bson_iter_regex (iter, &options);
if (VISIT_REGEX (iter, key, regex, options, data)) {
return true;
}
} break;
case BSON_TYPE_DBPOINTER: {
uint32_t collection_len = 0;
const char *collection = NULL;
const bson_oid_t *oid = NULL;
bson_iter_dbpointer (iter, &collection_len, &collection, &oid);
if (VISIT_DBPOINTER (
iter, key, collection_len, collection, oid, data)) {
return true;
}
} break;
case BSON_TYPE_CODE: {
uint32_t code_len;
const char *code;
code = bson_iter_code (iter, &code_len);
if (VISIT_CODE (iter, key, code_len, code, data)) {
return true;
}
} break;
case BSON_TYPE_SYMBOL: {
uint32_t symbol_len;
const char *symbol;
symbol = bson_iter_symbol (iter, &symbol_len);
if (VISIT_SYMBOL (iter, key, symbol_len, symbol, data)) {
return true;
}
} break;
case BSON_TYPE_CODEWSCOPE: {
uint32_t length = 0;
const char *code;
const uint8_t *docbuf = NULL;
uint32_t doclen = 0;
bson_t b;
code = bson_iter_codewscope (iter, &length, &doclen, &docbuf);
if (bson_init_static (&b, docbuf, doclen) &&
VISIT_CODEWSCOPE (iter, key, length, code, &b, data)) {
return true;
}
} break;
case BSON_TYPE_INT32:
if (VISIT_INT32 (iter, key, bson_iter_int32 (iter), data)) {
return true;
}
break;
case BSON_TYPE_TIMESTAMP: {
uint32_t timestamp;
uint32_t increment;
bson_iter_timestamp (iter, ×tamp, &increment);
if (VISIT_TIMESTAMP (iter, key, timestamp, increment, data)) {
return true;
}
} break;
case BSON_TYPE_INT64:
if (VISIT_INT64 (iter, key, bson_iter_int64 (iter), data)) {
return true;
}
break;
case BSON_TYPE_DECIMAL128: {
bson_decimal128_t dec;
bson_iter_decimal128 (iter, &dec);
if (VISIT_DECIMAL128 (iter, key, &dec, data)) {
return true;
}
} break;
case BSON_TYPE_MAXKEY:
if (VISIT_MAXKEY (iter, bson_iter_key_unsafe (iter), data)) {
return true;
}
break;
case BSON_TYPE_MINKEY:
if (VISIT_MINKEY (iter, bson_iter_key_unsafe (iter), data)) {
return true;
}
break;
case BSON_TYPE_EOD:
default:
break;
}
if (VISIT_AFTER (iter, bson_iter_key_unsafe (iter), data)) {
return true;
}
}
if (iter->err_off) {
if (unsupported && visitor->visit_unsupported_type &&
bson_utf8_validate (key, strlen (key), false)) {
visitor->visit_unsupported_type (iter, key, bson_type, data);
return false;
}
VISIT_CORRUPT (iter, data);
}
#undef VISIT_FIELD
return false;
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_overwrite_bool --
*
* Overwrites the current BSON_TYPE_BOOLEAN field with a new value.
* This is performed in-place and therefore no keys are moved.
*
* Returns:
* None.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
void
bson_iter_overwrite_bool (bson_iter_t *iter, /* IN */
bool value) /* IN */
{
BSON_ASSERT (iter);
value = !!value;
if (ITER_TYPE (iter) == BSON_TYPE_BOOL) {
memcpy ((void *) (iter->raw + iter->d1), &value, 1);
}
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_overwrite_int32 --
*
* Overwrites the current BSON_TYPE_INT32 field with a new value.
* This is performed in-place and therefore no keys are moved.
*
* Returns:
* None.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
void
bson_iter_overwrite_int32 (bson_iter_t *iter, /* IN */
int32_t value) /* IN */
{
BSON_ASSERT (iter);
if (ITER_TYPE (iter) == BSON_TYPE_INT32) {
#if BSON_BYTE_ORDER != BSON_LITTLE_ENDIAN
value = BSON_UINT32_TO_LE (value);
#endif
memcpy ((void *) (iter->raw + iter->d1), &value, sizeof (value));
}
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_overwrite_int64 --
*
* Overwrites the current BSON_TYPE_INT64 field with a new value.
* This is performed in-place and therefore no keys are moved.
*
* Returns:
* None.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
void
bson_iter_overwrite_int64 (bson_iter_t *iter, /* IN */
int64_t value) /* IN */
{
BSON_ASSERT (iter);
if (ITER_TYPE (iter) == BSON_TYPE_INT64) {
#if BSON_BYTE_ORDER != BSON_LITTLE_ENDIAN
value = BSON_UINT64_TO_LE (value);
#endif
memcpy ((void *) (iter->raw + iter->d1), &value, sizeof (value));
}
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_overwrite_double --
*
* Overwrites the current BSON_TYPE_DOUBLE field with a new value.
* This is performed in-place and therefore no keys are moved.
*
* Returns:
* None.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
void
bson_iter_overwrite_double (bson_iter_t *iter, /* IN */
double value) /* IN */
{
BSON_ASSERT (iter);
if (ITER_TYPE (iter) == BSON_TYPE_DOUBLE) {
value = BSON_DOUBLE_TO_LE (value);
memcpy ((void *) (iter->raw + iter->d1), &value, sizeof (value));
}
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_overwrite_decimal128 --
*
* Overwrites the current BSON_TYPE_DECIMAL128 field with a new value.
* This is performed in-place and therefore no keys are moved.
*
* Returns:
* None.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
void
bson_iter_overwrite_decimal128 (bson_iter_t *iter, /* IN */
bson_decimal128_t *value) /* IN */
{
BSON_ASSERT (iter);
if (ITER_TYPE (iter) == BSON_TYPE_DECIMAL128) {
#if BSON_BYTE_ORDER != BSON_LITTLE_ENDIAN
uint64_t data[2];
data[0] = BSON_UINT64_TO_LE (value->low);
data[1] = BSON_UINT64_TO_LE (value->high);
memcpy ((void *) (iter->raw + iter->d1), data, sizeof (data));
#else
memcpy ((void *) (iter->raw + iter->d1), value, sizeof (*value));
#endif
}
}
/*
*--------------------------------------------------------------------------
*
* bson_iter_value --
*
* Retrieves a bson_value_t containing the boxed value of the current
* element. The result of this function valid until the state of
* iter has been changed (through the use of bson_iter_next()).
*
* Returns:
* A bson_value_t that should not be modified or freed. If you need
* to hold on to the value, use bson_value_copy().
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
const bson_value_t *
bson_iter_value (bson_iter_t *iter) /* IN */
{
bson_value_t *value;
BSON_ASSERT (iter);
value = &iter->value;
value->value_type = ITER_TYPE (iter);
switch (value->value_type) {
case BSON_TYPE_DOUBLE:
value->value.v_double = bson_iter_double (iter);
break;
case BSON_TYPE_UTF8:
value->value.v_utf8.str =
(char *) bson_iter_utf8 (iter, &value->value.v_utf8.len);
break;
case BSON_TYPE_DOCUMENT:
bson_iter_document (iter,
&value->value.v_doc.data_len,
(const uint8_t **) &value->value.v_doc.data);
break;
case BSON_TYPE_ARRAY:
bson_iter_array (iter,
&value->value.v_doc.data_len,
(const uint8_t **) &value->value.v_doc.data);
break;
case BSON_TYPE_BINARY:
bson_iter_binary (iter,
&value->value.v_binary.subtype,
&value->value.v_binary.data_len,
(const uint8_t **) &value->value.v_binary.data);
break;
case BSON_TYPE_OID:
bson_oid_copy (bson_iter_oid (iter), &value->value.v_oid);
break;
case BSON_TYPE_BOOL:
value->value.v_bool = bson_iter_bool (iter);
break;
case BSON_TYPE_DATE_TIME:
value->value.v_datetime = bson_iter_date_time (iter);
break;
case BSON_TYPE_REGEX:
value->value.v_regex.regex = (char *) bson_iter_regex (
iter, (const char **) &value->value.v_regex.options);
break;
case BSON_TYPE_DBPOINTER: {
const bson_oid_t *oid;
bson_iter_dbpointer (iter,
&value->value.v_dbpointer.collection_len,
(const char **) &value->value.v_dbpointer.collection,
&oid);
bson_oid_copy (oid, &value->value.v_dbpointer.oid);
break;
}
case BSON_TYPE_CODE:
value->value.v_code.code =
(char *) bson_iter_code (iter, &value->value.v_code.code_len);
break;
case BSON_TYPE_SYMBOL:
value->value.v_symbol.symbol =
(char *) bson_iter_symbol (iter, &value->value.v_symbol.len);
break;
case BSON_TYPE_CODEWSCOPE:
value->value.v_codewscope.code = (char *) bson_iter_codewscope (
iter,
&value->value.v_codewscope.code_len,
&value->value.v_codewscope.scope_len,
(const uint8_t **) &value->value.v_codewscope.scope_data);
break;
case BSON_TYPE_INT32:
value->value.v_int32 = bson_iter_int32 (iter);
break;
case BSON_TYPE_TIMESTAMP:
bson_iter_timestamp (iter,
&value->value.v_timestamp.timestamp,
&value->value.v_timestamp.increment);
break;
case BSON_TYPE_INT64:
value->value.v_int64 = bson_iter_int64 (iter);
break;
case BSON_TYPE_DECIMAL128:
bson_iter_decimal128 (iter, &(value->value.v_decimal128));
break;
case BSON_TYPE_NULL:
case BSON_TYPE_UNDEFINED:
case BSON_TYPE_MAXKEY:
case BSON_TYPE_MINKEY:
break;
case BSON_TYPE_EOD:
default:
return NULL;
}
return value;
}
libbson-1.6.1/src/bson/bson-iter.h 0000664 0000000 0000000 00000026747 13057346540 0017001 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 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.
*/
#ifndef BSON_ITER_H
#define BSON_ITER_H
#if !defined(BSON_INSIDE) && !defined(BSON_COMPILATION)
#error "Only can be included directly."
#endif
#include "bson.h"
#include "bson-endian.h"
#include "bson-macros.h"
#include "bson-types.h"
BSON_BEGIN_DECLS
#define BSON_ITER_HOLDS_DOUBLE(iter) \
(bson_iter_type ((iter)) == BSON_TYPE_DOUBLE)
#define BSON_ITER_HOLDS_UTF8(iter) (bson_iter_type ((iter)) == BSON_TYPE_UTF8)
#define BSON_ITER_HOLDS_DOCUMENT(iter) \
(bson_iter_type ((iter)) == BSON_TYPE_DOCUMENT)
#define BSON_ITER_HOLDS_ARRAY(iter) (bson_iter_type ((iter)) == BSON_TYPE_ARRAY)
#define BSON_ITER_HOLDS_BINARY(iter) \
(bson_iter_type ((iter)) == BSON_TYPE_BINARY)
#define BSON_ITER_HOLDS_UNDEFINED(iter) \
(bson_iter_type ((iter)) == BSON_TYPE_UNDEFINED)
#define BSON_ITER_HOLDS_OID(iter) (bson_iter_type ((iter)) == BSON_TYPE_OID)
#define BSON_ITER_HOLDS_BOOL(iter) (bson_iter_type ((iter)) == BSON_TYPE_BOOL)
#define BSON_ITER_HOLDS_DATE_TIME(iter) \
(bson_iter_type ((iter)) == BSON_TYPE_DATE_TIME)
#define BSON_ITER_HOLDS_NULL(iter) (bson_iter_type ((iter)) == BSON_TYPE_NULL)
#define BSON_ITER_HOLDS_REGEX(iter) (bson_iter_type ((iter)) == BSON_TYPE_REGEX)
#define BSON_ITER_HOLDS_DBPOINTER(iter) \
(bson_iter_type ((iter)) == BSON_TYPE_DBPOINTER)
#define BSON_ITER_HOLDS_CODE(iter) (bson_iter_type ((iter)) == BSON_TYPE_CODE)
#define BSON_ITER_HOLDS_SYMBOL(iter) \
(bson_iter_type ((iter)) == BSON_TYPE_SYMBOL)
#define BSON_ITER_HOLDS_CODEWSCOPE(iter) \
(bson_iter_type ((iter)) == BSON_TYPE_CODEWSCOPE)
#define BSON_ITER_HOLDS_INT32(iter) (bson_iter_type ((iter)) == BSON_TYPE_INT32)
#define BSON_ITER_HOLDS_TIMESTAMP(iter) \
(bson_iter_type ((iter)) == BSON_TYPE_TIMESTAMP)
#define BSON_ITER_HOLDS_INT64(iter) (bson_iter_type ((iter)) == BSON_TYPE_INT64)
#define BSON_ITER_HOLDS_DECIMAL128(iter) \
(bson_iter_type (iter)) == BSON_TYPE_DECIMAL128
#define BSON_ITER_HOLDS_MAXKEY(iter) \
(bson_iter_type ((iter)) == BSON_TYPE_MAXKEY)
#define BSON_ITER_HOLDS_MINKEY(iter) \
(bson_iter_type ((iter)) == BSON_TYPE_MINKEY)
#define BSON_ITER_IS_KEY(iter, key) \
(0 == strcmp ((key), bson_iter_key ((iter))))
BSON_EXPORT (const bson_value_t *)
bson_iter_value (bson_iter_t *iter);
/**
* bson_iter_utf8_len_unsafe:
* @iter: a bson_iter_t.
*
* Returns the length of a string currently pointed to by @iter. This performs
* no validation so the is responsible for knowing the BSON is valid. Calling
* bson_validate() is one way to do this ahead of time.
*/
static BSON_INLINE uint32_t
bson_iter_utf8_len_unsafe (const bson_iter_t *iter)
{
int32_t val;
memcpy (&val, iter->raw + iter->d1, sizeof (val));
val = BSON_UINT32_FROM_LE (val);
return BSON_MAX (0, val - 1);
}
BSON_EXPORT (void)
bson_iter_array (const bson_iter_t *iter,
uint32_t *array_len,
const uint8_t **array);
BSON_EXPORT (void)
bson_iter_binary (const bson_iter_t *iter,
bson_subtype_t *subtype,
uint32_t *binary_len,
const uint8_t **binary);
BSON_EXPORT (const char *)
bson_iter_code (const bson_iter_t *iter, uint32_t *length);
/**
* bson_iter_code_unsafe:
* @iter: A bson_iter_t.
* @length: A location for the length of the resulting string.
*
* Like bson_iter_code() but performs no integrity checks.
*
* Returns: A string that should not be modified or freed.
*/
static BSON_INLINE const char *
bson_iter_code_unsafe (const bson_iter_t *iter, uint32_t *length)
{
*length = bson_iter_utf8_len_unsafe (iter);
return (const char *) (iter->raw + iter->d2);
}
BSON_EXPORT (const char *)
bson_iter_codewscope (const bson_iter_t *iter,
uint32_t *length,
uint32_t *scope_len,
const uint8_t **scope);
BSON_EXPORT (void)
bson_iter_dbpointer (const bson_iter_t *iter,
uint32_t *collection_len,
const char **collection,
const bson_oid_t **oid);
BSON_EXPORT (void)
bson_iter_document (const bson_iter_t *iter,
uint32_t *document_len,
const uint8_t **document);
BSON_EXPORT (double)
bson_iter_double (const bson_iter_t *iter);
/**
* bson_iter_double_unsafe:
* @iter: A bson_iter_t.
*
* Similar to bson_iter_double() but does not perform an integrity checking.
*
* Returns: A double.
*/
static BSON_INLINE double
bson_iter_double_unsafe (const bson_iter_t *iter)
{
double val;
memcpy (&val, iter->raw + iter->d1, sizeof (val));
return BSON_DOUBLE_FROM_LE (val);
}
BSON_EXPORT (bool)
bson_iter_init (bson_iter_t *iter, const bson_t *bson);
BSON_EXPORT (bool)
bson_iter_init_find (bson_iter_t *iter, const bson_t *bson, const char *key);
BSON_EXPORT (bool)
bson_iter_init_find_case (bson_iter_t *iter,
const bson_t *bson,
const char *key);
BSON_EXPORT (int32_t)
bson_iter_int32 (const bson_iter_t *iter);
/**
* bson_iter_int32_unsafe:
* @iter: A bson_iter_t.
*
* Similar to bson_iter_int32() but with no integrity checking.
*
* Returns: A 32-bit signed integer.
*/
static BSON_INLINE int32_t
bson_iter_int32_unsafe (const bson_iter_t *iter)
{
int32_t val;
memcpy (&val, iter->raw + iter->d1, sizeof (val));
return BSON_UINT32_FROM_LE (val);
}
BSON_EXPORT (int64_t)
bson_iter_int64 (const bson_iter_t *iter);
BSON_EXPORT (int64_t)
bson_iter_as_int64 (const bson_iter_t *iter);
/**
* bson_iter_int64_unsafe:
* @iter: a bson_iter_t.
*
* Similar to bson_iter_int64() but without integrity checking.
*
* Returns: A 64-bit signed integer.
*/
static BSON_INLINE int64_t
bson_iter_int64_unsafe (const bson_iter_t *iter)
{
int64_t val;
memcpy (&val, iter->raw + iter->d1, sizeof (val));
return BSON_UINT64_FROM_LE (val);
}
BSON_EXPORT (bool)
bson_iter_find (bson_iter_t *iter, const char *key);
BSON_EXPORT (bool)
bson_iter_find_case (bson_iter_t *iter, const char *key);
BSON_EXPORT (bool)
bson_iter_find_descendant (bson_iter_t *iter,
const char *dotkey,
bson_iter_t *descendant);
BSON_EXPORT (bool)
bson_iter_next (bson_iter_t *iter);
BSON_EXPORT (const bson_oid_t *)
bson_iter_oid (const bson_iter_t *iter);
/**
* bson_iter_oid_unsafe:
* @iter: A #bson_iter_t.
*
* Similar to bson_iter_oid() but performs no integrity checks.
*
* Returns: A #bson_oid_t that should not be modified or freed.
*/
static BSON_INLINE const bson_oid_t *
bson_iter_oid_unsafe (const bson_iter_t *iter)
{
return (const bson_oid_t *) (iter->raw + iter->d1);
}
BSON_EXPORT (bool)
bson_iter_decimal128 (const bson_iter_t *iter, bson_decimal128_t *dec);
/**
* bson_iter_decimal128_unsafe:
* @iter: A #bson_iter_t.
*
* Similar to bson_iter_decimal128() but performs no integrity checks.
*
* Returns: A #bson_decimal128_t.
*/
static BSON_INLINE void
bson_iter_decimal128_unsafe (const bson_iter_t *iter, bson_decimal128_t *dec)
{
uint64_t low_le;
uint64_t high_le;
memcpy (&low_le, iter->raw + iter->d1, sizeof (low_le));
memcpy (&high_le, iter->raw + iter->d1 + 8, sizeof (high_le));
dec->low = BSON_UINT64_FROM_LE (low_le);
dec->high = BSON_UINT64_FROM_LE (high_le);
}
BSON_EXPORT (const char *)
bson_iter_key (const bson_iter_t *iter);
/**
* bson_iter_key_unsafe:
* @iter: A bson_iter_t.
*
* Similar to bson_iter_key() but performs no integrity checking.
*
* Returns: A string that should not be modified or freed.
*/
static BSON_INLINE const char *
bson_iter_key_unsafe (const bson_iter_t *iter)
{
return (const char *) (iter->raw + iter->key);
}
BSON_EXPORT (const char *)
bson_iter_utf8 (const bson_iter_t *iter, uint32_t *length);
/**
* bson_iter_utf8_unsafe:
*
* Similar to bson_iter_utf8() but performs no integrity checking.
*
* Returns: A string that should not be modified or freed.
*/
static BSON_INLINE const char *
bson_iter_utf8_unsafe (const bson_iter_t *iter, size_t *length)
{
*length = bson_iter_utf8_len_unsafe (iter);
return (const char *) (iter->raw + iter->d2);
}
BSON_EXPORT (char *)
bson_iter_dup_utf8 (const bson_iter_t *iter, uint32_t *length);
BSON_EXPORT (int64_t)
bson_iter_date_time (const bson_iter_t *iter);
BSON_EXPORT (time_t)
bson_iter_time_t (const bson_iter_t *iter);
/**
* bson_iter_time_t_unsafe:
* @iter: A bson_iter_t.
*
* Similar to bson_iter_time_t() but performs no integrity checking.
*
* Returns: A time_t containing the number of seconds since UNIX epoch
* in UTC.
*/
static BSON_INLINE time_t
bson_iter_time_t_unsafe (const bson_iter_t *iter)
{
return (time_t) (bson_iter_int64_unsafe (iter) / 1000UL);
}
BSON_EXPORT (void)
bson_iter_timeval (const bson_iter_t *iter, struct timeval *tv);
/**
* bson_iter_timeval_unsafe:
* @iter: A bson_iter_t.
* @tv: A struct timeval.
*
* Similar to bson_iter_timeval() but performs no integrity checking.
*/
static BSON_INLINE void
bson_iter_timeval_unsafe (const bson_iter_t *iter, struct timeval *tv)
{
int64_t value = bson_iter_int64_unsafe (iter);
#ifdef BSON_OS_WIN32
tv->tv_sec = (long) (value / 1000);
#else
tv->tv_sec = (suseconds_t) (value / 1000);
#endif
tv->tv_usec = (value % 1000) * 1000;
}
BSON_EXPORT (void)
bson_iter_timestamp (const bson_iter_t *iter,
uint32_t *timestamp,
uint32_t *increment);
BSON_EXPORT (bool)
bson_iter_bool (const bson_iter_t *iter);
/**
* bson_iter_bool_unsafe:
* @iter: A bson_iter_t.
*
* Similar to bson_iter_bool() but performs no integrity checking.
*
* Returns: true or false.
*/
static BSON_INLINE bool
bson_iter_bool_unsafe (const bson_iter_t *iter)
{
char val;
memcpy (&val, iter->raw + iter->d1, 1);
return !!val;
}
BSON_EXPORT (bool)
bson_iter_as_bool (const bson_iter_t *iter);
BSON_EXPORT (const char *)
bson_iter_regex (const bson_iter_t *iter, const char **options);
BSON_EXPORT (const char *)
bson_iter_symbol (const bson_iter_t *iter, uint32_t *length);
BSON_EXPORT (bson_type_t)
bson_iter_type (const bson_iter_t *iter);
/**
* bson_iter_type_unsafe:
* @iter: A bson_iter_t.
*
* Similar to bson_iter_type() but performs no integrity checking.
*
* Returns: A bson_type_t.
*/
static BSON_INLINE bson_type_t
bson_iter_type_unsafe (const bson_iter_t *iter)
{
return (bson_type_t) (iter->raw + iter->type)[0];
}
BSON_EXPORT (bool)
bson_iter_recurse (const bson_iter_t *iter, bson_iter_t *child);
BSON_EXPORT (void)
bson_iter_overwrite_int32 (bson_iter_t *iter, int32_t value);
BSON_EXPORT (void)
bson_iter_overwrite_int64 (bson_iter_t *iter, int64_t value);
BSON_EXPORT (void)
bson_iter_overwrite_double (bson_iter_t *iter, double value);
BSON_EXPORT (void)
bson_iter_overwrite_decimal128 (bson_iter_t *iter, bson_decimal128_t *value);
BSON_EXPORT (void)
bson_iter_overwrite_bool (bson_iter_t *iter, bool value);
BSON_EXPORT (bool)
bson_iter_visit_all (bson_iter_t *iter,
const bson_visitor_t *visitor,
void *data);
BSON_END_DECLS
#endif /* BSON_ITER_H */
libbson-1.6.1/src/bson/bson-json.c 0000664 0000000 0000000 00000147430 13057346540 0016773 0 ustar 00root root 0000000 0000000 /*
* Copyright 2014 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
#include
#include
#include
#include "bson.h"
#include "bson-config.h"
#include "bson-json.h"
#include "bson-iso8601-private.h"
#include "b64_pton.h"
#include "jsonsl/jsonsl.h"
#ifdef _WIN32
#include
#include
#endif
#define STACK_MAX 100
#define BSON_JSON_DEFAULT_BUF_SIZE (1 << 14)
#define AT_LEAST_0(x) ((x) >= 0 ? (x) : 0)
typedef enum {
BSON_JSON_REGULAR,
BSON_JSON_DONE,
BSON_JSON_ERROR,
BSON_JSON_IN_START_MAP,
BSON_JSON_IN_BSON_TYPE,
BSON_JSON_IN_BSON_TYPE_DATE_NUMBERLONG,
BSON_JSON_IN_BSON_TYPE_DATE_ENDMAP,
BSON_JSON_IN_BSON_TYPE_TIMESTAMP_STARTMAP,
BSON_JSON_IN_BSON_TYPE_TIMESTAMP_VALUES,
BSON_JSON_IN_BSON_TYPE_TIMESTAMP_ENDMAP,
BSON_JSON_IN_BSON_TYPE_SCOPE_STARTMAP,
BSON_JSON_IN_SCOPE,
} bson_json_read_state_t;
typedef enum {
BSON_JSON_LF_REGEX,
BSON_JSON_LF_OPTIONS,
BSON_JSON_LF_CODE,
BSON_JSON_LF_SCOPE,
BSON_JSON_LF_OID,
BSON_JSON_LF_BINARY,
BSON_JSON_LF_TYPE,
BSON_JSON_LF_DATE,
BSON_JSON_LF_TIMESTAMP_T,
BSON_JSON_LF_TIMESTAMP_I,
BSON_JSON_LF_UNDEFINED,
BSON_JSON_LF_MINKEY,
BSON_JSON_LF_MAXKEY,
BSON_JSON_LF_INT64,
BSON_JSON_LF_DECIMAL128
} bson_json_read_bson_state_t;
typedef struct {
uint8_t *buf;
size_t n_bytes;
size_t len;
} bson_json_buf_t;
typedef struct {
int i;
bool is_array;
bool is_scope;
bson_t bson;
} bson_json_stack_frame_t;
typedef union {
struct {
bool has_regex;
bool has_options;
} regex;
struct {
bool has_oid;
bson_oid_t oid;
} oid;
struct {
bool has_binary;
bool has_subtype;
bson_subtype_t type;
} binary;
struct {
bool has_date;
int64_t date;
} date;
struct {
bool has_t;
bool has_i;
uint32_t t;
uint32_t i;
} timestamp;
struct {
bool has_undefined;
} undefined;
struct {
bool has_minkey;
} minkey;
struct {
bool has_maxkey;
} maxkey;
struct {
int64_t value;
} v_int64;
struct {
bson_decimal128_t value;
} v_decimal128;
} bson_json_bson_data_t;
/* collect info while parsing a {$code: "...", $scope: {...}} object */
typedef struct {
bool has_code;
bool has_scope;
bool in_scope;
bson_json_buf_t key_buf;
bson_json_buf_t code_buf;
} bson_json_code_t;
static void
_bson_json_code_cleanup (bson_json_code_t *code_data)
{
bson_free (code_data->key_buf.buf);
bson_free (code_data->code_buf.buf);
}
typedef struct {
bson_t *bson;
bson_json_stack_frame_t stack[STACK_MAX];
int n;
const char *key;
bson_json_buf_t key_buf;
bson_json_buf_t unescaped;
bson_json_read_state_t read_state;
bson_json_read_bson_state_t bson_state;
bson_type_t bson_type;
bson_json_buf_t bson_type_buf[3];
bson_json_bson_data_t bson_type_data;
bson_json_code_t code_data;
} bson_json_reader_bson_t;
typedef struct {
void *data;
bson_json_reader_cb cb;
bson_json_destroy_cb dcb;
uint8_t *buf;
size_t buf_size;
size_t bytes_read;
size_t bytes_parsed;
bool all_whitespace;
} bson_json_reader_producer_t;
struct _bson_json_reader_t {
bson_json_reader_producer_t producer;
bson_json_reader_bson_t bson;
jsonsl_t json;
ssize_t json_text_pos;
bool should_reset;
ssize_t advance;
bson_json_buf_t tok_accumulator;
bson_error_t *error;
};
typedef struct {
int fd;
bool do_close;
} bson_json_reader_handle_fd_t;
static void
_noop (void)
{
}
#define STACK_ELE(_delta, _name) (bson->stack[(_delta) + bson->n]._name)
#define STACK_BSON(_delta) \
(((_delta) + bson->n) == 0 ? bson->bson : &STACK_ELE (_delta, bson))
#define STACK_BSON_PARENT STACK_BSON (-1)
#define STACK_BSON_CHILD STACK_BSON (0)
#define STACK_I STACK_ELE (0, i)
#define STACK_IS_ARRAY STACK_ELE (0, is_array)
#define STACK_IS_SCOPE STACK_ELE (0, is_scope)
#define STACK_PUSH_ARRAY(statement) \
do { \
if (bson->n >= (STACK_MAX - 1)) { \
return; \
} \
bson->n++; \
STACK_I = 0; \
STACK_IS_ARRAY = 1; \
STACK_IS_SCOPE = 0; \
if (bson->n != 0) { \
statement; \
} \
} while (0)
#define STACK_PUSH_DOC(statement) \
do { \
if (bson->n >= (STACK_MAX - 1)) { \
return; \
} \
bson->n++; \
STACK_IS_ARRAY = 0; \
STACK_IS_SCOPE = 0; \
if (bson->n != 0) { \
statement; \
} \
} while (0)
#define STACK_PUSH_SCOPE(statement) \
do { \
if (bson->n >= (STACK_MAX - 1)) { \
return; \
} \
bson->n++; \
STACK_IS_ARRAY = 0; \
STACK_IS_SCOPE = 1; \
bson->code_data.in_scope = true; \
if (bson->n != 0) { \
statement; \
} \
} while (0)
#define STACK_POP_ARRAY(statement) \
do { \
if (!STACK_IS_ARRAY) { \
return; \
} \
if (bson->n < 0) { \
return; \
} \
if (bson->n > 0) { \
statement; \
} \
bson->n--; \
} while (0)
#define STACK_POP_DOC(statement) \
do { \
if (STACK_IS_ARRAY) { \
return; \
} \
if (bson->n < 0) { \
return; \
} \
if (bson->n > 0) { \
statement; \
} \
bson->n--; \
} while (0)
#define STACK_POP_SCOPE \
do { \
STACK_POP_DOC (_noop ()); \
bson->code_data.in_scope = false; \
} while (0);
#define BASIC_CB_PREAMBLE \
const char *key; \
size_t len; \
bson_json_reader_bson_t *bson = &reader->bson; \
_bson_json_read_fixup_key (bson); \
key = bson->key; \
len = bson->key_buf.len;
#define BASIC_CB_BAIL_IF_NOT_NORMAL(_type) \
if (bson->read_state != BSON_JSON_REGULAR) { \
_bson_json_read_set_error ( \
reader, "Invalid read of %s in state %d", (_type), bson->read_state); \
return; \
} else if (!key) { \
_bson_json_read_set_error (reader, \
"Invalid read of %s without key in state %d", \
(_type), \
bson->read_state); \
return; \
}
#define HANDLE_OPTION(_key, _type, _state) \
(len == strlen (_key) && strncmp ((const char *) val, (_key), len) == 0) \
{ \
if (bson->bson_type && bson->bson_type != (_type)) { \
_bson_json_read_set_error ( \
reader, \
"Invalid key %s. Looking for values for %d", \
(_key), \
bson->bson_type); \
return; \
} \
bson->bson_type = (_type); \
bson->bson_state = (_state); \
}
static void
_bson_json_read_set_error (bson_json_reader_t *reader, const char *fmt, ...)
BSON_GNUC_PRINTF (2, 3);
static void
_bson_json_read_set_error (bson_json_reader_t *reader, /* IN */
const char *fmt, /* IN */
...)
{
va_list ap;
if (reader->error) {
reader->error->domain = BSON_ERROR_JSON;
reader->error->code = BSON_JSON_ERROR_READ_INVALID_PARAM;
va_start (ap, fmt);
bson_vsnprintf (
reader->error->message, sizeof reader->error->message, fmt, ap);
va_end (ap);
reader->error->message[sizeof reader->error->message - 1] = '\0';
}
reader->bson.read_state = BSON_JSON_ERROR;
jsonsl_stop (reader->json);
}
static void
_bson_json_read_corrupt (bson_json_reader_t *reader, const char *fmt, ...)
BSON_GNUC_PRINTF (2, 3);
static void
_bson_json_read_corrupt (bson_json_reader_t *reader, /* IN */
const char *fmt, /* IN */
...)
{
va_list ap;
if (reader->error) {
reader->error->domain = BSON_ERROR_JSON;
reader->error->code = BSON_JSON_ERROR_READ_CORRUPT_JS;
va_start (ap, fmt);
bson_vsnprintf (
reader->error->message, sizeof reader->error->message, fmt, ap);
va_end (ap);
reader->error->message[sizeof reader->error->message - 1] = '\0';
}
reader->bson.read_state = BSON_JSON_ERROR;
jsonsl_stop (reader->json);
}
static void
_bson_json_buf_ensure (bson_json_buf_t *buf, /* IN */
size_t len) /* IN */
{
if (buf->n_bytes < len) {
bson_free (buf->buf);
buf->n_bytes = bson_next_power_of_two (len);
buf->buf = bson_malloc (buf->n_bytes);
}
}
static void
_bson_json_buf_set (bson_json_buf_t *buf, const void *from, size_t len)
{
_bson_json_buf_ensure (buf, len + 1);
memcpy (buf->buf, from, len);
buf->buf[len] = '\0';
buf->len = len;
}
static void
_bson_json_buf_append (bson_json_buf_t *buf, const void *from, size_t len)
{
size_t len_with_null = len + 1;
if (buf->len == 0) {
_bson_json_buf_ensure (buf, len_with_null);
} else if (buf->n_bytes < buf->len + len_with_null) {
buf->n_bytes = bson_next_power_of_two (buf->len + len_with_null);
buf->buf = bson_realloc (buf->buf, buf->n_bytes);
}
memcpy (buf->buf + buf->len, from, len);
buf->len += len;
buf->buf[buf->len] = '\0';
}
static void
_bson_json_read_fixup_key (bson_json_reader_bson_t *bson) /* IN */
{
bson_json_read_state_t rs = bson->read_state;
if (bson->n >= 0 && STACK_IS_ARRAY && rs == BSON_JSON_REGULAR) {
_bson_json_buf_ensure (&bson->key_buf, 12);
bson->key_buf.len = bson_uint32_to_string (
STACK_I, &bson->key, (char *) bson->key_buf.buf, 12);
STACK_I++;
}
}
static void
_bson_json_read_null (bson_json_reader_t *reader)
{
BASIC_CB_PREAMBLE;
BASIC_CB_BAIL_IF_NOT_NORMAL ("null");
bson_append_null (STACK_BSON_CHILD, key, (int) len);
}
static void
_bson_json_read_boolean (bson_json_reader_t *reader, /* IN */
int val) /* IN */
{
BASIC_CB_PREAMBLE;
if (bson->read_state == BSON_JSON_IN_BSON_TYPE &&
bson->bson_state == BSON_JSON_LF_UNDEFINED) {
bson->bson_type_data.undefined.has_undefined = true;
return;
}
BASIC_CB_BAIL_IF_NOT_NORMAL ("boolean");
bson_append_bool (STACK_BSON_CHILD, key, (int) len, val);
}
static void
_bson_json_read_integer (bson_json_reader_t *reader, /* IN */
int64_t val) /* IN */
{
bson_json_read_state_t rs;
bson_json_read_bson_state_t bs;
BASIC_CB_PREAMBLE;
rs = bson->read_state;
bs = bson->bson_state;
if (rs == BSON_JSON_REGULAR) {
BASIC_CB_BAIL_IF_NOT_NORMAL ("integer");
if (val <= INT32_MAX && val >= INT32_MIN) {
bson_append_int32 (STACK_BSON_CHILD, key, (int) len, (int) val);
} else {
bson_append_int64 (STACK_BSON_CHILD, key, (int) len, val);
}
} else if (rs == BSON_JSON_IN_BSON_TYPE ||
rs == BSON_JSON_IN_BSON_TYPE_TIMESTAMP_VALUES) {
switch (bs) {
case BSON_JSON_LF_DATE:
bson->bson_type_data.date.has_date = true;
bson->bson_type_data.date.date = val;
break;
case BSON_JSON_LF_TIMESTAMP_T:
bson->bson_type_data.timestamp.has_t = true;
bson->bson_type_data.timestamp.t = (uint32_t) val;
break;
case BSON_JSON_LF_TIMESTAMP_I:
bson->bson_type_data.timestamp.has_i = true;
bson->bson_type_data.timestamp.i = (uint32_t) val;
break;
case BSON_JSON_LF_MINKEY:
bson->bson_type_data.minkey.has_minkey = true;
break;
case BSON_JSON_LF_MAXKEY:
bson->bson_type_data.maxkey.has_maxkey = true;
break;
case BSON_JSON_LF_REGEX:
case BSON_JSON_LF_OPTIONS:
case BSON_JSON_LF_CODE:
case BSON_JSON_LF_SCOPE:
case BSON_JSON_LF_OID:
case BSON_JSON_LF_BINARY:
case BSON_JSON_LF_TYPE:
case BSON_JSON_LF_UNDEFINED:
case BSON_JSON_LF_INT64:
case BSON_JSON_LF_DECIMAL128:
default:
_bson_json_read_set_error (
reader, "Invalid special type for integer read %d", bs);
}
} else {
_bson_json_read_set_error (
reader, "Invalid state for integer read %d", rs);
}
}
static void
_bson_json_read_double (bson_json_reader_t *reader, /* IN */
double val) /* IN */
{
BASIC_CB_PREAMBLE;
BASIC_CB_BAIL_IF_NOT_NORMAL ("double");
bson_append_double (STACK_BSON_CHILD, key, (int) len, val);
}
static void
_bson_json_read_string (bson_json_reader_t *reader, /* IN */
const unsigned char *val, /* IN */
size_t vlen) /* IN */
{
bson_json_read_state_t rs;
bson_json_read_bson_state_t bs;
BASIC_CB_PREAMBLE;
rs = bson->read_state;
bs = bson->bson_state;
if (!bson_utf8_validate ((const char *) val, vlen, true /*allow null*/)) {
_bson_json_read_corrupt (reader, "invalid bytes in UTF8 string");
return;
}
if (rs == BSON_JSON_REGULAR) {
BASIC_CB_BAIL_IF_NOT_NORMAL ("string");
bson_append_utf8 (
STACK_BSON_CHILD, key, (int) len, (const char *) val, (int) vlen);
} else if (rs == BSON_JSON_IN_BSON_TYPE_SCOPE_STARTMAP) {
_bson_json_read_set_error (
reader, "Invalid read of %s in state %d", val, rs);
} else if (rs == BSON_JSON_IN_BSON_TYPE ||
rs == BSON_JSON_IN_BSON_TYPE_TIMESTAMP_VALUES ||
rs == BSON_JSON_IN_BSON_TYPE_DATE_NUMBERLONG) {
const char *val_w_null;
_bson_json_buf_set (&bson->bson_type_buf[2], val, vlen);
val_w_null = (const char *) bson->bson_type_buf[2].buf;
switch (bs) {
case BSON_JSON_LF_REGEX:
bson->bson_type_data.regex.has_regex = true;
_bson_json_buf_set (&bson->bson_type_buf[0], val, vlen);
break;
case BSON_JSON_LF_OPTIONS:
bson->bson_type_data.regex.has_options = true;
_bson_json_buf_set (&bson->bson_type_buf[1], val, vlen);
break;
case BSON_JSON_LF_OID:
if (vlen != 24) {
goto BAD_PARSE;
}
bson->bson_type_data.oid.has_oid = true;
bson_oid_init_from_string (&bson->bson_type_data.oid.oid, val_w_null);
break;
case BSON_JSON_LF_TYPE:
bson->bson_type_data.binary.has_subtype = true;
#ifdef _MSC_VER
#define SSCANF sscanf_s
#else
#define SSCANF sscanf
#endif
if (SSCANF (val_w_null, "%02x", &bson->bson_type_data.binary.type) !=
1) {
goto BAD_PARSE;
}
#undef SSCANF
break;
case BSON_JSON_LF_BINARY: {
int binary_len;
bson->bson_type_data.binary.has_binary = true;
binary_len = b64_pton (val_w_null, NULL, 0);
if (binary_len < 0) {
goto BAD_PARSE;
}
_bson_json_buf_ensure (&bson->bson_type_buf[0],
(size_t) binary_len + 1);
b64_pton (
val_w_null, bson->bson_type_buf[0].buf, (size_t) binary_len + 1);
bson->bson_type_buf[0].len = (size_t) binary_len;
break;
}
case BSON_JSON_LF_INT64: {
int64_t v64;
char *endptr = NULL;
errno = 0;
v64 = bson_ascii_strtoll ((const char *) val, &endptr, 10);
if (((v64 == INT64_MIN) || (v64 == INT64_MAX)) && (errno == ERANGE)) {
goto BAD_PARSE;
}
if (endptr != ((const char *) val + vlen)) {
goto BAD_PARSE;
}
if (bson->read_state == BSON_JSON_IN_BSON_TYPE) {
bson->bson_type_data.v_int64.value = v64;
} else if (bson->read_state ==
BSON_JSON_IN_BSON_TYPE_DATE_NUMBERLONG) {
bson->bson_type_data.date.has_date = true;
bson->bson_type_data.date.date = v64;
} else {
goto BAD_PARSE;
}
} break;
case BSON_JSON_LF_DATE: {
int64_t v64;
if (!_bson_iso8601_date_parse (
(char *) val, (int) vlen, &v64, reader->error)) {
jsonsl_stop (reader->json);
} else {
bson->bson_type_data.date.has_date = true;
bson->bson_type_data.date.date = v64;
}
} break;
case BSON_JSON_LF_DECIMAL128: {
bson_decimal128_t decimal128;
bson_decimal128_from_string (val_w_null, &decimal128);
if (bson->read_state == BSON_JSON_IN_BSON_TYPE) {
bson->bson_type_data.v_decimal128.value = decimal128;
} else {
goto BAD_PARSE;
}
} break;
case BSON_JSON_LF_CODE:
_bson_json_buf_set (&bson->code_data.code_buf, val, vlen);
break;
case BSON_JSON_LF_SCOPE:
case BSON_JSON_LF_TIMESTAMP_T:
case BSON_JSON_LF_TIMESTAMP_I:
case BSON_JSON_LF_UNDEFINED:
case BSON_JSON_LF_MINKEY:
case BSON_JSON_LF_MAXKEY:
default:
goto BAD_PARSE;
}
return;
BAD_PARSE:
_bson_json_read_set_error (
reader, "Invalid input string %s, looking for %d", val_w_null, bs);
} else {
_bson_json_read_set_error (
reader, "Invalid state to look for string %d", rs);
}
}
static void
_bson_json_read_start_map (bson_json_reader_t *reader) /* IN */
{
BASIC_CB_PREAMBLE;
if (bson->read_state == BSON_JSON_IN_BSON_TYPE &&
bson->bson_state == BSON_JSON_LF_DATE) {
bson->read_state = BSON_JSON_IN_BSON_TYPE_DATE_NUMBERLONG;
} else if (bson->read_state == BSON_JSON_IN_BSON_TYPE_TIMESTAMP_STARTMAP) {
bson->read_state = BSON_JSON_IN_BSON_TYPE_TIMESTAMP_VALUES;
} else if (bson->read_state == BSON_JSON_IN_BSON_TYPE_SCOPE_STARTMAP) {
bson->read_state = BSON_JSON_IN_SCOPE;
} else {
bson->read_state = BSON_JSON_IN_START_MAP;
}
/* silence some warnings */
(void) len;
(void) key;
}
static bool
_is_known_key (const char *key, size_t len)
{
bool ret;
#define IS_KEY(k) (len == strlen (k) && (0 == memcmp (k, key, len)))
ret = (IS_KEY ("$regex") || IS_KEY ("$options") || IS_KEY ("$code") ||
IS_KEY ("$scope") || IS_KEY ("$oid") || IS_KEY ("$binary") ||
IS_KEY ("$type") || IS_KEY ("$date") || IS_KEY ("$undefined") ||
IS_KEY ("$maxKey") || IS_KEY ("$minKey") || IS_KEY ("$timestamp") ||
IS_KEY ("$numberLong")) ||
IS_KEY ("$numberDecimal");
#undef IS_KEY
return ret;
}
static void
_bson_json_save_map_key (bson_json_reader_bson_t *bson,
const uint8_t *val,
size_t len)
{
_bson_json_buf_set (&bson->key_buf, val, len);
bson->key = (const char *) bson->key_buf.buf;
}
static void
_bson_json_read_code_or_scope_key (bson_json_reader_bson_t *bson,
bool is_scope,
const uint8_t *val,
size_t len)
{
bson_json_code_t *code = &bson->code_data;
if (code->in_scope) {
/* we're reading something weirdly nested, e.g. we just read "$code" in
* "$scope: {x: {$code: {}}}". just create the subdoc within the scope. */
bson->read_state = BSON_JSON_REGULAR;
STACK_PUSH_DOC (bson_append_document_begin (STACK_BSON_PARENT,
bson->key,
(int) bson->key_buf.len,
STACK_BSON_CHILD));
_bson_json_save_map_key (bson, val, len);
} else {
if (!bson->code_data.key_buf.len) {
/* save the key, e.g. {"key": {"$code": "return x", "$scope":{"x":1}}},
* in case it is overwritten while parsing scope sub-object */
_bson_json_buf_set (
&bson->code_data.key_buf, bson->key_buf.buf, bson->key_buf.len);
}
if (is_scope) {
bson->bson_type = BSON_TYPE_CODEWSCOPE;
bson->read_state = BSON_JSON_IN_BSON_TYPE_SCOPE_STARTMAP;
bson->bson_state = BSON_JSON_LF_SCOPE;
bson->code_data.has_scope = true;
} else {
bson->bson_type = BSON_TYPE_CODE;
bson->bson_state = BSON_JSON_LF_CODE;
bson->code_data.has_code = true;
}
}
}
static void
_bson_json_read_map_key (bson_json_reader_t *reader, /* IN */
const uint8_t *val, /* IN */
size_t len) /* IN */
{
bson_json_reader_bson_t *bson = &reader->bson;
if (!bson_utf8_validate ((const char *) val, len, true /* allow null */)) {
_bson_json_read_corrupt (reader, "invalid bytes in UTF8 string");
return;
}
if (bson->read_state == BSON_JSON_IN_START_MAP) {
if (len > 0 && val[0] == '$' && _is_known_key ((const char *) val, len)) {
bson->read_state = BSON_JSON_IN_BSON_TYPE;
bson->bson_type = (bson_type_t) 0;
memset (&bson->bson_type_data, 0, sizeof bson->bson_type_data);
} else {
bson->read_state = BSON_JSON_REGULAR;
STACK_PUSH_DOC (bson_append_document_begin (STACK_BSON_PARENT,
bson->key,
(int) bson->key_buf.len,
STACK_BSON_CHILD));
}
} else if (bson->read_state == BSON_JSON_IN_SCOPE) {
/* just read "key" in {$code: "", $scope: {key: ""}}*/
bson->read_state = BSON_JSON_REGULAR;
STACK_PUSH_SCOPE (bson_init (STACK_BSON_CHILD));
_bson_json_save_map_key (bson, val, len);
}
if (bson->read_state == BSON_JSON_IN_BSON_TYPE) {
if
HANDLE_OPTION ("$regex", BSON_TYPE_REGEX, BSON_JSON_LF_REGEX)
else if
HANDLE_OPTION ("$options", BSON_TYPE_REGEX, BSON_JSON_LF_OPTIONS)
else if
HANDLE_OPTION ("$oid", BSON_TYPE_OID, BSON_JSON_LF_OID)
else if
HANDLE_OPTION ("$binary", BSON_TYPE_BINARY, BSON_JSON_LF_BINARY)
else if
HANDLE_OPTION ("$type", BSON_TYPE_BINARY, BSON_JSON_LF_TYPE)
else if
HANDLE_OPTION ("$date", BSON_TYPE_DATE_TIME, BSON_JSON_LF_DATE)
else if
HANDLE_OPTION (
"$undefined", BSON_TYPE_UNDEFINED, BSON_JSON_LF_UNDEFINED)
else if
HANDLE_OPTION ("$minKey", BSON_TYPE_MINKEY, BSON_JSON_LF_MINKEY)
else if
HANDLE_OPTION ("$maxKey", BSON_TYPE_MAXKEY, BSON_JSON_LF_MAXKEY)
else if
HANDLE_OPTION ("$numberLong", BSON_TYPE_INT64, BSON_JSON_LF_INT64)
else if
HANDLE_OPTION (
"$numberDecimal", BSON_TYPE_DECIMAL128, BSON_JSON_LF_DECIMAL128)
else if (!strcmp ("$timestamp", (const char *) val)) {
bson->bson_type = BSON_TYPE_TIMESTAMP;
bson->read_state = BSON_JSON_IN_BSON_TYPE_TIMESTAMP_STARTMAP;
} else if (!strcmp ("$code", (const char *) val)) {
_bson_json_read_code_or_scope_key (
bson, false /* is_scope */, val, len);
} else if (!strcmp ("$scope", (const char *) val)) {
_bson_json_read_code_or_scope_key (
bson, true /* is_scope */, val, len);
} else {
_bson_json_read_set_error (
reader,
"Invalid key %s. Looking for values for %d",
val,
bson->bson_type);
}
} else if (bson->read_state == BSON_JSON_IN_BSON_TYPE_DATE_NUMBERLONG) {
if
HANDLE_OPTION ("$numberLong", BSON_TYPE_DATE_TIME, BSON_JSON_LF_INT64)
else {
_bson_json_read_set_error (
reader,
"Invalid key %s. Looking for values for %d",
val,
bson->bson_type);
}
} else if (bson->read_state == BSON_JSON_IN_BSON_TYPE_TIMESTAMP_VALUES) {
if
HANDLE_OPTION ("t", BSON_TYPE_TIMESTAMP, BSON_JSON_LF_TIMESTAMP_T)
else if
HANDLE_OPTION ("i", BSON_TYPE_TIMESTAMP, BSON_JSON_LF_TIMESTAMP_I)
else {
_bson_json_read_set_error (
reader,
"Invalid key %s. Looking for values for %d",
val,
bson->bson_type);
}
} else {
_bson_json_save_map_key (bson, val, len);
}
}
static void
_bson_json_read_append_binary (bson_json_reader_t *reader, /* IN */
bson_json_reader_bson_t *bson) /* IN */
{
if (!bson->bson_type_data.binary.has_binary) {
_bson_json_read_set_error (
reader, "Missing $binary after $type in BSON_TYPE_BINARY");
} else if (!bson->bson_type_data.binary.has_subtype) {
_bson_json_read_set_error (
reader, "Missing $type after $binary in BSON_TYPE_BINARY");
} else {
if (!bson_append_binary (STACK_BSON_CHILD,
bson->key,
(int) bson->key_buf.len,
bson->bson_type_data.binary.type,
bson->bson_type_buf[0].buf,
(uint32_t) bson->bson_type_buf[0].len)) {
_bson_json_read_set_error (reader, "Error storing binary data");
}
}
}
static void
_bson_json_read_append_regex (bson_json_reader_t *reader, /* IN */
bson_json_reader_bson_t *bson) /* IN */
{
char *regex = NULL;
char *options = NULL;
if (!bson->bson_type_data.regex.has_regex) {
_bson_json_read_set_error (
reader, "Missing $regex after $options in BSON_TYPE_REGEX");
return;
}
regex = (char *) bson->bson_type_buf[0].buf;
if (bson->bson_type_data.regex.has_options) {
options = (char *) bson->bson_type_buf[1].buf;
}
if (!bson_append_regex (STACK_BSON_CHILD,
bson->key,
(int) bson->key_buf.len,
regex,
options)) {
_bson_json_read_set_error (reader, "Error storing regex");
}
}
static void
_bson_json_read_append_code (bson_json_reader_t *reader, /* IN */
bson_json_reader_bson_t *bson) /* IN */
{
bson_json_code_t *code_data;
char *code = NULL;
bson_t *scope = NULL;
bool r;
code_data = &bson->code_data;
BSON_ASSERT (!code_data->in_scope);
if (!code_data->has_code) {
_bson_json_read_set_error (reader, "Missing $code after $scope");
return;
}
code = (char *) code_data->code_buf.buf;
if (code_data->has_scope) {
scope = STACK_BSON (1);
}
/* creates BSON "code" elem, or "code with scope" if scope is not NULL */
r = bson_append_code_with_scope (STACK_BSON_CHILD,
(const char *) code_data->key_buf.buf,
(int) code_data->key_buf.len,
code,
scope);
if (!r) {
_bson_json_read_set_error (reader, "Error storing Javascript code");
}
if (scope) {
bson_destroy (scope);
}
/* keep the buffer but truncate it */
code_data->key_buf.len = 0;
code_data->has_code = code_data->has_scope = false;
}
static void
_bson_json_read_append_oid (bson_json_reader_t *reader, /* IN */
bson_json_reader_bson_t *bson) /* IN */
{
if (!bson_append_oid (STACK_BSON_CHILD,
bson->key,
(int) bson->key_buf.len,
&bson->bson_type_data.oid.oid)) {
_bson_json_read_set_error (reader, "Error storing ObjectId");
}
}
static void
_bson_json_read_append_date_time (bson_json_reader_t *reader, /* IN */
bson_json_reader_bson_t *bson) /* IN */
{
if (!bson_append_date_time (STACK_BSON_CHILD,
bson->key,
(int) bson->key_buf.len,
bson->bson_type_data.date.date)) {
_bson_json_read_set_error (reader, "Error storing datetime");
}
}
static void
_bson_json_read_append_timestamp (bson_json_reader_t *reader, /* IN */
bson_json_reader_bson_t *bson) /* IN */
{
if (!bson->bson_type_data.timestamp.has_t) {
_bson_json_read_set_error (
reader, "Missing t after $timestamp in BSON_TYPE_TIMESTAMP");
return;
} else if (!bson->bson_type_data.timestamp.has_i) {
_bson_json_read_set_error (
reader, "Missing i after $timestamp in BSON_TYPE_TIMESTAMP");
return;
}
bson_append_timestamp (STACK_BSON_CHILD,
bson->key,
(int) bson->key_buf.len,
bson->bson_type_data.timestamp.t,
bson->bson_type_data.timestamp.i);
}
static void
_bad_extended_json (bson_json_reader_t *reader)
{
_bson_json_read_corrupt (reader, "Invalid MongoDB extended JSON");
}
static void
_bson_json_read_end_map (bson_json_reader_t *reader) /* IN */
{
bson_json_reader_bson_t *bson = &reader->bson;
if (bson->read_state == BSON_JSON_IN_START_MAP) {
bson->read_state = BSON_JSON_REGULAR;
STACK_PUSH_DOC (bson_append_document_begin (STACK_BSON_PARENT,
bson->key,
(int) bson->key_buf.len,
STACK_BSON_CHILD));
} else if (bson->read_state == BSON_JSON_IN_BSON_TYPE_SCOPE_STARTMAP) {
bson->read_state = BSON_JSON_REGULAR;
STACK_PUSH_SCOPE (bson_init (STACK_BSON_CHILD));
}
if (bson->read_state == BSON_JSON_IN_BSON_TYPE) {
if (!bson->key) {
/* invalid, like {$numberLong: "1"} at the document top level */
_bad_extended_json (reader);
return;
}
bson->read_state = BSON_JSON_REGULAR;
switch (bson->bson_type) {
case BSON_TYPE_REGEX:
_bson_json_read_append_regex (reader, bson);
break;
case BSON_TYPE_CODE:
case BSON_TYPE_CODEWSCOPE:
/* we've read the closing "}" in "{$code: ..., $scope: ...}" */
_bson_json_read_append_code (reader, bson);
break;
case BSON_TYPE_OID:
_bson_json_read_append_oid (reader, bson);
break;
case BSON_TYPE_BINARY:
_bson_json_read_append_binary (reader, bson);
break;
case BSON_TYPE_DATE_TIME:
_bson_json_read_append_date_time (reader, bson);
break;
case BSON_TYPE_UNDEFINED:
bson_append_undefined (
STACK_BSON_CHILD, bson->key, (int) bson->key_buf.len);
break;
case BSON_TYPE_MINKEY:
bson_append_minkey (
STACK_BSON_CHILD, bson->key, (int) bson->key_buf.len);
break;
case BSON_TYPE_MAXKEY:
bson_append_maxkey (
STACK_BSON_CHILD, bson->key, (int) bson->key_buf.len);
break;
case BSON_TYPE_INT64:
bson_append_int64 (STACK_BSON_CHILD,
bson->key,
(int) bson->key_buf.len,
bson->bson_type_data.v_int64.value);
break;
case BSON_TYPE_DECIMAL128:
bson_append_decimal128 (STACK_BSON_CHILD,
bson->key,
(int) bson->key_buf.len,
&bson->bson_type_data.v_decimal128.value);
break;
case BSON_TYPE_EOD:
case BSON_TYPE_DOUBLE:
case BSON_TYPE_UTF8:
case BSON_TYPE_DOCUMENT:
case BSON_TYPE_ARRAY:
case BSON_TYPE_BOOL:
case BSON_TYPE_NULL:
case BSON_TYPE_SYMBOL:
case BSON_TYPE_INT32:
case BSON_TYPE_TIMESTAMP:
case BSON_TYPE_DBPOINTER:
default:
_bson_json_read_set_error (reader, "Unknown type %d", bson->bson_type);
break;
}
} else if (bson->read_state == BSON_JSON_IN_BSON_TYPE_TIMESTAMP_VALUES) {
if (!bson->key) {
_bad_extended_json (reader);
return;
}
bson->read_state = BSON_JSON_IN_BSON_TYPE_TIMESTAMP_ENDMAP;
_bson_json_read_append_timestamp (reader, bson);
return;
} else if (bson->read_state == BSON_JSON_IN_BSON_TYPE_TIMESTAMP_ENDMAP) {
bson->read_state = BSON_JSON_REGULAR;
} else if (bson->read_state == BSON_JSON_IN_BSON_TYPE_DATE_NUMBERLONG) {
if (!bson->key) {
_bad_extended_json (reader);
return;
}
bson->read_state = BSON_JSON_IN_BSON_TYPE_DATE_ENDMAP;
_bson_json_read_append_date_time (reader, bson);
return;
} else if (bson->read_state == BSON_JSON_IN_BSON_TYPE_DATE_ENDMAP) {
bson->read_state = BSON_JSON_REGULAR;
} else if (bson->read_state == BSON_JSON_REGULAR) {
if (STACK_IS_SCOPE) {
bson->read_state = BSON_JSON_IN_BSON_TYPE;
bson->bson_type = BSON_TYPE_CODE;
STACK_POP_SCOPE;
} else {
STACK_POP_DOC (
bson_append_document_end (STACK_BSON_PARENT, STACK_BSON_CHILD));
}
if (bson->n == -1) {
bson->read_state = BSON_JSON_DONE;
}
} else if (bson->read_state == BSON_JSON_IN_SCOPE) {
/* empty $scope */
BSON_ASSERT (bson->code_data.has_scope);
STACK_PUSH_SCOPE (bson_init (STACK_BSON_CHILD));
STACK_POP_SCOPE;
bson->read_state = BSON_JSON_IN_BSON_TYPE;
bson->bson_type = BSON_TYPE_CODE;
} else {
_bson_json_read_set_error (reader, "Invalid state %d", bson->read_state);
}
}
static void
_bson_json_read_start_array (bson_json_reader_t *reader) /* IN */
{
const char *key;
size_t len;
bson_json_reader_bson_t *bson = &reader->bson;
if (bson->n < 0) {
STACK_PUSH_ARRAY (_noop ());
} else {
_bson_json_read_fixup_key (bson);
key = bson->key;
len = bson->key_buf.len;
BASIC_CB_BAIL_IF_NOT_NORMAL ("[");
STACK_PUSH_ARRAY (bson_append_array_begin (
STACK_BSON_PARENT, key, (int) len, STACK_BSON_CHILD));
}
}
static void
_bson_json_read_end_array (bson_json_reader_t *reader) /* IN */
{
bson_json_reader_bson_t *bson = &reader->bson;
if (bson->read_state != BSON_JSON_REGULAR) {
_bson_json_read_set_error (
reader, "Invalid read of %s in state %d", "]", bson->read_state);
return;
}
STACK_POP_ARRAY (
bson_append_array_end (STACK_BSON_PARENT, STACK_BSON_CHILD));
if (bson->n == -1) {
bson->read_state = BSON_JSON_DONE;
}
}
/* put unescaped text in reader->bson.unescaped, or set reader->error.
* json_text has length len and it is not null-terminated. */
static bool
_bson_json_unescape (bson_json_reader_t *reader,
struct jsonsl_state_st *state,
const char *json_text,
ssize_t len)
{
bson_json_reader_bson_t *reader_bson;
jsonsl_error_t err;
reader_bson = &reader->bson;
/* add 1 for NULL */
_bson_json_buf_ensure (&reader_bson->unescaped, (size_t) len + 1);
/* length of unescaped str is always <= len */
reader_bson->unescaped.len = jsonsl_util_unescape (
json_text, (char *) reader_bson->unescaped.buf, (size_t) len, NULL, &err);
if (err != JSONSL_ERROR_SUCCESS) {
bson_set_error (reader->error,
BSON_ERROR_JSON,
BSON_JSON_ERROR_READ_CORRUPT_JS,
"error near position %d: %s",
(int) state->pos_begin,
jsonsl_strerror (err));
return false;
}
reader_bson->unescaped.buf[reader_bson->unescaped.len] = '\0';
return true;
}
/* read the buffered JSON plus new data, and fill out @len with its length */
static const char *
_get_json_text (jsonsl_t json, /* IN */
struct jsonsl_state_st *state, /* IN */
const char *buf /* IN */,
ssize_t *len /* OUT */)
{
bson_json_reader_t *reader;
ssize_t bytes_available;
reader = (bson_json_reader_t *) json->data;
BSON_ASSERT (state->pos_cur > state->pos_begin);
*len = (ssize_t) (state->pos_cur - state->pos_begin);
bytes_available = buf - json->base;
if (*len <= bytes_available) {
/* read directly from stream, not from saved JSON */
return buf - (size_t) *len;
} else {
/* combine saved text with new data from the jsonsl_t */
ssize_t append = buf - json->base;
if (append > 0) {
_bson_json_buf_append (
&reader->tok_accumulator, buf - append, (size_t) append);
}
return (const char *) reader->tok_accumulator.buf;
}
}
static void
_push_callback (jsonsl_t json,
jsonsl_action_t action,
struct jsonsl_state_st *state,
const char *buf)
{
bson_json_reader_t *reader = (bson_json_reader_t *) json->data;
switch (state->type) {
case JSONSL_T_STRING:
case JSONSL_T_HKEY:
case JSONSL_T_SPECIAL:
case JSONSL_T_UESCAPE:
reader->json_text_pos = state->pos_begin;
break;
case JSONSL_T_OBJECT:
_bson_json_read_start_map (reader);
break;
case JSONSL_T_LIST:
_bson_json_read_start_array (reader);
break;
default:
break;
}
}
static void
_pop_callback (jsonsl_t json,
jsonsl_action_t action,
struct jsonsl_state_st *state,
const char *buf)
{
bson_json_reader_t *reader;
bson_json_reader_bson_t *reader_bson;
ssize_t len;
double d;
const char *obj_text;
reader = (bson_json_reader_t *) json->data;
reader_bson = &reader->bson;
switch (state->type) {
case JSONSL_T_HKEY:
case JSONSL_T_STRING:
obj_text = _get_json_text (json, state, buf, &len);
BSON_ASSERT (obj_text[0] == '"');
/* remove start/end quotes, replace backslash-escapes, null-terminate */
/* you'd think it would be faster to check if state->nescapes > 0 first,
* but tests show no improvement */
if (!_bson_json_unescape (reader, state, obj_text + 1, len - 1)) {
/* reader->error is set */
jsonsl_stop (json);
break;
}
if (state->type == JSONSL_T_HKEY) {
_bson_json_read_map_key (
reader, reader_bson->unescaped.buf, reader_bson->unescaped.len);
} else {
_bson_json_read_string (
reader, reader_bson->unescaped.buf, reader_bson->unescaped.len);
}
break;
case JSONSL_T_OBJECT:
_bson_json_read_end_map (reader);
break;
case JSONSL_T_LIST:
_bson_json_read_end_array (reader);
break;
case JSONSL_T_SPECIAL:
obj_text = _get_json_text (json, state, buf, &len);
if (state->special_flags & JSONSL_SPECIALf_NUMNOINT) {
d = strtod (obj_text, NULL);
if ((d == HUGE_VAL || d == -HUGE_VAL) && errno == ERANGE) {
_bson_json_read_set_error (
reader, "Number \"%.*s\" is out of range", (int) len, obj_text);
break;
}
_bson_json_read_double (reader, d);
} else if (state->special_flags & JSONSL_SPECIALf_NUMERIC) {
int64_t i = state->nelem;
/* jsonsl puts the unsigned value in state->nelem */
if (state->special_flags & JSONSL_SPECIALf_SIGNED) {
i *= -1;
}
_bson_json_read_integer (reader, i);
} else if (state->special_flags & JSONSL_SPECIALf_BOOLEAN) {
_bson_json_read_boolean (reader, obj_text[0] == 't' ? 1 : 0);
} else if (state->special_flags & JSONSL_SPECIALf_NULL) {
_bson_json_read_null (reader);
}
break;
default:
break;
}
reader->json_text_pos = -1;
reader->tok_accumulator.len = 0;
}
static int
_error_callback (jsonsl_t json,
jsonsl_error_t err,
struct jsonsl_state_st *state,
char *errat)
{
bson_json_reader_t *reader = (bson_json_reader_t *) json->data;
if (err == JSONSL_ERROR_CANT_INSERT && *errat == '{') {
/* start the next document */
reader->should_reset = true;
reader->advance = errat - json->base;
return 0;
}
bson_set_error (reader->error,
BSON_ERROR_JSON,
BSON_JSON_ERROR_READ_CORRUPT_JS,
"Got parse error at '%c', position %d: %s",
*errat,
(int) json->pos,
jsonsl_strerror (err));
return 0;
}
/*
*--------------------------------------------------------------------------
*
* bson_json_reader_read --
*
* Read the next json document from @reader and write its value
* into @bson. @bson will be allocated as part of this process.
*
* @bson MUST be initialized before calling this function as it
* will not be initialized automatically. The reasoning for this
* is so that you can chain together bson_json_reader_t with
* other components like bson_writer_t.
*
* Returns:
* 1 if successful and data was read.
* 0 if successful and no data was read.
* -1 if there was an error and @error is set.
*
* Side effects:
* @error may be set.
*
*--------------------------------------------------------------------------
*/
int
bson_json_reader_read (bson_json_reader_t *reader, /* IN */
bson_t *bson, /* IN */
bson_error_t *error) /* OUT */
{
bson_json_reader_producer_t *p;
ssize_t start_pos;
ssize_t r;
ssize_t buf_offset;
ssize_t accum;
bson_error_t error_tmp;
int ret = 0;
BSON_ASSERT (reader);
BSON_ASSERT (bson);
p = &reader->producer;
reader->bson.bson = bson;
reader->bson.n = -1;
reader->bson.read_state = BSON_JSON_REGULAR;
reader->error = error ? error : &error_tmp;
memset (reader->error, 0, sizeof (bson_error_t));
for (;;) {
start_pos = reader->json->pos;
if (p->bytes_read > 0) {
/* leftover data from previous JSON doc in the stream */
r = p->bytes_read;
} else {
/* read a chunk of bytes by executing the callback */
r = p->cb (p->data, p->buf, p->buf_size);
}
if (r < 0) {
if (error) {
bson_set_error (error,
BSON_ERROR_JSON,
BSON_JSON_ERROR_READ_CB_FAILURE,
"reader cb failed");
}
ret = -1;
goto cleanup;
} else if (r == 0) {
break;
} else {
ret = 1;
p->bytes_read = (size_t) r;
jsonsl_feed (reader->json, (const jsonsl_char_t *) p->buf, (size_t) r);
if (reader->should_reset) {
/* end of a document */
jsonsl_reset (reader->json);
reader->should_reset = false;
/* advance past already-parsed data */
memmove (p->buf, p->buf + reader->advance, r - reader->advance);
p->bytes_read -= reader->advance;
ret = 1;
goto cleanup;
}
if (reader->error->domain) {
ret = -1;
goto cleanup;
}
/* accumulate a key or string value */
if (reader->json_text_pos != -1) {
if (reader->json_text_pos < reader->json->pos) {
accum = BSON_MIN (reader->json->pos - reader->json_text_pos, r);
/* if this chunk stopped mid-token, buf_offset is how far into
* our current chunk the token begins. */
buf_offset = AT_LEAST_0 (reader->json_text_pos - start_pos);
_bson_json_buf_append (&reader->tok_accumulator,
p->buf + buf_offset,
(size_t) accum);
}
}
p->bytes_read = 0;
}
}
cleanup:
if (ret == 1 && reader->bson.read_state != BSON_JSON_DONE) {
/* data ended in the middle */
_bson_json_read_corrupt (reader, "%s", "Incomplete JSON");
return -1;
}
return ret;
}
bson_json_reader_t *
bson_json_reader_new (void *data, /* IN */
bson_json_reader_cb cb, /* IN */
bson_json_destroy_cb dcb, /* IN */
bool allow_multiple, /* unused */
size_t buf_size) /* IN */
{
bson_json_reader_t *r;
bson_json_reader_producer_t *p;
r = bson_malloc0 (sizeof *r);
r->json = jsonsl_new (STACK_MAX);
r->json->error_callback = _error_callback;
r->json->action_callback_PUSH = _push_callback;
r->json->action_callback_POP = _pop_callback;
r->json->data = r;
r->json_text_pos = -1;
jsonsl_enable_all_callbacks (r->json);
p = &r->producer;
p->data = data;
p->cb = cb;
p->dcb = dcb;
p->buf_size = buf_size ? buf_size : BSON_JSON_DEFAULT_BUF_SIZE;
p->buf = bson_malloc (p->buf_size);
return r;
}
void
bson_json_reader_destroy (bson_json_reader_t *reader) /* IN */
{
int i;
bson_json_reader_producer_t *p = &reader->producer;
bson_json_reader_bson_t *b = &reader->bson;
if (reader->producer.dcb) {
reader->producer.dcb (reader->producer.data);
}
bson_free (p->buf);
bson_free (b->key_buf.buf);
bson_free (b->unescaped.buf);
for (i = 0; i < 3; i++) {
bson_free (b->bson_type_buf[i].buf);
}
_bson_json_code_cleanup (&b->code_data);
jsonsl_destroy (reader->json);
bson_free (reader->tok_accumulator.buf);
bson_free (reader);
}
typedef struct {
const uint8_t *data;
size_t len;
size_t bytes_parsed;
} bson_json_data_reader_t;
static ssize_t
_bson_json_data_reader_cb (void *_ctx, uint8_t *buf, size_t len)
{
size_t bytes;
bson_json_data_reader_t *ctx = (bson_json_data_reader_t *) _ctx;
if (!ctx->data) {
return -1;
}
bytes = BSON_MIN (len, ctx->len - ctx->bytes_parsed);
memcpy (buf, ctx->data + ctx->bytes_parsed, bytes);
ctx->bytes_parsed += bytes;
return bytes;
}
bson_json_reader_t *
bson_json_data_reader_new (bool allow_multiple, /* IN */
size_t size) /* IN */
{
bson_json_data_reader_t *dr = bson_malloc0 (sizeof *dr);
return bson_json_reader_new (
dr, &_bson_json_data_reader_cb, &bson_free, allow_multiple, size);
}
void
bson_json_data_reader_ingest (bson_json_reader_t *reader, /* IN */
const uint8_t *data, /* IN */
size_t len) /* IN */
{
bson_json_data_reader_t *ctx =
(bson_json_data_reader_t *) reader->producer.data;
ctx->data = data;
ctx->len = len;
ctx->bytes_parsed = 0;
}
bson_t *
bson_new_from_json (const uint8_t *data, /* IN */
ssize_t len, /* IN */
bson_error_t *error) /* OUT */
{
bson_json_reader_t *reader;
bson_t *bson;
int r;
BSON_ASSERT (data);
if (len < 0) {
len = (ssize_t) strlen ((const char *) data);
}
bson = bson_new ();
reader = bson_json_data_reader_new (false, BSON_JSON_DEFAULT_BUF_SIZE);
bson_json_data_reader_ingest (reader, data, len);
r = bson_json_reader_read (reader, bson, error);
bson_json_reader_destroy (reader);
if (r == 0) {
bson_set_error (error,
BSON_ERROR_JSON,
BSON_JSON_ERROR_READ_INVALID_PARAM,
"Empty JSON string");
}
if (r != 1) {
bson_destroy (bson);
return NULL;
}
return bson;
}
bool
bson_init_from_json (bson_t *bson, /* OUT */
const char *data, /* IN */
ssize_t len, /* IN */
bson_error_t *error) /* OUT */
{
bson_json_reader_t *reader;
int r;
BSON_ASSERT (bson);
BSON_ASSERT (data);
if (len < 0) {
len = strlen (data);
}
bson_init (bson);
reader = bson_json_data_reader_new (false, BSON_JSON_DEFAULT_BUF_SIZE);
bson_json_data_reader_ingest (reader, (const uint8_t *) data, len);
r = bson_json_reader_read (reader, bson, error);
bson_json_reader_destroy (reader);
if (r == 0) {
bson_set_error (error,
BSON_ERROR_JSON,
BSON_JSON_ERROR_READ_INVALID_PARAM,
"Empty JSON string");
}
if (r != 1) {
bson_destroy (bson);
return false;
}
return true;
}
static void
_bson_json_reader_handle_fd_destroy (void *handle) /* IN */
{
bson_json_reader_handle_fd_t *fd = handle;
if (fd) {
if ((fd->fd != -1) && fd->do_close) {
#ifdef _WIN32
_close (fd->fd);
#else
close (fd->fd);
#endif
}
bson_free (fd);
}
}
static ssize_t
_bson_json_reader_handle_fd_read (void *handle, /* IN */
uint8_t *buf, /* IN */
size_t len) /* IN */
{
bson_json_reader_handle_fd_t *fd = handle;
ssize_t ret = -1;
if (fd && (fd->fd != -1)) {
again:
#ifdef BSON_OS_WIN32
ret = _read (fd->fd, buf, (unsigned int) len);
#else
ret = read (fd->fd, buf, len);
#endif
if ((ret == -1) && (errno == EAGAIN)) {
goto again;
}
}
return ret;
}
bson_json_reader_t *
bson_json_reader_new_from_fd (int fd, /* IN */
bool close_on_destroy) /* IN */
{
bson_json_reader_handle_fd_t *handle;
BSON_ASSERT (fd != -1);
handle = bson_malloc0 (sizeof *handle);
handle->fd = fd;
handle->do_close = close_on_destroy;
return bson_json_reader_new (handle,
_bson_json_reader_handle_fd_read,
_bson_json_reader_handle_fd_destroy,
true,
BSON_JSON_DEFAULT_BUF_SIZE);
}
bson_json_reader_t *
bson_json_reader_new_from_file (const char *path, /* IN */
bson_error_t *error) /* OUT */
{
char errmsg_buf[BSON_ERROR_BUFFER_SIZE];
char *errmsg;
int fd = -1;
BSON_ASSERT (path);
#ifdef BSON_OS_WIN32
_sopen_s (&fd, path, (_O_RDONLY | _O_BINARY), _SH_DENYNO, _S_IREAD);
#else
fd = open (path, O_RDONLY);
#endif
if (fd == -1) {
errmsg = bson_strerror_r (errno, errmsg_buf, sizeof errmsg_buf);
bson_set_error (
error, BSON_ERROR_READER, BSON_ERROR_READER_BADFD, "%s", errmsg);
return NULL;
}
return bson_json_reader_new_from_fd (fd, true);
}
libbson-1.6.1/src/bson/bson-json.h 0000664 0000000 0000000 00000004250 13057346540 0016770 0 ustar 00root root 0000000 0000000 /*
* Copyright 2014 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.
*/
#ifndef BSON_JSON_H
#define BSON_JSON_H
#if !defined(BSON_INSIDE) && !defined(BSON_COMPILATION)
#error "Only can be included directly."
#endif
#include "bson.h"
BSON_BEGIN_DECLS
typedef struct _bson_json_reader_t bson_json_reader_t;
typedef enum {
BSON_JSON_ERROR_READ_CORRUPT_JS = 1,
BSON_JSON_ERROR_READ_INVALID_PARAM,
BSON_JSON_ERROR_READ_CB_FAILURE,
} bson_json_error_code_t;
typedef ssize_t (*bson_json_reader_cb) (void *handle,
uint8_t *buf,
size_t count);
typedef void (*bson_json_destroy_cb) (void *handle);
BSON_EXPORT (bson_json_reader_t *)
bson_json_reader_new (void *data,
bson_json_reader_cb cb,
bson_json_destroy_cb dcb,
bool allow_multiple,
size_t buf_size);
BSON_EXPORT (bson_json_reader_t *)
bson_json_reader_new_from_fd (int fd, bool close_on_destroy);
BSON_EXPORT (bson_json_reader_t *)
bson_json_reader_new_from_file (const char *filename, bson_error_t *error);
BSON_EXPORT (void)
bson_json_reader_destroy (bson_json_reader_t *reader);
BSON_EXPORT (int)
bson_json_reader_read (bson_json_reader_t *reader,
bson_t *bson,
bson_error_t *error);
BSON_EXPORT (bson_json_reader_t *)
bson_json_data_reader_new (bool allow_multiple, size_t size);
BSON_EXPORT (void)
bson_json_data_reader_ingest (bson_json_reader_t *reader,
const uint8_t *data,
size_t len);
BSON_END_DECLS
#endif /* BSON_JSON_H */
libbson-1.6.1/src/bson/bson-keys.c 0000664 0000000 0000000 00000022340 13057346540 0016765 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 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
#include "bson-keys.h"
#include "bson-string.h"
static const char *gUint32Strs[] = {
"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10",
"11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21",
"22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32",
"33", "34", "35", "36", "37", "38", "39", "40", "41", "42", "43",
"44", "45", "46", "47", "48", "49", "50", "51", "52", "53", "54",
"55", "56", "57", "58", "59", "60", "61", "62", "63", "64", "65",
"66", "67", "68", "69", "70", "71", "72", "73", "74", "75", "76",
"77", "78", "79", "80", "81", "82", "83", "84", "85", "86", "87",
"88", "89", "90", "91", "92", "93", "94", "95", "96", "97", "98",
"99", "100", "101", "102", "103", "104", "105", "106", "107", "108", "109",
"110", "111", "112", "113", "114", "115", "116", "117", "118", "119", "120",
"121", "122", "123", "124", "125", "126", "127", "128", "129", "130", "131",
"132", "133", "134", "135", "136", "137", "138", "139", "140", "141", "142",
"143", "144", "145", "146", "147", "148", "149", "150", "151", "152", "153",
"154", "155", "156", "157", "158", "159", "160", "161", "162", "163", "164",
"165", "166", "167", "168", "169", "170", "171", "172", "173", "174", "175",
"176", "177", "178", "179", "180", "181", "182", "183", "184", "185", "186",
"187", "188", "189", "190", "191", "192", "193", "194", "195", "196", "197",
"198", "199", "200", "201", "202", "203", "204", "205", "206", "207", "208",
"209", "210", "211", "212", "213", "214", "215", "216", "217", "218", "219",
"220", "221", "222", "223", "224", "225", "226", "227", "228", "229", "230",
"231", "232", "233", "234", "235", "236", "237", "238", "239", "240", "241",
"242", "243", "244", "245", "246", "247", "248", "249", "250", "251", "252",
"253", "254", "255", "256", "257", "258", "259", "260", "261", "262", "263",
"264", "265", "266", "267", "268", "269", "270", "271", "272", "273", "274",
"275", "276", "277", "278", "279", "280", "281", "282", "283", "284", "285",
"286", "287", "288", "289", "290", "291", "292", "293", "294", "295", "296",
"297", "298", "299", "300", "301", "302", "303", "304", "305", "306", "307",
"308", "309", "310", "311", "312", "313", "314", "315", "316", "317", "318",
"319", "320", "321", "322", "323", "324", "325", "326", "327", "328", "329",
"330", "331", "332", "333", "334", "335", "336", "337", "338", "339", "340",
"341", "342", "343", "344", "345", "346", "347", "348", "349", "350", "351",
"352", "353", "354", "355", "356", "357", "358", "359", "360", "361", "362",
"363", "364", "365", "366", "367", "368", "369", "370", "371", "372", "373",
"374", "375", "376", "377", "378", "379", "380", "381", "382", "383", "384",
"385", "386", "387", "388", "389", "390", "391", "392", "393", "394", "395",
"396", "397", "398", "399", "400", "401", "402", "403", "404", "405", "406",
"407", "408", "409", "410", "411", "412", "413", "414", "415", "416", "417",
"418", "419", "420", "421", "422", "423", "424", "425", "426", "427", "428",
"429", "430", "431", "432", "433", "434", "435", "436", "437", "438", "439",
"440", "441", "442", "443", "444", "445", "446", "447", "448", "449", "450",
"451", "452", "453", "454", "455", "456", "457", "458", "459", "460", "461",
"462", "463", "464", "465", "466", "467", "468", "469", "470", "471", "472",
"473", "474", "475", "476", "477", "478", "479", "480", "481", "482", "483",
"484", "485", "486", "487", "488", "489", "490", "491", "492", "493", "494",
"495", "496", "497", "498", "499", "500", "501", "502", "503", "504", "505",
"506", "507", "508", "509", "510", "511", "512", "513", "514", "515", "516",
"517", "518", "519", "520", "521", "522", "523", "524", "525", "526", "527",
"528", "529", "530", "531", "532", "533", "534", "535", "536", "537", "538",
"539", "540", "541", "542", "543", "544", "545", "546", "547", "548", "549",
"550", "551", "552", "553", "554", "555", "556", "557", "558", "559", "560",
"561", "562", "563", "564", "565", "566", "567", "568", "569", "570", "571",
"572", "573", "574", "575", "576", "577", "578", "579", "580", "581", "582",
"583", "584", "585", "586", "587", "588", "589", "590", "591", "592", "593",
"594", "595", "596", "597", "598", "599", "600", "601", "602", "603", "604",
"605", "606", "607", "608", "609", "610", "611", "612", "613", "614", "615",
"616", "617", "618", "619", "620", "621", "622", "623", "624", "625", "626",
"627", "628", "629", "630", "631", "632", "633", "634", "635", "636", "637",
"638", "639", "640", "641", "642", "643", "644", "645", "646", "647", "648",
"649", "650", "651", "652", "653", "654", "655", "656", "657", "658", "659",
"660", "661", "662", "663", "664", "665", "666", "667", "668", "669", "670",
"671", "672", "673", "674", "675", "676", "677", "678", "679", "680", "681",
"682", "683", "684", "685", "686", "687", "688", "689", "690", "691", "692",
"693", "694", "695", "696", "697", "698", "699", "700", "701", "702", "703",
"704", "705", "706", "707", "708", "709", "710", "711", "712", "713", "714",
"715", "716", "717", "718", "719", "720", "721", "722", "723", "724", "725",
"726", "727", "728", "729", "730", "731", "732", "733", "734", "735", "736",
"737", "738", "739", "740", "741", "742", "743", "744", "745", "746", "747",
"748", "749", "750", "751", "752", "753", "754", "755", "756", "757", "758",
"759", "760", "761", "762", "763", "764", "765", "766", "767", "768", "769",
"770", "771", "772", "773", "774", "775", "776", "777", "778", "779", "780",
"781", "782", "783", "784", "785", "786", "787", "788", "789", "790", "791",
"792", "793", "794", "795", "796", "797", "798", "799", "800", "801", "802",
"803", "804", "805", "806", "807", "808", "809", "810", "811", "812", "813",
"814", "815", "816", "817", "818", "819", "820", "821", "822", "823", "824",
"825", "826", "827", "828", "829", "830", "831", "832", "833", "834", "835",
"836", "837", "838", "839", "840", "841", "842", "843", "844", "845", "846",
"847", "848", "849", "850", "851", "852", "853", "854", "855", "856", "857",
"858", "859", "860", "861", "862", "863", "864", "865", "866", "867", "868",
"869", "870", "871", "872", "873", "874", "875", "876", "877", "878", "879",
"880", "881", "882", "883", "884", "885", "886", "887", "888", "889", "890",
"891", "892", "893", "894", "895", "896", "897", "898", "899", "900", "901",
"902", "903", "904", "905", "906", "907", "908", "909", "910", "911", "912",
"913", "914", "915", "916", "917", "918", "919", "920", "921", "922", "923",
"924", "925", "926", "927", "928", "929", "930", "931", "932", "933", "934",
"935", "936", "937", "938", "939", "940", "941", "942", "943", "944", "945",
"946", "947", "948", "949", "950", "951", "952", "953", "954", "955", "956",
"957", "958", "959", "960", "961", "962", "963", "964", "965", "966", "967",
"968", "969", "970", "971", "972", "973", "974", "975", "976", "977", "978",
"979", "980", "981", "982", "983", "984", "985", "986", "987", "988", "989",
"990", "991", "992", "993", "994", "995", "996", "997", "998", "999"};
/*
*--------------------------------------------------------------------------
*
* bson_uint32_to_string --
*
* Converts @value to a string.
*
* If @value is from 0 to 1000, it will use a constant string in the
* data section of the library.
*
* If not, a string will be formatted using @str and snprintf(). This
* is much slower, of course and therefore we try to optimize it out.
*
* @strptr will always be set. It will either point to @str or a
* constant string. You will want to use this as your key.
*
* Parameters:
* @value: A #uint32_t to convert to string.
* @strptr: (out): A pointer to the resulting string.
* @str: (out): Storage for a string made with snprintf.
* @size: Size of @str.
*
* Returns:
* The number of bytes in the resulting string.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
size_t
bson_uint32_to_string (uint32_t value, /* IN */
const char **strptr, /* OUT */
char *str, /* OUT */
size_t size) /* IN */
{
if (value < 1000) {
*strptr = gUint32Strs[value];
if (value < 10) {
return 1;
} else if (value < 100) {
return 2;
} else {
return 3;
}
}
*strptr = str;
return bson_snprintf (str, size, "%u", value);
}
libbson-1.6.1/src/bson/bson-keys.h 0000664 0000000 0000000 00000001640 13057346540 0016772 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 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.
*/
#ifndef BSON_KEYS_H
#define BSON_KEYS_H
#include "bson-macros.h"
#include "bson-types.h"
BSON_BEGIN_DECLS
BSON_EXPORT (size_t)
bson_uint32_to_string (uint32_t value,
const char **strptr,
char *str,
size_t size);
BSON_END_DECLS
#endif /* BSON_KEYS_H */
libbson-1.6.1/src/bson/bson-macros.h 0000664 0000000 0000000 00000013733 13057346540 0017311 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 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.
*/
#ifndef BSON_MACROS_H
#define BSON_MACROS_H
#if !defined(BSON_INSIDE) && !defined(BSON_COMPILATION)
#error "Only can be included directly."
#endif
#include
#include
#ifdef __cplusplus
#include
#endif
#include "bson-config.h"
#if BSON_OS == 1
#define BSON_OS_UNIX
#elif BSON_OS == 2
#define BSON_OS_WIN32
#else
#error "Unknown operating system."
#endif
#ifdef __cplusplus
#define BSON_BEGIN_DECLS extern "C" {
#define BSON_END_DECLS }
#else
#define BSON_BEGIN_DECLS
#define BSON_END_DECLS
#endif
#define BSON_GNUC_CHECK_VERSION(major, minor) \
(defined (__GNUC__) && \
((__GNUC__ > (major)) || \
((__GNUC__ == (major)) && (__GNUC_MINOR__ >= (minor)))))
#define BSON_GNUC_IS_VERSION(major, minor) \
(defined (__GNUC__) && (__GNUC__ == (major)) && (__GNUC_MINOR__ == (minor)))
#ifdef _MSC_VER
#ifdef BSON_COMPILATION
#define BSON_API __declspec(dllexport)
#else
#define BSON_API __declspec(dllimport)
#endif
#define BSON_CALL __cdecl
#elif defined(__GNUC__)
#define BSON_API __attribute__ ((visibility ("default")))
#define BSON_CALL
#else
#define BSON_API
#define BSON_CALL
#endif
#define BSON_EXPORT(type) BSON_API type BSON_CALL
#ifdef MIN
#define BSON_MIN MIN
#elif defined(__cplusplus)
#define BSON_MIN(a, b) ((std::min) (a, b))
#elif defined(_MSC_VER)
#define BSON_MIN(a, b) ((a) < (b) ? (a) : (b))
#else
#define BSON_MIN(a, b) (((a) < (b)) ? (a) : (b))
#endif
#ifdef MAX
#define BSON_MAX MAX
#elif defined(__cplusplus)
#define BSON_MAX(a, b) ((std::max) (a, b))
#elif defined(_MSC_VER)
#define BSON_MAX(a, b) ((a) > (b) ? (a) : (b))
#else
#define BSON_MAX(a, b) (((a) > (b)) ? (a) : (b))
#endif
#ifdef ABS
#define BSON_ABS ABS
#else
#define BSON_ABS(a) (((a) < 0) ? ((a) * -1) : (a))
#endif
#ifdef _MSC_VER
#ifdef _WIN64
#define BSON_ALIGN_OF_PTR 8
#else
#define BSON_ALIGN_OF_PTR 4
#endif
#else
#define BSON_ALIGN_OF_PTR (sizeof (void *))
#endif
#ifdef BSON_EXTRA_ALIGN
#if defined(_MSC_VER)
#define BSON_ALIGNED_BEGIN(_N) __declspec(align (_N))
#define BSON_ALIGNED_END(_N)
#else
#define BSON_ALIGNED_BEGIN(_N)
#define BSON_ALIGNED_END(_N) __attribute__ ((aligned (_N)))
#endif
#else
#if defined(_MSC_VER)
#define BSON_ALIGNED_BEGIN(_N) __declspec(align (BSON_ALIGN_OF_PTR))
#define BSON_ALIGNED_END(_N)
#else
#define BSON_ALIGNED_BEGIN(_N)
#define BSON_ALIGNED_END(_N) \
__attribute__ ( \
(aligned ((_N) > BSON_ALIGN_OF_PTR ? BSON_ALIGN_OF_PTR : (_N))))
#endif
#endif
#define bson_str_empty(s) (!s[0])
#define bson_str_empty0(s) (!s || !s[0])
#if defined(_WIN32)
#define BSON_FUNC __FUNCTION__
#elif defined(__STDC_VERSION__) && __STDC_VERSION__ < 199901L
#define BSON_FUNC __FUNCTION__
#else
#define BSON_FUNC __func__
#endif
#define BSON_ASSERT(test) \
do { \
if (!(BSON_LIKELY (test))) { \
fprintf (stderr, \
"%s:%d %s(): precondition failed: %s\n", \
__FILE__, \
__LINE__, \
BSON_FUNC, \
#test); \
abort (); \
} \
} while (0)
#define BSON_STATIC_ASSERT(s) BSON_STATIC_ASSERT_ (s, __LINE__)
#define BSON_STATIC_ASSERT_JOIN(a, b) BSON_STATIC_ASSERT_JOIN2 (a, b)
#define BSON_STATIC_ASSERT_JOIN2(a, b) a##b
#define BSON_STATIC_ASSERT_(s, l) \
typedef char BSON_STATIC_ASSERT_JOIN (static_assert_test_, \
__LINE__)[(s) ? 1 : -1]
#if defined(__GNUC__)
#define BSON_GNUC_CONST __attribute__ ((const))
#define BSON_GNUC_WARN_UNUSED_RESULT __attribute__ ((warn_unused_result))
#else
#define BSON_GNUC_CONST
#define BSON_GNUC_WARN_UNUSED_RESULT
#endif
#if BSON_GNUC_CHECK_VERSION(4, 0) && !defined(_WIN32)
#define BSON_GNUC_NULL_TERMINATED __attribute__ ((sentinel))
#define BSON_GNUC_INTERNAL __attribute__ ((visibility ("hidden")))
#else
#define BSON_GNUC_NULL_TERMINATED
#define BSON_GNUC_INTERNAL
#endif
#if defined(__GNUC__)
#define BSON_LIKELY(x) __builtin_expect (!!(x), 1)
#define BSON_UNLIKELY(x) __builtin_expect (!!(x), 0)
#else
#define BSON_LIKELY(v) v
#define BSON_UNLIKELY(v) v
#endif
#if defined(__clang__)
#define BSON_GNUC_PRINTF(f, v) __attribute__ ((format (printf, f, v)))
#elif BSON_GNUC_CHECK_VERSION(4, 4)
#define BSON_GNUC_PRINTF(f, v) __attribute__ ((format (gnu_printf, f, v)))
#else
#define BSON_GNUC_PRINTF(f, v)
#endif
#if defined(__LP64__) || defined(_LP64)
#define BSON_WORD_SIZE 64
#else
#define BSON_WORD_SIZE 32
#endif
#if defined(_MSC_VER)
#define BSON_INLINE __inline
#else
#define BSON_INLINE __inline__
#endif
#ifdef _MSC_VER
#define BSON_ENSURE_ARRAY_PARAM_SIZE(_n)
#define BSON_TYPEOF decltype
#else
#define BSON_ENSURE_ARRAY_PARAM_SIZE(_n) static(_n)
#define BSON_TYPEOF typeof
#endif
#if BSON_GNUC_CHECK_VERSION(3, 1)
#define BSON_GNUC_DEPRECATED __attribute__ ((__deprecated__))
#else
#define BSON_GNUC_DEPRECATED
#endif
#if BSON_GNUC_CHECK_VERSION(4, 5)
#define BSON_GNUC_DEPRECATED_FOR(f) \
__attribute__ ((deprecated ("Use " #f " instead")))
#else
#define BSON_GNUC_DEPRECATED_FOR(f) BSON_GNUC_DEPRECATED
#endif
#endif /* BSON_MACROS_H */
libbson-1.6.1/src/bson/bson-md5.c 0000664 0000000 0000000 00000031012 13057346540 0016473 0 ustar 00root root 0000000 0000000 /*
Copyright (C) 1999, 2000, 2002 Aladdin Enterprises. All rights reserved.
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
L. Peter Deutsch
ghost@aladdin.com
*/
/* $Id: md5.c,v 1.6 2002/04/13 19:20:28 lpd Exp $ */
/*
Independent implementation of MD5 (RFC 1321).
This code implements the MD5 Algorithm defined in RFC 1321, whose
text is available at
http://www.ietf.org/rfc/rfc1321.txt
The code is derived from the text of the RFC, including the test suite
(section A.5) but excluding the rest of Appendix A. It does not include
any code or documentation that is identified in the RFC as being
copyrighted.
The original and principal author of md5.c is L. Peter Deutsch
. Other authors are noted in the change history
that follows (in reverse chronological order):
2002-04-13 lpd Clarified derivation from RFC 1321; now handles byte order
either statically or dynamically; added missing #include
in library.
2002-03-11 lpd Corrected argument list for main(), and added int return
type, in test program and T value program.
2002-02-21 lpd Added missing #include in test program.
2000-07-03 lpd Patched to eliminate warnings about "constant is
unsigned in ANSI C, signed in traditional"; made test program
self-checking.
1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5).
1999-05-03 lpd Original version.
*/
/*
* The following MD5 implementation has been modified to use types as
* specified in libbson.
*/
#include "bson-compat.h"
#include
#include "bson-md5.h"
#undef BYTE_ORDER /* 1 = big-endian, -1 = little-endian, 0 = unknown */
#if BSON_BYTE_ORDER == BSON_BIG_ENDIAN
#define BYTE_ORDER 1
#else
#define BYTE_ORDER -1
#endif
#define T_MASK ((uint32_t) ~0)
#define T1 /* 0xd76aa478 */ (T_MASK ^ 0x28955b87)
#define T2 /* 0xe8c7b756 */ (T_MASK ^ 0x173848a9)
#define T3 0x242070db
#define T4 /* 0xc1bdceee */ (T_MASK ^ 0x3e423111)
#define T5 /* 0xf57c0faf */ (T_MASK ^ 0x0a83f050)
#define T6 0x4787c62a
#define T7 /* 0xa8304613 */ (T_MASK ^ 0x57cfb9ec)
#define T8 /* 0xfd469501 */ (T_MASK ^ 0x02b96afe)
#define T9 0x698098d8
#define T10 /* 0x8b44f7af */ (T_MASK ^ 0x74bb0850)
#define T11 /* 0xffff5bb1 */ (T_MASK ^ 0x0000a44e)
#define T12 /* 0x895cd7be */ (T_MASK ^ 0x76a32841)
#define T13 0x6b901122
#define T14 /* 0xfd987193 */ (T_MASK ^ 0x02678e6c)
#define T15 /* 0xa679438e */ (T_MASK ^ 0x5986bc71)
#define T16 0x49b40821
#define T17 /* 0xf61e2562 */ (T_MASK ^ 0x09e1da9d)
#define T18 /* 0xc040b340 */ (T_MASK ^ 0x3fbf4cbf)
#define T19 0x265e5a51
#define T20 /* 0xe9b6c7aa */ (T_MASK ^ 0x16493855)
#define T21 /* 0xd62f105d */ (T_MASK ^ 0x29d0efa2)
#define T22 0x02441453
#define T23 /* 0xd8a1e681 */ (T_MASK ^ 0x275e197e)
#define T24 /* 0xe7d3fbc8 */ (T_MASK ^ 0x182c0437)
#define T25 0x21e1cde6
#define T26 /* 0xc33707d6 */ (T_MASK ^ 0x3cc8f829)
#define T27 /* 0xf4d50d87 */ (T_MASK ^ 0x0b2af278)
#define T28 0x455a14ed
#define T29 /* 0xa9e3e905 */ (T_MASK ^ 0x561c16fa)
#define T30 /* 0xfcefa3f8 */ (T_MASK ^ 0x03105c07)
#define T31 0x676f02d9
#define T32 /* 0x8d2a4c8a */ (T_MASK ^ 0x72d5b375)
#define T33 /* 0xfffa3942 */ (T_MASK ^ 0x0005c6bd)
#define T34 /* 0x8771f681 */ (T_MASK ^ 0x788e097e)
#define T35 0x6d9d6122
#define T36 /* 0xfde5380c */ (T_MASK ^ 0x021ac7f3)
#define T37 /* 0xa4beea44 */ (T_MASK ^ 0x5b4115bb)
#define T38 0x4bdecfa9
#define T39 /* 0xf6bb4b60 */ (T_MASK ^ 0x0944b49f)
#define T40 /* 0xbebfbc70 */ (T_MASK ^ 0x4140438f)
#define T41 0x289b7ec6
#define T42 /* 0xeaa127fa */ (T_MASK ^ 0x155ed805)
#define T43 /* 0xd4ef3085 */ (T_MASK ^ 0x2b10cf7a)
#define T44 0x04881d05
#define T45 /* 0xd9d4d039 */ (T_MASK ^ 0x262b2fc6)
#define T46 /* 0xe6db99e5 */ (T_MASK ^ 0x1924661a)
#define T47 0x1fa27cf8
#define T48 /* 0xc4ac5665 */ (T_MASK ^ 0x3b53a99a)
#define T49 /* 0xf4292244 */ (T_MASK ^ 0x0bd6ddbb)
#define T50 0x432aff97
#define T51 /* 0xab9423a7 */ (T_MASK ^ 0x546bdc58)
#define T52 /* 0xfc93a039 */ (T_MASK ^ 0x036c5fc6)
#define T53 0x655b59c3
#define T54 /* 0x8f0ccc92 */ (T_MASK ^ 0x70f3336d)
#define T55 /* 0xffeff47d */ (T_MASK ^ 0x00100b82)
#define T56 /* 0x85845dd1 */ (T_MASK ^ 0x7a7ba22e)
#define T57 0x6fa87e4f
#define T58 /* 0xfe2ce6e0 */ (T_MASK ^ 0x01d3191f)
#define T59 /* 0xa3014314 */ (T_MASK ^ 0x5cfebceb)
#define T60 0x4e0811a1
#define T61 /* 0xf7537e82 */ (T_MASK ^ 0x08ac817d)
#define T62 /* 0xbd3af235 */ (T_MASK ^ 0x42c50dca)
#define T63 0x2ad7d2bb
#define T64 /* 0xeb86d391 */ (T_MASK ^ 0x14792c6e)
static void
bson_md5_process (bson_md5_t *md5, const uint8_t *data)
{
uint32_t a = md5->abcd[0];
uint32_t b = md5->abcd[1];
uint32_t c = md5->abcd[2];
uint32_t d = md5->abcd[3];
uint32_t t;
#if BYTE_ORDER > 0
/* Define storage only for big-endian CPUs. */
uint32_t X[16];
#else
/* Define storage for little-endian or both types of CPUs. */
uint32_t xbuf[16];
const uint32_t *X;
#endif
{
#if BYTE_ORDER == 0
/*
* Determine dynamically whether this is a big-endian or
* little-endian machine, since we can use a more efficient
* algorithm on the latter.
*/
static const int w = 1;
if (*((const uint8_t *) &w)) /* dynamic little-endian */
#endif
#if BYTE_ORDER <= 0 /* little-endian */
{
/*
* On little-endian machines, we can process properly aligned
* data without copying it.
*/
if (!((data - (const uint8_t *) 0) & 3)) {
/* data are properly aligned */
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wcast-align"
#endif
X = (const uint32_t *) data;
#ifdef __clang__
#pragma clang diagnostic pop
#endif
} else {
/* not aligned */
memcpy (xbuf, data, sizeof (xbuf));
X = xbuf;
}
}
#endif
#if BYTE_ORDER == 0
else /* dynamic big-endian */
#endif
#if BYTE_ORDER >= 0 /* big-endian */
{
/*
* On big-endian machines, we must arrange the bytes in the
* right order.
*/
const uint8_t *xp = data;
int i;
#if BYTE_ORDER == 0
X = xbuf; /* (dynamic only) */
#else
#define xbuf X /* (static only) */
#endif
for (i = 0; i < 16; ++i, xp += 4)
xbuf[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24);
}
#endif
}
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
/* Round 1. */
/* Let [abcd k s i] denote the operation
a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
#define F(x, y, z) (((x) & (y)) | (~(x) & (z)))
#define SET(a, b, c, d, k, s, Ti) \
t = a + F (b, c, d) + X[k] + Ti; \
a = ROTATE_LEFT (t, s) + b
/* Do the following 16 operations. */
SET (a, b, c, d, 0, 7, T1);
SET (d, a, b, c, 1, 12, T2);
SET (c, d, a, b, 2, 17, T3);
SET (b, c, d, a, 3, 22, T4);
SET (a, b, c, d, 4, 7, T5);
SET (d, a, b, c, 5, 12, T6);
SET (c, d, a, b, 6, 17, T7);
SET (b, c, d, a, 7, 22, T8);
SET (a, b, c, d, 8, 7, T9);
SET (d, a, b, c, 9, 12, T10);
SET (c, d, a, b, 10, 17, T11);
SET (b, c, d, a, 11, 22, T12);
SET (a, b, c, d, 12, 7, T13);
SET (d, a, b, c, 13, 12, T14);
SET (c, d, a, b, 14, 17, T15);
SET (b, c, d, a, 15, 22, T16);
#undef SET
/* Round 2. */
/* Let [abcd k s i] denote the operation
a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
#define G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
#define SET(a, b, c, d, k, s, Ti) \
t = a + G (b, c, d) + X[k] + Ti; \
a = ROTATE_LEFT (t, s) + b
/* Do the following 16 operations. */
SET (a, b, c, d, 1, 5, T17);
SET (d, a, b, c, 6, 9, T18);
SET (c, d, a, b, 11, 14, T19);
SET (b, c, d, a, 0, 20, T20);
SET (a, b, c, d, 5, 5, T21);
SET (d, a, b, c, 10, 9, T22);
SET (c, d, a, b, 15, 14, T23);
SET (b, c, d, a, 4, 20, T24);
SET (a, b, c, d, 9, 5, T25);
SET (d, a, b, c, 14, 9, T26);
SET (c, d, a, b, 3, 14, T27);
SET (b, c, d, a, 8, 20, T28);
SET (a, b, c, d, 13, 5, T29);
SET (d, a, b, c, 2, 9, T30);
SET (c, d, a, b, 7, 14, T31);
SET (b, c, d, a, 12, 20, T32);
#undef SET
/* Round 3. */
/* Let [abcd k s t] denote the operation
a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
#define H(x, y, z) ((x) ^ (y) ^ (z))
#define SET(a, b, c, d, k, s, Ti) \
t = a + H (b, c, d) + X[k] + Ti; \
a = ROTATE_LEFT (t, s) + b
/* Do the following 16 operations. */
SET (a, b, c, d, 5, 4, T33);
SET (d, a, b, c, 8, 11, T34);
SET (c, d, a, b, 11, 16, T35);
SET (b, c, d, a, 14, 23, T36);
SET (a, b, c, d, 1, 4, T37);
SET (d, a, b, c, 4, 11, T38);
SET (c, d, a, b, 7, 16, T39);
SET (b, c, d, a, 10, 23, T40);
SET (a, b, c, d, 13, 4, T41);
SET (d, a, b, c, 0, 11, T42);
SET (c, d, a, b, 3, 16, T43);
SET (b, c, d, a, 6, 23, T44);
SET (a, b, c, d, 9, 4, T45);
SET (d, a, b, c, 12, 11, T46);
SET (c, d, a, b, 15, 16, T47);
SET (b, c, d, a, 2, 23, T48);
#undef SET
/* Round 4. */
/* Let [abcd k s t] denote the operation
a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
#define I(x, y, z) ((y) ^ ((x) | ~(z)))
#define SET(a, b, c, d, k, s, Ti) \
t = a + I (b, c, d) + X[k] + Ti; \
a = ROTATE_LEFT (t, s) + b
/* Do the following 16 operations. */
SET (a, b, c, d, 0, 6, T49);
SET (d, a, b, c, 7, 10, T50);
SET (c, d, a, b, 14, 15, T51);
SET (b, c, d, a, 5, 21, T52);
SET (a, b, c, d, 12, 6, T53);
SET (d, a, b, c, 3, 10, T54);
SET (c, d, a, b, 10, 15, T55);
SET (b, c, d, a, 1, 21, T56);
SET (a, b, c, d, 8, 6, T57);
SET (d, a, b, c, 15, 10, T58);
SET (c, d, a, b, 6, 15, T59);
SET (b, c, d, a, 13, 21, T60);
SET (a, b, c, d, 4, 6, T61);
SET (d, a, b, c, 11, 10, T62);
SET (c, d, a, b, 2, 15, T63);
SET (b, c, d, a, 9, 21, T64);
#undef SET
/* Then perform the following additions. (That is increment each
of the four registers by the value it had before this block
was started.) */
md5->abcd[0] += a;
md5->abcd[1] += b;
md5->abcd[2] += c;
md5->abcd[3] += d;
}
void
bson_md5_init (bson_md5_t *pms)
{
pms->count[0] = pms->count[1] = 0;
pms->abcd[0] = 0x67452301;
pms->abcd[1] = /*0xefcdab89*/ T_MASK ^ 0x10325476;
pms->abcd[2] = /*0x98badcfe*/ T_MASK ^ 0x67452301;
pms->abcd[3] = 0x10325476;
}
void
bson_md5_append (bson_md5_t *pms, const uint8_t *data, uint32_t nbytes)
{
const uint8_t *p = data;
int left = nbytes;
int offset = (pms->count[0] >> 3) & 63;
uint32_t nbits = (uint32_t) (nbytes << 3);
if (nbytes <= 0)
return;
/* Update the message length. */
pms->count[1] += nbytes >> 29;
pms->count[0] += nbits;
if (pms->count[0] < nbits)
pms->count[1]++;
/* Process an initial partial block. */
if (offset) {
int copy = (offset + nbytes > 64 ? 64 - offset : nbytes);
memcpy (pms->buf + offset, p, copy);
if (offset + copy < 64)
return;
p += copy;
left -= copy;
bson_md5_process (pms, pms->buf);
}
/* Process full blocks. */
for (; left >= 64; p += 64, left -= 64)
bson_md5_process (pms, p);
/* Process a final partial block. */
if (left)
memcpy (pms->buf, p, left);
}
void
bson_md5_finish (bson_md5_t *pms, uint8_t digest[16])
{
static const uint8_t pad[64] = {
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
uint8_t data[8];
int i;
/* Save the length before padding. */
for (i = 0; i < 8; ++i)
data[i] = (uint8_t) (pms->count[i >> 2] >> ((i & 3) << 3));
/* Pad to 56 bytes mod 64. */
bson_md5_append (pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1);
/* Append the length. */
bson_md5_append (pms, data, sizeof (data));
for (i = 0; i < 16; ++i)
digest[i] = (uint8_t) (pms->abcd[i >> 2] >> ((i & 3) << 3));
}
libbson-1.6.1/src/bson/bson-md5.h 0000664 0000000 0000000 00000005425 13057346540 0016511 0 ustar 00root root 0000000 0000000 /*
Copyright (C) 1999, 2002 Aladdin Enterprises. All rights reserved.
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
L. Peter Deutsch
ghost@aladdin.com
*/
/* $Id: md5.h,v 1.4 2002/04/13 19:20:28 lpd Exp $ */
/*
Independent implementation of MD5 (RFC 1321).
This code implements the MD5 Algorithm defined in RFC 1321, whose
text is available at
http://www.ietf.org/rfc/rfc1321.txt
The code is derived from the text of the RFC, including the test suite
(section A.5) but excluding the rest of Appendix A. It does not include
any code or documentation that is identified in the RFC as being
copyrighted.
The original and principal author of md5.h is L. Peter Deutsch
. Other authors are noted in the change history
that follows (in reverse chronological order):
2002-04-13 lpd Removed support for non-ANSI compilers; removed
references to Ghostscript; clarified derivation from RFC 1321;
now handles byte order either statically or dynamically.
1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5);
added conditionalization for C++ compilation from Martin
Purschke .
1999-05-03 lpd Original version.
*/
/*
* The following MD5 implementation has been modified to use types as
* specified in libbson.
*/
#ifndef BSON_MD5_H
#define BSON_MD5_H
#if !defined(BSON_INSIDE) && !defined(BSON_COMPILATION)
#error "Only can be included directly."
#endif
#include "bson-endian.h"
BSON_BEGIN_DECLS
typedef struct {
uint32_t count[2]; /* message length in bits, lsw first */
uint32_t abcd[4]; /* digest buffer */
uint8_t buf[64]; /* accumulate block */
} bson_md5_t;
BSON_EXPORT (void)
bson_md5_init (bson_md5_t *pms);
BSON_EXPORT (void)
bson_md5_append (bson_md5_t *pms, const uint8_t *data, uint32_t nbytes);
BSON_EXPORT (void)
bson_md5_finish (bson_md5_t *pms, uint8_t digest[16]);
BSON_END_DECLS
#endif /* BSON_MD5_H */
libbson-1.6.1/src/bson/bson-memory.c 0000664 0000000 0000000 00000015260 13057346540 0017325 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 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
#include
#include "bson-atomic.h"
#include "bson-config.h"
#include "bson-memory.h"
static bson_mem_vtable_t gMemVtable = {
malloc,
calloc,
#ifdef BSON_HAVE_REALLOCF
reallocf,
#else
realloc,
#endif
free,
};
/*
*--------------------------------------------------------------------------
*
* bson_malloc --
*
* Allocates @num_bytes of memory and returns a pointer to it. If
* malloc failed to allocate the memory, abort() is called.
*
* Libbson does not try to handle OOM conditions as it is beyond the
* scope of this library to handle so appropriately.
*
* Parameters:
* @num_bytes: The number of bytes to allocate.
*
* Returns:
* A pointer if successful; otherwise abort() is called and this
* function will never return.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
void *
bson_malloc (size_t num_bytes) /* IN */
{
void *mem = NULL;
if (BSON_LIKELY (num_bytes)) {
if (BSON_UNLIKELY (!(mem = gMemVtable.malloc (num_bytes)))) {
abort ();
}
}
return mem;
}
/*
*--------------------------------------------------------------------------
*
* bson_malloc0 --
*
* Like bson_malloc() except the memory is zeroed first. This is
* similar to calloc() except that abort() is called in case of
* failure to allocate memory.
*
* Parameters:
* @num_bytes: The number of bytes to allocate.
*
* Returns:
* A pointer if successful; otherwise abort() is called and this
* function will never return.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
void *
bson_malloc0 (size_t num_bytes) /* IN */
{
void *mem = NULL;
if (BSON_LIKELY (num_bytes)) {
if (BSON_UNLIKELY (!(mem = gMemVtable.calloc (1, num_bytes)))) {
abort ();
}
}
return mem;
}
/*
*--------------------------------------------------------------------------
*
* bson_realloc --
*
* This function behaves similar to realloc() except that if there is
* a failure abort() is called.
*
* Parameters:
* @mem: The memory to realloc, or NULL.
* @num_bytes: The size of the new allocation or 0 to free.
*
* Returns:
* The new allocation if successful; otherwise abort() is called and
* this function never returns.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
void *
bson_realloc (void *mem, /* IN */
size_t num_bytes) /* IN */
{
/*
* Not all platforms are guaranteed to free() the memory if a call to
* realloc() with a size of zero occurs. Windows, Linux, and FreeBSD do,
* however, OS X does not.
*/
if (BSON_UNLIKELY (num_bytes == 0)) {
gMemVtable.free (mem);
return NULL;
}
mem = gMemVtable.realloc (mem, num_bytes);
if (BSON_UNLIKELY (!mem)) {
abort ();
}
return mem;
}
/*
*--------------------------------------------------------------------------
*
* bson_realloc_ctx --
*
* This wraps bson_realloc and provides a compatible api for similar
* functions with a context
*
* Parameters:
* @mem: The memory to realloc, or NULL.
* @num_bytes: The size of the new allocation or 0 to free.
* @ctx: Ignored
*
* Returns:
* The new allocation if successful; otherwise abort() is called and
* this function never returns.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
void *
bson_realloc_ctx (void *mem, /* IN */
size_t num_bytes, /* IN */
void *ctx) /* IN */
{
return bson_realloc (mem, num_bytes);
}
/*
*--------------------------------------------------------------------------
*
* bson_free --
*
* Frees @mem using the underlying allocator.
*
* Currently, this only calls free() directly, but that is subject to
* change.
*
* Parameters:
* @mem: An allocation to free.
*
* Returns:
* None.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
void
bson_free (void *mem) /* IN */
{
gMemVtable.free (mem);
}
/*
*--------------------------------------------------------------------------
*
* bson_zero_free --
*
* Frees @mem using the underlying allocator. @size bytes of @mem will
* be zeroed before freeing the memory. This is useful in scenarios
* where @mem contains passwords or other sensitive information.
*
* Parameters:
* @mem: An allocation to free.
* @size: The number of bytes in @mem.
*
* Returns:
* None.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
void
bson_zero_free (void *mem, /* IN */
size_t size) /* IN */
{
if (BSON_LIKELY (mem)) {
memset (mem, 0, size);
gMemVtable.free (mem);
}
}
/*
*--------------------------------------------------------------------------
*
* bson_mem_set_vtable --
*
* This function will change our allocationt vtable.
*
* It is imperitive that this is called at the beginning of the
* process before any memory has been allocated by the default
* allocator.
*
* Returns:
* None.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
void
bson_mem_set_vtable (const bson_mem_vtable_t *vtable)
{
BSON_ASSERT (vtable);
if (!vtable->malloc || !vtable->calloc || !vtable->realloc ||
!vtable->free) {
fprintf (stderr,
"Failure to install BSON vtable, "
"missing functions.\n");
return;
}
gMemVtable = *vtable;
}
void
bson_mem_restore_vtable (void)
{
bson_mem_vtable_t vtable = {
malloc,
calloc,
#ifdef BSON_HAVE_REALLOCF
reallocf,
#else
realloc,
#endif
free,
};
bson_mem_set_vtable (&vtable);
}
libbson-1.6.1/src/bson/bson-memory.h 0000664 0000000 0000000 00000003227 13057346540 0017332 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 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.
*/
#ifndef BSON_MEMORY_H
#define BSON_MEMORY_H
#if !defined(BSON_INSIDE) && !defined(BSON_COMPILATION)
#error "Only can be included directly."
#endif
#include "bson-macros.h"
#include "bson-types.h"
BSON_BEGIN_DECLS
typedef void *(*bson_realloc_func) (void *mem, size_t num_bytes, void *ctx);
typedef struct _bson_mem_vtable_t {
void *(*malloc) (size_t num_bytes);
void *(*calloc) (size_t n_members, size_t num_bytes);
void *(*realloc) (void *mem, size_t num_bytes);
void (*free) (void *mem);
void *padding[4];
} bson_mem_vtable_t;
BSON_EXPORT (void)
bson_mem_set_vtable (const bson_mem_vtable_t *vtable);
BSON_EXPORT (void)
bson_mem_restore_vtable (void);
BSON_EXPORT (void *)
bson_malloc (size_t num_bytes);
BSON_EXPORT (void *)
bson_malloc0 (size_t num_bytes);
BSON_EXPORT (void *)
bson_realloc (void *mem, size_t num_bytes);
BSON_EXPORT (void *)
bson_realloc_ctx (void *mem, size_t num_bytes, void *ctx);
BSON_EXPORT (void)
bson_free (void *mem);
BSON_EXPORT (void)
bson_zero_free (void *mem, size_t size);
BSON_END_DECLS
#endif /* BSON_MEMORY_H */
libbson-1.6.1/src/bson/bson-oid.c 0000664 0000000 0000000 00000034731 13057346540 0016574 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 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 "bson-compat.h"
#include
#include
#include
#include
#include "bson-context-private.h"
#include "bson-md5.h"
#include "bson-oid.h"
#include "bson-string.h"
/*
* This table contains an array of two character pairs for every possible
* uint8_t. It is used as a lookup table when encoding a bson_oid_t
* to hex formatted ASCII. Performing two characters at a time roughly
* reduces the number of operations by one-half.
*/
static const uint16_t gHexCharPairs[] = {
#if BSON_BYTE_ORDER == BSON_BIG_ENDIAN
12336, 12337, 12338, 12339, 12340, 12341, 12342, 12343, 12344, 12345, 12385,
12386, 12387, 12388, 12389, 12390, 12592, 12593, 12594, 12595, 12596, 12597,
12598, 12599, 12600, 12601, 12641, 12642, 12643, 12644, 12645, 12646, 12848,
12849, 12850, 12851, 12852, 12853, 12854, 12855, 12856, 12857, 12897, 12898,
12899, 12900, 12901, 12902, 13104, 13105, 13106, 13107, 13108, 13109, 13110,
13111, 13112, 13113, 13153, 13154, 13155, 13156, 13157, 13158, 13360, 13361,
13362, 13363, 13364, 13365, 13366, 13367, 13368, 13369, 13409, 13410, 13411,
13412, 13413, 13414, 13616, 13617, 13618, 13619, 13620, 13621, 13622, 13623,
13624, 13625, 13665, 13666, 13667, 13668, 13669, 13670, 13872, 13873, 13874,
13875, 13876, 13877, 13878, 13879, 13880, 13881, 13921, 13922, 13923, 13924,
13925, 13926, 14128, 14129, 14130, 14131, 14132, 14133, 14134, 14135, 14136,
14137, 14177, 14178, 14179, 14180, 14181, 14182, 14384, 14385, 14386, 14387,
14388, 14389, 14390, 14391, 14392, 14393, 14433, 14434, 14435, 14436, 14437,
14438, 14640, 14641, 14642, 14643, 14644, 14645, 14646, 14647, 14648, 14649,
14689, 14690, 14691, 14692, 14693, 14694, 24880, 24881, 24882, 24883, 24884,
24885, 24886, 24887, 24888, 24889, 24929, 24930, 24931, 24932, 24933, 24934,
25136, 25137, 25138, 25139, 25140, 25141, 25142, 25143, 25144, 25145, 25185,
25186, 25187, 25188, 25189, 25190, 25392, 25393, 25394, 25395, 25396, 25397,
25398, 25399, 25400, 25401, 25441, 25442, 25443, 25444, 25445, 25446, 25648,
25649, 25650, 25651, 25652, 25653, 25654, 25655, 25656, 25657, 25697, 25698,
25699, 25700, 25701, 25702, 25904, 25905, 25906, 25907, 25908, 25909, 25910,
25911, 25912, 25913, 25953, 25954, 25955, 25956, 25957, 25958, 26160, 26161,
26162, 26163, 26164, 26165, 26166, 26167, 26168, 26169, 26209, 26210, 26211,
26212, 26213, 26214
#else
12336, 12592, 12848, 13104, 13360, 13616, 13872, 14128, 14384, 14640, 24880,
25136, 25392, 25648, 25904, 26160, 12337, 12593, 12849, 13105, 13361, 13617,
13873, 14129, 14385, 14641, 24881, 25137, 25393, 25649, 25905, 26161, 12338,
12594, 12850, 13106, 13362, 13618, 13874, 14130, 14386, 14642, 24882, 25138,
25394, 25650, 25906, 26162, 12339, 12595, 12851, 13107, 13363, 13619, 13875,
14131, 14387, 14643, 24883, 25139, 25395, 25651, 25907, 26163, 12340, 12596,
12852, 13108, 13364, 13620, 13876, 14132, 14388, 14644, 24884, 25140, 25396,
25652, 25908, 26164, 12341, 12597, 12853, 13109, 13365, 13621, 13877, 14133,
14389, 14645, 24885, 25141, 25397, 25653, 25909, 26165, 12342, 12598, 12854,
13110, 13366, 13622, 13878, 14134, 14390, 14646, 24886, 25142, 25398, 25654,
25910, 26166, 12343, 12599, 12855, 13111, 13367, 13623, 13879, 14135, 14391,
14647, 24887, 25143, 25399, 25655, 25911, 26167, 12344, 12600, 12856, 13112,
13368, 13624, 13880, 14136, 14392, 14648, 24888, 25144, 25400, 25656, 25912,
26168, 12345, 12601, 12857, 13113, 13369, 13625, 13881, 14137, 14393, 14649,
24889, 25145, 25401, 25657, 25913, 26169, 12385, 12641, 12897, 13153, 13409,
13665, 13921, 14177, 14433, 14689, 24929, 25185, 25441, 25697, 25953, 26209,
12386, 12642, 12898, 13154, 13410, 13666, 13922, 14178, 14434, 14690, 24930,
25186, 25442, 25698, 25954, 26210, 12387, 12643, 12899, 13155, 13411, 13667,
13923, 14179, 14435, 14691, 24931, 25187, 25443, 25699, 25955, 26211, 12388,
12644, 12900, 13156, 13412, 13668, 13924, 14180, 14436, 14692, 24932, 25188,
25444, 25700, 25956, 26212, 12389, 12645, 12901, 13157, 13413, 13669, 13925,
14181, 14437, 14693, 24933, 25189, 25445, 25701, 25957, 26213, 12390, 12646,
12902, 13158, 13414, 13670, 13926, 14182, 14438, 14694, 24934, 25190, 25446,
25702, 25958, 26214
#endif
};
/*
*--------------------------------------------------------------------------
*
* bson_oid_init_sequence --
*
* Initializes @oid with the next oid in the sequence. The first 4
* bytes contain the current time and the following 8 contain a 64-bit
* integer in big-endian format.
*
* The bson_oid_t generated by this function is not guaranteed to be
* globally unique. Only unique within this context. It is however,
* guaranteed to be sequential.
*
* Returns:
* None.
*
* Side effects:
* @oid is initialized.
*
*--------------------------------------------------------------------------
*/
void
bson_oid_init_sequence (bson_oid_t *oid, /* OUT */
bson_context_t *context) /* IN */
{
uint32_t now = (uint32_t) (time (NULL));
if (!context) {
context = bson_context_get_default ();
}
now = BSON_UINT32_TO_BE (now);
memcpy (&oid->bytes[0], &now, sizeof (now));
context->oid_get_seq64 (context, oid);
}
/*
*--------------------------------------------------------------------------
*
* bson_oid_init --
*
* Generates bytes for a new bson_oid_t and stores them in @oid. The
* bytes will be generated according to the specification and includes
* the current time, first 3 bytes of MD5(hostname), pid (or tid), and
* monotonic counter.
*
* The bson_oid_t generated by this function is not guaranteed to be
* globally unique. Only unique within this context. It is however,
* guaranteed to be sequential.
*
* Returns:
* None.
*
* Side effects:
* @oid is initialized.
*
*--------------------------------------------------------------------------
*/
void
bson_oid_init (bson_oid_t *oid, /* OUT */
bson_context_t *context) /* IN */
{
uint32_t now = (uint32_t) (time (NULL));
BSON_ASSERT (oid);
if (!context) {
context = bson_context_get_default ();
}
now = BSON_UINT32_TO_BE (now);
memcpy (&oid->bytes[0], &now, sizeof (now));
context->oid_get_host (context, oid);
context->oid_get_pid (context, oid);
context->oid_get_seq32 (context, oid);
}
/**
* bson_oid_init_from_data:
* @oid: A bson_oid_t to initialize.
* @bytes: A 12-byte buffer to copy into @oid.
*
*/
/*
*--------------------------------------------------------------------------
*
* bson_oid_init_from_data --
*
* Initializes an @oid from @data. @data MUST be a buffer of at least
* 12 bytes. This method is analagous to memcpy()'ing data into @oid.
*
* Returns:
* None.
*
* Side effects:
* @oid is initialized.
*
*--------------------------------------------------------------------------
*/
void
bson_oid_init_from_data (bson_oid_t *oid, /* OUT */
const uint8_t *data) /* IN */
{
BSON_ASSERT (oid);
BSON_ASSERT (data);
memcpy (oid, data, 12);
}
/*
*--------------------------------------------------------------------------
*
* bson_oid_init_from_string --
*
* Parses @str containing hex formatted bytes of an object id and
* places the bytes in @oid.
*
* Parameters:
* @oid: A bson_oid_t
* @str: A string containing at least 24 characters.
*
* Returns:
* None.
*
* Side effects:
* @oid is initialized.
*
*--------------------------------------------------------------------------
*/
void
bson_oid_init_from_string (bson_oid_t *oid, /* OUT */
const char *str) /* IN */
{
BSON_ASSERT (oid);
BSON_ASSERT (str);
bson_oid_init_from_string_unsafe (oid, str);
}
/*
*--------------------------------------------------------------------------
*
* bson_oid_get_time_t --
*
* Fetches the time for which @oid was created.
*
* Returns:
* A time_t.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
time_t
bson_oid_get_time_t (const bson_oid_t *oid) /* IN */
{
BSON_ASSERT (oid);
return bson_oid_get_time_t_unsafe (oid);
}
/*
*--------------------------------------------------------------------------
*
* bson_oid_to_string --
*
* Formats a bson_oid_t into a string. @str must contain enough bytes
* for the resulting string which is 25 bytes with a terminating
* NUL-byte.
*
* Parameters:
* @oid: A bson_oid_t.
* @str: A location to store the resulting string.
*
* Returns:
* None.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
void
bson_oid_to_string (const bson_oid_t *oid, /* IN */
char str[BSON_ENSURE_ARRAY_PARAM_SIZE (25)]) /* OUT */
{
#if !defined(__i386__) && !defined(__x86_64__) && !defined(_M_IX86) && \
!defined(_M_X64)
BSON_ASSERT (oid);
BSON_ASSERT (str);
bson_snprintf (str,
25,
"%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
oid->bytes[0],
oid->bytes[1],
oid->bytes[2],
oid->bytes[3],
oid->bytes[4],
oid->bytes[5],
oid->bytes[6],
oid->bytes[7],
oid->bytes[8],
oid->bytes[9],
oid->bytes[10],
oid->bytes[11]);
#else
uint16_t *dst;
uint8_t *id = (uint8_t *) oid;
BSON_ASSERT (oid);
BSON_ASSERT (str);
dst = (uint16_t *) (void *) str;
dst[0] = gHexCharPairs[id[0]];
dst[1] = gHexCharPairs[id[1]];
dst[2] = gHexCharPairs[id[2]];
dst[3] = gHexCharPairs[id[3]];
dst[4] = gHexCharPairs[id[4]];
dst[5] = gHexCharPairs[id[5]];
dst[6] = gHexCharPairs[id[6]];
dst[7] = gHexCharPairs[id[7]];
dst[8] = gHexCharPairs[id[8]];
dst[9] = gHexCharPairs[id[9]];
dst[10] = gHexCharPairs[id[10]];
dst[11] = gHexCharPairs[id[11]];
str[24] = '\0';
#endif
}
/*
*--------------------------------------------------------------------------
*
* bson_oid_hash --
*
* Hashes the bytes of the provided bson_oid_t using DJB hash. This
* allows bson_oid_t to be used as keys in a hash table.
*
* Returns:
* A hash value corresponding to @oid.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
uint32_t
bson_oid_hash (const bson_oid_t *oid) /* IN */
{
BSON_ASSERT (oid);
return bson_oid_hash_unsafe (oid);
}
/*
*--------------------------------------------------------------------------
*
* bson_oid_compare --
*
* A qsort() style compare function that will return less than zero if
* @oid1 is less than @oid2, zero if they are the same, and greater
* than zero if @oid2 is greater than @oid1.
*
* Returns:
* A qsort() style compare integer.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
int
bson_oid_compare (const bson_oid_t *oid1, /* IN */
const bson_oid_t *oid2) /* IN */
{
BSON_ASSERT (oid1);
BSON_ASSERT (oid2);
return bson_oid_compare_unsafe (oid1, oid2);
}
/*
*--------------------------------------------------------------------------
*
* bson_oid_equal --
*
* Compares for equality of @oid1 and @oid2. If they are equal, then
* true is returned, otherwise false.
*
* Returns:
* A boolean indicating the equality of @oid1 and @oid2.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
bool
bson_oid_equal (const bson_oid_t *oid1, /* IN */
const bson_oid_t *oid2) /* IN */
{
BSON_ASSERT (oid1);
BSON_ASSERT (oid2);
return bson_oid_equal_unsafe (oid1, oid2);
}
/*
*--------------------------------------------------------------------------
*
* bson_oid_copy --
*
* Copies the contents of @src to @dst.
*
* Parameters:
* @src: A bson_oid_t to copy from.
* @dst: A bson_oid_t to copy to.
*
* Returns:
* None.
*
* Side effects:
* @dst will contain a copy of the data in @src.
*
*--------------------------------------------------------------------------
*/
void
bson_oid_copy (const bson_oid_t *src, /* IN */
bson_oid_t *dst) /* OUT */
{
BSON_ASSERT (src);
BSON_ASSERT (dst);
bson_oid_copy_unsafe (src, dst);
}
/*
*--------------------------------------------------------------------------
*
* bson_oid_is_valid --
*
* Validates that @str is a valid OID string. @length MUST be 24, but
* is provided as a parameter to simplify calling code.
*
* Parameters:
* @str: A string to validate.
* @length: The length of @str.
*
* Returns:
* true if @str can be passed to bson_oid_init_from_string().
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
bool
bson_oid_is_valid (const char *str, /* IN */
size_t length) /* IN */
{
size_t i;
BSON_ASSERT (str);
if ((length == 25) && (str[24] == '\0')) {
length = 24;
}
if (length == 24) {
for (i = 0; i < length; i++) {
switch (str[i]) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
break;
default:
return false;
}
}
return true;
}
return false;
}
libbson-1.6.1/src/bson/bson-oid.h 0000664 0000000 0000000 00000013733 13057346540 0016600 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 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.
*/
#ifndef BSON_OID_H
#define BSON_OID_H
#if !defined(BSON_INSIDE) && !defined(BSON_COMPILATION)
#error "Only can be included directly."
#endif
#include
#include "bson-context.h"
#include "bson-macros.h"
#include "bson-types.h"
#include "bson-endian.h"
BSON_BEGIN_DECLS
BSON_EXPORT (int)
bson_oid_compare (const bson_oid_t *oid1, const bson_oid_t *oid2);
BSON_EXPORT (void)
bson_oid_copy (const bson_oid_t *src, bson_oid_t *dst);
BSON_EXPORT (bool)
bson_oid_equal (const bson_oid_t *oid1, const bson_oid_t *oid2);
BSON_EXPORT (bool)
bson_oid_is_valid (const char *str, size_t length);
BSON_EXPORT (time_t)
bson_oid_get_time_t (const bson_oid_t *oid);
BSON_EXPORT (uint32_t)
bson_oid_hash (const bson_oid_t *oid);
BSON_EXPORT (void)
bson_oid_init (bson_oid_t *oid, bson_context_t *context);
BSON_EXPORT (void)
bson_oid_init_from_data (bson_oid_t *oid, const uint8_t *data);
BSON_EXPORT (void)
bson_oid_init_from_string (bson_oid_t *oid, const char *str);
BSON_EXPORT (void)
bson_oid_init_sequence (bson_oid_t *oid, bson_context_t *context);
BSON_EXPORT (void)
bson_oid_to_string (const bson_oid_t *oid, char str[25]);
/**
* bson_oid_compare_unsafe:
* @oid1: A bson_oid_t.
* @oid2: A bson_oid_t.
*
* Performs a qsort() style comparison between @oid1 and @oid2.
*
* This function is meant to be as fast as possible and therefore performs
* no argument validation. That is the callers responsibility.
*
* Returns: An integer < 0 if @oid1 is less than @oid2. Zero if they are equal.
* An integer > 0 if @oid1 is greater than @oid2.
*/
static BSON_INLINE int
bson_oid_compare_unsafe (const bson_oid_t *oid1, const bson_oid_t *oid2)
{
return memcmp (oid1, oid2, sizeof *oid1);
}
/**
* bson_oid_equal_unsafe:
* @oid1: A bson_oid_t.
* @oid2: A bson_oid_t.
*
* Checks the equality of @oid1 and @oid2.
*
* This function is meant to be as fast as possible and therefore performs
* no checks for argument validity. That is the callers responsibility.
*
* Returns: true if @oid1 and @oid2 are equal; otherwise false.
*/
static BSON_INLINE bool
bson_oid_equal_unsafe (const bson_oid_t *oid1, const bson_oid_t *oid2)
{
return !memcmp (oid1, oid2, sizeof *oid1);
}
/**
* bson_oid_hash_unsafe:
* @oid: A bson_oid_t.
*
* This function performs a DJB style hash upon the bytes contained in @oid.
* The result is a hash key suitable for use in a hashtable.
*
* This function is meant to be as fast as possible and therefore performs no
* validation of arguments. The caller is responsible to ensure they are
* passing valid arguments.
*
* Returns: A uint32_t containing a hash code.
*/
static BSON_INLINE uint32_t
bson_oid_hash_unsafe (const bson_oid_t *oid)
{
uint32_t hash = 5381;
uint32_t i;
for (i = 0; i < sizeof oid->bytes; i++) {
hash = ((hash << 5) + hash) + oid->bytes[i];
}
return hash;
}
/**
* bson_oid_copy_unsafe:
* @src: A bson_oid_t to copy from.
* @dst: A bson_oid_t to copy into.
*
* Copies the contents of @src into @dst. This function is meant to be as
* fast as possible and therefore performs no argument checking. It is the
* callers responsibility to ensure they are passing valid data into the
* function.
*/
static BSON_INLINE void
bson_oid_copy_unsafe (const bson_oid_t *src, bson_oid_t *dst)
{
memcpy (dst, src, sizeof *src);
}
/**
* bson_oid_parse_hex_char:
* @hex: A character to parse to its integer value.
*
* This function contains a jump table to return the integer value for a
* character containing a hexidecimal value (0-9, a-f, A-F). If the character
* is not a hexidecimal character then zero is returned.
*
* Returns: An integer between 0 and 15.
*/
static BSON_INLINE uint8_t
bson_oid_parse_hex_char (char hex)
{
switch (hex) {
case '0':
return 0;
case '1':
return 1;
case '2':
return 2;
case '3':
return 3;
case '4':
return 4;
case '5':
return 5;
case '6':
return 6;
case '7':
return 7;
case '8':
return 8;
case '9':
return 9;
case 'a':
case 'A':
return 0xa;
case 'b':
case 'B':
return 0xb;
case 'c':
case 'C':
return 0xc;
case 'd':
case 'D':
return 0xd;
case 'e':
case 'E':
return 0xe;
case 'f':
case 'F':
return 0xf;
default:
return 0;
}
}
/**
* bson_oid_init_from_string_unsafe:
* @oid: A bson_oid_t to store the result.
* @str: A 24-character hexidecimal encoded string.
*
* Parses a string containing 24 hexidecimal encoded bytes into a bson_oid_t.
* This function is meant to be as fast as possible and inlined into your
* code. For that purpose, the function does not perform any sort of bounds
* checking and it is the callers responsibility to ensure they are passing
* valid input to the function.
*/
static BSON_INLINE void
bson_oid_init_from_string_unsafe (bson_oid_t *oid, const char *str)
{
int i;
for (i = 0; i < 12; i++) {
oid->bytes[i] = ((bson_oid_parse_hex_char (str[2 * i]) << 4) |
(bson_oid_parse_hex_char (str[2 * i + 1])));
}
}
/**
* bson_oid_get_time_t_unsafe:
* @oid: A bson_oid_t.
*
* Fetches the time @oid was generated.
*
* Returns: A time_t containing the UNIX timestamp of generation.
*/
static BSON_INLINE time_t
bson_oid_get_time_t_unsafe (const bson_oid_t *oid)
{
uint32_t t;
memcpy (&t, oid, sizeof (t));
return BSON_UINT32_FROM_BE (t);
}
BSON_END_DECLS
#endif /* BSON_OID_H */
libbson-1.6.1/src/bson/bson-private.h 0000664 0000000 0000000 00000004114 13057346540 0017470 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 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.
*/
#ifndef BSON_PRIVATE_H
#define BSON_PRIVATE_H
#include "bson-macros.h"
#include "bson-memory.h"
#include "bson-types.h"
BSON_BEGIN_DECLS
typedef enum {
BSON_FLAG_NONE = 0,
BSON_FLAG_INLINE = (1 << 0),
BSON_FLAG_STATIC = (1 << 1),
BSON_FLAG_RDONLY = (1 << 2),
BSON_FLAG_CHILD = (1 << 3),
BSON_FLAG_IN_CHILD = (1 << 4),
BSON_FLAG_NO_FREE = (1 << 5),
} bson_flags_t;
#define BSON_INLINE_DATA_SIZE 120
BSON_ALIGNED_BEGIN (128)
typedef struct {
bson_flags_t flags;
uint32_t len;
uint8_t data[BSON_INLINE_DATA_SIZE];
} bson_impl_inline_t BSON_ALIGNED_END (128);
BSON_STATIC_ASSERT (sizeof (bson_impl_inline_t) == 128);
BSON_ALIGNED_BEGIN (128)
typedef struct {
bson_flags_t flags; /* flags describing the bson_t */
uint32_t len; /* length of bson document in bytes */
bson_t *parent; /* parent bson if a child */
uint32_t depth; /* Subdocument depth. */
uint8_t **buf; /* pointer to buffer pointer */
size_t *buflen; /* pointer to buffer length */
size_t offset; /* our offset inside *buf */
uint8_t *alloc; /* buffer that we own. */
size_t alloclen; /* length of buffer that we own. */
bson_realloc_func realloc; /* our realloc implementation */
void *realloc_func_ctx; /* context for our realloc func */
} bson_impl_alloc_t BSON_ALIGNED_END (128);
BSON_STATIC_ASSERT (sizeof (bson_impl_alloc_t) <= 128);
BSON_END_DECLS
#endif /* BSON_PRIVATE_H */
libbson-1.6.1/src/bson/bson-reader.c 0000664 0000000 0000000 00000046024 13057346540 0017261 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 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 "bson.h"
#include
#include
#ifdef BSON_OS_WIN32
#include
#include
#endif
#include
#include
#include
#include
#include "bson-reader.h"
#include "bson-memory.h"
typedef enum {
BSON_READER_HANDLE = 1,
BSON_READER_DATA = 2,
} bson_reader_type_t;
typedef struct {
bson_reader_type_t type;
void *handle;
bool done : 1;
bool failed : 1;
size_t end;
size_t len;
size_t offset;
size_t bytes_read;
bson_t inline_bson;
uint8_t *data;
bson_reader_read_func_t read_func;
bson_reader_destroy_func_t destroy_func;
} bson_reader_handle_t;
typedef struct {
int fd;
bool do_close;
} bson_reader_handle_fd_t;
typedef struct {
bson_reader_type_t type;
const uint8_t *data;
size_t length;
size_t offset;
bson_t inline_bson;
} bson_reader_data_t;
/*
*--------------------------------------------------------------------------
*
* _bson_reader_handle_fill_buffer --
*
* Attempt to read as much as possible until the underlying buffer
* in @reader is filled or we have reached end-of-stream or
* read failure.
*
* Returns:
* None.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
static void
_bson_reader_handle_fill_buffer (bson_reader_handle_t *reader) /* IN */
{
ssize_t ret;
/*
* Handle first read specially.
*/
if ((!reader->done) && (!reader->offset) && (!reader->end)) {
ret = reader->read_func (reader->handle, &reader->data[0], reader->len);
if (ret <= 0) {
reader->done = true;
return;
}
reader->bytes_read += ret;
reader->end = ret;
return;
}
/*
* Move valid data to head.
*/
memmove (&reader->data[0],
&reader->data[reader->offset],
reader->end - reader->offset);
reader->end = reader->end - reader->offset;
reader->offset = 0;
/*
* Read in data to fill the buffer.
*/
ret = reader->read_func (
reader->handle, &reader->data[reader->end], reader->len - reader->end);
if (ret <= 0) {
reader->done = true;
reader->failed = (ret < 0);
} else {
reader->bytes_read += ret;
reader->end += ret;
}
BSON_ASSERT (reader->offset == 0);
BSON_ASSERT (reader->end <= reader->len);
}
/*
*--------------------------------------------------------------------------
*
* bson_reader_new_from_handle --
*
* Allocates and initializes a new bson_reader_t using the opaque
* handle provided.
*
* Parameters:
* @handle: an opaque handle to use to read data.
* @rf: a function to perform reads on @handle.
* @df: a function to release @handle, or NULL.
*
* Returns:
* A newly allocated bson_reader_t if successful, otherwise NULL.
* Free the successful result with bson_reader_destroy().
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
bson_reader_t *
bson_reader_new_from_handle (void *handle,
bson_reader_read_func_t rf,
bson_reader_destroy_func_t df)
{
bson_reader_handle_t *real;
BSON_ASSERT (handle);
BSON_ASSERT (rf);
real = bson_malloc0 (sizeof *real);
real->type = BSON_READER_HANDLE;
real->data = bson_malloc0 (1024);
real->handle = handle;
real->len = 1024;
real->offset = 0;
bson_reader_set_read_func ((bson_reader_t *) real, rf);
if (df) {
bson_reader_set_destroy_func ((bson_reader_t *) real, df);
}
_bson_reader_handle_fill_buffer (real);
return (bson_reader_t *) real;
}
/*
*--------------------------------------------------------------------------
*
* _bson_reader_handle_fd_destroy --
*
* Cleanup allocations associated with state created in
* bson_reader_new_from_fd().
*
* Returns:
* None.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
static void
_bson_reader_handle_fd_destroy (void *handle) /* IN */
{
bson_reader_handle_fd_t *fd = handle;
if (fd) {
if ((fd->fd != -1) && fd->do_close) {
#ifdef _WIN32
_close (fd->fd);
#else
close (fd->fd);
#endif
}
bson_free (fd);
}
}
/*
*--------------------------------------------------------------------------
*
* _bson_reader_handle_fd_read --
*
* Perform read on opaque handle created in
* bson_reader_new_from_fd().
*
* The underlying file descriptor is read from the current position
* using the bson_reader_handle_fd_t allocated.
*
* Returns:
* -1 on failure.
* 0 on end of stream.
* Greater than zero on success.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
static ssize_t
_bson_reader_handle_fd_read (void *handle, /* IN */
void *buf, /* IN */
size_t len) /* IN */
{
bson_reader_handle_fd_t *fd = handle;
ssize_t ret = -1;
if (fd && (fd->fd != -1)) {
again:
#ifdef BSON_OS_WIN32
ret = _read (fd->fd, buf, (unsigned int) len);
#else
ret = read (fd->fd, buf, len);
#endif
if ((ret == -1) && (errno == EAGAIN)) {
goto again;
}
}
return ret;
}
/*
*--------------------------------------------------------------------------
*
* bson_reader_new_from_fd --
*
* Create a new bson_reader_t using the file-descriptor provided.
*
* Parameters:
* @fd: a libc style file-descriptor.
* @close_on_destroy: if close() should be called on @fd when
* bson_reader_destroy() is called.
*
* Returns:
* A newly allocated bson_reader_t on success; otherwise NULL.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
bson_reader_t *
bson_reader_new_from_fd (int fd, /* IN */
bool close_on_destroy) /* IN */
{
bson_reader_handle_fd_t *handle;
BSON_ASSERT (fd != -1);
handle = bson_malloc0 (sizeof *handle);
handle->fd = fd;
handle->do_close = close_on_destroy;
return bson_reader_new_from_handle (
handle, _bson_reader_handle_fd_read, _bson_reader_handle_fd_destroy);
}
/**
* bson_reader_set_read_func:
* @reader: A bson_reader_t.
*
* Note that @reader must be initialized by bson_reader_init_from_handle(), or
* data
* will be destroyed.
*/
/*
*--------------------------------------------------------------------------
*
* bson_reader_set_read_func --
*
* Set the read func to be provided for @reader.
*
* You probably want to use bson_reader_new_from_handle() or
* bson_reader_new_from_fd() instead.
*
* Returns:
* None.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
void
bson_reader_set_read_func (bson_reader_t *reader, /* IN */
bson_reader_read_func_t func) /* IN */
{
bson_reader_handle_t *real = (bson_reader_handle_t *) reader;
BSON_ASSERT (reader->type == BSON_READER_HANDLE);
real->read_func = func;
}
/*
*--------------------------------------------------------------------------
*
* bson_reader_set_destroy_func --
*
* Set the function to cleanup state when @reader is destroyed.
*
* You probably want bson_reader_new_from_fd() or
* bson_reader_new_from_handle() instead.
*
* Returns:
* None.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
void
bson_reader_set_destroy_func (bson_reader_t *reader, /* IN */
bson_reader_destroy_func_t func) /* IN */
{
bson_reader_handle_t *real = (bson_reader_handle_t *) reader;
BSON_ASSERT (reader->type == BSON_READER_HANDLE);
real->destroy_func = func;
}
/*
*--------------------------------------------------------------------------
*
* _bson_reader_handle_grow_buffer --
*
* Grow the buffer to the next power of two.
*
* Returns:
* None.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
static void
_bson_reader_handle_grow_buffer (bson_reader_handle_t *reader) /* IN */
{
size_t size;
size = reader->len * 2;
reader->data = bson_realloc (reader->data, size);
reader->len = size;
}
/*
*--------------------------------------------------------------------------
*
* _bson_reader_handle_tell --
*
* Tell the current position within the underlying file-descriptor.
*
* Returns:
* An off_t containing the current offset.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
static off_t
_bson_reader_handle_tell (bson_reader_handle_t *reader) /* IN */
{
off_t off;
off = (off_t) reader->bytes_read;
off -= (off_t) reader->end;
off += (off_t) reader->offset;
return off;
}
/*
*--------------------------------------------------------------------------
*
* _bson_reader_handle_read --
*
* Read the next chunk of data from the underlying file descriptor
* and return a bson_t which should not be modified.
*
* There was a failure if NULL is returned and @reached_eof is
* not set to true.
*
* Returns:
* NULL on failure or end of stream.
*
* Side effects:
* @reached_eof is set if non-NULL.
*
*--------------------------------------------------------------------------
*/
static const bson_t *
_bson_reader_handle_read (bson_reader_handle_t *reader, /* IN */
bool *reached_eof) /* IN */
{
int32_t blen;
if (reached_eof) {
*reached_eof = false;
}
while (!reader->done) {
if ((reader->end - reader->offset) < 4) {
_bson_reader_handle_fill_buffer (reader);
continue;
}
memcpy (&blen, &reader->data[reader->offset], sizeof blen);
blen = BSON_UINT32_FROM_LE (blen);
if (blen < 5) {
return NULL;
}
if (blen > (int32_t) (reader->end - reader->offset)) {
if (blen > (int32_t) reader->len) {
_bson_reader_handle_grow_buffer (reader);
}
_bson_reader_handle_fill_buffer (reader);
continue;
}
if (!bson_init_static (&reader->inline_bson,
&reader->data[reader->offset],
(uint32_t) blen)) {
return NULL;
}
reader->offset += blen;
return &reader->inline_bson;
}
if (reached_eof) {
*reached_eof = reader->done && !reader->failed;
}
return NULL;
}
/*
*--------------------------------------------------------------------------
*
* bson_reader_new_from_data --
*
* Allocates and initializes a new bson_reader_t that reads the memory
* provided as a stream of BSON documents.
*
* Parameters:
* @data: A buffer to read BSON documents from.
* @length: The length of @data.
*
* Returns:
* A newly allocated bson_reader_t that should be freed with
* bson_reader_destroy().
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
bson_reader_t *
bson_reader_new_from_data (const uint8_t *data, /* IN */
size_t length) /* IN */
{
bson_reader_data_t *real;
BSON_ASSERT (data);
real = (bson_reader_data_t *) bson_malloc0 (sizeof *real);
real->type = BSON_READER_DATA;
real->data = data;
real->length = length;
real->offset = 0;
return (bson_reader_t *) real;
}
/*
*--------------------------------------------------------------------------
*
* _bson_reader_data_read --
*
* Read the next document from the underlying buffer.
*
* Returns:
* NULL on failure or end of stream.
* a bson_t which should not be modified.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
static const bson_t *
_bson_reader_data_read (bson_reader_data_t *reader, /* IN */
bool *reached_eof) /* IN */
{
int32_t blen;
if (reached_eof) {
*reached_eof = false;
}
if ((reader->offset + 4) < reader->length) {
memcpy (&blen, &reader->data[reader->offset], sizeof blen);
blen = BSON_UINT32_FROM_LE (blen);
if (blen < 5) {
return NULL;
}
if (blen > (int32_t) (reader->length - reader->offset)) {
return NULL;
}
if (!bson_init_static (&reader->inline_bson,
&reader->data[reader->offset],
(uint32_t) blen)) {
return NULL;
}
reader->offset += blen;
return &reader->inline_bson;
}
if (reached_eof) {
*reached_eof = (reader->offset == reader->length);
}
return NULL;
}
/*
*--------------------------------------------------------------------------
*
* _bson_reader_data_tell --
*
* Tell the current position in the underlying buffer.
*
* Returns:
* An off_t of the current offset.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
static off_t
_bson_reader_data_tell (bson_reader_data_t *reader) /* IN */
{
return (off_t) reader->offset;
}
/*
*--------------------------------------------------------------------------
*
* bson_reader_destroy --
*
* Release a bson_reader_t created with bson_reader_new_from_data(),
* bson_reader_new_from_fd(), or bson_reader_new_from_handle().
*
* Returns:
* None.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
void
bson_reader_destroy (bson_reader_t *reader) /* IN */
{
BSON_ASSERT (reader);
switch (reader->type) {
case 0:
break;
case BSON_READER_HANDLE: {
bson_reader_handle_t *handle = (bson_reader_handle_t *) reader;
if (handle->destroy_func) {
handle->destroy_func (handle->handle);
}
bson_free (handle->data);
} break;
case BSON_READER_DATA:
break;
default:
fprintf (stderr, "No such reader type: %02x\n", reader->type);
break;
}
reader->type = 0;
bson_free (reader);
}
/*
*--------------------------------------------------------------------------
*
* bson_reader_read --
*
* Reads the next bson_t in the underlying memory or storage. The
* resulting bson_t should not be modified or freed. You may copy it
* and iterate over it. Functions that take a const bson_t* are safe
* to use.
*
* This structure does not survive calls to bson_reader_read() or
* bson_reader_destroy() as it uses memory allocated by the reader or
* underlying storage/memory.
*
* If NULL is returned then @reached_eof will be set to true if the
* end of the file or buffer was reached. This indicates if there was
* an error parsing the document stream.
*
* Returns:
* A const bson_t that should not be modified or freed.
* NULL on failure or end of stream.
*
* Side effects:
* @reached_eof is set if non-NULL.
*
*--------------------------------------------------------------------------
*/
const bson_t *
bson_reader_read (bson_reader_t *reader, /* IN */
bool *reached_eof) /* OUT */
{
BSON_ASSERT (reader);
switch (reader->type) {
case BSON_READER_HANDLE:
return _bson_reader_handle_read ((bson_reader_handle_t *) reader,
reached_eof);
case BSON_READER_DATA:
return _bson_reader_data_read ((bson_reader_data_t *) reader,
reached_eof);
default:
fprintf (stderr, "No such reader type: %02x\n", reader->type);
break;
}
return NULL;
}
/*
*--------------------------------------------------------------------------
*
* bson_reader_tell --
*
* Return the current position in the underlying reader. This will
* always be at the beginning of a bson document or end of file.
*
* Returns:
* An off_t containing the current offset.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
off_t
bson_reader_tell (bson_reader_t *reader) /* IN */
{
BSON_ASSERT (reader);
switch (reader->type) {
case BSON_READER_HANDLE:
return _bson_reader_handle_tell ((bson_reader_handle_t *) reader);
case BSON_READER_DATA:
return _bson_reader_data_tell ((bson_reader_data_t *) reader);
default:
fprintf (stderr, "No such reader type: %02x\n", reader->type);
return -1;
}
}
/*
*--------------------------------------------------------------------------
*
* bson_reader_new_from_file --
*
* A convenience function to open a file containing sequential
* bson documents and read them using bson_reader_t.
*
* Returns:
* A new bson_reader_t if successful, otherwise NULL and
* @error is set. Free the non-NULL result with
* bson_reader_destroy().
*
* Side effects:
* @error may be set.
*
*--------------------------------------------------------------------------
*/
bson_reader_t *
bson_reader_new_from_file (const char *path, /* IN */
bson_error_t *error) /* OUT */
{
char errmsg_buf[BSON_ERROR_BUFFER_SIZE];
char *errmsg;
int fd;
BSON_ASSERT (path);
#ifdef BSON_OS_WIN32
if (_sopen_s (&fd, path, (_O_RDONLY | _O_BINARY), _SH_DENYNO, 0) != 0) {
fd = -1;
}
#else
fd = open (path, O_RDONLY);
#endif
if (fd == -1) {
errmsg = bson_strerror_r (errno, errmsg_buf, sizeof errmsg_buf);
bson_set_error (
error, BSON_ERROR_READER, BSON_ERROR_READER_BADFD, "%s", errmsg);
return NULL;
}
return bson_reader_new_from_fd (fd, true);
}
/*
*--------------------------------------------------------------------------
*
* bson_reader_reset --
*
* Restore the reader to its initial state. Valid only for readers
* created with bson_reader_new_from_data.
*
*--------------------------------------------------------------------------
*/
void
bson_reader_reset (bson_reader_t *reader)
{
bson_reader_data_t *real = (bson_reader_data_t *) reader;
if (real->type != BSON_READER_DATA) {
fprintf (stderr, "Reader type cannot be reset\n");
return;
}
real->offset = 0;
}
libbson-1.6.1/src/bson/bson-reader.h 0000664 0000000 0000000 00000006547 13057346540 0017274 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 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.
*/
#ifndef BSON_READER_H
#define BSON_READER_H
#if !defined(BSON_INSIDE) && !defined(BSON_COMPILATION)
#error "Only can be included directly."
#endif
#include "bson-compat.h"
#include "bson-oid.h"
#include "bson-types.h"
BSON_BEGIN_DECLS
#define BSON_ERROR_READER_BADFD 1
/*
*--------------------------------------------------------------------------
*
* bson_reader_read_func_t --
*
* This function is a callback used by bson_reader_t to read the
* next chunk of data from the underlying opaque file descriptor.
*
* This function is meant to operate similar to the read() function
* as part of libc on UNIX-like systems.
*
* Parameters:
* @handle: The handle to read from.
* @buf: The buffer to read into.
* @count: The number of bytes to read.
*
* Returns:
* 0 for end of stream.
* -1 for read failure.
* Greater than zero for number of bytes read into @buf.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
typedef ssize_t (*bson_reader_read_func_t) (void *handle, /* IN */
void *buf, /* IN */
size_t count); /* IN */
/*
*--------------------------------------------------------------------------
*
* bson_reader_destroy_func_t --
*
* Destroy callback to release any resources associated with the
* opaque handle.
*
* Parameters:
* @handle: the handle provided to bson_reader_new_from_handle().
*
* Returns:
* None.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
typedef void (*bson_reader_destroy_func_t) (void *handle); /* IN */
BSON_EXPORT (bson_reader_t *)
bson_reader_new_from_handle (void *handle,
bson_reader_read_func_t rf,
bson_reader_destroy_func_t df);
BSON_EXPORT (bson_reader_t *)
bson_reader_new_from_fd (int fd, bool close_on_destroy);
BSON_EXPORT (bson_reader_t *)
bson_reader_new_from_file (const char *path, bson_error_t *error);
BSON_EXPORT (bson_reader_t *)
bson_reader_new_from_data (const uint8_t *data, size_t length);
BSON_EXPORT (void)
bson_reader_destroy (bson_reader_t *reader);
BSON_EXPORT (void)
bson_reader_set_read_func (bson_reader_t *reader, bson_reader_read_func_t func);
BSON_EXPORT (void)
bson_reader_set_destroy_func (bson_reader_t *reader,
bson_reader_destroy_func_t func);
BSON_EXPORT (const bson_t *)
bson_reader_read (bson_reader_t *reader, bool *reached_eof);
BSON_EXPORT (off_t)
bson_reader_tell (bson_reader_t *reader);
BSON_EXPORT (void)
bson_reader_reset (bson_reader_t *reader);
BSON_END_DECLS
#endif /* BSON_READER_H */
libbson-1.6.1/src/bson/bson-stdint-win32.h 0000664 0000000 0000000 00000017261 13057346540 0020272 0 ustar 00root root 0000000 0000000 // ISO C9x compliant stdint.h for Microsoft Visual Studio
// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124
//
// Copyright (c) 2006-2013 Alexander Chemeris
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the product nor the names of its contributors may
// be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
///////////////////////////////////////////////////////////////////////////////
#ifndef _MSC_VER // [
#error "Use this header only with Microsoft Visual C++ compilers!"
#endif // _MSC_VER ]
#ifndef _MSC_STDINT_H_ // [
#define _MSC_STDINT_H_
#if _MSC_VER > 1000
#pragma once
#endif
#if _MSC_VER >= 1600 // [
#include
#else // ] _MSC_VER >= 1600 [
#include
// For Visual Studio 6 in C++ mode and for many Visual Studio versions when
// compiling for ARM we should wrap include with 'extern "C++" {}'
// or compiler give many errors like this:
// error C2733: second C linkage of overloaded function 'wmemchr' not allowed
#ifdef __cplusplus
extern "C" {
#endif
#include
#ifdef __cplusplus
}
#endif
// Define _W64 macros to mark types changing their size, like intptr_t.
#ifndef _W64
#if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300
#define _W64 __w64
#else
#define _W64
#endif
#endif
// 7.18.1 Integer types
// 7.18.1.1 Exact-width integer types
// Visual Studio 6 and Embedded Visual C++ 4 doesn't
// realize that, e.g. char has the same size as __int8
// so we give up on __intX for them.
#if (_MSC_VER < 1300)
typedef signed char int8_t;
typedef signed short int16_t;
typedef signed int int32_t;
typedef unsigned char uint8_t;
typedef unsigned short uint16_t;
typedef unsigned int uint32_t;
#else
typedef signed __int8 int8_t;
typedef signed __int16 int16_t;
typedef signed __int32 int32_t;
typedef unsigned __int8 uint8_t;
typedef unsigned __int16 uint16_t;
typedef unsigned __int32 uint32_t;
#endif
typedef signed __int64 int64_t;
typedef unsigned __int64 uint64_t;
// 7.18.1.2 Minimum-width integer types
typedef int8_t int_least8_t;
typedef int16_t int_least16_t;
typedef int32_t int_least32_t;
typedef int64_t int_least64_t;
typedef uint8_t uint_least8_t;
typedef uint16_t uint_least16_t;
typedef uint32_t uint_least32_t;
typedef uint64_t uint_least64_t;
// 7.18.1.3 Fastest minimum-width integer types
typedef int8_t int_fast8_t;
typedef int16_t int_fast16_t;
typedef int32_t int_fast32_t;
typedef int64_t int_fast64_t;
typedef uint8_t uint_fast8_t;
typedef uint16_t uint_fast16_t;
typedef uint32_t uint_fast32_t;
typedef uint64_t uint_fast64_t;
// 7.18.1.4 Integer types capable of holding object pointers
#ifdef _WIN64 // [
typedef signed __int64 intptr_t;
typedef unsigned __int64 uintptr_t;
#else // _WIN64 ][
typedef _W64 signed int intptr_t;
typedef _W64 unsigned int uintptr_t;
#endif // _WIN64 ]
// 7.18.1.5 Greatest-width integer types
typedef int64_t intmax_t;
typedef uint64_t uintmax_t;
// 7.18.2 Limits of specified-width integer types
#if !defined(__cplusplus) || \
defined( \
__STDC_LIMIT_MACROS) // [ See footnote 220 at page 257 and footnote
// 221 at page 259
// 7.18.2.1 Limits of exact-width integer types
#define INT8_MIN ((int8_t) _I8_MIN)
#define INT8_MAX _I8_MAX
#define INT16_MIN ((int16_t) _I16_MIN)
#define INT16_MAX _I16_MAX
#define INT32_MIN ((int32_t) _I32_MIN)
#define INT32_MAX _I32_MAX
#define INT64_MIN ((int64_t) _I64_MIN)
#define INT64_MAX _I64_MAX
#define UINT8_MAX _UI8_MAX
#define UINT16_MAX _UI16_MAX
#define UINT32_MAX _UI32_MAX
#define UINT64_MAX _UI64_MAX
// 7.18.2.2 Limits of minimum-width integer types
#define INT_LEAST8_MIN INT8_MIN
#define INT_LEAST8_MAX INT8_MAX
#define INT_LEAST16_MIN INT16_MIN
#define INT_LEAST16_MAX INT16_MAX
#define INT_LEAST32_MIN INT32_MIN
#define INT_LEAST32_MAX INT32_MAX
#define INT_LEAST64_MIN INT64_MIN
#define INT_LEAST64_MAX INT64_MAX
#define UINT_LEAST8_MAX UINT8_MAX
#define UINT_LEAST16_MAX UINT16_MAX
#define UINT_LEAST32_MAX UINT32_MAX
#define UINT_LEAST64_MAX UINT64_MAX
// 7.18.2.3 Limits of fastest minimum-width integer types
#define INT_FAST8_MIN INT8_MIN
#define INT_FAST8_MAX INT8_MAX
#define INT_FAST16_MIN INT16_MIN
#define INT_FAST16_MAX INT16_MAX
#define INT_FAST32_MIN INT32_MIN
#define INT_FAST32_MAX INT32_MAX
#define INT_FAST64_MIN INT64_MIN
#define INT_FAST64_MAX INT64_MAX
#define UINT_FAST8_MAX UINT8_MAX
#define UINT_FAST16_MAX UINT16_MAX
#define UINT_FAST32_MAX UINT32_MAX
#define UINT_FAST64_MAX UINT64_MAX
// 7.18.2.4 Limits of integer types capable of holding object pointers
#ifdef _WIN64 // [
#define INTPTR_MIN INT64_MIN
#define INTPTR_MAX INT64_MAX
#define UINTPTR_MAX UINT64_MAX
#else // _WIN64 ][
#define INTPTR_MIN INT32_MIN
#define INTPTR_MAX INT32_MAX
#define UINTPTR_MAX UINT32_MAX
#endif // _WIN64 ]
// 7.18.2.5 Limits of greatest-width integer types
#define INTMAX_MIN INT64_MIN
#define INTMAX_MAX INT64_MAX
#define UINTMAX_MAX UINT64_MAX
// 7.18.3 Limits of other integer types
#ifdef _WIN64 // [
#define PTRDIFF_MIN _I64_MIN
#define PTRDIFF_MAX _I64_MAX
#else // _WIN64 ][
#define PTRDIFF_MIN _I32_MIN
#define PTRDIFF_MAX _I32_MAX
#endif // _WIN64 ]
#define SIG_ATOMIC_MIN INT_MIN
#define SIG_ATOMIC_MAX INT_MAX
#ifndef SIZE_MAX // [
#ifdef _WIN64 // [
#define SIZE_MAX _UI64_MAX
#else // _WIN64 ][
#define SIZE_MAX _UI32_MAX
#endif // _WIN64 ]
#endif // SIZE_MAX ]
// WCHAR_MIN and WCHAR_MAX are also defined in
#ifndef WCHAR_MIN // [
#define WCHAR_MIN 0
#endif // WCHAR_MIN ]
#ifndef WCHAR_MAX // [
#define WCHAR_MAX _UI16_MAX
#endif // WCHAR_MAX ]
#define WINT_MIN 0
#define WINT_MAX _UI16_MAX
#endif // __STDC_LIMIT_MACROS ]
// 7.18.4 Limits of other integer types
#if !defined(__cplusplus) || \
defined(__STDC_CONSTANT_MACROS) // [ See footnote 224 at page 260
// 7.18.4.1 Macros for minimum-width integer constants
#define INT8_C(val) val##i8
#define INT16_C(val) val##i16
#define INT32_C(val) val##i32
#define INT64_C(val) val##i64
#define UINT8_C(val) val##ui8
#define UINT16_C(val) val##ui16
#define UINT32_C(val) val##ui32
#define UINT64_C(val) val##ui64
// 7.18.4.2 Macros for greatest-width integer constants
// These #ifndef's are needed to prevent collisions with .
// Check out Issue 9 for the details.
#ifndef INTMAX_C // [
#define INTMAX_C INT64_C
#endif // INTMAX_C ]
#ifndef UINTMAX_C // [
#define UINTMAX_C UINT64_C
#endif // UINTMAX_C ]
#endif // __STDC_CONSTANT_MACROS ]
#endif // _MSC_VER >= 1600 ]
#endif // _MSC_STDINT_H_ ]
libbson-1.6.1/src/bson/bson-string.c 0000664 0000000 0000000 00000040603 13057346540 0017322 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 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
#include
#include
#include "bson-compat.h"
#include "bson-config.h"
#include "bson-string.h"
#include "bson-memory.h"
#include "bson-utf8.h"
/*
*--------------------------------------------------------------------------
*
* bson_string_new --
*
* Create a new bson_string_t.
*
* bson_string_t is a power-of-2 allocation growing string. Every
* time data is appended the next power of two size is chosen for
* the allocation. Pretty standard stuff.
*
* It is UTF-8 aware through the use of bson_string_append_unichar().
* The proper UTF-8 character sequence will be used.
*
* Parameters:
* @str: a string to copy or NULL.
*
* Returns:
* A newly allocated bson_string_t that should be freed with
* bson_string_free().
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
bson_string_t *
bson_string_new (const char *str) /* IN */
{
bson_string_t *ret;
ret = bson_malloc0 (sizeof *ret);
ret->len = str ? (int) strlen (str) : 0;
ret->alloc = ret->len + 1;
if (!bson_is_power_of_two (ret->alloc)) {
ret->alloc = (uint32_t) bson_next_power_of_two ((size_t) ret->alloc);
}
BSON_ASSERT (ret->alloc >= 1);
ret->str = bson_malloc (ret->alloc);
if (str) {
memcpy (ret->str, str, ret->len);
}
ret->str[ret->len] = '\0';
ret->str[ret->len] = '\0';
return ret;
}
/*
*--------------------------------------------------------------------------
*
* bson_string_free --
*
* Free the bson_string_t @string and related allocations.
*
* If @free_segment is false, then the strings buffer will be
* returned and is not freed. Otherwise, NULL is returned.
*
* Returns:
* The string->str if free_segment is false.
* Otherwise NULL.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
char *
bson_string_free (bson_string_t *string, /* IN */
bool free_segment) /* IN */
{
char *ret = NULL;
BSON_ASSERT (string);
if (!free_segment) {
ret = string->str;
} else {
bson_free (string->str);
}
bson_free (string);
return ret;
}
/*
*--------------------------------------------------------------------------
*
* bson_string_append --
*
* Append the UTF-8 string @str to @string.
*
* Returns:
* None.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
void
bson_string_append (bson_string_t *string, /* IN */
const char *str) /* IN */
{
uint32_t len;
BSON_ASSERT (string);
BSON_ASSERT (str);
len = (uint32_t) strlen (str);
if ((string->alloc - string->len - 1) < len) {
string->alloc += len;
if (!bson_is_power_of_two (string->alloc)) {
string->alloc =
(uint32_t) bson_next_power_of_two ((size_t) string->alloc);
}
string->str = bson_realloc (string->str, string->alloc);
}
memcpy (string->str + string->len, str, len);
string->len += len;
string->str[string->len] = '\0';
}
/*
*--------------------------------------------------------------------------
*
* bson_string_append_c --
*
* Append the ASCII character @c to @string.
*
* Do not use this if you are working with UTF-8 sequences,
* use bson_string_append_unichar().
*
* Returns:
* None.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
void
bson_string_append_c (bson_string_t *string, /* IN */
char c) /* IN */
{
char cc[2];
BSON_ASSERT (string);
if (BSON_UNLIKELY (string->alloc == (string->len + 1))) {
cc[0] = c;
cc[1] = '\0';
bson_string_append (string, cc);
return;
}
string->str[string->len++] = c;
string->str[string->len] = '\0';
}
/*
*--------------------------------------------------------------------------
*
* bson_string_append_unichar --
*
* Append the bson_unichar_t @unichar to the string @string.
*
* Returns:
* None.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
void
bson_string_append_unichar (bson_string_t *string, /* IN */
bson_unichar_t unichar) /* IN */
{
uint32_t len;
char str[8];
BSON_ASSERT (string);
BSON_ASSERT (unichar);
bson_utf8_from_unichar (unichar, str, &len);
if (len <= 6) {
str[len] = '\0';
bson_string_append (string, str);
}
}
/*
*--------------------------------------------------------------------------
*
* bson_string_append_printf --
*
* Format a string according to @format and append it to @string.
*
* Returns:
* None.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
void
bson_string_append_printf (bson_string_t *string, const char *format, ...)
{
va_list args;
char *ret;
BSON_ASSERT (string);
BSON_ASSERT (format);
va_start (args, format);
ret = bson_strdupv_printf (format, args);
va_end (args);
bson_string_append (string, ret);
bson_free (ret);
}
/*
*--------------------------------------------------------------------------
*
* bson_string_truncate --
*
* Truncate the string @string to @len bytes.
*
* The underlying memory will be released via realloc() down to
* the minimum required size specified by @len.
*
* Returns:
* None.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
void
bson_string_truncate (bson_string_t *string, /* IN */
uint32_t len) /* IN */
{
uint32_t alloc;
BSON_ASSERT (string);
BSON_ASSERT (len < INT_MAX);
alloc = len + 1;
if (alloc < 16) {
alloc = 16;
}
if (!bson_is_power_of_two (alloc)) {
alloc = (uint32_t) bson_next_power_of_two ((size_t) alloc);
}
string->str = bson_realloc (string->str, alloc);
string->alloc = alloc;
string->len = len;
string->str[string->len] = '\0';
}
/*
*--------------------------------------------------------------------------
*
* bson_strdup --
*
* Portable strdup().
*
* Returns:
* A newly allocated string that should be freed with bson_free().
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
char *
bson_strdup (const char *str) /* IN */
{
long len;
char *out;
if (!str) {
return NULL;
}
len = (long) strlen (str);
out = bson_malloc (len + 1);
if (!out) {
return NULL;
}
memcpy (out, str, len + 1);
return out;
}
/*
*--------------------------------------------------------------------------
*
* bson_strdupv_printf --
*
* Like bson_strdup_printf() but takes a va_list.
*
* Returns:
* A newly allocated string that should be freed with bson_free().
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
char *
bson_strdupv_printf (const char *format, /* IN */
va_list args) /* IN */
{
va_list my_args;
char *buf;
int len = 32;
int n;
BSON_ASSERT (format);
buf = bson_malloc0 (len);
while (true) {
va_copy (my_args, args);
n = bson_vsnprintf (buf, len, format, my_args);
va_end (my_args);
if (n > -1 && n < len) {
return buf;
}
if (n > -1) {
len = n + 1;
} else {
len *= 2;
}
buf = bson_realloc (buf, len);
}
}
/*
*--------------------------------------------------------------------------
*
* bson_strdup_printf --
*
* Convenience function that formats a string according to @format
* and returns a copy of it.
*
* Returns:
* A newly created string that should be freed with bson_free().
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
char *
bson_strdup_printf (const char *format, /* IN */
...) /* IN */
{
va_list args;
char *ret;
BSON_ASSERT (format);
va_start (args, format);
ret = bson_strdupv_printf (format, args);
va_end (args);
return ret;
}
/*
*--------------------------------------------------------------------------
*
* bson_strndup --
*
* A portable strndup().
*
* Returns:
* A newly allocated string that should be freed with bson_free().
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
char *
bson_strndup (const char *str, /* IN */
size_t n_bytes) /* IN */
{
char *ret;
BSON_ASSERT (str);
ret = bson_malloc (n_bytes + 1);
bson_strncpy (ret, str, n_bytes + 1);
return ret;
}
/*
*--------------------------------------------------------------------------
*
* bson_strfreev --
*
* Frees each string in a NULL terminated array of strings.
* This also frees the underlying array.
*
* Returns:
* None.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
void
bson_strfreev (char **str) /* IN */
{
int i;
if (str) {
for (i = 0; str[i]; i++)
bson_free (str[i]);
bson_free (str);
}
}
/*
*--------------------------------------------------------------------------
*
* bson_strnlen --
*
* A portable strnlen().
*
* Returns:
* The length of @s up to @maxlen.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
size_t
bson_strnlen (const char *s, /* IN */
size_t maxlen) /* IN */
{
#ifdef BSON_HAVE_STRNLEN
return strnlen (s, maxlen);
#else
size_t i;
for (i = 0; i < maxlen; i++) {
if (s[i] == '\0') {
return i;
}
}
return maxlen;
#endif
}
/*
*--------------------------------------------------------------------------
*
* bson_strncpy --
*
* A portable strncpy.
*
* Copies @src into @dst, which must be @size bytes or larger.
* The result is guaranteed to be \0 terminated.
*
* Returns:
* None.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
void
bson_strncpy (char *dst, /* IN */
const char *src, /* IN */
size_t size) /* IN */
{
#ifdef _MSC_VER
strncpy_s (dst, size, src, _TRUNCATE);
#else
strncpy (dst, src, size);
dst[size - 1] = '\0';
#endif
}
/*
*--------------------------------------------------------------------------
*
* bson_vsnprintf --
*
* A portable vsnprintf.
*
* If more than @size bytes are required (exluding the null byte),
* then @size bytes will be written to @string and the return value
* is the number of bytes required.
*
* This function will always return a NULL terminated string.
*
* Returns:
* The number of bytes required for @format excluding the null byte.
*
* Side effects:
* @str is initialized with the formatted string.
*
*--------------------------------------------------------------------------
*/
int
bson_vsnprintf (char *str, /* IN */
size_t size, /* IN */
const char *format, /* IN */
va_list ap) /* IN */
{
#ifdef BSON_OS_WIN32
int r = -1;
BSON_ASSERT (str);
if (size != 0) {
r = _vsnprintf_s (str, size, _TRUNCATE, format, ap);
}
if (r == -1) {
r = _vscprintf (format, ap);
}
str[size - 1] = '\0';
return r;
#else
int r;
r = vsnprintf (str, size, format, ap);
str[size - 1] = '\0';
return r;
#endif
}
/*
*--------------------------------------------------------------------------
*
* bson_snprintf --
*
* A portable snprintf.
*
* If @format requires more than @size bytes, then @size bytes are
* written and the result is the number of bytes required (excluding
* the null byte).
*
* This function will always return a NULL terminated string.
*
* Returns:
* The number of bytes required for @format.
*
* Side effects:
* @str is initialized.
*
*--------------------------------------------------------------------------
*/
int
bson_snprintf (char *str, /* IN */
size_t size, /* IN */
const char *format, /* IN */
...)
{
int r;
va_list ap;
BSON_ASSERT (str);
va_start (ap, format);
r = bson_vsnprintf (str, size, format, ap);
va_end (ap);
return r;
}
/*
*--------------------------------------------------------------------------
*
* bson_ascii_strtoll --
*
* A portable strtoll.
*
* Convert a string to a 64-bit signed integer according to the given
* @base, which must be 16, 10, or 8. Leading whitespace will be ignord.
*
* If @e is not NULL, it will be assigned the address of the first invalid
* character of @s, or its null terminating byte if the entire string was
* valid.
*
* If an invalid value is encountered, errno will be set to EINVAL and
* zero will be returned. If the number is out of range, errno is set to
* ERANGE and LLONG_MAX or LLONG_MIN is returned.
*
* Returns:
* The result of the conversion.
*
* Side effects:
* errno will be set on error.
*
*--------------------------------------------------------------------------
*/
int64_t
bson_ascii_strtoll (const char *s, char **e, int base)
{
char *tok = (char *) s;
char *digits_start;
char c;
int64_t number = 0;
int64_t sign = 1;
int64_t cutoff;
int64_t cutlim;
errno = 0;
if (!s) {
errno = EINVAL;
return 0;
}
c = *tok;
while (isspace (c)) {
c = *++tok;
}
if (c == '-') {
sign = -1;
c = *++tok;
} else if (c == '+') {
c = *++tok;
} else if (!isdigit (c)) {
errno = EINVAL;
return 0;
}
/* from here down, inspired by NetBSD's strtoll */
if ((base == 0 || base == 16) && c == '0' &&
(tok[1] == 'x' || tok[1] == 'X')) {
tok += 2;
c = *tok;
base = 16;
}
if (base == 0) {
base = c == '0' ? 8 : 10;
}
/* Cutoff is the greatest magnitude we'll be able to multiply by base without
* range error. If the current number is past cutoff and we see valid digit,
* fail. If the number is *equal* to cutoff, then the next digit must be less
* than cutlim, otherwise fail.
*/
cutoff = sign == -1 ? INT64_MIN : INT64_MAX;
cutlim = (int) (cutoff % base);
cutoff /= base;
if (sign == -1) {
if (cutlim > 0) {
cutlim -= base;
cutoff += 1;
}
cutlim = -cutlim;
}
digits_start = tok;
while ((c = *tok)) {
if (isdigit (c)) {
c -= '0';
} else if (isalpha (c)) {
c -= isupper (c) ? 'A' - 10 : 'a' - 10;
} else {
/* end of number string */
break;
}
if (c >= base) {
break;
}
if (sign == -1) {
if (number < cutoff || (number == cutoff && c > cutlim)) {
number = INT64_MIN;
errno = ERANGE;
break;
} else {
number *= base;
number -= c;
}
} else {
if (number > cutoff || (number == cutoff && c > cutlim)) {
number = INT64_MAX;
errno = ERANGE;
break;
} else {
number *= base;
number += c;
}
}
tok++;
}
/* did we parse any digits at all? */
if (e != NULL && tok > digits_start) {
*e = tok;
}
return number;
}
libbson-1.6.1/src/bson/bson-string.h 0000664 0000000 0000000 00000004531 13057346540 0017327 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 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.
*/
#ifndef BSON_STRING_H
#define BSON_STRING_H
#if !defined(BSON_INSIDE) && !defined(BSON_COMPILATION)
#error "Only can be included directly."
#endif
#include
#include "bson-macros.h"
#include "bson-types.h"
BSON_BEGIN_DECLS
typedef struct {
char *str;
uint32_t len;
uint32_t alloc;
} bson_string_t;
BSON_EXPORT (bson_string_t *)
bson_string_new (const char *str);
BSON_EXPORT (char *)
bson_string_free (bson_string_t *string, bool free_segment);
BSON_EXPORT (void)
bson_string_append (bson_string_t *string, const char *str);
BSON_EXPORT (void)
bson_string_append_c (bson_string_t *string, char str);
BSON_EXPORT (void)
bson_string_append_unichar (bson_string_t *string, bson_unichar_t unichar);
BSON_EXPORT (void)
bson_string_append_printf (bson_string_t *string, const char *format, ...)
BSON_GNUC_PRINTF (2, 3);
BSON_EXPORT (void)
bson_string_truncate (bson_string_t *string, uint32_t len);
BSON_EXPORT (char *)
bson_strdup (const char *str);
BSON_EXPORT (char *)
bson_strdup_printf (const char *format, ...) BSON_GNUC_PRINTF (1, 2);
BSON_EXPORT (char *)
bson_strdupv_printf (const char *format, va_list args) BSON_GNUC_PRINTF (1, 0);
BSON_EXPORT (char *)
bson_strndup (const char *str, size_t n_bytes);
BSON_EXPORT (void)
bson_strncpy (char *dst, const char *src, size_t size);
BSON_EXPORT (int)
bson_vsnprintf (char *str, size_t size, const char *format, va_list ap)
BSON_GNUC_PRINTF (3, 0);
BSON_EXPORT (int)
bson_snprintf (char *str, size_t size, const char *format, ...)
BSON_GNUC_PRINTF (3, 4);
BSON_EXPORT (void)
bson_strfreev (char **strv);
BSON_EXPORT (size_t)
bson_strnlen (const char *s, size_t maxlen);
BSON_EXPORT (int64_t)
bson_ascii_strtoll (const char *str, char **endptr, int base);
BSON_END_DECLS
#endif /* BSON_STRING_H */
libbson-1.6.1/src/bson/bson-thread-private.h 0000664 0000000 0000000 00000004556 13057346540 0020747 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 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.
*/
#ifndef BSON_THREAD_PRIVATE_H
#define BSON_THREAD_PRIVATE_H
#if !defined(BSON_INSIDE) && !defined(BSON_COMPILATION)
#error "Only can be included directly."
#endif
#include "bson-compat.h"
#include "bson-config.h"
#include "bson-macros.h"
BSON_BEGIN_DECLS
#if defined(BSON_OS_UNIX)
#include
#define bson_mutex_t pthread_mutex_t
#define bson_mutex_init(_n) pthread_mutex_init ((_n), NULL)
#define bson_mutex_lock pthread_mutex_lock
#define bson_mutex_unlock pthread_mutex_unlock
#define bson_mutex_destroy pthread_mutex_destroy
#define bson_thread_t pthread_t
#define bson_thread_create(_t, _f, _d) pthread_create ((_t), NULL, (_f), (_d))
#define bson_thread_join(_n) pthread_join ((_n), NULL)
#define bson_once_t pthread_once_t
#define bson_once pthread_once
#define BSON_ONCE_FUN(n) void n (void)
#define BSON_ONCE_RETURN return
#ifdef BSON_PTHREAD_ONCE_INIT_NEEDS_BRACES
#define BSON_ONCE_INIT \
{ \
PTHREAD_ONCE_INIT \
}
#else
#define BSON_ONCE_INIT PTHREAD_ONCE_INIT
#endif
#else
#define bson_mutex_t CRITICAL_SECTION
#define bson_mutex_init InitializeCriticalSection
#define bson_mutex_lock EnterCriticalSection
#define bson_mutex_unlock LeaveCriticalSection
#define bson_mutex_destroy DeleteCriticalSection
#define bson_thread_t HANDLE
#define bson_thread_create(_t, _f, _d) \
(!(*(_t) = CreateThread (NULL, 0, (void *) _f, _d, 0, NULL)))
#define bson_thread_join(_n) WaitForSingleObject ((_n), INFINITE)
#define bson_once_t INIT_ONCE
#define BSON_ONCE_INIT INIT_ONCE_STATIC_INIT
#define bson_once(o, c) InitOnceExecuteOnce (o, c, NULL, NULL)
#define BSON_ONCE_FUN(n) \
BOOL CALLBACK n (PINIT_ONCE _ignored_a, PVOID _ignored_b, PVOID *_ignored_c)
#define BSON_ONCE_RETURN return true
#endif
BSON_END_DECLS
#endif /* BSON_THREAD_PRIVATE_H */
libbson-1.6.1/src/bson/bson-timegm-private.h 0000664 0000000 0000000 00000002734 13057346540 0020756 0 ustar 00root root 0000000 0000000 /*
* Copyright 2014 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.
*/
#ifndef BSON_TIMEGM_PRIVATE_H
#define BSON_TIMEGM_PRIVATE_H
#include "bson-compat.h"
#include "bson-macros.h"
BSON_BEGIN_DECLS
/* avoid system-dependent struct tm definitions */
struct bson_tm {
int64_t tm_sec; /* seconds after the minute [0-60] */
int64_t tm_min; /* minutes after the hour [0-59] */
int64_t tm_hour; /* hours since midnight [0-23] */
int64_t tm_mday; /* day of the month [1-31] */
int64_t tm_mon; /* months since January [0-11] */
int64_t tm_year; /* years since 1900 */
int64_t tm_wday; /* days since Sunday [0-6] */
int64_t tm_yday; /* days since January 1 [0-365] */
int64_t tm_isdst; /* Daylight Savings Time flag */
int64_t tm_gmtoff; /* offset from CUT in seconds */
char *tm_zone; /* timezone abbreviation */
};
int64_t
_bson_timegm (struct bson_tm *const tmp);
BSON_END_DECLS
#endif /* BSON_TIMEGM_PRIVATE_H */
libbson-1.6.1/src/bson/bson-timegm.c 0000664 0000000 0000000 00000055650 13057346540 0017306 0 ustar 00root root 0000000 0000000 /*
** The original version of this file is in the public domain, so clarified as of
** 1996-06-05 by Arthur David Olson.
*/
/*
** Leap second handling from Bradley White.
** POSIX-style TZ environment variable handling from Guy Harris.
** Updated to use int64_t's instead of system-dependent definitions of int64_t
** and struct tm by A. Jesse Jiryu Davis for MongoDB, Inc.
*/
#include "bson-compat.h"
#include "bson-macros.h"
#include "bson-timegm-private.h"
#include "errno.h"
#include "string.h"
#include "limits.h" /* for CHAR_BIT et al. */
/* Unlike 's isdigit, this also works if c < 0 | c > UCHAR_MAX. */
#define is_digit(c) ((unsigned) (c) - '0' <= 9)
#ifndef CHAR_BIT
#define CHAR_BIT 8
#endif
#if 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
#define ATTRIBUTE_CONST __attribute__ ((const))
#define ATTRIBUTE_PURE __attribute__ ((__pure__))
#define ATTRIBUTE_FORMAT(spec) __attribute__ ((__format__ spec))
#else
#define ATTRIBUTE_CONST /* empty */
#define ATTRIBUTE_PURE /* empty */
#define ATTRIBUTE_FORMAT(spec) /* empty */
#endif
#if !defined _Noreturn && \
(!defined(__STDC_VERSION__) || __STDC_VERSION__ < 201112)
#if 2 < __GNUC__ + (8 <= __GNUC_MINOR__)
#define _Noreturn __attribute__((__noreturn__))
#else
#define _Noreturn
#endif
#endif
#if (!defined(__STDC_VERSION__) || __STDC_VERSION__ < 199901) && \
!defined restrict
#define restrict /* empty */
#endif
#ifndef TYPE_BIT
#define TYPE_BIT(type) (sizeof (type) * CHAR_BIT)
#endif /* !defined TYPE_BIT */
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunknown-pragmas"
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wshift-negative-value"
#endif
/* The minimum and maximum finite time values. */
static int64_t const time_t_min = INT64_MIN;
static int64_t const time_t_max = INT64_MAX;
#ifdef __clang__
#pragma clang diagnostic pop
#pragma clang diagnostic pop
#endif
#ifndef TZ_MAX_TIMES
#define TZ_MAX_TIMES 2000
#endif /* !defined TZ_MAX_TIMES */
#ifndef TZ_MAX_TYPES
/* This must be at least 17 for Europe/Samara and Europe/Vilnius. */
#define TZ_MAX_TYPES 256 /* Limited by what (unsigned char)'s can hold */
#endif /* !defined TZ_MAX_TYPES */
#ifndef TZ_MAX_CHARS
#define TZ_MAX_CHARS 50 /* Maximum number of abbreviation characters */
/* (limited by what unsigned chars can hold) */
#endif /* !defined TZ_MAX_CHARS */
#ifndef TZ_MAX_LEAPS
#define TZ_MAX_LEAPS 50 /* Maximum number of leap second corrections */
#endif /* !defined TZ_MAX_LEAPS */
#define SECSPERMIN 60
#define MINSPERHOUR 60
#define HOURSPERDAY 24
#define DAYSPERWEEK 7
#define DAYSPERNYEAR 365
#define DAYSPERLYEAR 366
#define SECSPERHOUR (SECSPERMIN * MINSPERHOUR)
#define SECSPERDAY ((int_fast32_t) SECSPERHOUR * HOURSPERDAY)
#define MONSPERYEAR 12
#define TM_SUNDAY 0
#define TM_MONDAY 1
#define TM_TUESDAY 2
#define TM_WEDNESDAY 3
#define TM_THURSDAY 4
#define TM_FRIDAY 5
#define TM_SATURDAY 6
#define TM_JANUARY 0
#define TM_FEBRUARY 1
#define TM_MARCH 2
#define TM_APRIL 3
#define TM_MAY 4
#define TM_JUNE 5
#define TM_JULY 6
#define TM_AUGUST 7
#define TM_SEPTEMBER 8
#define TM_OCTOBER 9
#define TM_NOVEMBER 10
#define TM_DECEMBER 11
#define TM_YEAR_BASE 1900
#define EPOCH_YEAR 1970
#define EPOCH_WDAY TM_THURSDAY
#define isleap(y) (((y) % 4) == 0 && (((y) % 100) != 0 || ((y) % 400) == 0))
/*
** Since everything in isleap is modulo 400 (or a factor of 400), we know that
** isleap(y) == isleap(y % 400)
** and so
** isleap(a + b) == isleap((a + b) % 400)
** or
** isleap(a + b) == isleap(a % 400 + b % 400)
** This is true even if % means modulo rather than Fortran remainder
** (which is allowed by C89 but not C99).
** We use this to avoid addition overflow problems.
*/
#define isleap_sum(a, b) isleap ((a) % 400 + (b) % 400)
#ifndef TZ_ABBR_MAX_LEN
#define TZ_ABBR_MAX_LEN 16
#endif /* !defined TZ_ABBR_MAX_LEN */
#ifndef TZ_ABBR_CHAR_SET
#define TZ_ABBR_CHAR_SET \
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 :+-._"
#endif /* !defined TZ_ABBR_CHAR_SET */
#ifndef TZ_ABBR_ERR_CHAR
#define TZ_ABBR_ERR_CHAR '_'
#endif /* !defined TZ_ABBR_ERR_CHAR */
#ifndef WILDABBR
/*
** Someone might make incorrect use of a time zone abbreviation:
** 1. They might reference tzname[0] before calling tzset (explicitly
** or implicitly).
** 2. They might reference tzname[1] before calling tzset (explicitly
** or implicitly).
** 3. They might reference tzname[1] after setting to a time zone
** in which Daylight Saving Time is never observed.
** 4. They might reference tzname[0] after setting to a time zone
** in which Standard Time is never observed.
** 5. They might reference tm.TM_ZONE after calling offtime.
** What's best to do in the above cases is open to debate;
** for now, we just set things up so that in any of the five cases
** WILDABBR is used. Another possibility: initialize tzname[0] to the
** string "tzname[0] used before set", and similarly for the other cases.
** And another: initialize tzname[0] to "ERA", with an explanation in the
** manual page of what this "time zone abbreviation" means (doing this so
** that tzname[0] has the "normal" length of three characters).
*/
#define WILDABBR " "
#endif /* !defined WILDABBR */
#ifdef TM_ZONE
static const char wildabbr[] = WILDABBR;
static const char gmt[] = "GMT";
#endif
struct ttinfo { /* time type information */
int_fast32_t tt_gmtoff; /* UT offset in seconds */
int tt_isdst; /* used to set tm_isdst */
int tt_abbrind; /* abbreviation list index */
int tt_ttisstd; /* true if transition is std time */
int tt_ttisgmt; /* true if transition is UT */
};
struct lsinfo { /* leap second information */
int64_t ls_trans; /* transition time */
int_fast64_t ls_corr; /* correction to apply */
};
#define BIGGEST(a, b) (((a) > (b)) ? (a) : (b))
#ifdef TZNAME_MAX
#define MY_TZNAME_MAX TZNAME_MAX
#endif /* defined TZNAME_MAX */
#ifndef TZNAME_MAX
#define MY_TZNAME_MAX 255
#endif /* !defined TZNAME_MAX */
struct state {
int leapcnt;
int timecnt;
int typecnt;
int charcnt;
int goback;
int goahead;
int64_t ats[TZ_MAX_TIMES];
unsigned char types[TZ_MAX_TIMES];
struct ttinfo ttis[TZ_MAX_TYPES];
char chars[BIGGEST (TZ_MAX_CHARS + 1, (2 * (MY_TZNAME_MAX + 1)))];
struct lsinfo lsis[TZ_MAX_LEAPS];
int defaulttype; /* for early times or if no transitions */
};
struct rule {
int r_type; /* type of rule--see below */
int r_day; /* day number of rule */
int r_week; /* week number of rule */
int r_mon; /* month number of rule */
int_fast32_t r_time; /* transition time of rule */
};
#define JULIAN_DAY 0 /* Jn - Julian day */
#define DAY_OF_YEAR 1 /* n - day of year */
#define MONTH_NTH_DAY_OF_WEEK 2 /* Mm.n.d - month, week, day of week */
/*
** Prototypes for static functions.
*/
static void
gmtload (struct state *sp);
static struct bson_tm *
gmtsub (const int64_t *timep, int_fast32_t offset, struct bson_tm *tmp);
static int64_t
increment_overflow (int64_t *number, int64_t delta);
static int64_t
leaps_thru_end_of (int64_t y) ATTRIBUTE_PURE;
static int64_t
increment_overflow32 (int_fast32_t *number, int64_t delta);
static int64_t
normalize_overflow32 (int_fast32_t *tensptr, int64_t *unitsptr, int64_t base);
static int64_t
normalize_overflow (int64_t *tensptr, int64_t *unitsptr, int64_t base);
static int64_t
time1 (struct bson_tm *tmp,
struct bson_tm *(*funcp) (const int64_t *, int_fast32_t, struct bson_tm *),
int_fast32_t offset);
static int64_t
time2 (struct bson_tm *tmp,
struct bson_tm *(*funcp) (const int64_t *, int_fast32_t, struct bson_tm *),
int_fast32_t offset,
int64_t *okayp);
static int64_t
time2sub (struct bson_tm *tmp,
struct bson_tm *(*funcp) (const int64_t *, int_fast32_t, struct bson_tm *),
int_fast32_t offset,
int64_t *okayp,
int64_t do_norm_secs);
static struct bson_tm *
timesub (const int64_t *timep,
int_fast32_t offset,
const struct state *sp,
struct bson_tm *tmp);
static int64_t
tmcomp (const struct bson_tm *atmp, const struct bson_tm *btmp);
static struct state gmtmem;
#define gmtptr (&gmtmem)
static int gmt_is_set;
static const int mon_lengths[2][MONSPERYEAR] = {
{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
{31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}};
static const int year_lengths[2] = {DAYSPERNYEAR, DAYSPERLYEAR};
static void
gmtload (struct state *const sp)
{
memset (sp, 0, sizeof (struct state));
sp->typecnt = 1;
sp->charcnt = 4;
sp->chars[0] = 'G';
sp->chars[1] = 'M';
sp->chars[2] = 'T';
}
/*
** gmtsub is to gmtime as localsub is to localtime.
*/
static struct bson_tm *
gmtsub (const int64_t *const timep,
const int_fast32_t offset,
struct bson_tm *const tmp)
{
register struct bson_tm *result;
if (!gmt_is_set) {
gmt_is_set = true;
gmtload (gmtptr);
}
result = timesub (timep, offset, gmtptr, tmp);
#ifdef TM_ZONE
/*
** Could get fancy here and deliver something such as
** "UT+xxxx" or "UT-xxxx" if offset is non-zero,
** but this is no time for a treasure hunt.
*/
tmp->TM_ZONE = offset ? wildabbr : gmtptr ? gmtptr->chars : gmt;
#endif /* defined TM_ZONE */
return result;
}
/*
** Return the number of leap years through the end of the given year
** where, to make the math easy, the answer for year zero is defined as zero.
*/
static int64_t
leaps_thru_end_of (register const int64_t y)
{
return (y >= 0) ? (y / 4 - y / 100 + y / 400)
: -(leaps_thru_end_of (-(y + 1)) + 1);
}
static struct bson_tm *
timesub (const int64_t *const timep,
const int_fast32_t offset,
register const struct state *const sp,
register struct bson_tm *const tmp)
{
register const struct lsinfo *lp;
register int64_t tdays;
register int64_t idays; /* unsigned would be so 2003 */
register int_fast64_t rem;
int64_t y;
register const int *ip;
register int_fast64_t corr;
register int64_t hit;
register int64_t i;
corr = 0;
hit = 0;
i = (sp == NULL) ? 0 : sp->leapcnt;
while (--i >= 0) {
lp = &sp->lsis[i];
if (*timep >= lp->ls_trans) {
if (*timep == lp->ls_trans) {
hit = ((i == 0 && lp->ls_corr > 0) ||
lp->ls_corr > sp->lsis[i - 1].ls_corr);
if (hit)
while (i > 0 &&
sp->lsis[i].ls_trans == sp->lsis[i - 1].ls_trans + 1 &&
sp->lsis[i].ls_corr == sp->lsis[i - 1].ls_corr + 1) {
++hit;
--i;
}
}
corr = lp->ls_corr;
break;
}
}
y = EPOCH_YEAR;
tdays = *timep / SECSPERDAY;
rem = *timep - tdays * SECSPERDAY;
while (tdays < 0 || tdays >= year_lengths[isleap (y)]) {
int64_t newy;
register int64_t tdelta;
register int64_t idelta;
register int64_t leapdays;
tdelta = tdays / DAYSPERLYEAR;
idelta = tdelta;
if (idelta == 0)
idelta = (tdays < 0) ? -1 : 1;
newy = y;
if (increment_overflow (&newy, idelta))
return NULL;
leapdays = leaps_thru_end_of (newy - 1) - leaps_thru_end_of (y - 1);
tdays -= ((int64_t) newy - y) * DAYSPERNYEAR;
tdays -= leapdays;
y = newy;
}
{
register int_fast32_t seconds;
seconds = (int_fast32_t) (tdays * SECSPERDAY);
tdays = seconds / SECSPERDAY;
rem += seconds - tdays * SECSPERDAY;
}
/*
** Given the range, we can now fearlessly cast...
*/
idays = (int64_t) tdays;
rem += offset - corr;
while (rem < 0) {
rem += SECSPERDAY;
--idays;
}
while (rem >= SECSPERDAY) {
rem -= SECSPERDAY;
++idays;
}
while (idays < 0) {
if (increment_overflow (&y, -1))
return NULL;
idays += year_lengths[isleap (y)];
}
while (idays >= year_lengths[isleap (y)]) {
idays -= year_lengths[isleap (y)];
if (increment_overflow (&y, 1))
return NULL;
}
tmp->tm_year = y;
if (increment_overflow (&tmp->tm_year, -TM_YEAR_BASE))
return NULL;
tmp->tm_yday = idays;
/*
** The "extra" mods below avoid overflow problems.
*/
tmp->tm_wday =
EPOCH_WDAY +
((y - EPOCH_YEAR) % DAYSPERWEEK) * (DAYSPERNYEAR % DAYSPERWEEK) +
leaps_thru_end_of (y - 1) - leaps_thru_end_of (EPOCH_YEAR - 1) + idays;
tmp->tm_wday %= DAYSPERWEEK;
if (tmp->tm_wday < 0)
tmp->tm_wday += DAYSPERWEEK;
tmp->tm_hour = (int64_t) (rem / SECSPERHOUR);
rem %= SECSPERHOUR;
tmp->tm_min = (int64_t) (rem / SECSPERMIN);
/*
** A positive leap second requires a special
** representation. This uses "... ??:59:60" et seq.
*/
tmp->tm_sec = (int64_t) (rem % SECSPERMIN) + hit;
ip = mon_lengths[isleap (y)];
for (tmp->tm_mon = 0; idays >= ip[tmp->tm_mon]; ++(tmp->tm_mon))
idays -= ip[tmp->tm_mon];
tmp->tm_mday = (int64_t) (idays + 1);
tmp->tm_isdst = 0;
#ifdef TM_GMTOFF
tmp->TM_GMTOFF = offset;
#endif /* defined TM_GMTOFF */
return tmp;
}
/*
** Adapted from code provided by Robert Elz, who writes:
** The "best" way to do mktime I think is based on an idea of Bob
** Kridle's (so its said...) from a long time ago.
** It does a binary search of the int64_t space. Since int64_t's are
** just 32 bits, its a max of 32 iterations (even at 64 bits it
** would still be very reasonable).
*/
#ifndef WRONG
#define WRONG (-1)
#endif /* !defined WRONG */
/*
** Normalize logic courtesy Paul Eggert.
*/
static int64_t
increment_overflow (int64_t *const ip, int64_t j)
{
register int64_t const i = *ip;
/*
** If i >= 0 there can only be overflow if i + j > INT_MAX
** or if j > INT_MAX - i; given i >= 0, INT_MAX - i cannot overflow.
** If i < 0 there can only be overflow if i + j < INT_MIN
** or if j < INT_MIN - i; given i < 0, INT_MIN - i cannot overflow.
*/
if ((i >= 0) ? (j > INT_MAX - i) : (j < INT_MIN - i))
return true;
*ip += j;
return false;
}
static int64_t
increment_overflow32 (int_fast32_t *const lp, int64_t const m)
{
register int_fast32_t const l = *lp;
if ((l >= 0) ? (m > INT_FAST32_MAX - l) : (m < INT_FAST32_MIN - l))
return true;
*lp += m;
return false;
}
static int64_t
normalize_overflow (int64_t *const tensptr, int64_t *const unitsptr, const int64_t base)
{
register int64_t tensdelta;
tensdelta =
(*unitsptr >= 0) ? (*unitsptr / base) : (-1 - (-1 - *unitsptr) / base);
*unitsptr -= tensdelta * base;
return increment_overflow (tensptr, tensdelta);
}
static int64_t
normalize_overflow32 (int_fast32_t *const tensptr,
int64_t *const unitsptr,
const int64_t base)
{
register int64_t tensdelta;
tensdelta =
(*unitsptr >= 0) ? (*unitsptr / base) : (-1 - (-1 - *unitsptr) / base);
*unitsptr -= tensdelta * base;
return increment_overflow32 (tensptr, tensdelta);
}
static int64_t
tmcomp (register const struct bson_tm *const atmp,
register const struct bson_tm *const btmp)
{
register int64_t result;
if (atmp->tm_year != btmp->tm_year)
return atmp->tm_year < btmp->tm_year ? -1 : 1;
if ((result = (atmp->tm_mon - btmp->tm_mon)) == 0 &&
(result = (atmp->tm_mday - btmp->tm_mday)) == 0 &&
(result = (atmp->tm_hour - btmp->tm_hour)) == 0 &&
(result = (atmp->tm_min - btmp->tm_min)) == 0)
result = atmp->tm_sec - btmp->tm_sec;
return result;
}
static int64_t
time2sub (struct bson_tm *const tmp,
struct bson_tm *(*const funcp) (const int64_t *, int_fast32_t, struct bson_tm *),
const int_fast32_t offset,
int64_t *const okayp,
const int64_t do_norm_secs)
{
register const struct state *sp;
register int64_t dir;
register int64_t i, j;
register int64_t saved_seconds;
register int_fast32_t li;
register int64_t lo;
register int64_t hi;
int_fast32_t y;
int64_t newt;
int64_t t;
struct bson_tm yourtm, mytm;
*okayp = false;
yourtm = *tmp;
if (do_norm_secs) {
if (normalize_overflow (&yourtm.tm_min, &yourtm.tm_sec, SECSPERMIN))
return WRONG;
}
if (normalize_overflow (&yourtm.tm_hour, &yourtm.tm_min, MINSPERHOUR))
return WRONG;
if (normalize_overflow (&yourtm.tm_mday, &yourtm.tm_hour, HOURSPERDAY))
return WRONG;
y = yourtm.tm_year;
if (normalize_overflow32 (&y, &yourtm.tm_mon, MONSPERYEAR))
return WRONG;
/*
** Turn y into an actual year number for now.
** It is converted back to an offset from TM_YEAR_BASE later.
*/
if (increment_overflow32 (&y, TM_YEAR_BASE))
return WRONG;
while (yourtm.tm_mday <= 0) {
if (increment_overflow32 (&y, -1))
return WRONG;
li = y + (1 < yourtm.tm_mon);
yourtm.tm_mday += year_lengths[isleap (li)];
}
while (yourtm.tm_mday > DAYSPERLYEAR) {
li = y + (1 < yourtm.tm_mon);
yourtm.tm_mday -= year_lengths[isleap (li)];
if (increment_overflow32 (&y, 1))
return WRONG;
}
for (;;) {
i = mon_lengths[isleap (y)][yourtm.tm_mon];
if (yourtm.tm_mday <= i)
break;
yourtm.tm_mday -= i;
if (++yourtm.tm_mon >= MONSPERYEAR) {
yourtm.tm_mon = 0;
if (increment_overflow32 (&y, 1))
return WRONG;
}
}
if (increment_overflow32 (&y, -TM_YEAR_BASE))
return WRONG;
yourtm.tm_year = y;
if (yourtm.tm_year != y)
return WRONG;
if (yourtm.tm_sec >= 0 && yourtm.tm_sec < SECSPERMIN)
saved_seconds = 0;
else if (y + TM_YEAR_BASE < EPOCH_YEAR) {
/*
** We can't set tm_sec to 0, because that might push the
** time below the minimum representable time.
** Set tm_sec to 59 instead.
** This assumes that the minimum representable time is
** not in the same minute that a leap second was deleted from,
** which is a safer assumption than using 58 would be.
*/
if (increment_overflow (&yourtm.tm_sec, 1 - SECSPERMIN))
return WRONG;
saved_seconds = yourtm.tm_sec;
yourtm.tm_sec = SECSPERMIN - 1;
} else {
saved_seconds = yourtm.tm_sec;
yourtm.tm_sec = 0;
}
/*
** Do a binary search.
*/
lo = 1;
for (i = 0; i < (int64_t) TYPE_BIT (int64_t) - 1; ++i)
lo *= 2;
hi = -(lo + 1);
for (;;) {
t = lo / 2 + hi / 2;
if (t < lo)
t = lo;
else if (t > hi)
t = hi;
if ((*funcp) (&t, offset, &mytm) == NULL) {
/*
** Assume that t is too extreme to be represented in
** a struct bson_tm; arrange things so that it is less
** extreme on the next pass.
*/
dir = (t > 0) ? 1 : -1;
} else
dir = tmcomp (&mytm, &yourtm);
if (dir != 0) {
if (t == lo) {
if (t == time_t_max)
return WRONG;
++t;
++lo;
} else if (t == hi) {
if (t == time_t_min)
return WRONG;
--t;
--hi;
}
if (lo > hi)
return WRONG;
if (dir > 0)
hi = t;
else
lo = t;
continue;
}
if (yourtm.tm_isdst < 0 || mytm.tm_isdst == yourtm.tm_isdst)
break;
/*
** Right time, wrong type.
** Hunt for right time, right type.
** It's okay to guess wrong since the guess
** gets checked.
*/
sp = (const struct state *) gmtptr;
if (sp == NULL)
return WRONG;
for (i = sp->typecnt - 1; i >= 0; --i) {
if (sp->ttis[i].tt_isdst != yourtm.tm_isdst)
continue;
for (j = sp->typecnt - 1; j >= 0; --j) {
if (sp->ttis[j].tt_isdst == yourtm.tm_isdst)
continue;
newt = t + sp->ttis[j].tt_gmtoff - sp->ttis[i].tt_gmtoff;
if ((*funcp) (&newt, offset, &mytm) == NULL)
continue;
if (tmcomp (&mytm, &yourtm) != 0)
continue;
if (mytm.tm_isdst != yourtm.tm_isdst)
continue;
/*
** We have a match.
*/
t = newt;
goto label;
}
}
return WRONG;
}
label:
newt = t + saved_seconds;
if ((newt < t) != (saved_seconds < 0))
return WRONG;
t = newt;
if ((*funcp) (&t, offset, tmp))
*okayp = true;
return t;
}
static int64_t
time2 (struct bson_tm *const tmp,
struct bson_tm *(*const funcp) (const int64_t *, int_fast32_t, struct bson_tm *),
const int_fast32_t offset,
int64_t *const okayp)
{
int64_t t;
/*
** First try without normalization of seconds
** (in case tm_sec contains a value associated with a leap second).
** If that fails, try with normalization of seconds.
*/
t = time2sub (tmp, funcp, offset, okayp, false);
return *okayp ? t : time2sub (tmp, funcp, offset, okayp, true);
}
static int64_t
time1 (struct bson_tm *const tmp,
struct bson_tm *(*const funcp) (const int64_t *, int_fast32_t, struct bson_tm *),
const int_fast32_t offset)
{
register int64_t t;
register const struct state *sp;
register int64_t samei, otheri;
register int64_t sameind, otherind;
register int64_t i;
register int64_t nseen;
int64_t seen[TZ_MAX_TYPES];
int64_t types[TZ_MAX_TYPES];
int64_t okay;
if (tmp == NULL) {
errno = EINVAL;
return WRONG;
}
if (tmp->tm_isdst > 1)
tmp->tm_isdst = 1;
t = time2 (tmp, funcp, offset, &okay);
if (okay)
return t;
if (tmp->tm_isdst < 0)
#ifdef PCTS
/*
** POSIX Conformance Test Suite code courtesy Grant Sullivan.
*/
tmp->tm_isdst = 0; /* reset to std and try again */
#else
return t;
#endif /* !defined PCTS */
/*
** We're supposed to assume that somebody took a time of one type
** and did some math on it that yielded a "struct tm" that's bad.
** We try to divine the type they started from and adjust to the
** type they need.
*/
sp = (const struct state *) gmtptr;
if (sp == NULL)
return WRONG;
for (i = 0; i < sp->typecnt; ++i)
seen[i] = false;
nseen = 0;
for (i = sp->timecnt - 1; i >= 0; --i)
if (!seen[sp->types[i]]) {
seen[sp->types[i]] = true;
types[nseen++] = sp->types[i];
}
for (sameind = 0; sameind < nseen; ++sameind) {
samei = types[sameind];
if (sp->ttis[samei].tt_isdst != tmp->tm_isdst)
continue;
for (otherind = 0; otherind < nseen; ++otherind) {
otheri = types[otherind];
if (sp->ttis[otheri].tt_isdst == tmp->tm_isdst)
continue;
tmp->tm_sec += sp->ttis[otheri].tt_gmtoff - sp->ttis[samei].tt_gmtoff;
tmp->tm_isdst = !tmp->tm_isdst;
t = time2 (tmp, funcp, offset, &okay);
if (okay)
return t;
tmp->tm_sec -= sp->ttis[otheri].tt_gmtoff - sp->ttis[samei].tt_gmtoff;
tmp->tm_isdst = !tmp->tm_isdst;
}
}
return WRONG;
}
int64_t
_bson_timegm (struct bson_tm *const tmp)
{
if (tmp != NULL)
tmp->tm_isdst = 0;
return time1 (tmp, gmtsub, 0L);
}
libbson-1.6.1/src/bson/bson-types.h 0000664 0000000 0000000 00000041347 13057346540 0017173 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 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.
*/
#ifndef BSON_TYPES_H
#define BSON_TYPES_H
#if !defined(BSON_INSIDE) && !defined(BSON_COMPILATION)
#error "Only can be included directly."
#endif
#include
#include
#include "bson-macros.h"
#include "bson-config.h"
#include "bson-compat.h"
#include "bson-endian.h"
BSON_BEGIN_DECLS
/*
*--------------------------------------------------------------------------
*
* bson_unichar_t --
*
* bson_unichar_t provides an unsigned 32-bit type for containing
* unicode characters. When iterating UTF-8 sequences, this should
* be used to avoid losing the high-bits of non-ascii characters.
*
* See also:
* bson_string_append_unichar()
*
*--------------------------------------------------------------------------
*/
typedef uint32_t bson_unichar_t;
/**
* bson_context_flags_t:
*
* This enumeration is used to configure a bson_context_t.
*
* %BSON_CONTEXT_NONE: Use default options.
* %BSON_CONTEXT_THREAD_SAFE: Context will be called from multiple threads.
* %BSON_CONTEXT_DISABLE_PID_CACHE: Call getpid() instead of caching the
* result of getpid() when initializing the context.
* %BSON_CONTEXT_DISABLE_HOST_CACHE: Call gethostname() instead of caching the
* result of gethostname() when initializing the context.
*/
typedef enum {
BSON_CONTEXT_NONE = 0,
BSON_CONTEXT_THREAD_SAFE = (1 << 0),
BSON_CONTEXT_DISABLE_HOST_CACHE = (1 << 1),
BSON_CONTEXT_DISABLE_PID_CACHE = (1 << 2),
#ifdef BSON_HAVE_SYSCALL_TID
BSON_CONTEXT_USE_TASK_ID = (1 << 3),
#endif
} bson_context_flags_t;
/**
* bson_context_t:
*
* This structure manages context for the bson library. It handles
* configuration for thread-safety and other performance related requirements.
* Consumers will create a context and may use multiple under a variety of
* situations.
*
* If your program calls fork(), you should initialize a new bson_context_t
* using bson_context_init().
*
* If you are using threading, it is suggested that you use a bson_context_t
* per thread for best performance. Alternatively, you can initialize the
* bson_context_t with BSON_CONTEXT_THREAD_SAFE, although a performance penalty
* will be incurred.
*
* Many functions will require that you provide a bson_context_t such as OID
* generation.
*
* This structure is oqaque in that you cannot see the contents of the
* structure. However, it is stack allocatable in that enough padding is
* provided in _bson_context_t to hold the structure.
*/
typedef struct _bson_context_t bson_context_t;
/**
* bson_t:
*
* This structure manages a buffer whose contents are a properly formatted
* BSON document. You may perform various transforms on the BSON documents.
* Additionally, it can be iterated over using bson_iter_t.
*
* See bson_iter_init() for iterating the contents of a bson_t.
*
* When building a bson_t structure using the various append functions,
* memory allocations may occur. That is performed using power of two
* allocations and realloc().
*
* See http://bsonspec.org for the BSON document spec.
*
* This structure is meant to fit in two sequential 64-byte cachelines.
*/
BSON_ALIGNED_BEGIN (128)
typedef struct _bson_t {
uint32_t flags; /* Internal flags for the bson_t. */
uint32_t len; /* Length of BSON data. */
uint8_t padding[120]; /* Padding for stack allocation. */
} bson_t BSON_ALIGNED_END (128);
/**
* BSON_INITIALIZER:
*
* This macro can be used to initialize a #bson_t structure on the stack
* without calling bson_init().
*
* |[
* bson_t b = BSON_INITIALIZER;
* ]|
*/
#define BSON_INITIALIZER \
{ \
3, 5, \
{ \
5 \
} \
}
BSON_STATIC_ASSERT (sizeof (bson_t) == 128);
/**
* bson_oid_t:
*
* This structure contains the binary form of a BSON Object Id as specified
* on http://bsonspec.org. If you would like the bson_oid_t in string form
* see bson_oid_to_string() or bson_oid_to_string_r().
*/
typedef struct {
uint8_t bytes[12];
} bson_oid_t;
BSON_STATIC_ASSERT (sizeof (bson_oid_t) == 12);
/**
* bson_decimal128_t:
*
* @high The high-order bytes of the decimal128. This field contains sign,
* combination bits, exponent, and part of the coefficient continuation.
* @low The low-order bytes of the decimal128. This field contains the second
* part of the coefficient continuation.
*
* This structure is a boxed type containing the value for the BSON decimal128
* type. The structure stores the 128 bits such that they correspond to the
* native format for the IEEE decimal128 type, if it is implemented.
**/
typedef struct {
#if BSON_BYTE_ORDER == BSON_LITTLE_ENDIAN
uint64_t low;
uint64_t high;
#elif BSON_BYTE_ORDER == BSON_BIG_ENDIAN
uint64_t high;
uint64_t low;
#endif
} bson_decimal128_t;
/**
* bson_validate_flags_t:
*
* This enumeration is used for validation of BSON documents. It allows
* selective control on what you wish to validate.
*
* %BSON_VALIDATE_NONE: No additional validation occurs.
* %BSON_VALIDATE_UTF8: Check that strings are valid UTF-8.
* %BSON_VALIDATE_DOLLAR_KEYS: Check that keys do not start with $.
* %BSON_VALIDATE_DOT_KEYS: Check that keys do not contain a period.
* %BSON_VALIDATE_UTF8_ALLOW_NULL: Allow NUL bytes in UTF-8 text.
* %BSON_VALIDATE_EMPTY_KEYS: Prohibit zero-length field names
*/
typedef enum {
BSON_VALIDATE_NONE = 0,
BSON_VALIDATE_UTF8 = (1 << 0),
BSON_VALIDATE_DOLLAR_KEYS = (1 << 1),
BSON_VALIDATE_DOT_KEYS = (1 << 2),
BSON_VALIDATE_UTF8_ALLOW_NULL = (1 << 3),
BSON_VALIDATE_EMPTY_KEYS = (1 << 4),
} bson_validate_flags_t;
/**
* bson_type_t:
*
* This enumeration contains all of the possible types within a BSON document.
* Use bson_iter_type() to fetch the type of a field while iterating over it.
*/
typedef enum {
BSON_TYPE_EOD = 0x00,
BSON_TYPE_DOUBLE = 0x01,
BSON_TYPE_UTF8 = 0x02,
BSON_TYPE_DOCUMENT = 0x03,
BSON_TYPE_ARRAY = 0x04,
BSON_TYPE_BINARY = 0x05,
BSON_TYPE_UNDEFINED = 0x06,
BSON_TYPE_OID = 0x07,
BSON_TYPE_BOOL = 0x08,
BSON_TYPE_DATE_TIME = 0x09,
BSON_TYPE_NULL = 0x0A,
BSON_TYPE_REGEX = 0x0B,
BSON_TYPE_DBPOINTER = 0x0C,
BSON_TYPE_CODE = 0x0D,
BSON_TYPE_SYMBOL = 0x0E,
BSON_TYPE_CODEWSCOPE = 0x0F,
BSON_TYPE_INT32 = 0x10,
BSON_TYPE_TIMESTAMP = 0x11,
BSON_TYPE_INT64 = 0x12,
BSON_TYPE_DECIMAL128 = 0x13,
BSON_TYPE_MAXKEY = 0x7F,
BSON_TYPE_MINKEY = 0xFF,
} bson_type_t;
/**
* bson_subtype_t:
*
* This enumeration contains the various subtypes that may be used in a binary
* field. See http://bsonspec.org for more information.
*/
typedef enum {
BSON_SUBTYPE_BINARY = 0x00,
BSON_SUBTYPE_FUNCTION = 0x01,
BSON_SUBTYPE_BINARY_DEPRECATED = 0x02,
BSON_SUBTYPE_UUID_DEPRECATED = 0x03,
BSON_SUBTYPE_UUID = 0x04,
BSON_SUBTYPE_MD5 = 0x05,
BSON_SUBTYPE_USER = 0x80,
} bson_subtype_t;
/*
*--------------------------------------------------------------------------
*
* bson_value_t --
*
* A boxed type to contain various bson_type_t types.
*
* See also:
* bson_value_copy()
* bson_value_destroy()
*
*--------------------------------------------------------------------------
*/
BSON_ALIGNED_BEGIN (8)
typedef struct _bson_value_t {
bson_type_t value_type;
int32_t padding;
union {
bson_oid_t v_oid;
int64_t v_int64;
int32_t v_int32;
int8_t v_int8;
double v_double;
bool v_bool;
int64_t v_datetime;
struct {
uint32_t timestamp;
uint32_t increment;
} v_timestamp;
struct {
char *str;
uint32_t len;
} v_utf8;
struct {
uint8_t *data;
uint32_t data_len;
} v_doc;
struct {
uint8_t *data;
uint32_t data_len;
bson_subtype_t subtype;
} v_binary;
struct {
char *regex;
char *options;
} v_regex;
struct {
char *collection;
uint32_t collection_len;
bson_oid_t oid;
} v_dbpointer;
struct {
char *code;
uint32_t code_len;
} v_code;
struct {
char *code;
uint8_t *scope_data;
uint32_t code_len;
uint32_t scope_len;
} v_codewscope;
struct {
char *symbol;
uint32_t len;
} v_symbol;
bson_decimal128_t v_decimal128;
} value;
} bson_value_t BSON_ALIGNED_END (8);
/**
* bson_iter_t:
*
* This structure manages iteration over a bson_t structure. It keeps track
* of the location of the current key and value within the buffer. Using the
* various functions to get the value of the iter will read from these
* locations.
*
* This structure is safe to discard on the stack. No cleanup is necessary
* after using it.
*/
BSON_ALIGNED_BEGIN (128)
typedef struct {
const uint8_t *raw; /* The raw buffer being iterated. */
uint32_t len; /* The length of raw. */
uint32_t off; /* The offset within the buffer. */
uint32_t type; /* The offset of the type byte. */
uint32_t key; /* The offset of the key byte. */
uint32_t d1; /* The offset of the first data byte. */
uint32_t d2; /* The offset of the second data byte. */
uint32_t d3; /* The offset of the third data byte. */
uint32_t d4; /* The offset of the fourth data byte. */
uint32_t next_off; /* The offset of the next field. */
uint32_t err_off; /* The offset of the error. */
bson_value_t value; /* Internal value for various state. */
} bson_iter_t BSON_ALIGNED_END (128);
/**
* bson_reader_t:
*
* This structure is used to iterate over a sequence of BSON documents. It
* allows for them to be iterated with the possibility of no additional
* memory allocations under certain circumstances such as reading from an
* incoming mongo packet.
*/
BSON_ALIGNED_BEGIN (BSON_ALIGN_OF_PTR)
typedef struct {
uint32_t type;
/*< private >*/
} bson_reader_t BSON_ALIGNED_END (BSON_ALIGN_OF_PTR);
/**
* bson_visitor_t:
*
* This structure contains a series of pointers that can be executed for
* each field of a BSON document based on the field type.
*
* For example, if an int32 field is found, visit_int32 will be called.
*
* When visiting each field using bson_iter_visit_all(), you may provide a
* data pointer that will be provided with each callback. This might be useful
* if you are marshaling to another language.
*
* You may pre-maturely stop the visitation of fields by returning true in your
* visitor. Returning false will continue visitation to further fields.
*/
BSON_ALIGNED_BEGIN (8)
typedef struct {
/* run before / after descending into a document */
bool (*visit_before) (const bson_iter_t *iter, const char *key, void *data);
bool (*visit_after) (const bson_iter_t *iter, const char *key, void *data);
/* corrupt BSON, or unsupported type and visit_unsupported_type not set */
void (*visit_corrupt) (const bson_iter_t *iter, void *data);
/* normal bson field callbacks */
bool (*visit_double) (const bson_iter_t *iter,
const char *key,
double v_double,
void *data);
bool (*visit_utf8) (const bson_iter_t *iter,
const char *key,
size_t v_utf8_len,
const char *v_utf8,
void *data);
bool (*visit_document) (const bson_iter_t *iter,
const char *key,
const bson_t *v_document,
void *data);
bool (*visit_array) (const bson_iter_t *iter,
const char *key,
const bson_t *v_array,
void *data);
bool (*visit_binary) (const bson_iter_t *iter,
const char *key,
bson_subtype_t v_subtype,
size_t v_binary_len,
const uint8_t *v_binary,
void *data);
/* normal field with deprecated "Undefined" BSON type */
bool (*visit_undefined) (const bson_iter_t *iter,
const char *key,
void *data);
bool (*visit_oid) (const bson_iter_t *iter,
const char *key,
const bson_oid_t *v_oid,
void *data);
bool (*visit_bool) (const bson_iter_t *iter,
const char *key,
bool v_bool,
void *data);
bool (*visit_date_time) (const bson_iter_t *iter,
const char *key,
int64_t msec_since_epoch,
void *data);
bool (*visit_null) (const bson_iter_t *iter, const char *key, void *data);
bool (*visit_regex) (const bson_iter_t *iter,
const char *key,
const char *v_regex,
const char *v_options,
void *data);
bool (*visit_dbpointer) (const bson_iter_t *iter,
const char *key,
size_t v_collection_len,
const char *v_collection,
const bson_oid_t *v_oid,
void *data);
bool (*visit_code) (const bson_iter_t *iter,
const char *key,
size_t v_code_len,
const char *v_code,
void *data);
bool (*visit_symbol) (const bson_iter_t *iter,
const char *key,
size_t v_symbol_len,
const char *v_symbol,
void *data);
bool (*visit_codewscope) (const bson_iter_t *iter,
const char *key,
size_t v_code_len,
const char *v_code,
const bson_t *v_scope,
void *data);
bool (*visit_int32) (const bson_iter_t *iter,
const char *key,
int32_t v_int32,
void *data);
bool (*visit_timestamp) (const bson_iter_t *iter,
const char *key,
uint32_t v_timestamp,
uint32_t v_increment,
void *data);
bool (*visit_int64) (const bson_iter_t *iter,
const char *key,
int64_t v_int64,
void *data);
bool (*visit_maxkey) (const bson_iter_t *iter, const char *key, void *data);
bool (*visit_minkey) (const bson_iter_t *iter, const char *key, void *data);
/* if set, called instead of visit_corrupt when an apparently valid BSON
* includes an unrecognized field type (reading future version of BSON) */
void (*visit_unsupported_type) (const bson_iter_t *iter,
const char *key,
uint32_t type_code,
void *data);
bool (*visit_decimal128) (const bson_iter_t *iter,
const char *key,
const bson_decimal128_t *v_decimal128,
void *data);
void *padding[7];
} bson_visitor_t BSON_ALIGNED_END (8);
#define BSON_ERROR_BUFFER_SIZE 504
BSON_ALIGNED_BEGIN (8)
typedef struct _bson_error_t {
uint32_t domain;
uint32_t code;
char message[BSON_ERROR_BUFFER_SIZE];
} bson_error_t BSON_ALIGNED_END (8);
BSON_STATIC_ASSERT (sizeof (bson_error_t) == 512);
/**
* bson_next_power_of_two:
* @v: A 32-bit unsigned integer of required bytes.
*
* Determines the next larger power of two for the value of @v
* in a constant number of operations.
*
* It is up to the caller to guarantee this will not overflow.
*
* Returns: The next power of 2 from @v.
*/
static BSON_INLINE size_t
bson_next_power_of_two (size_t v)
{
v--;
v |= v >> 1;
v |= v >> 2;
v |= v >> 4;
v |= v >> 8;
v |= v >> 16;
#if BSON_WORD_SIZE == 64
v |= v >> 32;
#endif
v++;
return v;
}
static BSON_INLINE bool
bson_is_power_of_two (uint32_t v)
{
return ((v != 0) && ((v & (v - 1)) == 0));
}
BSON_END_DECLS
#endif /* BSON_TYPES_H */
libbson-1.6.1/src/bson/bson-utf8.c 0000664 0000000 0000000 00000027400 13057346540 0016702 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 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