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 <Python.h>
  21 #include "includes.h"
  22 #include "policy.h"
  23 #include "libcli/util/pyerrors.h"
  24
  25 static PyObject *py_get_gpo_flags(PyObject *self, PyObject *args)
  26 {
  27         int flags;
  28         PyObject *py_ret;
  29         const char **ret;
  30         TALLOC_CTX *mem_ctx;
  31         int i;
  32         NTSTATUS status;
  33
  34         if (!PyArg_ParseTuple(args, "i", &flags))
  35                 return NULL;
  36
  37         mem_ctx = talloc_new(NULL);
  38         if (mem_ctx == NULL) {
  39                 PyErr_NoMemory();
  40                 return NULL;
  41         }
  42
  43         status = gp_get_gpo_flags(mem_ctx, flags, &ret);
  44         if (!NT_STATUS_IS_OK(status)) {
  45                 PyErr_SetNTSTATUS(status);
  46                 talloc_free(mem_ctx);
  47                 return NULL;
  48         }
  49
  50         py_ret = PyList_New(0);
  51         for (i = 0; ret[i]; i++) {
  52                 PyObject *item = PyString_FromString(ret[i]);
  53                 if (item == NULL) {
  54                         talloc_free(mem_ctx);
  55                         Py_DECREF(py_ret);
  56                         PyErr_NoMemory();
  57                         return NULL;
  58                 }
  59                 PyList_Append(py_ret, item);
  60         }
  61
  62         talloc_free(mem_ctx);
  63
  64         return py_ret;
  65 }
  66
  67 static PyObject *py_get_gplink_options(PyObject *self, PyObject *args)
  68 {
  69         int flags;
  70         PyObject *py_ret;
  71         const char **ret;
  72         TALLOC_CTX *mem_ctx;
  73         int i;
  74         NTSTATUS status;
  75
  76         if (!PyArg_ParseTuple(args, "i", &flags))
  77                 return NULL;
  78
  79         mem_ctx = talloc_new(NULL);
  80         if (mem_ctx == NULL) {
  81                 PyErr_NoMemory();
  82                 return NULL;
  83         }
  84
  85         status = gp_get_gplink_options(mem_ctx, flags, &ret);
  86         if (!NT_STATUS_IS_OK(status)) {
  87                 PyErr_SetNTSTATUS(status);
  88                 talloc_free(mem_ctx);
  89                 return NULL;
  90         }
  91
  92         py_ret = PyList_New(0);
  93         for (i = 0; ret[i]; i++) {
  94                 PyObject *item = PyString_FromString(ret[i]);
  95                 if (item == NULL) {
  96                         talloc_free(mem_ctx);
  97                         Py_DECREF(py_ret);
  98                         PyErr_NoMemory();
  99                         return NULL;
 100                 }
 101                 PyList_Append(py_ret, item);
 102         }
 103
 104         talloc_free(mem_ctx);
 105
 106         return py_ret;
 107 }
 108
 109 static PyMethodDef py_policy_methods[] = {
 110         { "get_gpo_flags", (PyCFunction)py_get_gpo_flags, METH_VARARGS,
 111                 "get_gpo_flags(flags) -> list" },
 112     { "get_gplink_options", (PyCFunction)py_get_gplink_options, METH_VARARGS,
 113         "get_gplink_options(options) -> list" },
 114         { NULL }
 115 };
 116
 117 void initpolicy(void)
 118 {
 119         PyObject *m;
 120
 121         m = Py_InitModule3("policy", py_policy_methods, "(Group) Policy manipulation");
 122         if (!m)
 123                 return;
 124
 125         PyModule_AddObject(m, "GPO_FLAG_USER_DISABLE",
 126                                            PyInt_FromLong(GPO_FLAG_USER_DISABLE));
 127         PyModule_AddObject(m, "GPO_MACHINE_USER_DISABLE",
 128                                            PyInt_FromLong(GPO_FLAG_MACHINE_DISABLE));
 129         PyModule_AddObject(m, "GPLINK_OPT_DISABLE",
 130                                            PyInt_FromLong(GPLINK_OPT_DISABLE ));
 131         PyModule_AddObject(m, "GPLINK_OPT_ENFORCE ",
 132                                            PyInt_FromLong(GPLINK_OPT_ENFORCE ));
 133 }