From 87afc3aee1ea593069322a49355dd8780d99e123 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 28 Dec 2012 15:37:14 +0100 Subject: Move python modules from source4/scripting/python/ to python/. Reviewed-by: Andrew Bartlett Autobuild-User(master): Andrew Bartlett Autobuild-Date(master): Sat Mar 2 03:57:34 CET 2013 on sn-devel-104 --- python/pyglue.c | 250 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 250 insertions(+) create mode 100644 python/pyglue.c (limited to 'python/pyglue.c') diff --git a/python/pyglue.c b/python/pyglue.c new file mode 100644 index 0000000000..735f03a1e1 --- /dev/null +++ b/python/pyglue.c @@ -0,0 +1,250 @@ +/* + Unix SMB/CIFS implementation. + Copyright (C) Jelmer Vernooij 2007 + Copyright (C) Matthias Dieter Wallnöfer 2009 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include +#include "includes.h" +#include "version.h" +#include "param/pyparam.h" +#include "lib/socket/netif.h" + +void init_glue(void); + +#ifndef Py_RETURN_NONE +#define Py_RETURN_NONE return Py_INCREF(Py_None), Py_None +#endif + +static PyObject *py_generate_random_str(PyObject *self, PyObject *args) +{ + int len; + PyObject *ret; + char *retstr; + if (!PyArg_ParseTuple(args, "i", &len)) + return NULL; + + retstr = generate_random_str(NULL, len); + ret = PyString_FromString(retstr); + talloc_free(retstr); + return ret; +} + +static PyObject *py_generate_random_password(PyObject *self, PyObject *args) +{ + int min, max; + PyObject *ret; + char *retstr; + if (!PyArg_ParseTuple(args, "ii", &min, &max)) + return NULL; + + retstr = generate_random_password(NULL, min, max); + if (retstr == NULL) { + return NULL; + } + ret = PyString_FromString(retstr); + talloc_free(retstr); + return ret; +} + +static PyObject *py_unix2nttime(PyObject *self, PyObject *args) +{ + time_t t; + unsigned int _t; + NTTIME nt; + + if (!PyArg_ParseTuple(args, "I", &_t)) { + return NULL; + } + t = _t; + + unix_to_nt_time(&nt, t); + + return PyLong_FromLongLong((uint64_t)nt); +} + +static PyObject *py_nttime2unix(PyObject *self, PyObject *args) +{ + time_t t; + NTTIME nt; + if (!PyArg_ParseTuple(args, "K", &nt)) + return NULL; + + t = nt_time_to_unix(nt); + + return PyInt_FromLong((uint64_t)t); +} + +static PyObject *py_nttime2string(PyObject *self, PyObject *args) +{ + PyObject *ret; + NTTIME nt; + TALLOC_CTX *tmp_ctx; + const char *string; + if (!PyArg_ParseTuple(args, "K", &nt)) + return NULL; + + tmp_ctx = talloc_new(NULL); + if (tmp_ctx == NULL) { + PyErr_NoMemory(); + return NULL; + } + + string = nt_time_string(tmp_ctx, nt); + ret = PyString_FromString(string); + + talloc_free(tmp_ctx); + + return ret; +} + +static PyObject *py_set_debug_level(PyObject *self, PyObject *args) +{ + unsigned level; + if (!PyArg_ParseTuple(args, "I", &level)) + return NULL; + (DEBUGLEVEL) = level; + Py_RETURN_NONE; +} + +static PyObject *py_get_debug_level(PyObject *self) +{ + return PyInt_FromLong(DEBUGLEVEL); +} + +/* + return the list of interface IPs we have configured + takes an loadparm context, returns a list of IPs in string form + + Does not return addresses on 127.0.0.0/8 + */ +static PyObject *py_interface_ips(PyObject *self, PyObject *args) +{ + PyObject *pylist; + int count; + TALLOC_CTX *tmp_ctx; + PyObject *py_lp_ctx; + struct loadparm_context *lp_ctx; + struct interface *ifaces; + int i, ifcount; + int all_interfaces = 1; + + if (!PyArg_ParseTuple(args, "O|i", &py_lp_ctx, &all_interfaces)) + return NULL; + + tmp_ctx = talloc_new(NULL); + if (tmp_ctx == NULL) { + PyErr_NoMemory(); + return NULL; + } + + lp_ctx = lpcfg_from_py_object(tmp_ctx, py_lp_ctx); + if (lp_ctx == NULL) { + talloc_free(tmp_ctx); + return NULL; + } + + load_interface_list(tmp_ctx, lp_ctx, &ifaces); + + count = iface_list_count(ifaces); + + /* first count how many are not loopback addresses */ + for (ifcount = i = 0; i string\n" + "Generate random string with specified length." }, + { "generate_random_password", (PyCFunction)py_generate_random_password, + METH_VARARGS, "generate_random_password(min, max) -> string\n" + "Generate random password with a length >= min and <= max." }, + { "unix2nttime", (PyCFunction)py_unix2nttime, METH_VARARGS, + "unix2nttime(timestamp) -> nttime" }, + { "nttime2unix", (PyCFunction)py_nttime2unix, METH_VARARGS, + "nttime2unix(nttime) -> timestamp" }, + { "nttime2string", (PyCFunction)py_nttime2string, METH_VARARGS, + "nttime2string(nttime) -> string" }, + { "set_debug_level", (PyCFunction)py_set_debug_level, METH_VARARGS, + "set debug level" }, + { "get_debug_level", (PyCFunction)py_get_debug_level, METH_NOARGS, + "get debug level" }, + { "interface_ips", (PyCFunction)py_interface_ips, METH_VARARGS, + "interface_ips(lp_ctx[, all_interfaces) -> list_of_ifaces\n" + "\n" + "get interface IP address list"}, + { "strcasecmp_m", (PyCFunction)py_strcasecmp_m, METH_VARARGS, + "(for testing) compare two strings using Samba's strcasecmp_m()"}, + { "strstr_m", (PyCFunction)py_strstr_m, METH_VARARGS, + "(for testing) find one string in another with Samba's strstr_m()"}, + { NULL } +}; + +void init_glue(void) +{ + PyObject *m; + + debug_setup_talloc_log(); + + m = Py_InitModule3("_glue", py_misc_methods, + "Python bindings for miscellaneous Samba functions."); + if (m == NULL) + return; + + PyModule_AddObject(m, "version", + PyString_FromString(SAMBA_VERSION_STRING)); +} + -- cgit