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