From 6c52ca3958dcd7be49a692b132627bc50eb7678a Mon Sep 17 00:00:00 2001 From: behackett Date: Sun, 9 Jun 2013 14:10:10 -0700 Subject: [PATCH] Fix clang warnings. This fixes all compiler warnings under clang. The major change is safely downcasting from Py_ssize_t to int (BSON string lengths and document size are signed int32). This change also includes some code cleanup in the functions touched to fix compiler warnings. --- bson/_cbsonmodule.c | 392 +++++++++++++++++++++++--------------- pymongo/_cmessagemodule.c | 2 +- 2 files changed, 236 insertions(+), 158 deletions(-) diff --git a/bson/_cbsonmodule.c b/bson/_cbsonmodule.c index 3c52d4dd3..36732974d 100644 --- a/bson/_cbsonmodule.c +++ b/bson/_cbsonmodule.c @@ -83,34 +83,64 @@ static struct module_state _state; */ #if defined(_MSC_VER) && (_MSC_VER >= 1400) #define INT2STRING(buffer, i) \ - *(buffer) = malloc(_scprintf("%d", (i)) + 1), \ + *(buffer) = malloc(_scprintf("%ld", (i)) + 1), \ (!(buffer) ? \ -1 : \ _snprintf_s(*(buffer), \ - _scprintf("%d", (i)) + 1, \ - _scprintf("%d", (i)) + 1, \ - "%d", \ + _scprintf("%ld", (i)) + 1, \ + _scprintf("%ld", (i)) + 1, \ + "%ld", \ (i))) #define STRCAT(dest, n, src) strcat_s((dest), (n), (src)) #else #define INT2STRING(buffer, i) \ - *(buffer) = malloc(_scprintf("%d", (i)) + 1), \ + *(buffer) = malloc(_scprintf("%ld", (i)) + 1), \ (!(buffer) ? \ -1 : \ _snprintf(*(buffer), \ - _scprintf("%d", (i)) + 1, \ - "%d", \ + _scprintf("%ld", (i)) + 1, \ + "%ld", \ (i))) #define STRCAT(dest, n, src) strcat((dest), (src)) #endif #else -#define INT2STRING(buffer, i) asprintf((buffer), "%d", (i)) +#define INT2STRING(buffer, i) asprintf((buffer), "%ld", (i)) #define STRCAT(dest, n, src) strcat((dest), (src)) #endif #define JAVA_LEGACY 5 #define CSHARP_LEGACY 6 +#define BSON_MAX_SIZE 2147483647 +/* Get an error class from the bson.errors module. + * + * Returns a new ref */ +static PyObject* _error(char* name) { + PyObject* error; + PyObject* errors = PyImport_ImportModule("bson.errors"); + if (!errors) { + return NULL; + } + error = PyObject_GetAttrString(errors, name); + Py_DECREF(errors); + return error; +} + +/* Safely downcast from Py_ssize_t to int, setting an + * exception and returning -1 on error. */ +static int +_downcast_and_check(Py_ssize_t size, unsigned extra) { + if (size > BSON_MAX_SIZE || ((BSON_MAX_SIZE - extra) < size)) { + PyObject* InvalidStringData = _error("InvalidStringData"); + if (InvalidStringData) { + PyErr_SetString(InvalidStringData, + "String length must be <= 2147483647"); + Py_DECREF(InvalidStringData); + } + return -1; + } + return (int)size + extra; +} static PyObject* elements_to_dict(PyObject* self, const char* string, int max, PyObject* as_class, unsigned char tz_aware, @@ -192,23 +222,26 @@ int buffer_write_bytes(buffer_t buffer, const char* data, int size) { #if PY_MAJOR_VERSION >= 3 static int write_unicode(buffer_t buffer, PyObject* py_string) { - Py_ssize_t string_length; - const char* string; + int size; + const char* data; PyObject* encoded = PyUnicode_AsUTF8String(py_string); if (!encoded) { return 0; } - string = PyBytes_AsString(encoded); - if (!string) { + data = PyBytes_AsString(encoded); + if (!data) { Py_DECREF(encoded); return 0; } - string_length = PyBytes_Size(encoded) + 1; - if (!buffer_write_bytes(buffer, (const char*)&string_length, 4)) { + if ((size = _downcast_and_check(PyBytes_Size(encoded), 1)) == -1){ Py_DECREF(encoded); return 0; } - if (!buffer_write_bytes(buffer, string, string_length)) { + if (!buffer_write_bytes(buffer, (const char*)&size, 4)) { + Py_DECREF(encoded); + return 0; + } + if (!buffer_write_bytes(buffer, data, size)) { Py_DECREF(encoded); return 0; } @@ -219,49 +252,36 @@ static int write_unicode(buffer_t buffer, PyObject* py_string) { /* returns 0 on failure */ static int write_string(buffer_t buffer, PyObject* py_string) { - Py_ssize_t string_length; - const char* string; + int size; + const char* data; #if PY_MAJOR_VERSION >= 3 if (PyUnicode_Check(py_string)){ return write_unicode(buffer, py_string); } - string = PyBytes_AsString(py_string); + data = PyBytes_AsString(py_string); #else - string = PyString_AsString(py_string); + data = PyString_AsString(py_string); #endif - if (!string) { + if (!data) { return 0; } #if PY_MAJOR_VERSION >= 3 - string_length = PyBytes_Size(py_string) + 1; + if ((size = _downcast_and_check(PyBytes_Size(py_string), 1)) == -1) #else - string_length = PyString_Size(py_string) + 1; + if ((size = _downcast_and_check(PyString_Size(py_string), 1)) == -1) #endif + return 0; - if (!buffer_write_bytes(buffer, (const char*)&string_length, 4)) { + if (!buffer_write_bytes(buffer, (const char*)&size, 4)) { return 0; } - if (!buffer_write_bytes(buffer, string, string_length)) { + if (!buffer_write_bytes(buffer, data, size)) { return 0; } return 1; } -/* Get an error class from the bson.errors module. - * - * Returns a new ref */ -static PyObject* _error(char* name) { - PyObject* error; - PyObject* errors = PyImport_ImportModule("bson.errors"); - if (!errors) { - return NULL; - } - error = PyObject_GetAttrString(errors, name); - Py_DECREF(errors); - return error; -} - /* Reload a cached Python object. * * Returns non-zero on failure. */ @@ -339,7 +359,8 @@ static int write_element_to_buffer(PyObject* self, buffer_t buffer, int type_byt return result; } -static int _fix_java(const char* in, char* out) { +static void +_fix_java(const char* in, char* out) { int i, j; for (i = 0, j = 7; i < j; i++, j--) { out[i] = in[j]; @@ -349,7 +370,6 @@ static int _fix_java(const char* in, char* out) { out[i] = in[j]; out[j] = in[i]; } - return 0; } /* TODO our platform better be little-endian w/ 4-byte ints! */ @@ -417,11 +437,10 @@ static int _write_element_to_buffer(PyObject* self, buffer_t buffer, int type_by *(buffer_get_buffer(buffer) + type_byte) = 0x03; return write_dict(self, buffer, value, check_keys, uuid_subtype, 0); } else if (PyList_Check(value) || PyTuple_Check(value)) { + Py_ssize_t items, i; int start_position, length_location, - items, - length, - i; + length; char zero = 0; *(buffer_get_buffer(buffer) + type_byte) = 0x04; @@ -448,7 +467,7 @@ static int _write_element_to_buffer(PyObject* self, buffer_t buffer, int type_by PyErr_NoMemory(); return 0; } - if (!buffer_write_bytes(buffer, name, strlen(name) + 1)) { + if (!buffer_write_bytes(buffer, name, (int)strlen(name) + 1)) { free(name); return 0; } @@ -472,78 +491,91 @@ static int _write_element_to_buffer(PyObject* self, buffer_t buffer, int type_by return 1; } else if (PyObject_IsInstance(value, state->Binary)) { PyObject* subtype_object; + long subtype; + const char* data; + int size; *(buffer_get_buffer(buffer) + type_byte) = 0x05; subtype_object = PyObject_GetAttrString(value, "subtype"); if (!subtype_object) { return 0; } - { #if PY_MAJOR_VERSION >= 3 - const long long_subtype = PyLong_AsLong(subtype_object); - const char subtype = (const char)long_subtype; - const int length = PyBytes_Size(value); + subtype = PyLong_AsLong(subtype_object); #else - const long long_subtype = PyInt_AsLong(subtype_object); - const char subtype = (const char)long_subtype; - const int length = PyString_Size(value); + subtype = PyInt_AsLong(subtype_object); #endif - + if (subtype == -1) { Py_DECREF(subtype_object); - if (subtype == 2) { - const int other_length = length + 4; - if (!buffer_write_bytes(buffer, (const char*)&other_length, 4)) { - return 0; - } - if (!buffer_write_bytes(buffer, &subtype, 1)) { - return 0; - } - } - if (!buffer_write_bytes(buffer, (const char*)&length, 4)) { + return 0; + } +#if PY_MAJOR_VERSION >= 3 + size = _downcast_and_check(PyBytes_Size(value), 0); +#else + size = _downcast_and_check(PyString_Size(value), 0); +#endif + if (size == -1) { + Py_DECREF(subtype_object); + return 0; + } + + Py_DECREF(subtype_object); + if (subtype == 2) { +#if PY_MAJOR_VERSION >= 3 + int other_size = _downcast_and_check(PyBytes_Size(value), 4); +#else + int other_size = _downcast_and_check(PyString_Size(value), 4); +#endif + if (other_size == -1) + return 0; + if (!buffer_write_bytes(buffer, (const char*)&other_size, 4)) { return 0; } - if (subtype != 2) { - if (!buffer_write_bytes(buffer, &subtype, 1)) { - return 0; - } + if (!buffer_write_bytes(buffer, (const char*)&subtype, 1)) { + return 0; } - { + } + if (!buffer_write_bytes(buffer, (const char*)&size, 4)) { + return 0; + } + if (subtype != 2) { + if (!buffer_write_bytes(buffer, (const char*)&subtype, 1)) { + return 0; + } + } #if PY_MAJOR_VERSION >= 3 - const char* string = PyBytes_AsString(value); + data = PyBytes_AsString(value); #else - const char* string = PyString_AsString(value); + data = PyString_AsString(value); #endif - if (!string) { - return 0; - } - if (!buffer_write_bytes(buffer, string, length)) { - return 0; - } - } + if (!data) { + return 0; + } + if (!buffer_write_bytes(buffer, data, size)) { + return 0; } return 1; } else if (state->UUID && PyObject_IsInstance(value, state->UUID)) { - // Just a special case of Binary above, but simpler to do as a separate case - + /* Just a special case of Binary above, but + * simpler to do as a separate case. */ PyObject* bytes; - - // Could be bytes, bytearray, str... - const char* binarr; - // UUID is always 16 bytes - int length = 16; - char subtype; + /* Could be bytes, bytearray, str... */ + const char* data; + /* UUID is always 16 bytes */ + int size = 16; + int subtype; if (uuid_subtype == JAVA_LEGACY || uuid_subtype == CSHARP_LEGACY) { subtype = 3; } else { - subtype = (char)uuid_subtype; + subtype = uuid_subtype; } *(buffer_get_buffer(buffer) + type_byte) = 0x05; - if (!buffer_write_bytes(buffer, (const char*)&length, 4)) { + if (!buffer_write_bytes(buffer, (const char*)&size, 4)) { return 0; } - if (!buffer_write_bytes(buffer, &subtype, 1)) { + if (!buffer_write_bytes(buffer, (const char*)&subtype, 1)) { return 0; } @@ -560,25 +592,28 @@ static int _write_element_to_buffer(PyObject* self, buffer_t buffer, int type_by #if PY_MAJOR_VERSION >= 3 /* Work around http://bugs.python.org/issue7380 */ if (PyByteArray_Check(bytes)) { - binarr = PyByteArray_AsString(bytes); + data = PyByteArray_AsString(bytes); } else { - binarr = PyBytes_AsString(bytes); + data = PyBytes_AsString(bytes); } #else - binarr = PyString_AsString(bytes); + data = PyString_AsString(bytes); #endif + if (data == NULL) { + Py_DECREF(bytes); + } if (uuid_subtype == JAVA_LEGACY) { /* Store in legacy java byte order. */ char as_legacy_java[16]; - _fix_java(binarr, as_legacy_java); - if (!buffer_write_bytes(buffer, as_legacy_java, length)) { + _fix_java(data, as_legacy_java); + if (!buffer_write_bytes(buffer, as_legacy_java, size)) { Py_DECREF(bytes); return 0; } } else { - if (!buffer_write_bytes(buffer, binarr, length)) { + if (!buffer_write_bytes(buffer, data, size)) { Py_DECREF(bytes); return 0; } @@ -629,28 +664,36 @@ static int _write_element_to_buffer(PyObject* self, buffer_t buffer, int type_by #if PY_MAJOR_VERSION >= 3 /* Python3 special case. Store bytes as BSON binary subtype 0. */ } else if (PyBytes_Check(value)) { - Py_ssize_t length = PyBytes_Size(value); - const char subtype = 0; + int subtype = 0; + int size; + const char* data = PyBytes_AsString(value); + if (!data) + return 0; + if ((size = _downcast_and_check(PyBytes_Size(value), 0)) == -1) + return 0; *(buffer_get_buffer(buffer) + type_byte) = 0x05; - if (!buffer_write_bytes(buffer, (const char*)&length, 4)) { + if (!buffer_write_bytes(buffer, (const char*)&size, 4)) { return 0; } - if (!buffer_write_bytes(buffer, &subtype, 1)) { + if (!buffer_write_bytes(buffer, (const char*)&subtype, 1)) { return 0; } - if (!buffer_write_bytes(buffer, PyBytes_AsString(value), length)) { + if (!buffer_write_bytes(buffer, data, size)) { return 0; } return 1; #else /* PyString_Check only works in Python 2.x. */ } else if (PyString_Check(value)) { - int result; result_t status; - + const char* data; + int size; + if (!(data = PyString_AsString(value))) + return 0; + if ((size = _downcast_and_check(PyString_Size(value), 0)) == -1) + return 0; *(buffer_get_buffer(buffer) + type_byte) = 0x02; - status = check_string((const unsigned char*)PyString_AsString(value), - PyString_Size(value), 1, 0); + status = check_string((const unsigned char*)data, size, 1, 0); if (status == NOT_UTF_8) { PyObject* InvalidStringData = _error("InvalidStringData"); @@ -677,8 +720,7 @@ static int _write_element_to_buffer(PyObject* self, buffer_t buffer, int type_by } return 0; } - result = write_string(buffer, value); - return result; + return write_string(buffer, value); #endif } else if (PyUnicode_Check(value)) { PyObject* encoded; @@ -709,27 +751,26 @@ static int _write_element_to_buffer(PyObject* self, buffer_t buffer, int type_by *(buffer_get_buffer(buffer) + type_byte) = 0x09; return buffer_write_bytes(buffer, (const char*)&millis, 8); } else if (PyObject_IsInstance(value, state->ObjectId)) { + const char* data; PyObject* pystring = PyObject_GetAttrString(value, "_ObjectId__id"); if (!pystring) { return 0; } - { #if PY_MAJOR_VERSION >= 3 - const char* as_string = PyBytes_AsString(pystring); + data = PyBytes_AsString(pystring); #else - const char* as_string = PyString_AsString(pystring); + data = PyString_AsString(pystring); #endif - if (!as_string) { - Py_DECREF(pystring); - return 0; - } - if (!buffer_write_bytes(buffer, as_string, 12)) { - Py_DECREF(pystring); - return 0; - } + if (!data) { Py_DECREF(pystring); - *(buffer_get_buffer(buffer) + type_byte) = 0x07; + return 0; } + if (!buffer_write_bytes(buffer, data, 12)) { + Py_DECREF(pystring); + return 0; + } + Py_DECREF(pystring); + *(buffer_get_buffer(buffer) + type_byte) = 0x07; return 1; } else if (PyObject_IsInstance(value, state->DBRef)) { PyObject* as_doc = PyObject_CallMethod(value, "as_doc", NULL); @@ -779,16 +820,17 @@ static int _write_element_to_buffer(PyObject* self, buffer_t buffer, int type_by return 1; } else if (PyObject_TypeCheck(value, state->REType)) { - PyObject* py_flags = PyObject_GetAttrString(value, "flags"); + PyObject* py_flags; PyObject* py_pattern; PyObject* encoded_pattern; long int_flags; char flags[FLAGS_SIZE]; char check_utf8 = 0; - int pattern_length, - flags_length; + const char* pattern_data; + int pattern_length, flags_length; result_t status; + py_flags = PyObject_GetAttrString(value, "flags"); if (!py_flags) { return 0; } @@ -815,12 +857,26 @@ static int _write_element_to_buffer(PyObject* self, buffer_t buffer, int type_by } #if PY_MAJOR_VERSION >= 3 - status = check_string((const unsigned char*)PyBytes_AsString(encoded_pattern), - PyBytes_Size(encoded_pattern), check_utf8, 1); + if (!(pattern_data = PyBytes_AsString(encoded_pattern))) { + Py_DECREF(encoded_pattern); + return 0; + } + if ((pattern_length = _downcast_and_check(PyBytes_Size(encoded_pattern), 0)) == -1) { + Py_DECREF(encoded_pattern); + return 0; + } #else - status = check_string((const unsigned char*)PyString_AsString(encoded_pattern), - PyString_Size(encoded_pattern), check_utf8, 1); + if (!(pattern_data = PyString_AsString(encoded_pattern))) { + Py_DECREF(encoded_pattern); + return 0; + } + if ((pattern_length = _downcast_and_check(PyString_Size(encoded_pattern), 0)) == -1) { + Py_DECREF(encoded_pattern); + return 0; + } #endif + status = check_string((const unsigned char*)pattern_data, + pattern_length, check_utf8, 1); if (status == NOT_UTF_8) { PyObject* InvalidStringData = _error("InvalidStringData"); if (InvalidStringData) { @@ -841,18 +897,9 @@ static int _write_element_to_buffer(PyObject* self, buffer_t buffer, int type_by return 0; } - { -#if PY_MAJOR_VERSION >= 3 - const char* pattern = PyBytes_AsString(encoded_pattern); -#else - const char* pattern = PyString_AsString(encoded_pattern); -#endif - pattern_length = strlen(pattern) + 1; - - if (!buffer_write_bytes(buffer, pattern, pattern_length)) { - Py_DECREF(encoded_pattern); - return 0; - } + if (!buffer_write_bytes(buffer, pattern_data, pattern_length + 1)) { + Py_DECREF(encoded_pattern); + return 0; } Py_DECREF(encoded_pattern); @@ -876,7 +923,7 @@ static int _write_element_to_buffer(PyObject* self, buffer_t buffer, int type_by if (int_flags & 64) { STRCAT(flags, FLAGS_SIZE, "x"); } - flags_length = strlen(flags) + 1; + flags_length = (int)strlen(flags) + 1; if (!buffer_write_bytes(buffer, flags, flags_length)) { return 0; } @@ -989,6 +1036,9 @@ int write_pair(PyObject* self, buffer_t buffer, const char* name, Py_ssize_t nam PyObject* value, unsigned char check_keys, unsigned char uuid_subtype, unsigned char allow_id) { int type_byte; + int length; + if ((length = _downcast_and_check(name_length, 1)) == -1) + return 0; /* Don't write any _id elements unless we're explicitly told to - * _id has to be written first so we do so, but don't bother @@ -1005,7 +1055,7 @@ int write_pair(PyObject* self, buffer_t buffer, const char* name, Py_ssize_t nam if (check_keys && !check_key_name(name, name_length)) { return 0; } - if (!buffer_write_bytes(buffer, name, name_length + 1)) { + if (!buffer_write_bytes(buffer, name, length)) { return 0; } if (!write_element_to_buffer(self, buffer, type_byte, value, @@ -1020,6 +1070,8 @@ int decode_and_write_pair(PyObject* self, buffer_t buffer, unsigned char check_keys, unsigned char uuid_subtype, unsigned char top_level) { PyObject* encoded; + const char* data; + int size; if (PyUnicode_Check(key)) { result_t status; encoded = PyUnicode_AsUTF8String(key); @@ -1027,13 +1079,25 @@ int decode_and_write_pair(PyObject* self, buffer_t buffer, return 0; } #if PY_MAJOR_VERSION >= 3 - status = check_string((const unsigned char*)PyBytes_AsString(encoded), - PyBytes_Size(encoded), 0, 1); + if (!(data = PyBytes_AsString(encoded))) { + Py_DECREF(encoded); + return 0; + } + if ((size = _downcast_and_check(PyBytes_Size(encoded), 0)) == -1) { + Py_DECREF(encoded); + return 0; + } #else - status = check_string((const unsigned char*)PyString_AsString(encoded), - PyString_Size(encoded), 0, 1); + if (!(data = PyString_AsString(encoded))) { + Py_DECREF(encoded); + return 0; + } + if ((size = _downcast_and_check(PyString_Size(encoded), 0)) == -1) { + Py_DECREF(encoded); + return 0; + } #endif - + status = check_string((const unsigned char*)data, size, 0, 1); if (status == HAS_NULL) { PyObject* InvalidDocument = _error("InvalidDocument"); if (InvalidDocument) { @@ -1041,6 +1105,7 @@ int decode_and_write_pair(PyObject* self, buffer_t buffer, "Key names must not contain the NULL byte"); Py_DECREF(InvalidDocument); } + Py_DECREF(encoded); return 0; } #if PY_MAJOR_VERSION < 3 @@ -1049,8 +1114,15 @@ int decode_and_write_pair(PyObject* self, buffer_t buffer, encoded = key; Py_INCREF(encoded); - status = check_string((const unsigned char*)PyString_AsString(encoded), - PyString_Size(encoded), 1, 1); + if (!(data = PyString_AsString(encoded))) { + Py_DECREF(encoded); + return 0; + } + if ((size = _downcast_and_check(PyString_Size(encoded), 0)) == -1) { + Py_DECREF(encoded); + return 0; + } + status = check_string((const unsigned char*)data, size, 1, 1); if (status == NOT_UTF_8) { PyObject* InvalidStringData = _error("InvalidStringData"); @@ -1059,6 +1131,7 @@ int decode_and_write_pair(PyObject* self, buffer_t buffer, "strings in documents must be valid UTF-8"); Py_DECREF(InvalidStringData); } + Py_DECREF(encoded); return 0; } else if (status == HAS_NULL) { PyObject* InvalidDocument = _error("InvalidDocument"); @@ -1067,6 +1140,7 @@ int decode_and_write_pair(PyObject* self, buffer_t buffer, "Key names must not contain the NULL byte"); Py_DECREF(InvalidDocument); } + Py_DECREF(encoded); return 0; } #endif @@ -1109,11 +1183,11 @@ int decode_and_write_pair(PyObject* self, buffer_t buffer, /* If top_level is True, don't allow writing _id here - it was already written. */ #if PY_MAJOR_VERSION >= 3 - if (!write_pair(self, buffer, PyBytes_AsString(encoded), + if (!write_pair(self, buffer, data, PyBytes_Size(encoded), value, check_keys, uuid_subtype, !top_level)) { #else - if (!write_pair(self, buffer, PyString_AsString(encoded), + if (!write_pair(self, buffer, data, PyString_Size(encoded), value, check_keys, uuid_subtype, !top_level)) { #endif @@ -1350,10 +1424,15 @@ static PyObject* get_value(PyObject* self, const char* buffer, int* position, PyObject* to_append; int bson_type = (int)buffer[(*position)++]; - int key_size = strlen(buffer + *position); - *position += key_size + 1; /* just skip the key, they're in order. */ + size_t key_size = strlen(buffer + *position); + if ((size_t)(int)key_size != key_size) { + Py_DECREF(value); + goto invalid; + } + /* just skip the key, they're in order. */ + *position += key_size + 1; to_append = get_value(self, buffer, position, bson_type, - max - key_size, as_class, tz_aware, uuid_subtype); + max - (int)key_size, as_class, tz_aware, uuid_subtype); if (!to_append) { Py_DECREF(value); return NULL; @@ -1542,10 +1621,9 @@ static PyObject* get_value(PyObject* self, const char* buffer, int* position, case 11: { PyObject* pattern; - int flags_length, - flags, - i; - int pattern_length = strlen(buffer + *position); + int flags; + size_t flags_length, i; + size_t pattern_length = strlen(buffer + *position); if (max < pattern_length) { goto invalid; } @@ -1582,7 +1660,7 @@ static PyObject* get_value(PyObject* self, const char* buffer, int* position, } case 12: { - int collection_length; + size_t collection_length; PyObject* collection; PyObject* id; @@ -1630,8 +1708,8 @@ static PyObject* get_value(PyObject* self, const char* buffer, int* position, } case 15: { - int code_length, - scope_size; + size_t code_length; + int scope_size; PyObject* code; PyObject* scope; @@ -1752,7 +1830,7 @@ static PyObject* elements_to_dict(PyObject* self, const char* string, int max, PyObject* name; PyObject* value; int type = (int)string[position++]; - int name_length = strlen(string + position); + size_t name_length = strlen(string + position); if (position + name_length >= max) { PyObject* InvalidBSON = _error("InvalidBSON"); if (InvalidBSON) { diff --git a/pymongo/_cmessagemodule.c b/pymongo/_cmessagemodule.c index 259a0e1fd..b40c9c82f 100644 --- a/pymongo/_cmessagemodule.c +++ b/pymongo/_cmessagemodule.c @@ -73,7 +73,7 @@ static int add_last_error(PyObject* self, buffer_t buffer, PyObject* one; char *p = strchr(ns, '.'); /* Length of the database portion of ns. */ - nslen = p ? (p - ns) : nslen; + nslen = p ? (int)(p - ns) : nslen; message_start = buffer_save_space(buffer, 4); if (message_start == -1) {