Move python modules from source4/scripting/python/ to python/.
[bbaumbach/samba-autobuild/.git] / python / pyglue.c
1 /* 
2    Unix SMB/CIFS implementation.
3    Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2007
4    Copyright (C) Matthias Dieter Wallnöfer          2009
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 "version.h"
23 #include "param/pyparam.h"
24 #include "lib/socket/netif.h"
25
26 void init_glue(void);
27
28 #ifndef Py_RETURN_NONE
29 #define Py_RETURN_NONE return Py_INCREF(Py_None), Py_None
30 #endif
31
32 static PyObject *py_generate_random_str(PyObject *self, PyObject *args)
33 {
34         int len;
35         PyObject *ret;
36         char *retstr;
37         if (!PyArg_ParseTuple(args, "i", &len))
38                 return NULL;
39
40         retstr = generate_random_str(NULL, len);
41         ret = PyString_FromString(retstr);
42         talloc_free(retstr);
43         return ret;
44 }
45
46 static PyObject *py_generate_random_password(PyObject *self, PyObject *args)
47 {
48         int min, max;
49         PyObject *ret;
50         char *retstr;
51         if (!PyArg_ParseTuple(args, "ii", &min, &max))
52                 return NULL;
53
54         retstr = generate_random_password(NULL, min, max);
55         if (retstr == NULL) {
56                 return NULL;
57         }
58         ret = PyString_FromString(retstr);
59         talloc_free(retstr);
60         return ret;
61 }
62
63 static PyObject *py_unix2nttime(PyObject *self, PyObject *args)
64 {
65         time_t t;
66         unsigned int _t;
67         NTTIME nt;
68
69         if (!PyArg_ParseTuple(args, "I", &_t)) {
70                 return NULL;
71         }
72         t = _t;
73
74         unix_to_nt_time(&nt, t);
75
76         return PyLong_FromLongLong((uint64_t)nt);
77 }
78
79 static PyObject *py_nttime2unix(PyObject *self, PyObject *args)
80 {
81         time_t t;
82         NTTIME nt;
83         if (!PyArg_ParseTuple(args, "K", &nt))
84                 return NULL;
85
86         t = nt_time_to_unix(nt);
87
88         return PyInt_FromLong((uint64_t)t);
89 }
90
91 static PyObject *py_nttime2string(PyObject *self, PyObject *args)
92 {
93         PyObject *ret;
94         NTTIME nt;
95         TALLOC_CTX *tmp_ctx;
96         const char *string;
97         if (!PyArg_ParseTuple(args, "K", &nt))
98                 return NULL;
99
100         tmp_ctx = talloc_new(NULL);
101         if (tmp_ctx == NULL) {
102                 PyErr_NoMemory();
103                 return NULL;
104         }
105
106         string = nt_time_string(tmp_ctx, nt);
107         ret =  PyString_FromString(string);
108
109         talloc_free(tmp_ctx);
110
111         return ret;
112 }
113
114 static PyObject *py_set_debug_level(PyObject *self, PyObject *args)
115 {
116         unsigned level;
117         if (!PyArg_ParseTuple(args, "I", &level))
118                 return NULL;
119         (DEBUGLEVEL) = level;
120         Py_RETURN_NONE;
121 }
122
123 static PyObject *py_get_debug_level(PyObject *self)
124 {
125         return PyInt_FromLong(DEBUGLEVEL);
126 }
127
128 /*
129   return the list of interface IPs we have configured
130   takes an loadparm context, returns a list of IPs in string form
131
132   Does not return addresses on 127.0.0.0/8
133  */
134 static PyObject *py_interface_ips(PyObject *self, PyObject *args)
135 {
136         PyObject *pylist;
137         int count;
138         TALLOC_CTX *tmp_ctx;
139         PyObject *py_lp_ctx;
140         struct loadparm_context *lp_ctx;
141         struct interface *ifaces;
142         int i, ifcount;
143         int all_interfaces = 1;
144
145         if (!PyArg_ParseTuple(args, "O|i", &py_lp_ctx, &all_interfaces))
146                 return NULL;
147
148         tmp_ctx = talloc_new(NULL);
149         if (tmp_ctx == NULL) {
150                 PyErr_NoMemory();
151                 return NULL;
152         }
153
154         lp_ctx = lpcfg_from_py_object(tmp_ctx, py_lp_ctx);
155         if (lp_ctx == NULL) {
156                 talloc_free(tmp_ctx);
157                 return NULL;
158         }
159
160         load_interface_list(tmp_ctx, lp_ctx, &ifaces);
161
162         count = iface_list_count(ifaces);
163
164         /* first count how many are not loopback addresses */
165         for (ifcount = i = 0; i<count; i++) {
166                 const char *ip = iface_list_n_ip(ifaces, i);
167                 if (!(!all_interfaces && iface_list_same_net(ip, "127.0.0.1", "255.0.0.0"))) {
168                         ifcount++;
169                 }
170         }
171
172         pylist = PyList_New(ifcount);
173         for (ifcount = i = 0; i<count; i++) {
174                 const char *ip = iface_list_n_ip(ifaces, i);
175                 if (!(!all_interfaces && iface_list_same_net(ip, "127.0.0.1", "255.0.0.0"))) {
176                         PyList_SetItem(pylist, ifcount, PyString_FromString(ip));
177                         ifcount++;
178                 }
179         }
180         talloc_free(tmp_ctx);
181         return pylist;
182 }
183
184 static PyObject *py_strcasecmp_m(PyObject *self, PyObject *args)
185 {
186         char *s1, *s2;
187
188         if (!PyArg_ParseTuple(args, "ss", &s1, &s2))
189                 return NULL;
190
191         return PyInt_FromLong(strcasecmp_m(s1, s2));
192 }
193
194 static PyObject *py_strstr_m(PyObject *self, PyObject *args)
195 {
196         char *s1, *s2, *ret;
197
198         if (!PyArg_ParseTuple(args, "ss", &s1, &s2))
199                 return NULL;
200
201         ret = strstr_m(s1, s2);
202         if (!ret) {
203                 Py_RETURN_NONE;
204         }
205         return PyString_FromString(ret);
206 }
207
208 static PyMethodDef py_misc_methods[] = {
209         { "generate_random_str", (PyCFunction)py_generate_random_str, METH_VARARGS,
210                 "generate_random_str(len) -> string\n"
211                 "Generate random string with specified length." },
212         { "generate_random_password", (PyCFunction)py_generate_random_password,
213                 METH_VARARGS, "generate_random_password(min, max) -> string\n"
214                 "Generate random password with a length >= min and <= max." },
215         { "unix2nttime", (PyCFunction)py_unix2nttime, METH_VARARGS,
216                 "unix2nttime(timestamp) -> nttime" },
217         { "nttime2unix", (PyCFunction)py_nttime2unix, METH_VARARGS,
218                 "nttime2unix(nttime) -> timestamp" },
219         { "nttime2string", (PyCFunction)py_nttime2string, METH_VARARGS,
220                 "nttime2string(nttime) -> string" },
221         { "set_debug_level", (PyCFunction)py_set_debug_level, METH_VARARGS,
222                 "set debug level" },
223         { "get_debug_level", (PyCFunction)py_get_debug_level, METH_NOARGS,
224                 "get debug level" },
225         { "interface_ips", (PyCFunction)py_interface_ips, METH_VARARGS,
226                 "interface_ips(lp_ctx[, all_interfaces) -> list_of_ifaces\n"
227                 "\n"
228                 "get interface IP address list"},
229         { "strcasecmp_m", (PyCFunction)py_strcasecmp_m, METH_VARARGS,
230                 "(for testing) compare two strings using Samba's strcasecmp_m()"},
231         { "strstr_m", (PyCFunction)py_strstr_m, METH_VARARGS,
232                 "(for testing) find one string in another with Samba's strstr_m()"},
233         { NULL }
234 };
235
236 void init_glue(void)
237 {
238         PyObject *m;
239
240         debug_setup_talloc_log();
241
242         m = Py_InitModule3("_glue", py_misc_methods, 
243                            "Python bindings for miscellaneous Samba functions.");
244         if (m == NULL)
245                 return;
246
247         PyModule_AddObject(m, "version",
248                                            PyString_FromString(SAMBA_VERSION_STRING));
249 }
250