Modules/nismodule.c

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