Line data Source code
1 : /*
2 : Unix SMB/CIFS implementation.
3 : Samba utility functions
4 : Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2007-2008
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 "python/py3compat.h"
22 : #include "includes.h"
23 : #include "param/param.h"
24 : #include "param/loadparm.h"
25 : #include <pytalloc.h>
26 : #include "dynconfig/dynconfig.h"
27 :
28 : #define PyLoadparmContext_AsLoadparmContext(obj) pytalloc_get_type(obj, struct loadparm_context)
29 : #define PyLoadparmService_AsLoadparmService(obj) pytalloc_get_type(obj, struct loadparm_service)
30 :
31 : extern PyTypeObject PyLoadparmContext;
32 : extern PyTypeObject PyLoadparmService;
33 :
34 0 : static PyObject *PyLoadparmService_FromService(struct loadparm_service *service)
35 : {
36 0 : return pytalloc_reference(&PyLoadparmService, service);
37 : }
38 :
39 47382 : static PyObject *py_lp_ctx_get_helper(struct loadparm_context *lp_ctx, const char *service_name, const char *param_name)
40 : {
41 47382 : struct parm_struct *parm = NULL;
42 47382 : void *parm_ptr = NULL;
43 : int i;
44 :
45 50911 : if (service_name != NULL && strwicmp(service_name, GLOBAL_NAME) &&
46 7038 : strwicmp(service_name, GLOBAL_NAME2)) {
47 : struct loadparm_service *service;
48 : /* its a share parameter */
49 3529 : service = lpcfg_service(lp_ctx, service_name);
50 3529 : if (service == NULL) {
51 20 : return NULL;
52 : }
53 3509 : if (strchr(param_name, ':')) {
54 : /* its a parametric option on a share */
55 0 : const char *type = talloc_strndup(lp_ctx, param_name,
56 : strcspn(param_name, ":"));
57 0 : const char *option = strchr(param_name, ':') + 1;
58 : const char *value;
59 0 : if (type == NULL || option == NULL) {
60 0 : return NULL;
61 : }
62 0 : value = lpcfg_get_parametric(lp_ctx, service, type, option);
63 0 : if (value == NULL) {
64 0 : return NULL;
65 : }
66 0 : return PyUnicode_FromString(value);
67 : }
68 :
69 3509 : parm = lpcfg_parm_struct(lp_ctx, param_name);
70 3509 : if (parm == NULL || parm->p_class == P_GLOBAL) {
71 0 : return NULL;
72 : }
73 3509 : parm_ptr = lpcfg_parm_ptr(lp_ctx, service, parm);
74 43853 : } else if (strchr(param_name, ':')) {
75 : /* its a global parametric option */
76 25062 : const char *type = talloc_strndup(lp_ctx,
77 : param_name, strcspn(param_name, ":"));
78 25062 : const char *option = strchr(param_name, ':') + 1;
79 : const char *value;
80 25062 : if (type == NULL || option == NULL) {
81 0 : return NULL;
82 : }
83 25062 : value = lpcfg_get_parametric(lp_ctx, NULL, type, option);
84 25062 : if (value == NULL)
85 1031 : return NULL;
86 24031 : return PyUnicode_FromString(value);
87 : } else {
88 : /* its a global parameter */
89 18791 : parm = lpcfg_parm_struct(lp_ctx, param_name);
90 18791 : if (parm == NULL) {
91 0 : return NULL;
92 : }
93 18791 : parm_ptr = lpcfg_parm_ptr(lp_ctx, NULL, parm);
94 : }
95 :
96 22300 : if (parm == NULL || parm_ptr == NULL) {
97 0 : return NULL;
98 : }
99 :
100 : /* construct and return the right type of python object */
101 22300 : switch (parm->type) {
102 0 : case P_CHAR:
103 0 : return PyUnicode_FromFormat("%c", *(char *)parm_ptr);
104 13991 : case P_STRING:
105 : case P_USTRING:
106 13991 : return PyUnicode_FromString(*(char **)parm_ptr);
107 113 : case P_BOOL:
108 113 : return PyBool_FromLong(*(bool *)parm_ptr);
109 0 : case P_BOOLREV:
110 0 : return PyBool_FromLong(!(*(bool *)parm_ptr));
111 2746 : case P_INTEGER:
112 : case P_OCTAL:
113 : case P_BYTES:
114 2746 : return PyLong_FromLong(*(int *)parm_ptr);
115 2192 : case P_ENUM:
116 4247 : for (i=0; parm->enum_list[i].name; i++) {
117 4247 : if (*(int *)parm_ptr == parm->enum_list[i].value) {
118 2192 : return PyUnicode_FromString(parm->enum_list[i].name);
119 : }
120 : }
121 0 : return NULL;
122 3258 : case P_CMDLIST:
123 : case P_LIST:
124 : {
125 : int j;
126 3258 : const char **strlist = *(const char ***)parm_ptr;
127 : PyObject *pylist;
128 :
129 3258 : if(strlist == NULL) {
130 2984 : return PyList_New(0);
131 : }
132 :
133 274 : pylist = PyList_New(str_list_length(strlist));
134 1863 : for (j = 0; strlist[j]; j++)
135 1589 : PyList_SetItem(pylist, j,
136 1589 : PyUnicode_FromString(strlist[j]));
137 274 : return pylist;
138 : }
139 : }
140 0 : return NULL;
141 :
142 : }
143 :
144 16897 : static PyObject *py_lp_ctx_load(PyObject *self, PyObject *args)
145 : {
146 : char *filename;
147 : bool ret;
148 16897 : if (!PyArg_ParseTuple(args, "s", &filename))
149 0 : return NULL;
150 :
151 16897 : ret = lpcfg_load(PyLoadparmContext_AsLoadparmContext(self), filename);
152 :
153 16897 : if (!ret) {
154 0 : PyErr_Format(PyExc_RuntimeError, "Unable to load file %s", filename);
155 0 : return NULL;
156 : }
157 16897 : Py_RETURN_NONE;
158 : }
159 :
160 3 : static PyObject *py_lp_ctx_load_default(PyObject *self, PyObject *unused)
161 : {
162 : bool ret;
163 3 : ret = lpcfg_load_default(PyLoadparmContext_AsLoadparmContext(self));
164 :
165 3 : if (!ret) {
166 0 : PyErr_SetString(PyExc_RuntimeError, "Unable to load default file");
167 0 : return NULL;
168 : }
169 3 : Py_RETURN_NONE;
170 : }
171 :
172 47382 : static PyObject *py_lp_ctx_get(PyObject *self, PyObject *args)
173 : {
174 : char *param_name;
175 47382 : char *section_name = NULL;
176 : PyObject *ret;
177 47382 : if (!PyArg_ParseTuple(args, "s|z", ¶m_name, §ion_name))
178 0 : return NULL;
179 :
180 47382 : ret = py_lp_ctx_get_helper(PyLoadparmContext_AsLoadparmContext(self), section_name, param_name);
181 47382 : if (ret == NULL)
182 1051 : Py_RETURN_NONE;
183 46331 : return ret;
184 : }
185 :
186 0 : static PyObject *py_lp_ctx_is_myname(PyObject *self, PyObject *args)
187 : {
188 : char *name;
189 0 : if (!PyArg_ParseTuple(args, "s", &name))
190 0 : return NULL;
191 :
192 0 : return PyBool_FromLong(lpcfg_is_myname(PyLoadparmContext_AsLoadparmContext(self), name));
193 : }
194 :
195 0 : static PyObject *py_lp_ctx_is_mydomain(PyObject *self, PyObject *args)
196 : {
197 : char *name;
198 0 : if (!PyArg_ParseTuple(args, "s", &name))
199 0 : return NULL;
200 :
201 0 : return PyBool_FromLong(lpcfg_is_mydomain(PyLoadparmContext_AsLoadparmContext(self), name));
202 : }
203 :
204 2966 : static PyObject *py_lp_ctx_set(PyObject *self, PyObject *args)
205 : {
206 : char *name, *value;
207 : bool ret;
208 2966 : if (!PyArg_ParseTuple(args, "ss", &name, &value))
209 0 : return NULL;
210 :
211 2966 : ret = lpcfg_set_cmdline(PyLoadparmContext_AsLoadparmContext(self), name, value);
212 2966 : if (!ret) {
213 2 : PyErr_SetString(PyExc_RuntimeError, "Unable to set parameter");
214 2 : return NULL;
215 : }
216 :
217 2964 : Py_RETURN_NONE;
218 : }
219 :
220 22128 : static PyObject *py_lp_ctx_private_path(PyObject *self, PyObject *args)
221 : {
222 : char *name, *path;
223 : PyObject *ret;
224 22128 : if (!PyArg_ParseTuple(args, "s", &name))
225 0 : return NULL;
226 :
227 22128 : path = lpcfg_private_path(NULL, PyLoadparmContext_AsLoadparmContext(self), name);
228 22128 : ret = PyUnicode_FromString(path);
229 22128 : talloc_free(path);
230 :
231 22128 : return ret;
232 : }
233 :
234 212 : static PyObject *py_lp_ctx_services(PyObject *self, PyObject *unused)
235 : {
236 212 : struct loadparm_context *lp_ctx = PyLoadparmContext_AsLoadparmContext(self);
237 : PyObject *ret;
238 : int i;
239 212 : ret = PyList_New(lpcfg_numservices(lp_ctx));
240 3196 : for (i = 0; i < lpcfg_numservices(lp_ctx); i++) {
241 2984 : struct loadparm_service *service = lpcfg_servicebynum(lp_ctx, i);
242 2984 : if (service != NULL) {
243 2984 : PyList_SetItem(ret, i, PyUnicode_FromString(lpcfg_servicename(service)));
244 : }
245 : }
246 212 : return ret;
247 : }
248 :
249 140 : static PyObject *py_lp_ctx_server_role(PyObject *self, PyObject *unused)
250 : {
251 140 : struct loadparm_context *lp_ctx = PyLoadparmContext_AsLoadparmContext(self);
252 : uint32_t role;
253 : const char *role_str;
254 :
255 140 : role = lpcfg_server_role(lp_ctx);
256 140 : role_str = server_role_str(role);
257 :
258 140 : return PyUnicode_FromString(role_str);
259 : }
260 :
261 670 : static PyObject *py_lp_dump(PyObject *self, PyObject *args)
262 : {
263 670 : bool show_defaults = false;
264 670 : const char *file_name = "";
265 670 : const char *mode = "w";
266 : FILE *f;
267 670 : struct loadparm_context *lp_ctx = PyLoadparmContext_AsLoadparmContext(self);
268 :
269 670 : if (!PyArg_ParseTuple(args, "|bss", &show_defaults, &file_name, &mode))
270 0 : return NULL;
271 :
272 670 : if (file_name[0] == '\0') {
273 519 : f = stdout;
274 : } else {
275 151 : f = fopen(file_name, mode);
276 : }
277 :
278 670 : if (f == NULL) {
279 0 : PyErr_SetFromErrno(PyExc_IOError);
280 0 : return NULL;
281 : }
282 :
283 670 : lpcfg_dump(lp_ctx, f, show_defaults, lpcfg_numservices(lp_ctx));
284 :
285 670 : if (f != stdout) {
286 151 : fclose(f);
287 : }
288 :
289 670 : Py_RETURN_NONE;
290 : }
291 :
292 0 : static PyObject *py_lp_dump_globals(PyObject *self, PyObject *args)
293 : {
294 0 : bool show_defaults = false;
295 0 : const char *file_name = "";
296 0 : const char *mode = "w";
297 : FILE *f;
298 0 : struct loadparm_context *lp_ctx = PyLoadparmContext_AsLoadparmContext(self);
299 :
300 0 : if (!PyArg_ParseTuple(args, "|bss", &show_defaults, &file_name, &mode))
301 0 : return NULL;
302 :
303 0 : if (file_name[0] == '\0') {
304 0 : f = stdout;
305 : } else {
306 0 : f = fopen(file_name, mode);
307 : }
308 :
309 0 : if (f == NULL) {
310 0 : PyErr_SetFromErrno(PyExc_IOError);
311 0 : return NULL;
312 : }
313 :
314 0 : lpcfg_dump_globals(lp_ctx, f, show_defaults);
315 :
316 0 : if (f != stdout) {
317 0 : fclose(f);
318 : }
319 :
320 0 : Py_RETURN_NONE;
321 : }
322 :
323 1466 : static PyObject *py_lp_dump_a_parameter(PyObject *self, PyObject *args)
324 : {
325 : char *param_name;
326 1466 : const char *section_name = NULL;
327 1466 : const char *file_name = "";
328 1466 : const char *mode = "w";
329 : FILE *f;
330 1466 : struct loadparm_context *lp_ctx = PyLoadparmContext_AsLoadparmContext(self);
331 : struct loadparm_service *service;
332 : bool ret;
333 :
334 1466 : if (!PyArg_ParseTuple(args, "s|zss", ¶m_name, §ion_name, &file_name, &mode))
335 0 : return NULL;
336 :
337 1466 : if (file_name[0] == '\0') {
338 1466 : f = stdout;
339 : } else {
340 0 : f = fopen(file_name, mode);
341 : }
342 :
343 1466 : if (f == NULL) {
344 0 : return NULL;
345 : }
346 :
347 1862 : if (section_name != NULL && strwicmp(section_name, GLOBAL_NAME) &&
348 396 : strwicmp(section_name, GLOBAL_NAME2)) {
349 : /* it's a share parameter */
350 396 : service = lpcfg_service(lp_ctx, section_name);
351 792 : if (service == NULL) {
352 0 : PyErr_Format(PyExc_RuntimeError, "Unknown section %s", section_name);
353 0 : return NULL;
354 : }
355 : } else {
356 : /* it's global */
357 1070 : service = NULL;
358 1070 : section_name = "global";
359 : }
360 :
361 1466 : ret = lpcfg_dump_a_parameter(lp_ctx, service, param_name, f);
362 :
363 1466 : if (!ret) {
364 0 : PyErr_Format(PyExc_RuntimeError, "Parameter %s unknown for section %s", param_name, section_name);
365 0 : if (f != stdout) {
366 0 : fclose(f);
367 : }
368 0 : return NULL;
369 : }
370 :
371 1466 : if (f != stdout) {
372 0 : fclose(f);
373 : }
374 :
375 1466 : Py_RETURN_NONE;
376 :
377 : }
378 :
379 1476 : static PyObject *py_lp_log_level(PyObject *self, PyObject *unused)
380 : {
381 1476 : int ret = debuglevel_get();
382 1476 : return PyLong_FromLong(ret);
383 : }
384 :
385 :
386 2740 : static PyObject *py_samdb_url(PyObject *self, PyObject *unused)
387 : {
388 2740 : struct loadparm_context *lp_ctx = PyLoadparmContext_AsLoadparmContext(self);
389 2740 : return PyUnicode_FromFormat("tdb://%s/sam.ldb", lpcfg_private_dir(lp_ctx));
390 : }
391 :
392 0 : static PyObject *py_cache_path(PyObject *self, PyObject *args)
393 : {
394 0 : struct loadparm_context *lp_ctx = PyLoadparmContext_AsLoadparmContext(self);
395 0 : char *name = NULL;
396 0 : char *path = NULL;
397 0 : PyObject *ret = NULL;
398 :
399 0 : if (!PyArg_ParseTuple(args, "s", &name)) {
400 0 : return NULL;
401 : }
402 :
403 0 : path = lpcfg_cache_path(NULL, lp_ctx, name);
404 0 : if (!path) {
405 0 : PyErr_Format(PyExc_RuntimeError,
406 : "Unable to access cache %s", name);
407 0 : return NULL;
408 : }
409 0 : ret = PyUnicode_FromString(path);
410 0 : talloc_free(path);
411 :
412 0 : return ret;
413 : }
414 :
415 0 : static PyObject *py_state_path(PyObject *self, PyObject *args)
416 : {
417 0 : struct loadparm_context *lp_ctx =
418 0 : PyLoadparmContext_AsLoadparmContext(self);
419 0 : char *name = NULL;
420 0 : char *path = NULL;
421 0 : PyObject *ret = NULL;
422 :
423 0 : if (!PyArg_ParseTuple(args, "s", &name)) {
424 0 : return NULL;
425 : }
426 :
427 0 : path = lpcfg_state_path(NULL, lp_ctx, name);
428 0 : if (!path) {
429 0 : PyErr_Format(PyExc_RuntimeError,
430 : "Unable to access cache %s", name);
431 0 : return NULL;
432 : }
433 0 : ret = PyUnicode_FromString(path);
434 0 : talloc_free(path);
435 :
436 0 : return ret;
437 : }
438 :
439 : static PyMethodDef py_lp_ctx_methods[] = {
440 : { "load", py_lp_ctx_load, METH_VARARGS,
441 : "S.load(filename) -> None\n"
442 : "Load specified file." },
443 : { "load_default", py_lp_ctx_load_default, METH_NOARGS,
444 : "S.load_default() -> None\n"
445 : "Load default smb.conf file." },
446 : { "is_myname", py_lp_ctx_is_myname, METH_VARARGS,
447 : "S.is_myname(name) -> bool\n"
448 : "Check whether the specified name matches one of our netbios names." },
449 : { "is_mydomain", py_lp_ctx_is_mydomain, METH_VARARGS,
450 : "S.is_mydomain(name) -> bool\n"
451 : "Check whether the specified name matches our domain name." },
452 : { "get", py_lp_ctx_get, METH_VARARGS,
453 : "S.get(name, service_name) -> value\n"
454 : "Find specified parameter." },
455 : { "set", py_lp_ctx_set, METH_VARARGS,
456 : "S.set(name, value) -> bool\n"
457 : "Change a parameter." },
458 : { "private_path", py_lp_ctx_private_path, METH_VARARGS,
459 : "S.private_path(name) -> path\n" },
460 : { "services", py_lp_ctx_services, METH_NOARGS,
461 : "S.services() -> list" },
462 : { "server_role", py_lp_ctx_server_role, METH_NOARGS,
463 : "S.server_role() -> value\n"
464 : "Get the server role." },
465 : { "dump", py_lp_dump, METH_VARARGS,
466 : "S.dump(show_defaults=False, file_name='', mode='w')" },
467 : { "dump_globals", py_lp_dump_globals, METH_VARARGS,
468 : "S.dump_globals(show_defaults=False, file_name='', mode='w')" },
469 : { "dump_a_parameter", py_lp_dump_a_parameter, METH_VARARGS,
470 : "S.dump_a_parameter(name, service_name, file_name='', mode='w')" },
471 : { "log_level", py_lp_log_level, METH_NOARGS,
472 : "S.log_level() -> int\n Get the active log level" },
473 : { "samdb_url", py_samdb_url, METH_NOARGS,
474 : "S.samdb_url() -> string\n"
475 : "Returns the current URL for sam.ldb." },
476 : { "cache_path", py_cache_path, METH_VARARGS,
477 : "S.cache_path(name) -> string\n"
478 : "Returns a path in the Samba cache directory." },
479 : { "state_path", py_state_path, METH_VARARGS,
480 : "S.state_path(name) -> string\n"
481 : "Returns a path in the Samba state directory." },
482 : {0}
483 : };
484 :
485 0 : static PyObject *py_lp_ctx_default_service(PyObject *self, void *closure)
486 : {
487 0 : return PyLoadparmService_FromService(lpcfg_default_service(PyLoadparmContext_AsLoadparmContext(self)));
488 : }
489 :
490 3222 : static PyObject *py_lp_ctx_config_file(PyObject *self, void *closure)
491 : {
492 3222 : const char *configfile = lpcfg_configfile(PyLoadparmContext_AsLoadparmContext(self));
493 3222 : if (configfile == NULL)
494 0 : Py_RETURN_NONE;
495 : else
496 3222 : return PyUnicode_FromString(configfile);
497 : }
498 :
499 0 : static PyObject *py_lp_ctx_weak_crypto(PyObject *self, void *closure)
500 : {
501 0 : enum samba_weak_crypto weak_crypto =
502 0 : lpcfg_weak_crypto(PyLoadparmContext_AsLoadparmContext(self));
503 :
504 0 : switch(weak_crypto) {
505 0 : case SAMBA_WEAK_CRYPTO_UNKNOWN:
506 0 : Py_RETURN_NONE;
507 0 : case SAMBA_WEAK_CRYPTO_ALLOWED:
508 0 : return PyUnicode_FromString("allowed");
509 0 : case SAMBA_WEAK_CRYPTO_DISALLOWED:
510 0 : return PyUnicode_FromString("disallowed");
511 : }
512 :
513 0 : Py_RETURN_NONE;
514 : }
515 :
516 : static PyGetSetDef py_lp_ctx_getset[] = {
517 : {
518 : .name = discard_const_p(char, "default_service"),
519 : .get = (getter)py_lp_ctx_default_service,
520 : },
521 : {
522 : .name = discard_const_p(char, "configfile"),
523 : .get = (getter)py_lp_ctx_config_file,
524 : .doc = discard_const_p(char, "Name of last config file that was loaded.")
525 : },
526 : {
527 : .name = discard_const_p(char, "weak_crypto"),
528 : .get = (getter)py_lp_ctx_weak_crypto,
529 : .doc = discard_const_p(char, "If weak crypto is allowed.")
530 : },
531 : { .name = NULL }
532 : };
533 :
534 16006 : static PyObject *py_lp_ctx_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
535 : {
536 16006 : const char *kwnames[] = {"filename_for_non_global_lp", NULL};
537 : PyObject *lp_ctx;
538 16006 : const char *non_global_conf = NULL;
539 : struct loadparm_context *ctx;
540 :
541 16006 : if (!PyArg_ParseTupleAndKeywords(args,
542 : kwargs,
543 : "|s",
544 : discard_const_p(char *,
545 : kwnames),
546 : &non_global_conf)) {
547 0 : return NULL;
548 : }
549 :
550 : /*
551 : * by default, any LoadParm python objects map to a single global
552 : * underlying object. The filename_for_non_global_lp arg overrides this
553 : * default behaviour and creates a separate underlying LoadParm object.
554 : */
555 16006 : if (non_global_conf != NULL) {
556 : bool ok;
557 51 : ctx = loadparm_init(NULL);
558 51 : if (ctx == NULL) {
559 0 : PyErr_NoMemory();
560 0 : return NULL;
561 : }
562 :
563 51 : lp_ctx = pytalloc_reference(type, ctx);
564 51 : if (lp_ctx == NULL) {
565 0 : PyErr_NoMemory();
566 0 : return NULL;
567 : }
568 :
569 102 : ok = lpcfg_load_no_global(
570 51 : PyLoadparmContext_AsLoadparmContext(lp_ctx),
571 : non_global_conf);
572 51 : if (!ok) {
573 0 : PyErr_Format(PyExc_ValueError,
574 : "Could not load non-global conf %s",
575 : non_global_conf);
576 0 : return NULL;
577 : }
578 51 : return lp_ctx;
579 : } else{
580 15955 : return pytalloc_reference(type, loadparm_init_global(false));
581 : }
582 : }
583 :
584 0 : static Py_ssize_t py_lp_ctx_len(PyObject *self)
585 : {
586 0 : return lpcfg_numservices(PyLoadparmContext_AsLoadparmContext(self));
587 : }
588 :
589 0 : static PyObject *py_lp_ctx_getitem(PyObject *self, PyObject *name)
590 : {
591 : struct loadparm_service *service;
592 0 : if (!PyUnicode_Check(name)) {
593 0 : PyErr_SetString(PyExc_TypeError, "Only string subscripts are supported");
594 0 : return NULL;
595 : }
596 0 : service = lpcfg_service(PyLoadparmContext_AsLoadparmContext(self), PyUnicode_AsUTF8(name));
597 0 : if (service == NULL) {
598 0 : PyErr_SetString(PyExc_KeyError, "No such section");
599 0 : return NULL;
600 : }
601 0 : return PyLoadparmService_FromService(service);
602 : }
603 :
604 : static PyMappingMethods py_lp_ctx_mapping = {
605 : .mp_length = (lenfunc)py_lp_ctx_len,
606 : .mp_subscript = (binaryfunc)py_lp_ctx_getitem,
607 : };
608 :
609 : PyTypeObject PyLoadparmContext = {
610 : .tp_name = "param.LoadParm",
611 : .tp_getset = py_lp_ctx_getset,
612 : .tp_methods = py_lp_ctx_methods,
613 : .tp_new = py_lp_ctx_new,
614 : .tp_as_mapping = &py_lp_ctx_mapping,
615 : .tp_flags = Py_TPFLAGS_DEFAULT,
616 : };
617 :
618 0 : static PyObject *py_lp_service_dump(PyObject *self, PyObject *args)
619 : {
620 0 : bool show_defaults = false;
621 : FILE *f;
622 0 : const char *file_name = "";
623 0 : const char *mode = "w";
624 0 : struct loadparm_service *service = PyLoadparmService_AsLoadparmService(self);
625 : struct loadparm_service *default_service;
626 : PyObject *py_default_service;
627 :
628 0 : if (!PyArg_ParseTuple(args, "O|bss", &py_default_service, &show_defaults, &file_name, &mode))
629 0 : return NULL;
630 :
631 0 : if (file_name[0] == '\0') {
632 0 : f = stdout;
633 : } else {
634 0 : f = fopen(file_name, mode);
635 : }
636 :
637 0 : if (f == NULL) {
638 0 : return NULL;
639 : }
640 :
641 0 : if (!PyObject_TypeCheck(py_default_service, &PyLoadparmService)) {
642 0 : PyErr_SetNone(PyExc_TypeError);
643 0 : if (f != stdout) {
644 0 : fclose(f);
645 : }
646 0 : return NULL;
647 : }
648 :
649 0 : default_service = PyLoadparmService_AsLoadparmService(py_default_service);
650 :
651 0 : lpcfg_dump_one(f, show_defaults, service, default_service);
652 :
653 0 : if (f != stdout) {
654 0 : fclose(f);
655 : }
656 :
657 0 : Py_RETURN_NONE;
658 : }
659 :
660 : static PyMethodDef py_lp_service_methods[] = {
661 : { "dump", (PyCFunction)py_lp_service_dump, METH_VARARGS,
662 : "S.dump(default_service, show_defaults=False, file_name='', mode='w')" },
663 : {0}
664 : };
665 :
666 : PyTypeObject PyLoadparmService = {
667 : .tp_name = "param.LoadparmService",
668 : .tp_methods = py_lp_service_methods,
669 : .tp_flags = Py_TPFLAGS_DEFAULT,
670 : };
671 :
672 69 : static PyObject *py_data_dir(PyObject *self)
673 : {
674 69 : return PyUnicode_FromString(dyn_DATADIR);
675 : }
676 :
677 0 : static PyObject *py_default_path(PyObject *self, PyObject *Py_UNUSED(ignored))
678 : {
679 0 : return PyUnicode_FromString(lp_default_path());
680 : }
681 :
682 5600 : static PyObject *py_setup_dir(PyObject *self, PyObject *Py_UNUSED(ignored))
683 : {
684 5600 : return PyUnicode_FromString(dyn_SETUPDIR);
685 : }
686 :
687 23806 : static PyObject *py_modules_dir(PyObject *self, PyObject *Py_UNUSED(ignored))
688 : {
689 23806 : return PyUnicode_FromString(dyn_MODULESDIR);
690 : }
691 :
692 257 : static PyObject *py_bin_dir(PyObject *self, PyObject *Py_UNUSED(ignored))
693 : {
694 257 : return PyUnicode_FromString(dyn_BINDIR);
695 : }
696 :
697 0 : static PyObject *py_sbin_dir(PyObject *self, PyObject *Py_UNUSED(ignored))
698 : {
699 0 : return PyUnicode_FromString(dyn_SBINDIR);
700 : }
701 :
702 : static PyMethodDef pyparam_methods[] = {
703 : { "data_dir", (PyCFunction)py_data_dir, METH_NOARGS,
704 : "Returns the compiled in location of data directory." },
705 : { "default_path", (PyCFunction)py_default_path, METH_NOARGS,
706 : "Returns the default smb.conf path." },
707 : { "setup_dir", (PyCFunction)py_setup_dir, METH_NOARGS,
708 : "Returns the compiled in location of provision templates." },
709 : { "modules_dir", (PyCFunction)py_modules_dir, METH_NOARGS,
710 : "Returns the compiled in location of modules." },
711 : { "bin_dir", (PyCFunction)py_bin_dir, METH_NOARGS,
712 : "Returns the compiled in BINDIR." },
713 : { "sbin_dir", (PyCFunction)py_sbin_dir, METH_NOARGS,
714 : "Returns the compiled in SBINDIR." },
715 : {0}
716 : };
717 :
718 : static struct PyModuleDef moduledef = {
719 : PyModuleDef_HEAD_INIT,
720 : .m_name = "param",
721 : .m_doc = "Parsing and writing Samba configuration files.",
722 : .m_size = -1,
723 : .m_methods = pyparam_methods,
724 : };
725 :
726 7561 : MODULE_INIT_FUNC(param)
727 : {
728 : PyObject *m;
729 7561 : PyTypeObject *talloc_type = pytalloc_GetObjectType();
730 7561 : if (talloc_type == NULL)
731 0 : return NULL;
732 :
733 7561 : if (pytalloc_BaseObject_PyType_Ready(&PyLoadparmContext) < 0)
734 0 : return NULL;
735 :
736 7561 : if (pytalloc_BaseObject_PyType_Ready(&PyLoadparmService) < 0)
737 0 : return NULL;
738 :
739 7561 : m = PyModule_Create(&moduledef);
740 7561 : if (m == NULL)
741 0 : return NULL;
742 :
743 7561 : Py_INCREF(&PyLoadparmContext);
744 7561 : PyModule_AddObject(m, "LoadParm", (PyObject *)&PyLoadparmContext);
745 7561 : return m;
746 : }
|
