#endif
#include "bupsplit.h"
+#include "bup/intprops.h"
#if defined(FS_IOC_GETFLAGS) && defined(FS_IOC_SETFLAGS)
#define BUP_HAVE_FILE_ATTRS 1
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; \
- })
-
+#define INTEGER_TO_PY(x) \
+ EXPR_SIGNED(x) ? PyLong_FromLongLong(x) : PyLong_FromUnsignedLongLong(x)
#if PY_MAJOR_VERSION < 3
static int bup_ulong_from_pyint(unsigned long *x, PyObject *py,
}
-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);
}
}
}
- assert(byte <= (INT_MAX >> 3));
- return Py_BuildValue("i", byte*8 + bit);
+ unsigned long long 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_FromUnsignedLongLong(result);
}
}
#endif /* def BUP_MINCORE_BUF_TYPE */
+static unsigned int vuint_encode(long long val, char *buf)
+{
+ unsigned int len = 0;
+
+ if (val < 0) {
+ PyErr_SetString(PyExc_Exception, "vuints must not be negative");
+ return 0;
+ }
+
+ do {
+ buf[len] = val & 0x7f;
+
+ val >>= 7;
+ if (val)
+ buf[len] |= 0x80;
+
+ len++;
+ } while (val);
+
+ return len;
+}
+
+static unsigned int vint_encode(long long val, char *buf)
+{
+ unsigned int len = 1;
+ char sign = 0;
+
+ if (val < 0) {
+ sign = 0x40;
+ val = -val;
+ }
+
+ buf[0] = (val & 0x3f) | sign;
+ val >>= 6;
+ if (val)
+ buf[0] |= 0x80;
+
+ while (val) {
+ buf[len] = val & 0x7f;
+ val >>= 7;
+ if (val)
+ buf[len] |= 0x80;
+ len++;
+ }
+
+ return len;
+}
+
+static PyObject *bup_vuint_encode(PyObject *self, PyObject *args)
+{
+ long long val;
+ // size the buffer appropriately - need 8 bits to encode each 7
+ char buf[(sizeof(val) + 1) / 7 * 8];
+
+ if (!PyArg_ParseTuple(args, "L", &val))
+ return NULL;
+
+ unsigned int len = vuint_encode(val, buf);
+ if (!len)
+ return NULL;
+
+ return PyBytes_FromStringAndSize(buf, len);
+}
+
+static PyObject *bup_vint_encode(PyObject *self, PyObject *args)
+{
+ long long val;
+ // size the buffer appropriately - need 8 bits to encode each 7
+ char buf[(sizeof(val) + 1) / 7 * 8];
+
+ if (!PyArg_ParseTuple(args, "L", &val))
+ return NULL;
+
+ return PyBytes_FromStringAndSize(buf, vint_encode(val, buf));
+}
static PyObject *tuple_from_cstrs(char **cstrs)
{
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;
}
}
#endif
+static PyObject *bup_limited_vint_pack(PyObject *self, PyObject *args)
+{
+ const char *fmt;
+ PyObject *packargs, *result;
+ Py_ssize_t sz, i, bufsz;
+ char *buf, *pos, *end;
+
+ if (!PyArg_ParseTuple(args, "sO", &fmt, &packargs))
+ return NULL;
+
+ if (!PyTuple_Check(packargs))
+ return PyErr_Format(PyExc_Exception, "pack() arg must be tuple");
+
+ sz = PyTuple_GET_SIZE(packargs);
+ if (sz != (Py_ssize_t)strlen(fmt))
+ return PyErr_Format(PyExc_Exception,
+ "number of arguments (%ld) does not match format string (%ld)",
+ (unsigned long)sz, (unsigned long)strlen(fmt));
+
+ if (sz > INT_MAX / 20)
+ return PyErr_Format(PyExc_Exception, "format is far too long");
+
+ // estimate no more than 20 bytes for each on average, the maximum
+ // vint/vuint we can encode is anyway 10 bytes, so this gives us
+ // some headroom for a few strings before we need to realloc ...
+ bufsz = sz * 20;
+ buf = malloc(bufsz);
+ if (!buf)
+ return PyErr_NoMemory();
+
+ pos = buf;
+ end = buf + bufsz;
+ for (i = 0; i < sz; i++) {
+ PyObject *item = PyTuple_GET_ITEM(packargs, i);
+ const char *bytes;
+
+ switch (fmt[i]) {
+ case 'V': {
+ long long val = PyLong_AsLongLong(item);
+ if (val == -1 && PyErr_Occurred())
+ return PyErr_Format(PyExc_OverflowError,
+ "pack arg %d invalid", (int)i);
+ if (end - pos < 10)
+ goto overflow;
+ pos += vuint_encode(val, pos);
+ break;
+ }
+ case 'v': {
+ long long val = PyLong_AsLongLong(item);
+ if (val == -1 && PyErr_Occurred())
+ return PyErr_Format(PyExc_OverflowError,
+ "pack arg %d invalid", (int)i);
+ if (end - pos < 10)
+ goto overflow;
+ pos += vint_encode(val, pos);
+ break;
+ }
+ case 's': {
+ bytes = PyBytes_AsString(item);
+ if (!bytes)
+ goto error;
+ if (end - pos < 10)
+ goto overflow;
+ Py_ssize_t val = PyBytes_GET_SIZE(item);
+ pos += vuint_encode(val, pos);
+ if (end - pos < val)
+ goto overflow;
+ memcpy(pos, bytes, val);
+ pos += val;
+ break;
+ }
+ default:
+ PyErr_Format(PyExc_Exception, "unknown xpack format string item %c",
+ fmt[i]);
+ goto error;
+ }
+ }
+
+ result = PyBytes_FromStringAndSize(buf, pos - buf);
+ free(buf);
+ return result;
+
+ overflow:
+ PyErr_SetString(PyExc_OverflowError, "buffer (potentially) overflowed");
+ error:
+ free(buf);
+ return NULL;
+}
+
static PyMethodDef helper_methods[] = {
{ "write_sparsely", bup_write_sparsely, METH_VARARGS,
"Write buf excepting zeros at the end. Return trailing zero count." },
"apply_acl(name, acl, def=None)\n\n"
"Given a file/dirname (bytes) and the ACLs to restore, do that." },
#endif /* HAVE_ACLS */
+ { "vuint_encode", bup_vuint_encode, METH_VARARGS, "encode an int to vuint" },
+ { "vint_encode", bup_vint_encode, METH_VARARGS, "encode an int to vint" },
+ { "limited_vint_pack", bup_limited_vint_pack, METH_VARARGS,
+ "Try to pack vint/vuint/str, throwing OverflowError when unable." },
{ NULL, NULL, 0, NULL }, // sentinel
};
// 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();
projects / bup.git / blobdiff