#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>
#include <arpa/inet.h>
#endif
#include "bupsplit.h"
+#include "bup/intprops.h"
#if defined(FS_IOC_GETFLAGS) && defined(FS_IOC_SETFLAGS)
#define BUP_HAVE_FILE_ATTRS 1
#endif
+#if PY_MAJOR_VERSION > 2
+# define BUP_USE_PYTHON_UTIME 1
+#endif
+
+#ifndef BUP_USE_PYTHON_UTIME // just for Python 2 now
/*
* Check for incomplete UTIMENSAT support (NetBSD 6), and if so,
* pretend we don't have it.
#if !defined(AT_FDCWD) || !defined(AT_SYMLINK_NOFOLLOW)
#undef HAVE_UTIMENSAT
#endif
+#endif // defined BUP_USE_PYTHON_UTIME
#ifndef FS_NOCOW_FL
// Of course, this assumes it's a bitfield value.
// 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 %lu items of size %lu is too large",
+ "request to allocate %zu items of size %zu is too large",
n, size);
return NULL;
}
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
-
-// 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; \
- })
-
-
-// At the moment any code that calls INTEGER_TO_PY() will have to
-// disable -Wtautological-compare for clang. See below.
+#define INTEGRAL_ASSIGNMENT_FITS(dest, src) INT_ADD_OK(src, 0, dest)
#define INTEGER_TO_PY(x) \
- (((x) >= 0) ? PyLong_FromUnsignedLongLong(x) : PyLong_FromLongLong(x))
-
-
-
-#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
+ 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);
}
-
-// Probably we should use autoconf or something and set HAVE_PY_GETARGCARGV...
-#if __WIN32__ || __CYGWIN__
-
-// There's no 'ps' on win32 anyway, and Py_GetArgcArgv() isn't available.
-static void unpythonize_argv(void) { }
-
-#else // not __WIN32__
-
-// For some reason this isn't declared in Python.h
-extern void Py_GetArgcArgv(int *argc, char ***argv);
-
-static void unpythonize_argv(void)
-{
- int argc, i;
- char **argv, *arge;
-
- Py_GetArgcArgv(&argc, &argv);
-
- for (i = 0; i < argc-1; i++)
- {
- if (argv[i] + strlen(argv[i]) + 1 != argv[i+1])
- {
- // The argv block doesn't work the way we expected; it's unsafe
- // to mess with it.
- return;
- }
- }
-
- arge = argv[argc-1] + strlen(argv[argc-1]) + 1;
-
- if (strstr(argv[0], "python") && argv[1] == argv[0] + strlen(argv[0]) + 1)
- {
- char *p;
- size_t len, diff;
- p = strrchr(argv[1], '/');
- if (p)
- {
- p++;
- diff = p - argv[0];
- len = arge - p;
- memmove(argv[0], p, len);
- memset(arge - diff, 0, diff);
- for (i = 0; i < argc; i++)
- argv[i] = argv[i+1] ? argv[i+1]-diff : NULL;
- }
- }
-}
-
-#endif // not __WIN32__ or __CYGWIN__
-
-
static int write_all(int fd, const void *buf, const size_t count)
{
size_t written = 0;
}
-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);
}
PyObject *part;
unsigned int total = 0;
uint32_t count;
- int i, j, ofs64_count;
+ int i;
uint32_t *fan_ptr, *crc_ptr, *ofs_ptr;
uint64_t *ofs64_ptr;
struct sha *sha_ptr;
ofs64_ptr = (uint64_t *)&ofs_ptr[total];
count = 0;
- ofs64_count = 0;
+ uint32_t ofs64_count = 0;
for (i = 0; i < FAN_ENTRIES; ++i)
{
- Py_ssize_t plen;
part = PyList_GET_ITEM(idx, i);
PyList_Sort(part);
- plen = PyList_GET_SIZE(part);
- if (plen > UINT32_MAX || UINT32_MAX - count < plen) {
+ uint32_t plen;
+ if (!INTEGRAL_ASSIGNMENT_FITS(&plen, PyList_GET_SIZE(part))
+ || UINT32_MAX - count < plen) {
PyErr_Format(PyExc_OverflowError, "too many objects in index part");
goto clean_and_return;
}
- count += (uint32_t) plen;
+ count += plen;
*fan_ptr++ = htonl(count);
+ uint32_t j;
for (j = 0; j < plen; ++j)
{
unsigned char *sha = NULL;
#endif /* def BUP_HAVE_FILE_ATTRS */
+#ifndef BUP_USE_PYTHON_UTIME // just for Python 2 now
#ifndef HAVE_UTIMENSAT
#ifndef HAVE_UTIMES
#error "cannot find utimensat or utimes()"
#error "cannot find utimensat or lutimes()"
#endif
#endif
+#endif // defined BUP_USE_PYTHON_UTIME
#define ASSIGN_PYLONG_TO_INTEGRAL(dest, pylong, overflow) \
({ \
})
+#ifndef BUP_USE_PYTHON_UTIME // just for Python 2 now
#ifdef HAVE_UTIMENSAT
static PyObject *bup_utimensat(PyObject *self, PyObject *args)
}
#endif /* def HAVE_LUTIMES */
+#endif // defined BUP_USE_PYTHON_UTIME
+
#ifdef HAVE_STAT_ST_ATIM
# define BUP_STAT_ATIME_NS(st) (st)->st_atim.tv_nsec
#endif
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wtautological-compare" // For INTEGER_TO_PY().
-
static PyObject *stat_struct_to_py(const struct stat *st,
const char *filename,
int fd)
(long) BUP_STAT_CTIME_NS(st));
}
-#pragma clang diagnostic pop // ignored "-Wtautological-compare"
static PyObject *bup_stat(PyObject *self, PyObject *args)
{
result = PyErr_Format(PyExc_OverflowError, "src_n overflows size_t");
goto clean_and_return;
}
- int rc = mincore((void *)(src.buf + src_off), src_n,
+ int rc = mincore((void *)(src.buf + src_off), length,
(BUP_MINCORE_BUF_TYPE *) (dest.buf + dest_off));
if (rc != 0) {
result = PyErr_SetFromErrno(PyExc_OSError);
}
#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)
{
return result;
}
+static PyObject *appropriate_errno_ex(void)
+{
+ switch (errno) {
+ case ENOMEM:
+ return PyErr_NoMemory();
+ case EIO:
+ case EMFILE:
+ case ENFILE:
+ // In 3.3 IOError was merged into OSError.
+ return PyErr_SetFromErrno(PyExc_IOError);
+ default:
+ return PyErr_SetFromErrno(PyExc_OSError);
+ }
+}
-static long getpw_buf_size;
-static PyObject *pwd_struct_to_py(const struct passwd *pwd, int rc)
+static PyObject *pwd_struct_to_py(const struct passwd *pwd)
{
// We can check the known (via POSIX) signed and unsigned types at
// compile time, but not (easily) the unspecified types, so handle
// those via INTEGER_TO_PY().
- if (pwd != NULL)
- return Py_BuildValue(cstr_argf cstr_argf "OO"
- cstr_argf cstr_argf cstr_argf,
- pwd->pw_name,
- pwd->pw_passwd,
- INTEGER_TO_PY(pwd->pw_uid),
- INTEGER_TO_PY(pwd->pw_gid),
- pwd->pw_gecos,
- pwd->pw_dir,
- pwd->pw_shell);
- if (rc == 0)
- return Py_BuildValue("O", Py_None);
- if (rc == EIO || rc == EMFILE || rc == ENFILE)
- return PyErr_SetFromErrno(PyExc_IOError);
- if (rc < 0)
- return PyErr_SetFromErrno(PyExc_OSError);
- assert(0);
+ if (pwd == NULL)
+ Py_RETURN_NONE;
+ return Py_BuildValue(cstr_argf cstr_argf "OO"
+ cstr_argf cstr_argf cstr_argf,
+ pwd->pw_name,
+ pwd->pw_passwd,
+ INTEGER_TO_PY(pwd->pw_uid),
+ INTEGER_TO_PY(pwd->pw_gid),
+ pwd->pw_gecos,
+ pwd->pw_dir,
+ pwd->pw_shell);
}
static PyObject *bup_getpwuid(PyObject *self, PyObject *args)
if (!INTEGRAL_ASSIGNMENT_FITS(&uid, py_uid))
return PyErr_Format(PyExc_OverflowError, "uid too large for uid_t");
- struct passwd pwd, *result_pwd;
- char *buf = PyMem_Malloc(getpw_buf_size);
- if (buf == NULL)
- return NULL;
-
- int rc = getpwuid_r(uid, &pwd, buf, getpw_buf_size, &result_pwd);
- PyObject *result = pwd_struct_to_py(result_pwd, rc);
- PyMem_Free(buf);
- return result;
+ errno = 0;
+ struct passwd *pwd = getpwuid(uid);
+ if (!pwd && errno)
+ return appropriate_errno_ex();
+ return pwd_struct_to_py(pwd);
}
static PyObject *bup_getpwnam(PyObject *self, PyObject *args)
if (!PyArg_ParseTuple(args, "S", &py_name))
return NULL;
- struct passwd pwd, *result_pwd;
- char *buf = PyMem_Malloc(getpw_buf_size);
- if (buf == NULL)
- return NULL;
-
char *name = PyBytes_AS_STRING(py_name);
- int rc = getpwnam_r(name, &pwd, buf, getpw_buf_size, &result_pwd);
- PyObject *result = pwd_struct_to_py(result_pwd, rc);
- PyMem_Free(buf);
- return result;
+ errno = 0;
+ struct passwd *pwd = getpwnam(name);
+ if (!pwd && errno)
+ return appropriate_errno_ex();
+ return pwd_struct_to_py(pwd);
}
-static long getgr_buf_size;
-
-static PyObject *grp_struct_to_py(const struct group *grp, int rc)
+static PyObject *grp_struct_to_py(const struct group *grp)
{
// We can check the known (via POSIX) signed and unsigned types at
// compile time, but not (easily) the unspecified types, so handle
// those via INTEGER_TO_PY().
- if (grp != NULL) {
- PyObject *members = tuple_from_cstrs(grp->gr_mem);
- if (members == NULL)
- return NULL;
- return Py_BuildValue(cstr_argf cstr_argf "OO",
- grp->gr_name,
- grp->gr_passwd,
- INTEGER_TO_PY(grp->gr_gid),
- members);
- }
- if (rc == 0)
- return Py_BuildValue("O", Py_None);
- errno = rc;
- if (rc == EIO || rc == EMFILE || rc == ENFILE)
- return PyErr_SetFromErrno(PyExc_IOError);
- return PyErr_SetFromErrno(PyExc_OSError);
+ if (grp == NULL)
+ Py_RETURN_NONE;
+
+ PyObject *members = tuple_from_cstrs(grp->gr_mem);
+ if (members == NULL)
+ return NULL;
+ return Py_BuildValue(cstr_argf cstr_argf "OO",
+ grp->gr_name,
+ grp->gr_passwd,
+ INTEGER_TO_PY(grp->gr_gid),
+ members);
}
static PyObject *bup_getgrgid(PyObject *self, PyObject *args)
if (!INTEGRAL_ASSIGNMENT_FITS(&gid, py_gid))
return PyErr_Format(PyExc_OverflowError, "gid too large for gid_t");
- struct group grp, *result_grp;
- char *buf = PyMem_Malloc(getgr_buf_size);
- if (buf == NULL)
- return NULL;
-
- int rc = getgrgid_r(gid, &grp, buf, getgr_buf_size, &result_grp);
- PyObject *result = grp_struct_to_py(result_grp, rc);
- PyMem_Free(buf);
- return result;
+ errno = 0;
+ struct group *grp = getgrgid(gid);
+ if (!grp && errno)
+ return appropriate_errno_ex();
+ return grp_struct_to_py(grp);
}
static PyObject *bup_getgrnam(PyObject *self, PyObject *args)
if (!PyArg_ParseTuple(args, "S", &py_name))
return NULL;
- struct group grp, *result_grp;
- char *buf = PyMem_Malloc(getgr_buf_size);
- if (buf == NULL)
- return NULL;
-
char *name = PyBytes_AS_STRING(py_name);
- int rc = getgrnam_r(name, &grp, buf, getgr_buf_size, &result_grp);
- PyObject *result = grp_struct_to_py(result_grp, rc);
- PyMem_Free(buf);
- return result;
+ errno = 0;
+ struct group *grp = getgrnam(name);
+ if (!grp && errno)
+ return appropriate_errno_ex();
+ return grp_struct_to_py(grp);
}
+
static PyObject *bup_gethostname(PyObject *mod, PyObject *ignore)
{
#ifdef HOST_NAME_MAX
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;
}
static PyObject *
bup_get_completer_word_break_characters(PyObject *self, PyObject *args)
{
- if (!PyArg_ParseTuple(args, ""))
- return NULL;
return PyBytes_FromString(rl_completer_word_break_characters);
}
static PyObject *bup_get_line_buffer(PyObject *self, PyObject *args)
{
- if (!PyArg_ParseTuple(args, ""))
- return NULL;
return PyBytes_FromString(rl_line_buffer);
}
}
#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." },
{ "set_linux_file_attr", bup_set_linux_file_attr, METH_VARARGS,
"Set the Linux attributes for the given file." },
#endif
+
+#ifndef BUP_USE_PYTHON_UTIME // just for Python 2 now
#ifdef HAVE_UTIMENSAT
{ "bup_utimensat", bup_utimensat, METH_VARARGS,
"Change path timestamps with nanosecond precision (POSIX)." },
"Change path timestamps with microsecond precision;"
" don't follow symlinks." },
#endif
+#endif // defined BUP_USE_PYTHON_UTIME
+
{ "stat", bup_stat, METH_VARARGS,
"Extended version of stat." },
{ "lstat", bup_lstat, METH_VARARGS,
"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();
}
char *e;
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wtautological-compare" // For INTEGER_TO_PY().
{
PyObject *value;
value = INTEGER_TO_PY(INT_MAX);
PyObject_SetAttrString(m, "UINT_MAX", value);
Py_DECREF(value);
}
+
+#ifndef BUP_USE_PYTHON_UTIME // just for Python 2 now
#ifdef HAVE_UTIMENSAT
{
PyObject *value;
Py_DECREF(value);
}
#endif
+#endif // defined BUP_USE_PYTHON_UTIME
+
#ifdef BUP_HAVE_MINCORE_INCORE
{
PyObject *value;
Py_DECREF(value);
}
#endif
-#pragma clang diagnostic pop // ignored "-Wtautological-compare"
-
- getpw_buf_size = sysconf(_SC_GETPW_R_SIZE_MAX);
- if (getpw_buf_size == -1)
- getpw_buf_size = 16384;
-
- getgr_buf_size = sysconf(_SC_GETGR_R_SIZE_MAX);
- if (getgr_buf_size == -1)
- getgr_buf_size = 16384;
e = getenv("BUP_FORCE_TTY");
get_state(m)->istty2 = isatty(2) || (atoi(e ? e : "0") & 2);
- unpythonize_argv();
return 1;
}
-#if PY_MAJOR_VERSION < 3
-
-PyMODINIT_FUNC init_helpers(void)
-{
- PyObject *m = Py_InitModule("_helpers", helper_methods);
- if (m == NULL)
- return;
-
- if (!setup_module(m))
- {
- 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