+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
+