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