source4/lib/policy/pypolicy.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  Python bindings for libpolicy
   4  *  Copyright (C) Jelmer Vernooij 2010
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 3 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "lib/replace/system/python.h"
  21 #include "includes.h"
  22 #include "python/py3compat.h"
  23 #include "policy.h"
  24 #include "libcli/util/pyerrors.h"
  25
  26 void initpolicy(void);
  27
  28 static PyObject *py_get_gpo_flags(PyObject *self, PyObject *args)
  29 {
  30         int flags;
  31         PyObject *py_ret;
  32         const char **ret;
  33         TALLOC_CTX *mem_ctx;
  34         int i;
  35         NTSTATUS status;
  36
  37         if (!PyArg_ParseTuple(args, "i", &flags))
  38                 return NULL;
  39
  40         mem_ctx = talloc_new(NULL);
  41         if (mem_ctx == NULL) {
  42                 PyErr_NoMemory();
  43                 return NULL;
  44         }
  45
  46         status = gp_get_gpo_flags(mem_ctx, flags, &ret);
  47         if (!NT_STATUS_IS_OK(status)) {
  48                 PyErr_SetNTSTATUS(status);
  49                 talloc_free(mem_ctx);
  50                 return NULL;
  51         }
  52
  53         py_ret = PyList_New(0);
  54         for (i = 0; ret[i]; i++) {
  55                 int res = 0;
  56                 PyObject *item = PyUnicode_FromString(ret[i]);
  57                 if (item == NULL) {
  58                         talloc_free(mem_ctx);
  59                         Py_DECREF(py_ret);
  60                         PyErr_NoMemory();
  61                         return NULL;
  62                 }
  63                 res = PyList_Append(py_ret, item);
  64                 Py_CLEAR(item);
  65                 if (res == -1) {
  66                         Py_DECREF(py_ret);
  67                         talloc_free(mem_ctx);
  68                         return NULL;
  69                 }
  70         }
  71
  72         talloc_free(mem_ctx);
  73
  74         return py_ret;
  75 }
  76
  77 static PyObject *py_get_gplink_options(PyObject *self, PyObject *args)
  78 {
  79         int flags;
  80         PyObject *py_ret;
  81         const char **ret;
  82         TALLOC_CTX *mem_ctx;
  83         int i;
  84         NTSTATUS status;
  85
  86         if (!PyArg_ParseTuple(args, "i", &flags))
  87                 return NULL;
  88
  89         mem_ctx = talloc_new(NULL);
  90         if (mem_ctx == NULL) {
  91                 PyErr_NoMemory();
  92                 return NULL;
  93         }
  94
  95         status = gp_get_gplink_options(mem_ctx, flags, &ret);
  96         if (!NT_STATUS_IS_OK(status)) {
  97                 PyErr_SetNTSTATUS(status);
  98                 talloc_free(mem_ctx);
  99                 return NULL;
 100         }
 101
 102         py_ret = PyList_New(0);
 103         for (i = 0; ret[i]; i++) {
 104                 int res = 0;
 105                 PyObject *item = PyUnicode_FromString(ret[i]);
 106                 if (item == NULL) {
 107                         talloc_free(mem_ctx);
 108                         Py_DECREF(py_ret);
 109                         PyErr_NoMemory();
 110                         return NULL;
 111                 }
 112                 res = PyList_Append(py_ret, item);
 113                 Py_CLEAR(item);
 114                 if (res == -1) {
 115                         Py_DECREF(py_ret);
 116                         talloc_free(mem_ctx);
 117                         return NULL;
 118                 }
 119         }
 120
 121         talloc_free(mem_ctx);
 122
 123         return py_ret;
 124 }
 125
 126 static PyObject *py_ads_to_dir_access_mask(PyObject *self, PyObject *args)
 127 {
 128         uint32_t access_mask, dir_mask;
 129
 130         if (! PyArg_ParseTuple(args, "I", &access_mask))
 131                 return NULL;
 132
 133         dir_mask = gp_ads_to_dir_access_mask(access_mask);
 134
 135         return Py_BuildValue("I", dir_mask);
 136 }
 137
 138
 139 static PyMethodDef py_policy_methods[] = {
 140         { "get_gpo_flags", (PyCFunction)py_get_gpo_flags, METH_VARARGS,
 141                 "get_gpo_flags(flags) -> list" },
 142         { "get_gplink_options", (PyCFunction)py_get_gplink_options, METH_VARARGS,
 143                 "get_gplink_options(options) -> list" },
 144         { "ads_to_dir_access_mask", (PyCFunction)py_ads_to_dir_access_mask, METH_VARARGS,
 145                 "ads_to_dir_access_mask(access_mask) -> dir_mask" },
 146         {0}
 147 };
 148
 149 static struct PyModuleDef moduledef = {
 150     PyModuleDef_HEAD_INIT,
 151     .m_name = "policy",
 152     .m_doc = "(Group) Policy manipulation",
 153     .m_size = -1,
 154     .m_methods = py_policy_methods,
 155 };
 156
 157 MODULE_INIT_FUNC(policy)
 158 {
 159         PyObject *m = NULL;
 160
 161         m = PyModule_Create(&moduledef);
 162         if (!m)
 163                 return m;
 164
 165         PyModule_AddObject(m, "GPO_FLAG_USER_DISABLE",
 166                                            PyLong_FromLong(GPO_FLAG_USER_DISABLE));
 167         PyModule_AddObject(m, "GPO_MACHINE_USER_DISABLE",
 168                                            PyLong_FromLong(GPO_FLAG_MACHINE_DISABLE));
 169         PyModule_AddObject(m, "GPLINK_OPT_DISABLE",
 170                                            PyLong_FromLong(GPLINK_OPT_DISABLE ));
 171         PyModule_AddObject(m, "GPLINK_OPT_ENFORCE ",
 172                                            PyLong_FromLong(GPLINK_OPT_ENFORCE ));
 173         return m;
 174 }