// http://docs.python.org/2/c-api/intro.html#include-files
#include <Python.h>
+#include <arpa/inet.h>
#include <assert.h>
#include <errno.h>
#include <fcntl.h>
-#include <arpa/inet.h>
+#include <grp.h>
+#include <pwd.h>
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
#include <time.h>
#endif
+#if defined(BUP_RL_EXPECTED_XOPEN_SOURCE) \
+ && (!defined(_XOPEN_SOURCE) || _XOPEN_SOURCE < BUP_RL_EXPECTED_XOPEN_SOURCE)
+# warning "_XOPEN_SOURCE version is incorrect for readline"
+#endif
+
+#ifdef BUP_HAVE_READLINE
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wstrict-prototypes"
+# ifdef BUP_READLINE_INCLUDES_IN_SUBDIR
+# include <readline/readline.h>
+# include <readline/history.h>
+# else
+# include <readline.h>
+# include <history.h>
+# endif
+# pragma GCC diagnostic pop
+#endif
+
#include "bupsplit.h"
#if defined(FS_IOC_GETFLAGS) && defined(FS_IOC_SETFLAGS)
#endif // PY_MAJOR_VERSION >= 3
+static void *checked_calloc(size_t n, size_t size)
+{
+ void *result = calloc(n, size);
+ if (!result)
+ PyErr_NoMemory();
+ 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;
return result;
}
-static void *checked_calloc(size_t n, size_t size)
-{
- void *result = calloc(n, size);
- if (!result)
- PyErr_NoMemory();
- return result;
-}
+#endif // defined BUP_HAVE_BUILTIN_MUL_OVERFLOW
#ifndef htonll
({ \
_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; \
})
PyErr_Format(PyExc_OverflowError, "%s too big for unsigned int", name);
return 0;
}
- *x = tmp;
+ *x = (unsigned int) tmp;
return 1;
}
}
+static PyObject *bup_cat_bytes(PyObject *self, PyObject *args)
+{
+ unsigned char *bufx = NULL, *bufy = NULL;
+ Py_ssize_t bufx_len, bufx_ofs, bufx_n;
+ Py_ssize_t bufy_len, bufy_ofs, bufy_n;
+ if (!PyArg_ParseTuple(args,
+ rbuf_argf "nn"
+ rbuf_argf "nn",
+ &bufx, &bufx_len, &bufx_ofs, &bufx_n,
+ &bufy, &bufy_len, &bufy_ofs, &bufy_n))
+ return NULL;
+ if (bufx_ofs < 0)
+ return PyErr_Format(PyExc_ValueError, "negative x offset");
+ if (bufx_n < 0)
+ return PyErr_Format(PyExc_ValueError, "negative x extent");
+ if (bufx_ofs > bufx_len)
+ return PyErr_Format(PyExc_ValueError, "x offset greater than length");
+ if (bufx_n > bufx_len - bufx_ofs)
+ return PyErr_Format(PyExc_ValueError, "x extent past end of buffer");
+
+ if (bufy_ofs < 0)
+ return PyErr_Format(PyExc_ValueError, "negative y offset");
+ if (bufy_n < 0)
+ return PyErr_Format(PyExc_ValueError, "negative y extent");
+ if (bufy_ofs > bufy_len)
+ return PyErr_Format(PyExc_ValueError, "y offset greater than length");
+ if (bufy_n > bufy_len - bufy_ofs)
+ return PyErr_Format(PyExc_ValueError, "y extent past end of buffer");
+
+ if (bufy_n > PY_SSIZE_T_MAX - bufx_n)
+ return PyErr_Format(PyExc_OverflowError, "result length too long");
+
+ PyObject *result = PyBytes_FromStringAndSize(NULL, bufx_n + bufy_n);
+ if (!result)
+ return PyErr_NoMemory();
+ char *buf = PyBytes_AS_STRING(result);
+ memcpy(buf, bufx + bufx_ofs, bufx_n);
+ memcpy(buf + bufx_n, bufy + bufy_ofs, bufy_n);
+ return result;
+}
+
+
+
// Probably we should use autoconf or something and set HAVE_PY_GETARGCARGV...
#if __WIN32__ || __CYGWIN__
if (!PyArg_ParseTuple(args, "t#", &buf, &len))
return NULL;
assert(len <= INT_MAX);
- out = bupsplit_find_ofs(buf, len, &bits);
+ out = bupsplit_find_ofs(buf, (int) len, &bits);
}
if (out) assert(bits >= BUP_BLOBBITS);
return Py_BuildValue("ii", out, bits);
static void _fix_idx_order(struct idx **idxs, Py_ssize_t *last_i)
{
struct idx *idx;
- int low, mid, high, c = 0;
+ Py_ssize_t low, mid, high;
+ int c = 0;
idx = idxs[*last_i];
if (idxs[*last_i]->cur >= idxs[*last_i]->end)
ofs64_count = 0;
for (i = 0; i < FAN_ENTRIES; ++i)
{
- int plen;
+ Py_ssize_t plen;
part = PyList_GET_ITEM(idx, i);
PyList_Sort(part);
plen = PyList_GET_SIZE(part);
- count += plen;
+ if (plen > UINT32_MAX || UINT32_MAX - count < plen) {
+ PyErr_Format(PyExc_OverflowError, "too many objects in index part");
+ goto clean_and_return;
+ }
+ count += (uint32_t) plen;
*fan_ptr++ = htonl(count);
- for (j = 0; j < plen; ++j)
+ for (j = 0; j < plen; ++j)
{
unsigned char *sha = NULL;
Py_ssize_t sha_len = 0;
{
unsigned i;
for (i = 0; i < sizeof(buf)/sizeof(buf[0]); i++)
- buf[i] = random();
+ buf[i] = (uint32_t) random();
ret = write(fd, buf, sizeof(buf));
if (ret < 0)
ret = 0;
{
unsigned i;
for (i = 0; i < sizeof(buf)/sizeof(buf[0]); i++)
- buf[i] = random();
+ buf[i] = (uint32_t) random();
ret = write(fd, buf, len % 1024);
if (ret < 0)
ret = 0;
if (!seeded)
{
assert(sizeof(shabuf) == 20);
- srandom(time(NULL));
+ srandom((unsigned int) time(NULL));
seeded = 1;
}
memset(shabuf, 0, sizeof(shabuf));
for (i=0; i < 20/4; i++)
- shabuf[i] = random();
+ shabuf[i] = (uint32_t) random();
return Py_BuildValue(rbuf_argf, shabuf, 20);
}
#endif /* def BUP_MINCORE_BUF_TYPE */
+static PyObject *tuple_from_cstrs(char **cstrs)
+{
+ // Assumes list is null terminated
+ size_t n = 0;
+ while(cstrs[n] != NULL)
+ n++;
+
+ Py_ssize_t sn;
+ if (!INTEGRAL_ASSIGNMENT_FITS(&sn, n))
+ return PyErr_Format(PyExc_OverflowError, "string array too large");
+
+ PyObject *result = PyTuple_New(sn);
+ Py_ssize_t i = 0;
+ for (i = 0; i < sn; i++)
+ {
+ PyObject *gname = Py_BuildValue(cstr_argf, cstrs[i]);
+ if (gname == NULL)
+ {
+ Py_DECREF(result);
+ return NULL;
+ }
+ PyTuple_SET_ITEM(result, i, gname);
+ }
+ 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 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)
+ 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)
+{
+ unsigned long long py_uid;
+ if (!PyArg_ParseTuple(args, "K", &py_uid))
+ return NULL;
+ uid_t uid;
+ if (!INTEGRAL_ASSIGNMENT_FITS(&uid, py_uid))
+ return PyErr_Format(PyExc_OverflowError, "uid too large for uid_t");
+
+ 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)
+{
+ PyObject *py_name;
+ if (!PyArg_ParseTuple(args, "S", &py_name))
+ return NULL;
+
+ char *name = PyBytes_AS_STRING(py_name);
+ errno = 0;
+ struct passwd *pwd = getpwnam(name);
+ if (!pwd && errno)
+ return appropriate_errno_ex();
+ return pwd_struct_to_py(pwd);
+}
+
+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)
+ 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)
+{
+ unsigned long long py_gid;
+ if (!PyArg_ParseTuple(args, "K", &py_gid))
+ return NULL;
+ gid_t gid;
+ if (!INTEGRAL_ASSIGNMENT_FITS(&gid, py_gid))
+ return PyErr_Format(PyExc_OverflowError, "gid too large for gid_t");
+
+ 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)
+{
+ PyObject *py_name;
+ if (!PyArg_ParseTuple(args, "S", &py_name))
+ return NULL;
+
+ char *name = PyBytes_AS_STRING(py_name);
+ 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
+ char buf[HOST_NAME_MAX + 1] = {};
+#else
+ /* 'SUSv2 guarantees that "Host names are limited to 255 bytes".' */
+ char buf[256] = {};
+#endif
+
+ if (gethostname(buf, sizeof(buf) - 1))
+ return PyErr_SetFromErrno(PyExc_IOError);
+ return PyBytes_FromString(buf);
+}
+
+
+#ifdef BUP_HAVE_READLINE
+
+static char *cstr_from_bytes(PyObject *bytes)
+{
+ char *buf;
+ Py_ssize_t length;
+ int rc = PyBytes_AsStringAndSize(bytes, &buf, &length);
+ if (rc == -1)
+ return NULL;
+ char *result = checked_malloc(length, sizeof(char));
+ if (!result)
+ return NULL;
+ memcpy(result, buf, length);
+ return result;
+}
+
+static char **cstrs_from_seq(PyObject *seq)
+{
+ char **result = NULL;
+ seq = PySequence_Fast(seq, "Cannot convert sequence items to C strings");
+ if (!seq)
+ return NULL;
+
+ const Py_ssize_t len = PySequence_Fast_GET_SIZE(seq);
+ if (len > PY_SSIZE_T_MAX - 1) {
+ PyErr_Format(PyExc_OverflowError,
+ "Sequence length %zd too large for conversion to C array",
+ len);
+ goto finish;
+ }
+ result = checked_malloc(len + 1, sizeof(char *));
+ if (!result)
+ goto finish;
+ Py_ssize_t i = 0;
+ for (i = 0; i < len; i++)
+ {
+ PyObject *item = PySequence_Fast_GET_ITEM(seq, i);
+ if (!item)
+ goto abandon_result;
+ result[i] = cstr_from_bytes(item);
+ if (!result[i]) {
+ i--;
+ goto abandon_result;
+ }
+ }
+ result[len] = NULL;
+ goto finish;
+
+ abandon_result:
+ if (result) {
+ for (; i > 0; i--)
+ free(result[i]);
+ free(result);
+ result = NULL;
+ }
+ finish:
+ Py_DECREF(seq);
+ return result;
+}
+
+static char* our_word_break_chars = NULL;
+
+static PyObject *
+bup_set_completer_word_break_characters(PyObject *self, PyObject *args)
+{
+ char *bytes;
+ if (!PyArg_ParseTuple(args, cstr_argf, &bytes))
+ return NULL;
+ char *prev = our_word_break_chars;
+ char *next = strdup(bytes);
+ if (!next)
+ return PyErr_NoMemory();
+ our_word_break_chars = next;
+ rl_completer_word_break_characters = next;
+ if (prev)
+ free(prev);
+ Py_RETURN_NONE;
+}
+
+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);
+}
+
+static PyObject *
+bup_parse_and_bind(PyObject *self, PyObject *args)
+{
+ char *bytes;
+ if (!PyArg_ParseTuple(args, cstr_argf ":parse_and_bind", &bytes))
+ return NULL;
+ char *tmp = strdup(bytes); // Because it may modify the arg
+ if (!tmp)
+ return PyErr_NoMemory();
+ int rc = rl_parse_and_bind(tmp);
+ free(tmp);
+ if (rc != 0)
+ return PyErr_Format(PyExc_OSError,
+ "system rl_parse_and_bind failed (%d)", rc);
+ Py_RETURN_NONE;
+}
+
+
+static PyObject *py_on_attempted_completion;
+static char **prev_completions;
+
+static char **on_attempted_completion(const char *text, int start, int end)
+{
+ if (!py_on_attempted_completion)
+ return NULL;
+
+ char **result = NULL;
+ PyObject *py_result = PyObject_CallFunction(py_on_attempted_completion,
+ cstr_argf "ii",
+ text, start, end);
+ if (!py_result)
+ return NULL;
+ if (py_result != Py_None) {
+ result = cstrs_from_seq(py_result);
+ free(prev_completions);
+ prev_completions = result;
+ }
+ Py_DECREF(py_result);
+ return result;
+}
+
+static PyObject *
+bup_set_attempted_completion_function(PyObject *self, PyObject *args)
+{
+ PyObject *completer;
+ if (!PyArg_ParseTuple(args, "O", &completer))
+ return NULL;
+
+ PyObject *prev = py_on_attempted_completion;
+ if (completer == Py_None)
+ {
+ py_on_attempted_completion = NULL;
+ rl_attempted_completion_function = NULL;
+ } else {
+ py_on_attempted_completion = completer;
+ rl_attempted_completion_function = on_attempted_completion;
+ Py_INCREF(completer);
+ }
+ Py_XDECREF(prev);
+ Py_RETURN_NONE;
+}
+
+
+static PyObject *py_on_completion_entry;
+
+static char *on_completion_entry(const char *text, int state)
+{
+ if (!py_on_completion_entry)
+ return NULL;
+
+ PyObject *py_result = PyObject_CallFunction(py_on_completion_entry,
+ cstr_argf "i", text, state);
+ if (!py_result)
+ return NULL;
+ char *result = (py_result == Py_None) ? NULL : cstr_from_bytes(py_result);
+ Py_DECREF(py_result);
+ return result;
+}
+
+static PyObject *
+bup_set_completion_entry_function(PyObject *self, PyObject *args)
+{
+ PyObject *completer;
+ if (!PyArg_ParseTuple(args, "O", &completer))
+ return NULL;
+
+ PyObject *prev = py_on_completion_entry;
+ if (completer == Py_None) {
+ py_on_completion_entry = NULL;
+ rl_completion_entry_function = NULL;
+ } else {
+ py_on_completion_entry = completer;
+ rl_completion_entry_function = on_completion_entry;
+ Py_INCREF(completer);
+ }
+ Py_XDECREF(prev);
+ Py_RETURN_NONE;
+}
+
+static PyObject *
+bup_readline(PyObject *self, PyObject *args)
+{
+ char *prompt;
+ if (!PyArg_ParseTuple(args, cstr_argf, &prompt))
+ return NULL;
+ char *line = readline(prompt);
+ if (!line)
+ return PyErr_Format(PyExc_EOFError, "readline EOF");
+ PyObject *result = PyBytes_FromString(line);
+ free(line);
+ return result;
+}
+
+#endif // defined BUP_HAVE_READLINE
+
+#if defined(HAVE_SYS_ACL_H) && \
+ defined(HAVE_ACL_LIBACL_H) && \
+ defined(HAVE_ACL_EXTENDED_FILE) && \
+ defined(HAVE_ACL_GET_FILE) && \
+ defined(HAVE_ACL_TO_ANY_TEXT) && \
+ defined(HAVE_ACL_FROM_TEXT) && \
+ defined(HAVE_ACL_SET_FILE)
+#define ACL_SUPPORT 1
+#include <sys/acl.h>
+#include <acl/libacl.h>
+
+// Returns
+// 0 for success
+// -1 for errors, with python exception set
+// -2 for ignored errors (not supported)
+static int bup_read_acl_to_text(const char *name, acl_type_t type,
+ char **txt, char **num)
+{
+ acl_t acl;
+
+ acl = acl_get_file(name, type);
+ if (!acl) {
+ if (errno == EOPNOTSUPP || errno == ENOSYS)
+ return -2;
+ PyErr_SetFromErrno(PyExc_IOError);
+ return -1;
+ }
+
+ *num = NULL;
+ *txt = acl_to_any_text(acl, "", '\n', TEXT_ABBREVIATE);
+ if (*txt)
+ *num = acl_to_any_text(acl, "", '\n', TEXT_ABBREVIATE | TEXT_NUMERIC_IDS);
+
+ if (*txt && *num)
+ return 0;
+
+ if (errno == ENOMEM)
+ PyErr_NoMemory();
+ else
+ PyErr_SetFromErrno(PyExc_IOError);
+
+ if (*txt)
+ acl_free((acl_t)*txt);
+ if (*num)
+ acl_free((acl_t)*num);
+
+ return -1;
+}
+
+static PyObject *bup_read_acl(PyObject *self, PyObject *args)
+{
+ char *name;
+ int isdir, rv;
+ PyObject *ret = NULL;
+ char *acl_txt = NULL, *acl_num = NULL;
+
+ if (!PyArg_ParseTuple(args, cstr_argf "i", &name, &isdir))
+ return NULL;
+
+ if (!acl_extended_file(name))
+ Py_RETURN_NONE;
+
+ rv = bup_read_acl_to_text(name, ACL_TYPE_ACCESS, &acl_txt, &acl_num);
+ if (rv)
+ goto out;
+
+ if (isdir) {
+ char *def_txt = NULL, *def_num = NULL;
+
+ rv = bup_read_acl_to_text(name, ACL_TYPE_DEFAULT, &def_txt, &def_num);
+ if (rv)
+ goto out;
+
+ ret = Py_BuildValue("[" cstr_argf cstr_argf cstr_argf cstr_argf "]",
+ acl_txt, acl_num, def_txt, def_num);
+
+ if (def_txt)
+ acl_free((acl_t)def_txt);
+ if (def_num)
+ acl_free((acl_t)def_num);
+ } else {
+ ret = Py_BuildValue("[" cstr_argf cstr_argf "]",
+ acl_txt, acl_num);
+ }
+
+out:
+ if (acl_txt)
+ acl_free((acl_t)acl_txt);
+ if (acl_num)
+ acl_free((acl_t)acl_num);
+ if (rv == -2)
+ Py_RETURN_NONE;
+ return ret;
+}
+
+static int bup_apply_acl_string(const char *name, const char *s)
+{
+ acl_t acl = acl_from_text(s);
+ int ret = 0;
+
+ if (!acl) {
+ PyErr_SetFromErrno(PyExc_IOError);
+ return -1;
+ }
+
+ if (acl_set_file(name, ACL_TYPE_ACCESS, acl)) {
+ PyErr_SetFromErrno(PyExc_IOError);
+ ret = -1;
+ }
+
+ acl_free(acl);
+
+ return ret;
+}
+
+static PyObject *bup_apply_acl(PyObject *self, PyObject *args)
+{
+ char *name, *acl, *def = NULL;
+
+ if (!PyArg_ParseTuple(args, cstr_argf cstr_argf "|" cstr_argf, &name, &acl, &def))
+ return NULL;
+
+ if (bup_apply_acl_string(name, acl))
+ return NULL;
+
+ if (def && bup_apply_acl_string(name, def))
+ return NULL;
+
+ Py_RETURN_NONE;
+}
+#endif
+
static PyMethodDef helper_methods[] = {
{ "write_sparsely", bup_write_sparsely, METH_VARARGS,
"Write buf excepting zeros at the end. Return trailing zero count." },
#endif
{ "bytescmp", bup_bytescmp, METH_VARARGS,
"Return a negative value if x < y, zero if equal, positive otherwise."},
+ { "cat_bytes", bup_cat_bytes, METH_VARARGS,
+ "For (x_bytes, x_ofs, x_n, y_bytes, y_ofs, y_n) arguments, return their concatenation."},
#ifdef BUP_MINCORE_BUF_TYPE
{ "mincore", bup_mincore, METH_VARARGS,
"For mincore(src, src_n, src_off, dest, dest_off)"
" call the system mincore(src + src_off, src_n, &dest[dest_off])." },
#endif
+ { "getpwuid", bup_getpwuid, METH_VARARGS,
+ "Return the password database entry for the given numeric user id,"
+ " as a tuple with all C strings as bytes(), or None if the user does"
+ " not exist." },
+ { "getpwnam", bup_getpwnam, METH_VARARGS,
+ "Return the password database entry for the given user name,"
+ " as a tuple with all C strings as bytes(), or None if the user does"
+ " not exist." },
+ { "getgrgid", bup_getgrgid, METH_VARARGS,
+ "Return the group database entry for the given numeric group id,"
+ " as a tuple with all C strings as bytes(), or None if the group does"
+ " not exist." },
+ { "getgrnam", bup_getgrnam, METH_VARARGS,
+ "Return the group database entry for the given group name,"
+ " as a tuple with all C strings as bytes(), or None if the group does"
+ " not exist." },
+ { "gethostname", bup_gethostname, METH_NOARGS,
+ "Return the current hostname (as bytes)" },
+#ifdef BUP_HAVE_READLINE
+ { "set_completion_entry_function", bup_set_completion_entry_function, METH_VARARGS,
+ "Set rl_completion_entry_function. Called as f(text, state)." },
+ { "set_attempted_completion_function", bup_set_attempted_completion_function, METH_VARARGS,
+ "Set rl_attempted_completion_function. Called as f(text, start, end)." },
+ { "parse_and_bind", bup_parse_and_bind, METH_VARARGS,
+ "Call rl_parse_and_bind." },
+ { "get_line_buffer", bup_get_line_buffer, METH_NOARGS,
+ "Return rl_line_buffer." },
+ { "get_completer_word_break_characters", bup_get_completer_word_break_characters, METH_NOARGS,
+ "Return rl_completer_word_break_characters." },
+ { "set_completer_word_break_characters", bup_set_completer_word_break_characters, METH_VARARGS,
+ "Set rl_completer_word_break_characters." },
+ { "readline", bup_readline, METH_VARARGS,
+ "Call readline(prompt)." },
+#endif // defined BUP_HAVE_READLINE
+#ifdef ACL_SUPPORT
+ { "read_acl", bup_read_acl, METH_VARARGS,
+ "read_acl(name, isdir)\n\n"
+ "Read ACLs for the given file/dirname and return the correctly encoded"
+ " list [txt, num, def_tx, def_num] (the def_* being empty bytestrings"
+ " unless the second argument 'isdir' is True)." },
+ { "apply_acl", bup_apply_acl, 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 */
{ NULL, NULL, 0, NULL }, // sentinel
};
projects / bup.git / blobdiff