4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber#include <Python.h>

7f95145833bb24f54e037f73ecc37444d6635697Dwight Engen#include "structmember.h"

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber#include <lxc/lxccontainer.h>

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber#include <lxc/utils.h>

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber#include <stdio.h>

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber#include <sys/wait.h>

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Grabertypedef struct {

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber PyObject_HEAD

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber struct lxc_container *container;

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber} Container;

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graberchar**

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graberconvert_tuple_to_char_pointer_array(PyObject *argv) {

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber int argc;

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber int i, j;

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber /* not a list or tuple */

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber if (!PyList_Check(argv) && !PyTuple_Check(argv)) {

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber PyErr_SetString(PyExc_TypeError, "Expected list or tuple.");

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber return NULL;

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber }

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber argc = PySequence_Fast_GET_SIZE(argv);

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber char **result = (char**) calloc(argc + 1, sizeof(char*));

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber if (result == NULL) {

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber PyErr_SetNone(PyExc_MemoryError);

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber return NULL;

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber }

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

8128cf421081b683bca4610aa2db3e3ed851ab92KATOH Yasufumi for (i = 0; i < argc; i++) {

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber PyObject *pyobj = PySequence_Fast_GET_ITEM(argv, i);

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber assert(pyobj != NULL);

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber char *str = NULL;

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber PyObject *pystr = NULL;

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber if (!PyUnicode_Check(pyobj)) {

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber PyErr_SetString(PyExc_ValueError, "Expected a string");

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber goto error;

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber }

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber pystr = PyUnicode_AsUTF8String(pyobj);

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber if (!pystr) {

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber /* Maybe it wasn't UTF-8 encoded. An exception is already set. */

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber goto error;

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber }

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber str = PyBytes_AsString(pystr);

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber if (!str) {

1bc07a5b8dbaef4b6eb6d30a260e9c2153ed368bKATOH Yasufumi /* Maybe pystr wasn't a valid object. An exception is already set.

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber Py_DECREF(pystr);

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber goto error;

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber }

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber /* We must make a copy of str, because it points into internal memory

1bc07a5b8dbaef4b6eb6d30a260e9c2153ed368bKATOH Yasufumi result[i] = strdup(str);

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber /* Do not decref pyobj since we stole a reference by using

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber Py_DECREF(pystr);

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber if (result[i] == NULL) {

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber PyErr_SetNone(PyExc_MemoryError);

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber goto error;

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber }

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber }

1bc07a5b8dbaef4b6eb6d30a260e9c2153ed368bKATOH Yasufumi

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber result[argc] = NULL;

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber return result;

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Grabererror:

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber /* We can only iterate up to but not including i because malloc() does not

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber for (j = 0; j < i; j++)

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber free(result[j]);

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber free(result);

1bc07a5b8dbaef4b6eb6d30a260e9c2153ed368bKATOH Yasufumi return NULL;

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber}

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graberstatic void

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane GraberContainer_dealloc(Container* self)

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber{

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber lxc_container_put(self->container);

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber Py_TYPE(self)->tp_free((PyObject*)self);

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber}

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graberstatic PyObject *

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane GraberContainer_new(PyTypeObject *type, PyObject *args, PyObject *kwds)

1bc07a5b8dbaef4b6eb6d30a260e9c2153ed368bKATOH Yasufumi{

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber Container *self;

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber self = (Container *)type->tp_alloc(type, 0);

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber return (PyObject *)self;

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber}

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graberstatic int

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane GraberContainer_init(Container *self, PyObject *args, PyObject *kwds)

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber{

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber static char *kwlist[] = {"name", "config_path", NULL};

1bc07a5b8dbaef4b6eb6d30a260e9c2153ed368bKATOH Yasufumi char *name = NULL;

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber PyObject *fs_config_path = NULL;

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber char *config_path = NULL;

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber if (!PyArg_ParseTupleAndKeywords(args, kwds, "s|O&", kwlist,

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber &name,

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber PyUnicode_FSConverter, &fs_config_path))

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber return -1;

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

8128cf421081b683bca4610aa2db3e3ed851ab92KATOH Yasufumi if (fs_config_path != NULL) {

8128cf421081b683bca4610aa2db3e3ed851ab92KATOH Yasufumi config_path = PyBytes_AS_STRING(fs_config_path);

1bc07a5b8dbaef4b6eb6d30a260e9c2153ed368bKATOH Yasufumi assert(config_path != NULL);

8128cf421081b683bca4610aa2db3e3ed851ab92KATOH Yasufumi }

8128cf421081b683bca4610aa2db3e3ed851ab92KATOH Yasufumi

8128cf421081b683bca4610aa2db3e3ed851ab92KATOH Yasufumi self->container = lxc_container_new(name, config_path);

8128cf421081b683bca4610aa2db3e3ed851ab92KATOH Yasufumi if (!self->container) {

8128cf421081b683bca4610aa2db3e3ed851ab92KATOH Yasufumi Py_XDECREF(fs_config_path);

8128cf421081b683bca4610aa2db3e3ed851ab92KATOH Yasufumi fprintf(stderr, "%d: error creating container %s\n", __LINE__, name);

8128cf421081b683bca4610aa2db3e3ed851ab92KATOH Yasufumi return -1;

8128cf421081b683bca4610aa2db3e3ed851ab92KATOH Yasufumi }

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber Py_XDECREF(fs_config_path);

1bc07a5b8dbaef4b6eb6d30a260e9c2153ed368bKATOH Yasufumi return 0;

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber}

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graberstatic PyObject *

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane GraberLXC_get_default_config_path(PyObject *self, PyObject *args)

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber{

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber return PyUnicode_FromString(lxc_get_default_config_path());

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber}

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graberstatic PyObject *

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane GraberLXC_get_version(PyObject *self, PyObject *args)

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber{

1bc07a5b8dbaef4b6eb6d30a260e9c2153ed368bKATOH Yasufumi return PyUnicode_FromString(lxc_get_version());

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber}

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graberstatic PyObject *

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane GraberContainer_config_file_name(Container *self, void *closure)

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber{

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber return PyUnicode_FromString(

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber self->container->config_file_name(self->container));

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber}

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graberstatic PyObject *

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane GraberContainer_defined(Container *self, void *closure)

1bc07a5b8dbaef4b6eb6d30a260e9c2153ed368bKATOH Yasufumi{

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber if (self->container->is_defined(self->container)) {

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber Py_RETURN_TRUE;

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber }

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

56e4a18564f8ab3d93c0f2b5f91aa5cff4f171c9KATOH Yasufumi Py_RETURN_FALSE;

56e4a18564f8ab3d93c0f2b5f91aa5cff4f171c9KATOH Yasufumi}

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graberstatic PyObject *

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane GraberContainer_init_pid(Container *self, void *closure)

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber{

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber return PyLong_FromLong(self->container->init_pid(self->container));

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber}

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graberstatic PyObject *

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane GraberContainer_name(Container *self, void *closure)

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber{

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber return PyUnicode_FromString(self->container->name);

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber}

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graberstatic PyObject *

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane GraberContainer_running(Container *self, void *closure)

d438f5a0ef0f304917e227405d26aef6e7b30303Qiang Huang{

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber if (self->container->is_running(self->container)) {

d438f5a0ef0f304917e227405d26aef6e7b30303Qiang Huang Py_RETURN_TRUE;

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber }

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber Py_RETURN_FALSE;

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber}

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graberstatic PyObject *

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane GraberContainer_state(Container *self, void *closure)

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber{

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber return PyUnicode_FromString(self->container->state(self->container));

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber}

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graberstatic PyObject *

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane GraberContainer_clear_config_item(Container *self, PyObject *args, PyObject *kwds)

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber{

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber static char *kwlist[] = {"key", NULL};

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber char *key = NULL;

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber if (! PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist,

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber &key))

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber return NULL;

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber if (self->container->clear_config_item(self->container, key)) {

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber Py_RETURN_TRUE;

02e5d92b70562457a963f0803f0069053ce3292bChristian Brauner }

02e5d92b70562457a963f0803f0069053ce3292bChristian Brauner

02e5d92b70562457a963f0803f0069053ce3292bChristian Brauner Py_RETURN_FALSE;

02e5d92b70562457a963f0803f0069053ce3292bChristian Brauner}

02e5d92b70562457a963f0803f0069053ce3292bChristian Brauner

02e5d92b70562457a963f0803f0069053ce3292bChristian Braunerstatic PyObject *

02e5d92b70562457a963f0803f0069053ce3292bChristian BraunerContainer_create(Container *self, PyObject *args, PyObject *kwds)

02e5d92b70562457a963f0803f0069053ce3292bChristian Brauner{

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber char* template_name = NULL;

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber char** create_args = {NULL};

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber PyObject *retval = NULL, *vargs = NULL;

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber int i = 0;

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber static char *kwlist[] = {"template", "args", NULL};

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber if (! PyArg_ParseTupleAndKeywords(args, kwds, "s|O", kwlist,

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber &template_name, &vargs))

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber return NULL;

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber if (vargs) {

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber if (PyTuple_Check(vargs)) {

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber create_args = convert_tuple_to_char_pointer_array(vargs);

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber if (!create_args) {

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber return NULL;

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber }

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber }

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber else {

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber PyErr_SetString(PyExc_ValueError, "args needs to be a tuple");

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber return NULL;

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber }

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber }

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber

4019712d198a7d50b08b326ade17f5ff1666efbbStéphane Graber if (self->container->create(self->container, template_name, NULL, NULL, 0, create_args))

retval = Py_True;

else

retval = Py_False;

if (vargs) {

/* We cannot have gotten here unless vargs was given and create_args

for (i = 0; i < PyTuple_GET_SIZE(vargs); i++)

free(create_args[i]);

free(create_args);

}

Py_INCREF(retval);

return retval;

}

static PyObject *

Container_destroy(Container *self, PyObject *args, PyObject *kwds)

{

if (self->container->destroy(self->container)) {

Py_RETURN_TRUE;

}

Py_RETURN_FALSE;

}

static PyObject *

Container_freeze(Container *self, PyObject *args, PyObject *kwds)

{

if (self->container->freeze(self->container)) {

Py_RETURN_TRUE;

}

Py_RETURN_FALSE;

}

static PyObject *

Container_get_cgroup_item(Container *self, PyObject *args, PyObject *kwds)

{

static char *kwlist[] = {"key", NULL};

char* key = NULL;

int len = 0;

PyObject *ret = NULL;

if (! PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist,

&key))

return NULL;

len = self->container->get_cgroup_item(self->container, key, NULL, 0);

if (len < 0) {

PyErr_SetString(PyExc_KeyError, "Invalid cgroup entry");

return NULL;

}

char* value = (char*) malloc(sizeof(char)*len + 1);

if (value == NULL)

return PyErr_NoMemory();

if (self->container->get_cgroup_item(self->container,

key, value, len + 1) != len) {

PyErr_SetString(PyExc_ValueError, "Unable to read config value");

free(value);

return NULL;

}

ret = PyUnicode_FromString(value);

free(value);

return ret;

}

static PyObject *

Container_get_config_item(Container *self, PyObject *args, PyObject *kwds)

{

static char *kwlist[] = {"key", NULL};

char* key = NULL;

int len = 0;

PyObject *ret = NULL;

if (! PyArg_ParseTupleAndKeywords(args, kwds, "s|", kwlist,

&key))

return NULL;

len = self->container->get_config_item(self->container, key, NULL, 0);

if (len < 0) {

PyErr_SetString(PyExc_KeyError, "Invalid configuration key");

return NULL;

}

char* value = (char*) malloc(sizeof(char)*len + 1);

if (value == NULL)

return PyErr_NoMemory();

if (self->container->get_config_item(self->container,

key, value, len + 1) != len) {

PyErr_SetString(PyExc_ValueError, "Unable to read config value");

free(value);

return NULL;

}

ret = PyUnicode_FromString(value);

free(value);

return ret;

}

static PyObject *

Container_get_config_path(Container *self, PyObject *args, PyObject *kwds)

{

return PyUnicode_FromString(

self->container->get_config_path(self->container));

}

static PyObject *

Container_get_keys(Container *self, PyObject *args, PyObject *kwds)

{

static char *kwlist[] = {"key", NULL};

char* key = NULL;

int len = 0;

PyObject *ret = NULL;

if (! PyArg_ParseTupleAndKeywords(args, kwds, "|s", kwlist,

&key))

return NULL;

len = self->container->get_keys(self->container, key, NULL, 0);

if (len < 0) {

PyErr_SetString(PyExc_KeyError, "Invalid configuration key");

return NULL;

}

char* value = (char*) malloc(sizeof(char)*len + 1);

if (value == NULL)

return PyErr_NoMemory();

if (self->container->get_keys(self->container,

key, value, len + 1) != len) {

PyErr_SetString(PyExc_ValueError, "Unable to read config keys");

free(value);

return NULL;

}

ret = PyUnicode_FromString(value);

free(value);

return ret;

}

static PyObject *

Container_get_ips(Container *self, PyObject *args, PyObject *kwds)

{

static char *kwlist[] = {"interface", "family", "scope", NULL};

char* interface = NULL;

char* family = NULL;

int scope = 0;

int i = 0;

char** ips = NULL;

PyObject* ret;

if (! PyArg_ParseTupleAndKeywords(args, kwds, "|ssi", kwlist,

&interface, &family, &scope))

return NULL;

/* Get the IPs */

ips = self->container->get_ips(self->container, interface, family, scope);

if (!ips)

return PyTuple_New(0);

/* Count the entries */

while (ips[i])

i++;

/* Create the new tuple */

ret = PyTuple_New(i);

if (!ret)

return NULL;

/* Add the entries to the tuple and free the memory */

i = 0;

while (ips[i]) {

PyObject *unicode = PyUnicode_FromString(ips[i]);

if (!unicode) {

Py_DECREF(ret);

ret = NULL;

break;

}

PyTuple_SET_ITEM(ret, i, unicode);

i++;

}

/* Free the list of IPs */

i = 0;

while (ips[i]) {

free(ips[i]);

i++;

}

free(ips);

return ret;

}

static PyObject *

Container_load_config(Container *self, PyObject *args, PyObject *kwds)

{

static char *kwlist[] = {"path", NULL};

PyObject *fs_path = NULL;

char* path = NULL;

if (! PyArg_ParseTupleAndKeywords(args, kwds, "|O&", kwlist,

PyUnicode_FSConverter, &fs_path))

return NULL;

if (fs_path != NULL) {

path = PyBytes_AS_STRING(fs_path);

assert(path != NULL);

}

if (self->container->load_config(self->container, path)) {

Py_XDECREF(fs_path);

Py_RETURN_TRUE;

}

Py_XDECREF(fs_path);

Py_RETURN_FALSE;

}

static PyObject *

Container_save_config(Container *self, PyObject *args, PyObject *kwds)

{

static char *kwlist[] = {"path", NULL};

PyObject *fs_path = NULL;

char* path = NULL;

if (! PyArg_ParseTupleAndKeywords(args, kwds, "|O&", kwlist,

PyUnicode_FSConverter, &fs_path))

return NULL;

if (fs_path != NULL) {

path = PyBytes_AS_STRING(fs_path);

assert(path != NULL);

}

if (self->container->save_config(self->container, path)) {

Py_XDECREF(fs_path);

Py_RETURN_TRUE;

}

Py_XDECREF(fs_path);

Py_RETURN_FALSE;

}

static PyObject *

Container_set_cgroup_item(Container *self, PyObject *args, PyObject *kwds)

{

static char *kwlist[] = {"key", "value", NULL};

char *key = NULL;

char *value = NULL;

if (! PyArg_ParseTupleAndKeywords(args, kwds, "ss", kwlist,

&key, &value))

return NULL;

if (self->container->set_cgroup_item(self->container, key, value)) {

Py_RETURN_TRUE;

}

Py_RETURN_FALSE;

}

static PyObject *

Container_set_config_item(Container *self, PyObject *args, PyObject *kwds)

{

static char *kwlist[] = {"key", "value", NULL};

char *key = NULL;

char *value = NULL;

if (! PyArg_ParseTupleAndKeywords(args, kwds, "ss", kwlist,

&key, &value))

return NULL;

if (self->container->set_config_item(self->container, key, value)) {

Py_RETURN_TRUE;

}

Py_RETURN_FALSE;

}

static PyObject *

Container_set_config_path(Container *self, PyObject *args, PyObject *kwds)

{

static char *kwlist[] = {"path", NULL};

char *path = NULL;

if (! PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist,

&path))

return NULL;

if (self->container->set_config_path(self->container, path)) {

Py_RETURN_TRUE;

}

Py_RETURN_FALSE;

}

static PyObject *

Container_shutdown(Container *self, PyObject *args, PyObject *kwds)

{

static char *kwlist[] = {"timeout", NULL};

int timeout = -1;

if (! PyArg_ParseTupleAndKeywords(args, kwds, "|i", kwlist,

&timeout))

return NULL;

if (self->container->shutdown(self->container, timeout)) {

Py_RETURN_TRUE;

}

Py_RETURN_FALSE;

}

static PyObject *

Container_start(Container *self, PyObject *args, PyObject *kwds)

{

char** init_args = {NULL};

PyObject *useinit = NULL, *retval = NULL, *vargs = NULL;

int init_useinit = 0, i = 0;

static char *kwlist[] = {"useinit", "cmd", NULL};

if (! PyArg_ParseTupleAndKeywords(args, kwds, "|OO", kwlist,

&useinit, &vargs))

return NULL;

if (useinit && useinit == Py_True) {

init_useinit = 1;

}

if (vargs && PyTuple_Check(vargs)) {

init_args = convert_tuple_to_char_pointer_array(vargs);

if (!init_args) {

return NULL;

}

}

self->container->want_daemonize(self->container);

if (self->container->start(self->container, init_useinit, init_args))

retval = Py_True;

else

retval = Py_False;

if (vargs) {

/* We cannot have gotten here unless vargs was given and create_args

for (i = 0; i < PyTuple_GET_SIZE(vargs); i++)

free(init_args[i]);

free(init_args);

}

Py_INCREF(retval);

return retval;

}

static PyObject *

Container_stop(Container *self, PyObject *args, PyObject *kwds)

{

if (self->container->stop(self->container)) {

Py_RETURN_TRUE;

}

Py_RETURN_FALSE;

}

static PyObject *

Container_unfreeze(Container *self, PyObject *args, PyObject *kwds)

{

if (self->container->unfreeze(self->container)) {

Py_RETURN_TRUE;

}

Py_RETURN_FALSE;

}

static PyObject *

Container_console(Container *self, PyObject *args, PyObject *kwds)

{

static char *kwlist[] = {"ttynum", "stdinfd", "stdoutfd", "stderrfd", "escape", NULL};

int ttynum = -1, stdinfd = 0, stdoutfd = 1, stderrfd = 2, escape = 1;

if (! PyArg_ParseTupleAndKeywords(args, kwds, "|iiiii", kwlist,

&ttynum, &stdinfd, &stdoutfd, &stderrfd,

&escape))

return NULL;

if (self->container->console(self->container, ttynum,

stdinfd, stdoutfd, stderrfd, escape) == 0) {

Py_RETURN_TRUE;

}

Py_RETURN_FALSE;

}

static PyObject *

Container_console_getfd(Container *self, PyObject *args, PyObject *kwds)

{

static char *kwlist[] = {"ttynum", NULL};

int ttynum = -1, masterfd;

if (! PyArg_ParseTupleAndKeywords(args, kwds, "|i", kwlist, &ttynum))

return NULL;

if (self->container->console_getfd(self->container, &ttynum, &masterfd) < 0) {

PyErr_SetString(PyExc_ValueError, "Unable to allocate tty");

return NULL;

}

return PyLong_FromLong(masterfd);

}

static PyObject *

Container_wait(Container *self, PyObject *args, PyObject *kwds)

{

static char *kwlist[] = {"state", "timeout", NULL};

char *state = NULL;

int timeout = -1;

if (! PyArg_ParseTupleAndKeywords(args, kwds, "s|i", kwlist,

&state, &timeout))

return NULL;

if (self->container->wait(self->container, state, timeout)) {

Py_RETURN_TRUE;

}

Py_RETURN_FALSE;

}

struct lxc_attach_python_payload {

PyObject *fn;

PyObject *arg;

};

static int lxc_attach_python_exec(void* _payload)

{

struct lxc_attach_python_payload *payload = (struct lxc_attach_python_payload *)_payload;

PyObject *result = PyObject_CallFunctionObjArgs(payload->fn, payload->arg, NULL);

if (!result) {

PyErr_Print();

return -1;

}

if (PyLong_Check(result))

return (int)PyLong_AsLong(result);

else

return -1;

}

static lxc_attach_options_t *lxc_attach_parse_options(PyObject *kwds)

{

static char *kwlist[] = {"attach_flags", "namespaces", "personality", "initial_cwd", "uid", "gid", "env_policy", "extra_env_vars", "extra_keep_env", "stdin", "stdout", "stderr", NULL};

long temp_uid, temp_gid;

int temp_env_policy;

PyObject *extra_env_vars_obj = NULL;

PyObject *extra_keep_env_obj = NULL;

PyObject *stdin_obj = NULL;

PyObject *stdout_obj = NULL;

PyObject *stderr_obj = NULL;

PyObject *initial_cwd_obj = NULL;

PyObject *dummy;

bool parse_result;

lxc_attach_options_t default_options = LXC_ATTACH_OPTIONS_DEFAULT;

lxc_attach_options_t *options = malloc(sizeof(*options));

if (!options) {

PyErr_SetNone(PyExc_MemoryError);

return NULL;

}

memcpy(options, &default_options, sizeof(*options));

/* we need some dummy variables because we can't be sure

temp_uid = -1;

temp_gid = -1;

temp_env_policy = options->env_policy;

/* we need a dummy tuple */

dummy = PyTuple_New(0);

parse_result = PyArg_ParseTupleAndKeywords(dummy, kwds, "|iilO&lliOOOOO", kwlist,

&options->attach_flags, &options->namespaces, &options->personality,

PyUnicode_FSConverter, &initial_cwd_obj, &temp_uid, &temp_gid,

&temp_env_policy, &extra_env_vars_obj, &extra_keep_env_obj,

&stdin_obj, &stdout_obj, &stderr_obj);

/* immediately get rid of the dummy tuple */

Py_DECREF(dummy);

if (!parse_result)

return NULL;

/* duplicate the string, so we don't depend on some random Python object */

if (initial_cwd_obj != NULL) {

options->initial_cwd = strndup(PyBytes_AsString(initial_cwd_obj), PyBytes_Size(initial_cwd_obj));

Py_DECREF(initial_cwd_obj);

}

/* do the type conversion from the types that match the parse string */

if (temp_uid != -1) options->uid = (uid_t)temp_uid;

if (temp_gid != -1) options->gid = (gid_t)temp_gid;

options->env_policy = (lxc_attach_env_policy_t)temp_env_policy;

if (extra_env_vars_obj)

options->extra_env_vars = convert_tuple_to_char_pointer_array(extra_env_vars_obj);

if (extra_keep_env_obj)

options->extra_keep_env = convert_tuple_to_char_pointer_array(extra_keep_env_obj);

if (stdin_obj) {

options->stdin_fd = PyObject_AsFileDescriptor(stdin_obj);

if (options->stdin_fd < 0)

return NULL;

}

if (stdout_obj) {

options->stdout_fd = PyObject_AsFileDescriptor(stdout_obj);

if (options->stdout_fd < 0)

return NULL;

}

if (stderr_obj) {

options->stderr_fd = PyObject_AsFileDescriptor(stderr_obj);

if (options->stderr_fd < 0)

return NULL;

}

return options;

}

void lxc_attach_free_options(lxc_attach_options_t *options)

{

int i;

if (!options)

return;

if (options->initial_cwd)

free(options->initial_cwd);

if (options->extra_env_vars) {

for (i = 0; options->extra_env_vars[i]; i++)

free(options->extra_env_vars[i]);

free(options->extra_env_vars);

}

if (options->extra_keep_env) {

for (i = 0; options->extra_keep_env[i]; i++)

free(options->extra_keep_env[i]);

free(options->extra_keep_env);

}

free(options);

}

static PyObject *

Container_attach_and_possibly_wait(Container *self, PyObject *args, PyObject *kwds, int wait)

{

struct lxc_attach_python_payload payload = { NULL, NULL };

lxc_attach_options_t *options = NULL;

long ret;

pid_t pid;

if (!PyArg_ParseTuple(args, "O|O", &payload.fn, &payload.arg))

return NULL;

if (!PyCallable_Check(payload.fn)) {

PyErr_Format(PyExc_TypeError, "attach: object not callable");

return NULL;

}

options = lxc_attach_parse_options(kwds);

if (!options)

return NULL;

ret = self->container->attach(self->container, lxc_attach_python_exec, &payload, options, &pid);

if (ret < 0)

goto out;

if (wait) {

ret = lxc_wait_for_pid_status(pid);

/* handle case where attach fails */

if (WIFEXITED(ret) && WEXITSTATUS(ret) == 255)

ret = -1;

} else {

ret = (long)pid;

}

out:

lxc_attach_free_options(options);

return PyLong_FromLong(ret);

}

static PyObject *

Container_attach(Container *self, PyObject *args, PyObject *kwds)

{

return Container_attach_and_possibly_wait(self, args, kwds, 0);

}

static PyObject *

Container_attach_wait(Container *self, PyObject *args, PyObject *kwds)

{

return Container_attach_and_possibly_wait(self, args, kwds, 1);

}

static PyObject *

LXC_attach_run_shell(PyObject *self, PyObject *arg)

{

int rv;

rv = lxc_attach_run_shell(NULL);

return PyLong_FromLong(rv);

}

static PyObject *

LXC_attach_run_command(PyObject *self, PyObject *arg)

{

PyObject *args_obj = NULL;

int i, rv;

lxc_attach_command_t cmd = {

NULL, /* program */

NULL /* argv[] */

};

if (!PyArg_ParseTuple(arg, "sO", (const char**)&cmd.program, &args_obj))

return NULL;

if (args_obj && PyList_Check(args_obj)) {

cmd.argv = convert_tuple_to_char_pointer_array(args_obj);

} else {

PyErr_Format(PyExc_TypeError, "Second part of tuple passed to attach_run_command must be a list.");

return NULL;

}

if (!cmd.argv)

return NULL;

rv = lxc_attach_run_command(&cmd);

for (i = 0; cmd.argv[i]; i++)

free(cmd.argv[i]);

free(cmd.argv);

return PyLong_FromLong(rv);

}

static PyGetSetDef Container_getseters[] = {

{"config_file_name",

(getter)Container_config_file_name, NULL,

"Path to the container configuration",

NULL},

{"defined",

(getter)Container_defined, NULL,

"Boolean indicating whether the container configuration exists",

NULL},

{"init_pid",

(getter)Container_init_pid, NULL,

"PID of the container's init process in the host's PID namespace",

NULL},

{"name",

(getter)Container_name, NULL,

"Container name",

NULL},

{"running",

(getter)Container_running, NULL,

"Boolean indicating whether the container is running or not",

NULL},

{"state",

(getter)Container_state, NULL,

"Container state",

NULL},

{NULL, NULL, NULL, NULL, NULL}

};

static PyMethodDef Container_methods[] = {

{"clear_config_item", (PyCFunction)Container_clear_config_item,

METH_VARARGS|METH_KEYWORDS,

"clear_config_item(key) -> boolean\n"

"\n"

"Clear the current value of a config key."

},

{"create", (PyCFunction)Container_create,

METH_VARARGS|METH_KEYWORDS,

"create(template, args = (,)) -> boolean\n"

"\n"

"Create a new rootfs for the container, using the given template "

"and passing some optional arguments to it."

},

{"destroy", (PyCFunction)Container_destroy,

METH_NOARGS,

"destroy() -> boolean\n"

"\n"

"Destroys the container."

},

{"freeze", (PyCFunction)Container_freeze,

METH_NOARGS,

"freeze() -> boolean\n"

"\n"

"Freezes the container and returns its return code."

},

{"get_cgroup_item", (PyCFunction)Container_get_cgroup_item,

METH_VARARGS|METH_KEYWORDS,

"get_cgroup_item(key) -> string\n"

"\n"

"Get the current value of a cgroup entry."

},

{"get_config_item", (PyCFunction)Container_get_config_item,

METH_VARARGS|METH_KEYWORDS,

"get_config_item(key) -> string\n"

"\n"

"Get the current value of a config key."

},

{"get_config_path", (PyCFunction)Container_get_config_path,

METH_NOARGS,

"get_config_path() -> string\n"

"\n"

"Return the LXC config path (where the containers are stored)."

},

{"get_keys", (PyCFunction)Container_get_keys,

METH_VARARGS|METH_KEYWORDS,

"get_keys(key) -> string\n"

"\n"

"Get a list of valid sub-keys for a key."

},

{"get_ips", (PyCFunction)Container_get_ips,

METH_VARARGS|METH_KEYWORDS,

"get_ips(interface, family, scope) -> tuple\n"

"\n"

"Get a tuple of IPs for the container."

},

{"load_config", (PyCFunction)Container_load_config,

METH_VARARGS|METH_KEYWORDS,

"load_config(path = DEFAULT) -> boolean\n"

"\n"

"Read the container configuration from its default "

"location or from an alternative location if provided."

},

{"save_config", (PyCFunction)Container_save_config,

METH_VARARGS|METH_KEYWORDS,

"save_config(path = DEFAULT) -> boolean\n"

"\n"

"Save the container configuration to its default "

"location or to an alternative location if provided."

},

{"set_cgroup_item", (PyCFunction)Container_set_cgroup_item,

METH_VARARGS|METH_KEYWORDS,

"set_cgroup_item(key, value) -> boolean\n"

"\n"

"Set a cgroup entry to the provided value."

},

{"set_config_item", (PyCFunction)Container_set_config_item,

METH_VARARGS|METH_KEYWORDS,

"set_config_item(key, value) -> boolean\n"

"\n"

"Set a config key to the provided value."

},

{"set_config_path", (PyCFunction)Container_set_config_path,

METH_VARARGS|METH_KEYWORDS,

"set_config_path(path) -> boolean\n"

"\n"

"Set the LXC config path (where the containers are stored)."

},

{"shutdown", (PyCFunction)Container_shutdown,

METH_VARARGS|METH_KEYWORDS,

"shutdown(timeout = -1) -> boolean\n"

"\n"

"Sends SIGPWR to the container and wait for it to shutdown "

"unless timeout is set to a positive value, in which case "

"the container will be killed when the timeout is reached."

},

{"start", (PyCFunction)Container_start,

METH_VARARGS|METH_KEYWORDS,

"start(useinit = False, cmd = (,)) -> boolean\n"

"\n"

"Start the container, optionally using lxc-init and "

"an alternate init command, then returns its return code."

},

{"stop", (PyCFunction)Container_stop,

METH_NOARGS,

"stop() -> boolean\n"

"\n"

"Stop the container and returns its return code."

},

{"unfreeze", (PyCFunction)Container_unfreeze,

METH_NOARGS,

"unfreeze() -> boolean\n"

"\n"

"Unfreezes the container and returns its return code."

},

{"wait", (PyCFunction)Container_wait,

METH_VARARGS|METH_KEYWORDS,

"wait(state, timeout = -1) -> boolean\n"

"\n"

"Wait for the container to reach a given state or timeout."

},

{"console", (PyCFunction)Container_console,

METH_VARARGS|METH_KEYWORDS,

"console(ttynum = -1, stdinfd = 0, stdoutfd = 1, stderrfd = 2, escape = 0) -> boolean\n"

"\n"

"Attach to container's console."

},

{"console_getfd", (PyCFunction)Container_console_getfd,

METH_VARARGS|METH_KEYWORDS,

"console(ttynum = -1) -> boolean\n"

"\n"

"Attach to container's console."

},

{"attach", (PyCFunction)Container_attach,

METH_VARARGS|METH_KEYWORDS,

"attach(run, payload) -> int\n"

"\n"

"Attach to the container. Returns the pid of the attached process."

},

{"attach_wait", (PyCFunction)Container_attach_wait,

METH_VARARGS|METH_KEYWORDS,

"attach(run, payload) -> int\n"

"\n"

"Attach to the container. Returns the exit code of the process."

},

{NULL, NULL, 0, NULL}

};

static PyTypeObject _lxc_ContainerType = {

PyVarObject_HEAD_INIT(NULL, 0)

"lxc.Container", /* tp_name */

sizeof(Container), /* tp_basicsize */

0, /* tp_itemsize */

(destructor)Container_dealloc, /* tp_dealloc */

0, /* tp_print */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_reserved */

0, /* tp_repr */

0, /* tp_as_number */

0, /* tp_as_sequence */

0, /* tp_as_mapping */

0, /* tp_hash */

0, /* tp_call */

0, /* tp_str */

0, /* tp_getattro */

0, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT |

Py_TPFLAGS_BASETYPE, /* tp_flags */

"Container objects", /* tp_doc */

0, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

Container_methods, /* tp_methods */

0, /* tp_members */

Container_getseters, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

0, /* tp_descr_get */

0, /* tp_descr_set */

0, /* tp_dictoffset */

(initproc)Container_init, /* tp_init */

0, /* tp_alloc */

Container_new, /* tp_new */

};

static PyMethodDef LXC_methods[] = {

{"attach_run_shell", (PyCFunction)LXC_attach_run_shell, METH_O,

"Starts up a shell when attaching, to use as the run parameter for attach or attach_wait"},

{"attach_run_command", (PyCFunction)LXC_attach_run_command, METH_O,

"Runs a command when attaching, to use as the run parameter for attach or attach_wait"},

{"get_default_config_path", (PyCFunction)LXC_get_default_config_path, METH_NOARGS,

"Returns the current LXC config path"},

{"get_version", (PyCFunction)LXC_get_version, METH_NOARGS,

"Returns the current LXC library version"},

{NULL, NULL, 0, NULL}

};

static PyModuleDef _lxcmodule = {

PyModuleDef_HEAD_INIT,

"_lxc",

"Binding for liblxc in python",

-1,

LXC_methods

};

PyInit__lxc(void)

{

PyObject* m;

PyObject* d;

if (PyType_Ready(&_lxc_ContainerType) < 0)

return NULL;

m = PyModule_Create(&_lxcmodule);

if (m == NULL)

return NULL;

Py_INCREF(&_lxc_ContainerType);

PyModule_AddObject(m, "Container", (PyObject *)&_lxc_ContainerType);

/* add constants */

d = PyModule_GetDict(m);

PyDict_SetItemString(d, "LXC_ATTACH_KEEP_ENV", PyLong_FromLong(LXC_ATTACH_KEEP_ENV));

PyDict_SetItemString(d, "LXC_ATTACH_CLEAR_ENV", PyLong_FromLong(LXC_ATTACH_CLEAR_ENV));

PyDict_SetItemString(d, "LXC_ATTACH_MOVE_TO_CGROUP", PyLong_FromLong(LXC_ATTACH_MOVE_TO_CGROUP));

PyDict_SetItemString(d, "LXC_ATTACH_DROP_CAPABILITIES", PyLong_FromLong(LXC_ATTACH_DROP_CAPABILITIES));

PyDict_SetItemString(d, "LXC_ATTACH_SET_PERSONALITY", PyLong_FromLong(LXC_ATTACH_SET_PERSONALITY));

PyDict_SetItemString(d, "LXC_ATTACH_APPARMOR", PyLong_FromLong(LXC_ATTACH_APPARMOR));

PyDict_SetItemString(d, "LXC_ATTACH_REMOUNT_PROC_SYS", PyLong_FromLong(LXC_ATTACH_REMOUNT_PROC_SYS));

PyDict_SetItemString(d, "LXC_ATTACH_DEFAULT", PyLong_FromLong(LXC_ATTACH_DEFAULT));

return m;

}