Branch data Line data Source code
1 : : /***********************************************************
2 : : Written by:
3 : : Fred Gansevles <Fred.Gansevles@cs.utwente.nl>
4 : : B&O group,
5 : : Faculteit der Informatica,
6 : : Universiteit Twente,
7 : : Enschede,
8 : : the Netherlands.
9 : : ******************************************************************/
10 : :
11 : : /* NIS module implementation */
12 : :
13 : : #include "Python.h"
14 : :
15 : : #include <stdlib.h> // free()
16 : : #include <sys/time.h>
17 : : #include <sys/types.h>
18 : : #include <rpc/rpc.h>
19 : : #include <rpcsvc/yp_prot.h>
20 : : #include <rpcsvc/ypclnt.h>
21 : :
22 : : #ifdef __sgi
23 : : /* This is missing from rpcsvc/ypclnt.h */
24 : : extern int yp_get_default_domain(char **);
25 : : #endif
26 : :
27 : : PyDoc_STRVAR(get_default_domain__doc__,
28 : : "get_default_domain() -> str\n\
29 : : Corresponds to the C library yp_get_default_domain() call, returning\n\
30 : : the default NIS domain.\n");
31 : :
32 : : PyDoc_STRVAR(match__doc__,
33 : : "match(key, map, domain = defaultdomain)\n\
34 : : Corresponds to the C library yp_match() call, returning the value of\n\
35 : : key in the given map. Optionally domain can be specified but it\n\
36 : : defaults to the system default domain.\n");
37 : :
38 : : PyDoc_STRVAR(cat__doc__,
39 : : "cat(map, domain = defaultdomain)\n\
40 : : Returns the entire map as a dictionary. Optionally domain can be\n\
41 : : specified but it defaults to the system default domain.\n");
42 : :
43 : : PyDoc_STRVAR(maps__doc__,
44 : : "maps(domain = defaultdomain)\n\
45 : : Returns an array of all available NIS maps within a domain. If domain\n\
46 : : is not specified it defaults to the system default domain.\n");
47 : :
48 : : typedef struct {
49 : : PyObject *nis_error;
50 : : } nis_state;
51 : :
52 : : static inline nis_state*
53 : 65 : get_nis_state(PyObject *module)
54 : : {
55 : 65 : void *state = PyModule_GetState(module);
56 : : assert(state != NULL);
57 : 65 : return (nis_state *)state;
58 : : }
59 : :
60 : : static int
61 : 4 : nis_clear(PyObject *m)
62 : : {
63 [ + + ]: 4 : Py_CLEAR(get_nis_state(m)->nis_error);
64 : 4 : return 0;
65 : : }
66 : :
67 : : static int
68 : 28 : nis_traverse(PyObject *m, visitproc visit, void *arg)
69 : : {
70 [ + - - + ]: 28 : Py_VISIT(get_nis_state(m)->nis_error);
71 : 28 : return 0;
72 : : }
73 : :
74 : : static void
75 : 2 : nis_free(void *m)
76 : : {
77 : 2 : nis_clear((PyObject *) m);
78 : 2 : }
79 : :
80 : : static PyObject *
81 : 1 : nis_error(nis_state *state, int err)
82 : : {
83 : 1 : PyErr_SetString(state->nis_error, yperr_string(err));
84 : 1 : return NULL;
85 : : }
86 : :
87 : : static struct nis_map {
88 : : char *alias;
89 : : char *map;
90 : : int fix;
91 : : } aliases [] = {
92 : : {"passwd", "passwd.byname", 0},
93 : : {"group", "group.byname", 0},
94 : : {"networks", "networks.byaddr", 0},
95 : : {"hosts", "hosts.byname", 0},
96 : : {"protocols", "protocols.bynumber", 0},
97 : : {"services", "services.byname", 0},
98 : : {"aliases", "mail.aliases", 1}, /* created with 'makedbm -a' */
99 : : {"ethers", "ethers.byname", 0},
100 : : {0L, 0L, 0}
101 : : };
102 : :
103 : : static char *
104 : 0 : nis_mapname(char *map, int *pfix)
105 : : {
106 : : int i;
107 : :
108 : 0 : *pfix = 0;
109 [ # # ]: 0 : for (i=0; aliases[i].alias != 0L; i++) {
110 [ # # # # ]: 0 : if (!strcmp (aliases[i].alias, map) || !strcmp (aliases[i].map, map)) {
111 : 0 : *pfix = aliases[i].fix;
112 : 0 : return aliases[i].map;
113 : : }
114 : : }
115 : :
116 : 0 : return map;
117 : : }
118 : :
119 : : #if defined(__APPLE__) || defined(__OpenBSD__) || defined(__FreeBSD__)
120 : : typedef int (*foreachfunc)(unsigned long, char *, int, char *, int, void *);
121 : : #else
122 : : typedef int (*foreachfunc)(int, char *, int, char *, int, char *);
123 : : #endif
124 : :
125 : : struct ypcallback_data {
126 : : PyObject *dict;
127 : : int fix;
128 : : PyThreadState *state;
129 : : };
130 : :
131 : : static int
132 : 0 : nis_foreach(int instatus, char *inkey, int inkeylen, char *inval,
133 : : int invallen, struct ypcallback_data *indata)
134 : : {
135 [ # # ]: 0 : if (instatus == YP_TRUE) {
136 : : PyObject *key;
137 : : PyObject *val;
138 : : int err;
139 : :
140 : 0 : PyEval_RestoreThread(indata->state);
141 [ # # ]: 0 : if (indata->fix) {
142 [ # # # # ]: 0 : if (inkeylen > 0 && inkey[inkeylen-1] == '\0')
143 : 0 : inkeylen--;
144 [ # # # # ]: 0 : if (invallen > 0 && inval[invallen-1] == '\0')
145 : 0 : invallen--;
146 : : }
147 : 0 : key = PyUnicode_DecodeFSDefaultAndSize(inkey, inkeylen);
148 : 0 : val = PyUnicode_DecodeFSDefaultAndSize(inval, invallen);
149 [ # # # # ]: 0 : if (key == NULL || val == NULL) {
150 : : /* XXX error -- don't know how to handle */
151 : 0 : PyErr_Clear();
152 : 0 : Py_XDECREF(key);
153 : 0 : Py_XDECREF(val);
154 : 0 : indata->state = PyEval_SaveThread();
155 : 0 : return 1;
156 : : }
157 : 0 : err = PyDict_SetItem(indata->dict, key, val);
158 : 0 : Py_DECREF(key);
159 : 0 : Py_DECREF(val);
160 [ # # ]: 0 : if (err != 0)
161 : 0 : PyErr_Clear();
162 : 0 : indata->state = PyEval_SaveThread();
163 [ # # ]: 0 : if (err != 0)
164 : 0 : return 1;
165 : 0 : return 0;
166 : : }
167 : 0 : return 1;
168 : : }
169 : :
170 : : static PyObject *
171 : 0 : nis_get_default_domain(PyObject *module, PyObject *Py_UNUSED(ignored))
172 : : {
173 : : char *domain;
174 : : int err;
175 : : PyObject *res;
176 : 0 : nis_state *state = get_nis_state(module);
177 [ # # ]: 0 : if ((err = yp_get_default_domain(&domain)) != 0) {
178 : 0 : return nis_error(state, err);
179 : : }
180 : :
181 : 0 : res = PyUnicode_FromStringAndSize (domain, strlen(domain));
182 : 0 : return res;
183 : : }
184 : :
185 : : static PyObject *
186 : 0 : nis_match(PyObject *module, PyObject *args, PyObject *kwdict)
187 : : {
188 : : char *match;
189 : 0 : char *domain = NULL;
190 : : Py_ssize_t keylen;
191 : : int len;
192 : : char *key, *map;
193 : : int err;
194 : : PyObject *ukey, *bkey, *res;
195 : : int fix;
196 : : static char *kwlist[] = {"key", "map", "domain", NULL};
197 : :
198 [ # # ]: 0 : if (!PyArg_ParseTupleAndKeywords(args, kwdict,
199 : : "Us|s:match", kwlist,
200 : : &ukey, &map, &domain)) {
201 : 0 : return NULL;
202 : : }
203 [ # # ]: 0 : if ((bkey = PyUnicode_EncodeFSDefault(ukey)) == NULL) {
204 : 0 : return NULL;
205 : : }
206 : : /* check for embedded null bytes */
207 [ # # ]: 0 : if (PyBytes_AsStringAndSize(bkey, &key, &keylen) == -1) {
208 : 0 : Py_DECREF(bkey);
209 : 0 : return NULL;
210 : : }
211 : :
212 : 0 : nis_state *state = get_nis_state(module);
213 [ # # # # ]: 0 : if (!domain && ((err = yp_get_default_domain(&domain)) != 0)) {
214 : 0 : Py_DECREF(bkey);
215 : 0 : return nis_error(state, err);
216 : : }
217 : 0 : map = nis_mapname (map, &fix);
218 [ # # ]: 0 : if (fix)
219 : 0 : keylen++;
220 : 0 : Py_BEGIN_ALLOW_THREADS
221 : 0 : err = yp_match (domain, map, key, keylen, &match, &len);
222 : 0 : Py_END_ALLOW_THREADS
223 : 0 : Py_DECREF(bkey);
224 [ # # ]: 0 : if (fix)
225 : 0 : len--;
226 [ # # ]: 0 : if (err != 0) {
227 : 0 : return nis_error(state, err);
228 : : }
229 : 0 : res = PyUnicode_DecodeFSDefaultAndSize(match, len);
230 : 0 : free (match);
231 : 0 : return res;
232 : : }
233 : :
234 : : static PyObject *
235 : 0 : nis_cat(PyObject *module, PyObject *args, PyObject *kwdict)
236 : : {
237 : 0 : char *domain = NULL;
238 : : char *map;
239 : : struct ypall_callback cb;
240 : : struct ypcallback_data data;
241 : : PyObject *dict;
242 : : int err;
243 : : static char *kwlist[] = {"map", "domain", NULL};
244 : :
245 [ # # ]: 0 : if (!PyArg_ParseTupleAndKeywords(args, kwdict, "s|s:cat",
246 : : kwlist, &map, &domain)) {
247 : 0 : return NULL;
248 : : }
249 : 0 : nis_state *state = get_nis_state(module);
250 [ # # # # ]: 0 : if (!domain && ((err = yp_get_default_domain(&domain)) != 0)) {
251 : 0 : return nis_error(state, err);
252 : : }
253 : 0 : dict = PyDict_New ();
254 [ # # ]: 0 : if (dict == NULL)
255 : 0 : return NULL;
256 : 0 : cb.foreach = (foreachfunc)nis_foreach;
257 : 0 : data.dict = dict;
258 : 0 : map = nis_mapname (map, &data.fix);
259 : 0 : cb.data = (char *)&data;
260 : 0 : data.state = PyEval_SaveThread();
261 : 0 : err = yp_all (domain, map, &cb);
262 : 0 : PyEval_RestoreThread(data.state);
263 [ # # ]: 0 : if (err != 0) {
264 : 0 : Py_DECREF(dict);
265 : 0 : return nis_error(state, err);
266 : : }
267 : 0 : return dict;
268 : : }
269 : :
270 : : /* These should be u_long on Sun h/w but not on 64-bit h/w.
271 : : This is not portable to machines with 16-bit ints and no prototypes */
272 : : #ifndef YPPROC_MAPLIST
273 : : #define YPPROC_MAPLIST 11
274 : : #endif
275 : : #ifndef YPPROG
276 : : #define YPPROG 100004
277 : : #endif
278 : : #ifndef YPVERS
279 : : #define YPVERS 2
280 : : #endif
281 : :
282 : : typedef char *domainname;
283 : : typedef char *mapname;
284 : :
285 : : enum nisstat {
286 : : NIS_TRUE = 1,
287 : : NIS_NOMORE = 2,
288 : : NIS_FALSE = 0,
289 : : NIS_NOMAP = -1,
290 : : NIS_NODOM = -2,
291 : : NIS_NOKEY = -3,
292 : : NIS_BADOP = -4,
293 : : NIS_BADDB = -5,
294 : : NIS_YPERR = -6,
295 : : NIS_BADARGS = -7,
296 : : NIS_VERS = -8
297 : : };
298 : : typedef enum nisstat nisstat;
299 : :
300 : : struct nismaplist {
301 : : mapname map;
302 : : struct nismaplist *next;
303 : : };
304 : : typedef struct nismaplist nismaplist;
305 : :
306 : : struct nisresp_maplist {
307 : : nisstat stat;
308 : : nismaplist *maps;
309 : : };
310 : : typedef struct nisresp_maplist nisresp_maplist;
311 : :
312 : : static struct timeval TIMEOUT = { 25, 0 };
313 : :
314 : : static
315 : : bool_t
316 : 0 : nis_xdr_domainname(XDR *xdrs, domainname *objp)
317 : : {
318 [ # # ]: 0 : if (!xdr_string(xdrs, objp, YPMAXDOMAIN)) {
319 : 0 : return (FALSE);
320 : : }
321 : 0 : return (TRUE);
322 : : }
323 : :
324 : : static
325 : : bool_t
326 : 0 : nis_xdr_mapname(XDR *xdrs, mapname *objp)
327 : : {
328 [ # # ]: 0 : if (!xdr_string(xdrs, objp, YPMAXMAP)) {
329 : 0 : return (FALSE);
330 : : }
331 : 0 : return (TRUE);
332 : : }
333 : :
334 : : static
335 : : bool_t
336 : 0 : nis_xdr_ypmaplist(XDR *xdrs, nismaplist *objp)
337 : : {
338 [ # # ]: 0 : if (!nis_xdr_mapname(xdrs, &objp->map)) {
339 : 0 : return (FALSE);
340 : : }
341 [ # # ]: 0 : if (!xdr_pointer(xdrs, (char **)&objp->next,
342 : : sizeof(nismaplist), (xdrproc_t)nis_xdr_ypmaplist))
343 : : {
344 : 0 : return (FALSE);
345 : : }
346 : 0 : return (TRUE);
347 : : }
348 : :
349 : : static
350 : : bool_t
351 : 0 : nis_xdr_ypstat(XDR *xdrs, nisstat *objp)
352 : : {
353 [ # # ]: 0 : if (!xdr_enum(xdrs, (enum_t *)objp)) {
354 : 0 : return (FALSE);
355 : : }
356 : 0 : return (TRUE);
357 : : }
358 : :
359 : :
360 : : static
361 : : bool_t
362 : 0 : nis_xdr_ypresp_maplist(XDR *xdrs, nisresp_maplist *objp)
363 : : {
364 [ # # ]: 0 : if (!nis_xdr_ypstat(xdrs, &objp->stat)) {
365 : 0 : return (FALSE);
366 : : }
367 [ # # ]: 0 : if (!xdr_pointer(xdrs, (char **)&objp->maps,
368 : : sizeof(nismaplist), (xdrproc_t)nis_xdr_ypmaplist))
369 : : {
370 : 0 : return (FALSE);
371 : : }
372 : 0 : return (TRUE);
373 : : }
374 : :
375 : :
376 : : static
377 : : nisresp_maplist *
378 : 0 : nisproc_maplist_2(domainname *argp, CLIENT *clnt)
379 : : {
380 : : static nisresp_maplist res;
381 : :
382 : 0 : memset(&res, 0, sizeof(res));
383 [ # # ]: 0 : if (clnt_call(clnt, YPPROC_MAPLIST,
384 : : (xdrproc_t)nis_xdr_domainname, (caddr_t)argp,
385 : : (xdrproc_t)nis_xdr_ypresp_maplist, (caddr_t)&res,
386 : : TIMEOUT) != RPC_SUCCESS)
387 : : {
388 : 0 : return (NULL);
389 : : }
390 : 0 : return (&res);
391 : : }
392 : :
393 : : static
394 : : nismaplist *
395 : 0 : nis_maplist(nis_state *state, char *dom)
396 : : {
397 : : nisresp_maplist *list;
398 : : CLIENT *cl;
399 : 0 : char *server = NULL;
400 : 0 : int mapi = 0;
401 : :
402 [ # # # # ]: 0 : while (!server && aliases[mapi].map != 0L) {
403 : 0 : yp_master (dom, aliases[mapi].map, &server);
404 : 0 : mapi++;
405 : : }
406 [ # # ]: 0 : if (!server) {
407 : 0 : PyErr_SetString(state->nis_error, "No NIS master found for any map");
408 : 0 : return NULL;
409 : : }
410 : 0 : cl = clnt_create(server, YPPROG, YPVERS, "tcp");
411 [ # # ]: 0 : if (cl == NULL) {
412 : 0 : PyErr_SetString(state->nis_error, clnt_spcreateerror(server));
413 : 0 : goto finally;
414 : : }
415 : 0 : list = nisproc_maplist_2 (&dom, cl);
416 : 0 : clnt_destroy(cl);
417 [ # # ]: 0 : if (list == NULL)
418 : 0 : goto finally;
419 [ # # ]: 0 : if (list->stat != NIS_TRUE)
420 : 0 : goto finally;
421 : :
422 : 0 : free(server);
423 : 0 : return list->maps;
424 : :
425 : 0 : finally:
426 : 0 : free(server);
427 : 0 : return NULL;
428 : : }
429 : :
430 : : static PyObject *
431 : 1 : nis_maps (PyObject *module, PyObject *args, PyObject *kwdict)
432 : : {
433 : 1 : char *domain = NULL;
434 : : nismaplist *maps;
435 : : PyObject *list;
436 : : int err;
437 : : static char *kwlist[] = {"domain", NULL};
438 : :
439 [ - + ]: 1 : if (!PyArg_ParseTupleAndKeywords(args, kwdict,
440 : : "|s:maps", kwlist, &domain)) {
441 : 0 : return NULL;
442 : : }
443 : :
444 : 1 : nis_state *state = get_nis_state(module);
445 [ + - + - ]: 1 : if (!domain && ((err = yp_get_default_domain (&domain)) != 0)) {
446 : 1 : nis_error(state, err);
447 : 1 : return NULL;
448 : : }
449 : :
450 [ # # ]: 0 : if ((maps = nis_maplist(state, domain)) == NULL) {
451 : 0 : return NULL;
452 : : }
453 [ # # ]: 0 : if ((list = PyList_New(0)) == NULL) {
454 : 0 : return NULL;
455 : : }
456 [ # # ]: 0 : for (; maps; maps = maps->next) {
457 : 0 : PyObject *str = PyUnicode_FromString(maps->map);
458 [ # # # # ]: 0 : if (!str || PyList_Append(list, str) < 0)
459 : : {
460 : 0 : Py_XDECREF(str);
461 : 0 : Py_DECREF(list);
462 : 0 : list = NULL;
463 : 0 : break;
464 : : }
465 : 0 : Py_DECREF(str);
466 : : }
467 : : /* XXX Shouldn't we free the list of maps now? */
468 : 0 : return list;
469 : : }
470 : :
471 : : static PyMethodDef nis_methods[] = {
472 : : {"match", _PyCFunction_CAST(nis_match),
473 : : METH_VARARGS | METH_KEYWORDS,
474 : : match__doc__},
475 : : {"cat", _PyCFunction_CAST(nis_cat),
476 : : METH_VARARGS | METH_KEYWORDS,
477 : : cat__doc__},
478 : : {"maps", _PyCFunction_CAST(nis_maps),
479 : : METH_VARARGS | METH_KEYWORDS,
480 : : maps__doc__},
481 : : {"get_default_domain", nis_get_default_domain,
482 : : METH_NOARGS,
483 : : get_default_domain__doc__},
484 : : {NULL, NULL} /* Sentinel */
485 : : };
486 : :
487 : : static int
488 : 2 : nis_exec(PyObject *module)
489 : : {
490 : 2 : nis_state* state = get_nis_state(module);
491 : 2 : state->nis_error = PyErr_NewException("nis.error", NULL, NULL);
492 [ - + ]: 2 : if (state->nis_error == NULL) {
493 : 0 : return -1;
494 : : }
495 : :
496 : 2 : Py_INCREF(state->nis_error);
497 [ - + ]: 2 : if (PyModule_AddObject(module, "error", state->nis_error) < 0) {
498 : 0 : Py_DECREF(state->nis_error);
499 : 0 : return -1;
500 : : }
501 : 2 : return 0;
502 : : }
503 : :
504 : : static PyModuleDef_Slot nis_slots[] = {
505 : : {Py_mod_exec, nis_exec},
506 : : {0, NULL}
507 : : };
508 : :
509 : : PyDoc_STRVAR(nis__doc__,
510 : : "This module contains functions for accessing NIS maps.\n");
511 : :
512 : : static struct PyModuleDef nismodule = {
513 : : PyModuleDef_HEAD_INIT,
514 : : .m_name = "nis",
515 : : .m_doc = nis__doc__,
516 : : .m_size = sizeof(nis_state),
517 : : .m_methods = nis_methods,
518 : : .m_traverse = nis_traverse,
519 : : .m_clear = nis_clear,
520 : : .m_free = nis_free,
521 : : .m_slots = nis_slots,
522 : : };
523 : :
524 : : PyMODINIT_FUNC
525 : 2 : PyInit_nis(void)
526 : : {
527 [ - + ]: 2 : if (PyErr_WarnEx(PyExc_DeprecationWarning,
528 : : "'nis' is deprecated and slated for removal in "
529 : : "Python 3.13",
530 : : 7)) {
531 : 0 : return NULL;
532 : : }
533 : 2 : return PyModuleDef_Init(&nismodule);
534 : : }
|
