#include "../../config/config.h"
// According to Python, its header has to go first:
-// http://docs.python.org/2/c-api/intro.html#include-files
// http://docs.python.org/3/c-api/intro.html#include-files
#include <Python.h>
#endif
#include "bupsplit.h"
+#include "bup/intprops.h"
#if defined(FS_IOC_GETFLAGS) && defined(FS_IOC_SETFLAGS)
#define BUP_HAVE_FILE_ATTRS 1
// rbuf_argf: for read-only byte vectors
// wbuf_argf: for mutable byte vectors
-#if PY_MAJOR_VERSION < 3
-static state_t state;
-# define get_state(x) (&state)
-# define cstr_argf "s"
-# define rbuf_argf "s#"
-# define wbuf_argf "s*"
-#else
-# define get_state(x) ((state_t *) PyModule_GetState(x))
-# define cstr_argf "y"
-# define rbuf_argf "y#"
-# define wbuf_argf "y*"
-#endif // PY_MAJOR_VERSION >= 3
+#define get_state(x) ((state_t *) PyModule_GetState(x))
+#define cstr_argf "y"
+#define rbuf_argf "y#"
+#define wbuf_argf "y*"
static void *checked_calloc(size_t n, size_t size)
return result;
}
-#ifndef BUP_HAVE_BUILTIN_MUL_OVERFLOW
-
-#define checked_malloc checked_calloc
-
-#else // defined BUP_HAVE_BUILTIN_MUL_OVERFLOW
-
static void *checked_malloc(size_t n, size_t size)
{
size_t total;
- if (__builtin_mul_overflow(n, size, &total))
+ if (!INT_MULTIPLY_OK(n, size, &total))
{
PyErr_Format(PyExc_OverflowError,
"request to allocate %zu items of size %zu is too large",
return result;
}
-#endif // defined BUP_HAVE_BUILTIN_MUL_OVERFLOW
-
#ifndef htonll
// This function should technically be macro'd out if it's going to be used
}
#endif
+#define INTEGRAL_ASSIGNMENT_FITS(dest, src) INT_ADD_OK(src, 0, dest)
-// Disabling sign-compare here should be fine since we're explicitly
-// checking for a sign mismatch, i.e. if the signs don't match, then
-// it doesn't matter what the value comparison says.
-// FIXME: ... so should we reverse the order?
-#define INTEGRAL_ASSIGNMENT_FITS(dest, src) \
- ({ \
- _Pragma("GCC diagnostic push"); \
- _Pragma("GCC diagnostic ignored \"-Wsign-compare\""); \
- _Pragma("clang diagnostic push"); \
- _Pragma("clang diagnostic ignored \"-Wshorten-64-to-32\""); \
- *(dest) = (src); \
- int result = *(dest) == (src) && (*(dest) < 1) == ((src) < 1); \
- _Pragma("clang diagnostic pop"); \
- _Pragma("GCC diagnostic pop"); \
- result; \
- })
-
-
-#define INTEGER_TO_PY(x) \
- ({ \
- _Pragma("GCC diagnostic push"); \
- _Pragma("GCC diagnostic ignored \"-Wtype-limits\""); \
- _Pragma("clang diagnostic push"); \
- _Pragma("clang diagnostic ignored \"-Wtautological-compare\""); \
- PyObject *result = ((x) >= 0) ? PyLong_FromUnsignedLongLong(x) : PyLong_FromLongLong(x); \
- _Pragma("clang diagnostic pop"); \
- _Pragma("GCC diagnostic pop"); \
- result; \
- })
-
-
-#if PY_MAJOR_VERSION < 3
-static int bup_ulong_from_pyint(unsigned long *x, PyObject *py,
- const char *name)
-{
- const long tmp = PyInt_AsLong(py);
- if (tmp == -1 && PyErr_Occurred())
- {
- if (PyErr_ExceptionMatches(PyExc_OverflowError))
- PyErr_Format(PyExc_OverflowError, "%s too big for unsigned long",
- name);
- return 0;
- }
- if (tmp < 0)
- {
- PyErr_Format(PyExc_OverflowError,
- "negative %s cannot be converted to unsigned long", name);
- return 0;
- }
- *x = tmp;
- return 1;
-}
-#endif
+#define INTEGER_TO_PY(x) \
+ EXPR_SIGNED(x) ? PyLong_FromLongLong(x) : PyLong_FromUnsignedLongLong(x)
static int bup_ulong_from_py(unsigned long *x, PyObject *py, const char *name)
{
-#if PY_MAJOR_VERSION < 3
- if (PyInt_Check(py))
- return bup_ulong_from_pyint(x, py, name);
-#endif
-
if (!PyLong_Check(py))
{
PyErr_Format(PyExc_TypeError, "expected integer %s", name);
static int bup_ullong_from_py(unsigned PY_LONG_LONG *x, PyObject *py,
const char *name)
{
-#if PY_MAJOR_VERSION < 3
- if (PyInt_Check(py))
- {
- unsigned long tmp;
- if (bup_ulong_from_pyint(&tmp, py, name))
- {
- *x = tmp;
- return 1;
- }
- return 0;
- }
-#endif
-
if (!PyLong_Check(py))
{
PyErr_Format(PyExc_TypeError, "integer argument expected for %s", name);
}
-static int uadd(unsigned long long *dest,
- const unsigned long long x,
- const unsigned long long y)
+static inline int uadd(unsigned long long *dest,
+ const unsigned long long x,
+ const unsigned long long y)
{
- const unsigned long long result = x + y;
- if (result < x || result < y)
- return 0;
- *dest = result;
- return 1;
+ return INT_ADD_OK(x, y, dest);
}
static PyObject *splitbuf(PyObject *self, PyObject *args)
{
- // We stick to buffers in python 2 because they appear to be
- // substantially smaller than memoryviews, and because
- // zlib.compress() in python 2 can't accept a memoryview
- // (cf. hashsplit.py).
int out = 0, bits = -1;
- if (PY_MAJOR_VERSION > 2)
- {
- Py_buffer buf;
- if (!PyArg_ParseTuple(args, "y*", &buf))
- return NULL;
- assert(buf.len <= INT_MAX);
- out = bupsplit_find_ofs(buf.buf, buf.len, &bits);
- PyBuffer_Release(&buf);
- }
- else
- {
- unsigned char *buf = NULL;
- Py_ssize_t len = 0;
- if (!PyArg_ParseTuple(args, "t#", &buf, &len))
- return NULL;
- assert(len <= INT_MAX);
- out = bupsplit_find_ofs(buf, (int) len, &bits);
- }
+ Py_buffer buf;
+ if (!PyArg_ParseTuple(args, "y*", &buf))
+ return NULL;
+ assert(buf.len <= INT_MAX);
+ out = bupsplit_find_ofs(buf.buf, buf.len, &bits);
+ PyBuffer_Release(&buf);
if (out) assert(bits >= BUP_BLOBBITS);
return Py_BuildValue("ii", out, bits);
}
}
}
- assert(byte <= (INT_MAX >> 3));
- return Py_BuildValue("i", byte*8 + bit);
+ Py_ssize_t result;
+ if (!INT_MULTIPLY_OK(byte, 8, &result)
+ || !INT_ADD_OK(result, bit, &result))
+ {
+ PyErr_Format(PyExc_OverflowError, "bitmatch bit count too large");
+ return NULL;
+ }
+ return PyLong_FromSsize_t(result);
}
if (gethostname(buf, sizeof(buf) - 1))
return PyErr_SetFromErrno(PyExc_IOError);
+ buf[sizeof(buf) - 1] = 0;
return PyBytes_FromString(buf);
}
int rc = PyBytes_AsStringAndSize(bytes, &buf, &length);
if (rc == -1)
return NULL;
- char *result = checked_malloc(length, sizeof(char));
+ size_t c_len;
+ if (!INT_ADD_OK(length, 1, &c_len)) {
+ PyErr_Format(PyExc_OverflowError,
+ "Cannot convert ssize_t sized bytes object (%zd) to C string",
+ length);
+ return NULL;
+ }
+ char *result = checked_malloc(c_len, sizeof(char));
if (!result)
return NULL;
memcpy(result, buf, length);
+ result[length] = 0;
return result;
}
// Just be sure (relevant when passing timestamps back to Python above).
assert(sizeof(PY_LONG_LONG) <= sizeof(long long));
assert(sizeof(unsigned PY_LONG_LONG) <= sizeof(unsigned long long));
+ // At least for INTEGER_TO_PY
+ assert(sizeof(intmax_t) <= sizeof(long long));
+ assert(sizeof(uintmax_t) <= sizeof(unsigned long long));
test_integral_assignment_fits();
}
-#if PY_MAJOR_VERSION < 3
-
-PyMODINIT_FUNC init_helpers(void)
-{
- PyObject *m = Py_InitModule("_helpers", helper_methods);
- if (m == NULL) {
- PyErr_SetString(PyExc_RuntimeError, "bup._helpers init failed");
- return;
- }
- if (!setup_module(m))
- {
- PyErr_SetString(PyExc_RuntimeError, "bup._helpers set up failed");
- Py_DECREF(m);
- return;
- }
-}
-
-# else // PY_MAJOR_VERSION >= 3
-
static struct PyModuleDef helpers_def = {
PyModuleDef_HEAD_INIT,
"_helpers",
}
return module;
}
-
-#endif // PY_MAJOR_VERSION >= 3
projects / bup.git / blobdiff