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