#define _LARGEFILE64_SOURCE 1
+#define PY_SSIZE_T_CLEAN 1
#undef NDEBUG
#include "../../config/config.h"
-#include "bupsplit.h"
+
+// According to Python, its header has to go first:
+// http://docs.python.org/2/c-api/intro.html#include-files
#include <Python.h>
+
#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
+#include <sys/mman.h>
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#include <sys/ioctl.h>
#endif
+#include "bupsplit.h"
+
#if defined(FS_IOC_GETFLAGS) && defined(FS_IOC_SETFLAGS)
#define BUP_HAVE_FILE_ATTRS 1
#endif
static PyObject *splitbuf(PyObject *self, PyObject *args)
{
unsigned char *buf = NULL;
- int len = 0, out = 0, bits = -1;
+ Py_ssize_t len = 0;
+ int out = 0, bits = -1;
if (!PyArg_ParseTuple(args, "t#", &buf, &len))
return NULL;
+ assert(len <= INT_MAX);
out = bupsplit_find_ofs(buf, len, &bits);
if (out) assert(bits >= BUP_BLOBBITS);
return Py_BuildValue("ii", out, bits);
static PyObject *bitmatch(PyObject *self, PyObject *args)
{
unsigned char *buf1 = NULL, *buf2 = NULL;
- int len1 = 0, len2 = 0;
- int byte, bit;
+ Py_ssize_t len1 = 0, len2 = 0;
+ Py_ssize_t byte;
+ int bit;
if (!PyArg_ParseTuple(args, "t#t#", &buf1, &len1, &buf2, &len2))
return NULL;
}
}
+ assert(byte <= (INT_MAX >> 3));
return Py_BuildValue("i", byte*8 + bit);
}
static PyObject *firstword(PyObject *self, PyObject *args)
{
unsigned char *buf = NULL;
- int len = 0;
+ Py_ssize_t len = 0;
uint32_t v;
if (!PyArg_ParseTuple(args, "t#", &buf, &len))
#define BLOOM2_HEADERLEN 16
-typedef struct {
- uint32_t high;
- unsigned char low;
-} bits40_t;
-
-static void to_bloom_address_bitmask4(const bits40_t *buf,
+static void to_bloom_address_bitmask4(const unsigned char *buf,
const int nbits, uint64_t *v, unsigned char *bitmask)
{
int bit;
+ uint32_t high;
uint64_t raw, mask;
+ memcpy(&high, buf, 4);
mask = (1<<nbits) - 1;
- raw = (((uint64_t)ntohl(buf->high)) << 8) | buf->low;
+ raw = (((uint64_t)ntohl(high) << 8) | buf[4]);
bit = (raw >> (37-nbits)) & 0x7;
*v = (raw >> (40-nbits)) & mask;
*bitmask = 1 << bit;
}
-static void to_bloom_address_bitmask5(const uint32_t *buf,
+static void to_bloom_address_bitmask5(const unsigned char *buf,
const int nbits, uint32_t *v, unsigned char *bitmask)
{
int bit;
+ uint32_t high;
uint32_t raw, mask;
+ memcpy(&high, buf, 4);
mask = (1<<nbits) - 1;
- raw = ntohl(*buf);
+ raw = ntohl(high);
bit = (raw >> (29-nbits)) & 0x7;
*v = (raw >> (32-nbits)) & mask;
*bitmask = 1 << bit;
}
-#define BLOOM_SET_BIT(name, address, itype, otype) \
-static void name(unsigned char *bloom, const void *buf, const int nbits)\
+#define BLOOM_SET_BIT(name, address, otype) \
+static void name(unsigned char *bloom, const unsigned char *buf, const int nbits)\
{\
unsigned char bitmask;\
otype v;\
- address((itype *)buf, nbits, &v, &bitmask);\
+ address(buf, nbits, &v, &bitmask);\
bloom[BLOOM2_HEADERLEN+v] |= bitmask;\
}
-BLOOM_SET_BIT(bloom_set_bit4, to_bloom_address_bitmask4, bits40_t, uint64_t)
-BLOOM_SET_BIT(bloom_set_bit5, to_bloom_address_bitmask5, uint32_t, uint32_t)
+BLOOM_SET_BIT(bloom_set_bit4, to_bloom_address_bitmask4, uint64_t)
+BLOOM_SET_BIT(bloom_set_bit5, to_bloom_address_bitmask5, uint32_t)
-#define BLOOM_GET_BIT(name, address, itype, otype) \
-static int name(const unsigned char *bloom, const void *buf, const int nbits)\
+#define BLOOM_GET_BIT(name, address, otype) \
+static int name(const unsigned char *bloom, const unsigned char *buf, const int nbits)\
{\
unsigned char bitmask;\
otype v;\
- address((itype *)buf, nbits, &v, &bitmask);\
+ address(buf, nbits, &v, &bitmask);\
return bloom[BLOOM2_HEADERLEN+v] & bitmask;\
}
-BLOOM_GET_BIT(bloom_get_bit4, to_bloom_address_bitmask4, bits40_t, uint64_t)
-BLOOM_GET_BIT(bloom_get_bit5, to_bloom_address_bitmask5, uint32_t, uint32_t)
+BLOOM_GET_BIT(bloom_get_bit4, to_bloom_address_bitmask4, uint64_t)
+BLOOM_GET_BIT(bloom_get_bit5, to_bloom_address_bitmask5, uint32_t)
static PyObject *bloom_add(PyObject *self, PyObject *args)
{
unsigned char *sha = NULL, *bloom = NULL;
unsigned char *end;
- int len = 0, blen = 0, nbits = 0, k = 0;
+ Py_ssize_t len = 0, blen = 0;
+ int nbits = 0, k = 0;
if (!PyArg_ParseTuple(args, "w#s#ii", &bloom, &blen, &sha, &len, &nbits, &k))
return NULL;
return NULL;
- return Py_BuildValue("i", len/20);
+ return Py_BuildValue("n", len/20);
}
static PyObject *bloom_contains(PyObject *self, PyObject *args)
{
unsigned char *sha = NULL, *bloom = NULL;
- int len = 0, blen = 0, nbits = 0, k = 0;
+ Py_ssize_t len = 0, blen = 0;
+ int nbits = 0, k = 0;
unsigned char *end;
int steps;
v = (v >> (32-nbits)) & mask;
return v;
}
+
+
static PyObject *extract_bits(PyObject *self, PyObject *args)
{
unsigned char *buf = NULL;
- int len = 0, nbits = 0;
+ Py_ssize_t len = 0;
+ int nbits = 0;
if (!PyArg_ParseTuple(args, "t#i", &buf, &len, &nbits))
return NULL;
struct sha {
unsigned char bytes[20];
};
+
+
struct idx {
unsigned char *map;
struct sha *cur;
struct sha *end;
uint32_t *cur_name;
- long bytes;
+ Py_ssize_t bytes;
int name_base;
};
struct sha *sha_ptr, *sha_start = NULL;
uint32_t *table_ptr, *name_ptr, *name_start;
struct idx **idxs = NULL;
- int flen = 0, bits = 0, i;
- uint32_t total, count, prefix;
+ Py_ssize_t flen = 0;
+ int bits = 0, i;
+ unsigned int total;
+ uint32_t count, prefix;
int num_i;
int last_i;
return value; // already in network byte order MSB-LSB
}
-#define PACK_IDX_V2_HEADERLEN 8
#define FAN_ENTRIES 256
static PyObject *write_idx(PyObject *self, PyObject *args)
{
- PyObject *pf = NULL, *idx = NULL;
+ char *filename = NULL;
+ PyObject *idx = NULL;
PyObject *part;
- FILE *f;
unsigned char *fmap = NULL;
- int flen = 0;
- uint32_t total = 0;
+ Py_ssize_t flen = 0;
+ unsigned int total = 0;
uint32_t count;
int i, j, ofs64_count;
uint32_t *fan_ptr, *crc_ptr, *ofs_ptr;
+ uint64_t *ofs64_ptr;
struct sha *sha_ptr;
- if (!PyArg_ParseTuple(args, "Ow#OI", &pf, &fmap, &flen, &idx, &total))
+ if (!PyArg_ParseTuple(args, "sw#OI", &filename, &fmap, &flen, &idx, &total))
return NULL;
- fan_ptr = (uint32_t *)&fmap[PACK_IDX_V2_HEADERLEN];
+ if (PyList_Size (idx) != FAN_ENTRIES) // Check for list of the right length.
+ return PyErr_Format (PyExc_TypeError, "idx must contain %d entries",
+ FAN_ENTRIES);
+
+ const char idx_header[] = "\377tOc\0\0\0\002";
+ memcpy (fmap, idx_header, sizeof(idx_header) - 1);
+
+ fan_ptr = (uint32_t *)&fmap[sizeof(idx_header) - 1];
sha_ptr = (struct sha *)&fan_ptr[FAN_ENTRIES];
crc_ptr = (uint32_t *)&sha_ptr[total];
ofs_ptr = (uint32_t *)&crc_ptr[total];
- f = PyFile_AsFile(pf);
+ ofs64_ptr = (uint64_t *)&ofs_ptr[total];
count = 0;
ofs64_count = 0;
for (j = 0; j < plen; ++j)
{
unsigned char *sha = NULL;
- int sha_len = 0;
- uint32_t crc = 0;
- uint64_t ofs = 0;
+ Py_ssize_t sha_len = 0;
+ unsigned int crc = 0;
+ unsigned PY_LONG_LONG ofs_py = 0;
+ uint64_t ofs;
if (!PyArg_ParseTuple(PyList_GET_ITEM(part, j), "t#IK",
- &sha, &sha_len, &crc, &ofs))
+ &sha, &sha_len, &crc, &ofs_py))
return NULL;
+ assert(crc <= UINT32_MAX);
+ assert(ofs_py <= UINT64_MAX);
+ ofs = ofs_py;
if (sha_len != sizeof(struct sha))
return NULL;
memcpy(sha_ptr++, sha, sizeof(struct sha));
*crc_ptr++ = htonl(crc);
if (ofs > 0x7fffffff)
{
- uint64_t nofs = htonll(ofs);
- if (fwrite(&nofs, sizeof(uint64_t), 1, f) != 1)
- return PyErr_SetFromErrno(PyExc_OSError);
+ *ofs64_ptr++ = htonll(ofs);
ofs = 0x80000000 | ofs64_count++;
}
*ofs_ptr++ = htonl((uint32_t)ofs);
}
}
+
+ int rc = msync(fmap, flen, MS_ASYNC);
+ if (rc != 0)
+ return PyErr_SetFromErrnoWithFilename(PyExc_IOError, filename);
+
return PyLong_FromUnsignedLong(count);
}
static PyObject *bup_get_linux_file_attr(PyObject *self, PyObject *args)
{
int rc;
- unsigned long attr;
+ unsigned int attr;
char *path;
int fd;
}
close(fd);
- return Py_BuildValue("k", attr);
+ return Py_BuildValue("I", attr);
}
#endif /* def BUP_HAVE_FILE_ATTRS */
static PyObject *bup_set_linux_file_attr(PyObject *self, PyObject *args)
{
int rc;
- unsigned long orig_attr, attr;
+ unsigned int orig_attr, attr;
char *path;
int fd;
- if (!PyArg_ParseTuple(args, "sk", &path, &attr))
+ if (!PyArg_ParseTuple(args, "sI", &path, &attr))
return NULL;
fd = open(path, O_RDONLY | O_NONBLOCK | O_LARGEFILE | O_NOFOLLOW);
#endif /* def BUP_HAVE_FILE_ATTRS */
+#ifndef HAVE_UTIMENSAT
+#ifndef HAVE_UTIMES
+#error "cannot find utimensat or utimes()"
+#endif
+#ifndef HAVE_LUTIMES
+#error "cannot find utimensat or lutimes()"
+#endif
+#endif
+
+
#if defined(HAVE_UTIMENSAT) || defined(HAVE_FUTIMES) || defined(HAVE_LUTIMES)
static int bup_parse_xutime_args(char **path,
access, access_ns,
modification, modification_ns))
return 0;
-
- if (isnan(*access))
- {
- PyErr_SetString(PyExc_ValueError, "access time is NaN");
- return 0;
- }
- else if (isinf(*access))
- {
- PyErr_SetString(PyExc_ValueError, "access time is infinite");
- return 0;
- }
- else if (isnan(*modification))
- {
- PyErr_SetString(PyExc_ValueError, "modification time is NaN");
- return 0;
- }
- else if (isinf(*modification))
- {
- PyErr_SetString(PyExc_ValueError, "modification time is infinite");
- return 0;
- }
-
- if (isnan(*access_ns))
- {
- PyErr_SetString(PyExc_ValueError, "access time ns is NaN");
- return 0;
- }
- else if (isinf(*access_ns))
- {
- PyErr_SetString(PyExc_ValueError, "access time ns is infinite");
- return 0;
- }
- else if (isnan(*modification_ns))
- {
- PyErr_SetString(PyExc_ValueError, "modification time ns is NaN");
- return 0;
- }
- else if (isinf(*modification_ns))
- {
- PyErr_SetString(PyExc_ValueError, "modification time ns is infinite");
- return 0;
- }
-
return 1;
}
|| defined(HAVE_LUTIMES) */
+#define INTEGRAL_ASSIGNMENT_FITS(dest, src) \
+ ({ \
+ *(dest) = (src); \
+ *(dest) == (src) && (*(dest) < 1) == ((src) < 1); \
+ })
+
+
+#define ASSIGN_PYLONG_TO_INTEGRAL(dest, pylong, overflow) \
+ ({ \
+ int result = 0; \
+ *(overflow) = 0; \
+ const long long ltmp = PyLong_AsLongLong(pylong); \
+ if (ltmp == -1 && PyErr_Occurred()) \
+ { \
+ if (PyErr_ExceptionMatches(PyExc_OverflowError)) \
+ { \
+ const unsigned long ultmp = PyLong_AsUnsignedLongLong(pylong); \
+ if (ultmp == (unsigned long long) -1 && PyErr_Occurred()) \
+ { \
+ if (PyErr_ExceptionMatches(PyExc_OverflowError)) \
+ { \
+ PyErr_Clear(); \
+ *(overflow) = 1; \
+ } \
+ } \
+ if (INTEGRAL_ASSIGNMENT_FITS((dest), ultmp)) \
+ result = 1; \
+ else \
+ *(overflow) = 1; \
+ } \
+ } \
+ else \
+ { \
+ if (INTEGRAL_ASSIGNMENT_FITS((dest), ltmp)) \
+ result = 1; \
+ else \
+ *(overflow) = 1; \
+ } \
+ result; \
+ })
+
+
#ifdef HAVE_UTIMENSAT
-static PyObject *bup_xutime_ns(PyObject *self, PyObject *args,
- int follow_symlinks)
+static PyObject *bup_utimensat(PyObject *self, PyObject *args)
{
int rc;
+ int fd, flag;
char *path;
- long access, access_ns, modification, modification_ns;
+ PyObject *access_py, *modification_py;
struct timespec ts[2];
- if (!bup_parse_xutime_args(&path, &access, &access_ns,
- &modification, &modification_ns,
- self, args))
- return NULL;
+ if (!PyArg_ParseTuple(args, "is((Ol)(Ol))i",
+ &fd,
+ &path,
+ &access_py, &(ts[0].tv_nsec),
+ &modification_py, &(ts[1].tv_nsec),
+ &flag))
+ return NULL;
- ts[0].tv_sec = access;
- ts[0].tv_nsec = access_ns;
- ts[1].tv_sec = modification;
- ts[1].tv_nsec = modification_ns;
- rc = utimensat(AT_FDCWD, path, ts,
- follow_symlinks ? 0 : AT_SYMLINK_NOFOLLOW);
+ int overflow;
+ if (!ASSIGN_PYLONG_TO_INTEGRAL(&(ts[0].tv_sec), access_py, &overflow))
+ {
+ if (overflow)
+ PyErr_SetString(PyExc_ValueError,
+ "unable to convert access time seconds for utimensat");
+ return NULL;
+ }
+ if (!ASSIGN_PYLONG_TO_INTEGRAL(&(ts[1].tv_sec), modification_py, &overflow))
+ {
+ if (overflow)
+ PyErr_SetString(PyExc_ValueError,
+ "unable to convert modification time seconds for utimensat");
+ return NULL;
+ }
+ rc = utimensat(fd, path, ts, flag);
if (rc != 0)
return PyErr_SetFromErrnoWithFilename(PyExc_OSError, path);
return Py_BuildValue("O", Py_None);
}
-
-#define BUP_HAVE_BUP_UTIME_NS 1
-static PyObject *bup_utime_ns(PyObject *self, PyObject *args)
-{
- return bup_xutime_ns(self, args, 1);
-}
-
-
-#define BUP_HAVE_BUP_LUTIME_NS 1
-static PyObject *bup_lutime_ns(PyObject *self, PyObject *args)
-{
- return bup_xutime_ns(self, args, 0);
-}
-
-
-#else /* not defined(HAVE_UTIMENSAT) */
+#endif /* def HAVE_UTIMENSAT */
#ifdef HAVE_UTIMES
#endif /* def HAVE_LUTIMES */
-#endif /* not defined(HAVE_UTIMENSAT) */
-
-
#ifdef HAVE_STAT_ST_ATIM
# define BUP_STAT_ATIME_NS(st) (st)->st_atim.tv_nsec
# define BUP_STAT_MTIME_NS(st) (st)->st_mtim.tv_nsec
}
+#define INTEGER_TO_PY(x) \
+ (((x) >= 0) ? PyLong_FromUnsignedLongLong(x) : PyLong_FromLongLong(x))
+
+
static PyObject *stat_struct_to_py(const struct stat *st,
const char *filename,
int fd)
if (!normalize_timespec_values("ctime", &ctime, &ctime_ns, filename, fd))
return NULL;
- return Py_BuildValue("kkkkkkkk(Ll)(Ll)(Ll)",
- (unsigned long) st->st_mode,
- (unsigned long) st->st_ino,
- (unsigned long) st->st_dev,
- (unsigned long) st->st_nlink,
- (unsigned long) st->st_uid,
- (unsigned long) st->st_gid,
- (unsigned long) st->st_rdev,
- (unsigned long) st->st_size,
- (long long) atime,
+ // 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().
+ return Py_BuildValue("OKOOOOOL(Ll)(Ll)(Ll)",
+ INTEGER_TO_PY(st->st_mode),
+ (unsigned PY_LONG_LONG) st->st_ino,
+ INTEGER_TO_PY(st->st_dev),
+ INTEGER_TO_PY(st->st_nlink),
+ INTEGER_TO_PY(st->st_uid),
+ INTEGER_TO_PY(st->st_gid),
+ INTEGER_TO_PY(st->st_rdev),
+ (PY_LONG_LONG) st->st_size,
+ (PY_LONG_LONG) atime,
(long) atime_ns,
- (long long) mtime,
+ (PY_LONG_LONG) mtime,
(long) mtime_ns,
- (long long) ctime,
+ (PY_LONG_LONG) ctime,
(long) ctime_ns);
}
{ "set_linux_file_attr", bup_set_linux_file_attr, METH_VARARGS,
"Set the Linux attributes for the given file." },
#endif
+#ifdef HAVE_UTIMENSAT
+ { "bup_utimensat", bup_utimensat, METH_VARARGS,
+ "Change path timestamps with nanosecond precision (POSIX)." },
+#endif
#ifdef BUP_HAVE_BUP_UTIME_NS
{ "bup_utime_ns", bup_utime_ns, METH_VARARGS,
"Change path timestamps with up to nanosecond precision." },
PyMODINIT_FUNC init_helpers(void)
{
+ // FIXME: migrate these tests to configure. Check against the
+ // type we're going to use when passing to python. Other stat
+ // types are tested at runtime.
+ assert(sizeof(ino_t) <= sizeof(unsigned PY_LONG_LONG));
+ assert(sizeof(off_t) <= sizeof(PY_LONG_LONG));
+ assert(sizeof(blksize_t) <= sizeof(PY_LONG_LONG));
+ assert(sizeof(blkcnt_t) <= sizeof(PY_LONG_LONG));
+ // Just be sure (relevant when passing timestamps back to Python above).
+ assert(sizeof(PY_LONG_LONG) <= sizeof(long long));
+
char *e;
PyObject *m = Py_InitModule("_helpers", helper_methods);
if (m == NULL)
return;
+
+#ifdef HAVE_UTIMENSAT
+ {
+ PyObject *value;
+ value = INTEGER_TO_PY(AT_FDCWD);
+ PyObject_SetAttrString(m, "AT_FDCWD", value);
+ Py_DECREF(value);
+ value = INTEGER_TO_PY(AT_SYMLINK_NOFOLLOW);
+ PyObject_SetAttrString(m, "AT_SYMLINK_NOFOLLOW", value);
+ Py_DECREF(value);
+ value = INTEGER_TO_PY(UTIME_NOW);
+ PyObject_SetAttrString(m, "UTIME_NOW", value);
+ Py_DECREF(value);
+ }
+#endif
+
e = getenv("BUP_FORCE_TTY");
istty2 = isatty(2) || (atoi(e ? e : "0") & 2);
unpythonize_argv();
projects / bup.git / blobdiff