Ignore:
Timestamp:
Mar 19, 2014, 11:11:30 AM (11 years ago)
Author:
dmik
Message:

python: Update vendor to 2.7.6.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • python/vendor/current/Modules/nismodule.c

    r2 r388  
    11/***********************************************************
    22    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.
     3    Fred Gansevles <Fred.Gansevles@cs.utwente.nl>
     4    B&O group,
     5    Faculteit der Informatica,
     6    Universiteit Twente,
     7    Enschede,
     8    the Netherlands.
    99******************************************************************/
    1010
    … …  
    2424#endif
    2525
    26 PyDoc_STRVAR(get_default_domain__doc__, 
     26PyDoc_STRVAR(get_default_domain__doc__,
    2727"get_default_domain() -> str\n\
    2828Corresponds to the C library yp_get_default_domain() call, returning\n\
    … …  
    5050nis_error (int err)
    5151{
    52         PyErr_SetString(NisError, yperr_string(err));
    53         return NULL;
     52    PyErr_SetString(NisError, yperr_string(err));
     53    return NULL;
    5454}
    5555
    5656static struct nis_map {
    57         char *alias;
    58         char *map;
    59         int  fix;
     57    char *alias;
     58    char *map;
     59    int  fix;
    6060} 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}
     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}
    7070};
    7171
    … …  
    7373nis_mapname (char *map, int *pfix)
    7474{
    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;
     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;
    9090}
    9191
    … …  
    9797
    9898struct ypcallback_data {
    99         PyObject        *dict;
    100         int                     fix;
    101         PyThreadState *state;
     99    PyObject            *dict;
     100    int                         fix;
     101    PyThreadState *state;
    102102};
    103103
    … …  
    106106             int invallen, struct ypcallback_data *indata)
    107107{
    108         if (instatus == YP_TRUE) {
    109                 PyObject *key;
    110                 PyObject *val;
    111                 int err;
    112 
    113                 PyEval_RestoreThread(indata->state);
    114                 if (indata->fix) {
    115                     if (inkeylen > 0 && inkey[inkeylen-1] == '\0')
    116                         inkeylen--;
    117                     if (invallen > 0 && inval[invallen-1] == '\0')
    118                         invallen--;
    119                 }
    120                 key = PyString_FromStringAndSize(inkey, inkeylen);
    121                 val = PyString_FromStringAndSize(inval, invallen);
    122                 if (key == NULL || val == NULL) {
    123                         /* XXX error -- don't know how to handle */
    124                         PyErr_Clear();
    125                         Py_XDECREF(key);
    126                         Py_XDECREF(val);
    127                         return 1;
    128                 }
    129                 err = PyDict_SetItem(indata->dict, key, val);
    130                 Py_DECREF(key);
    131                 Py_DECREF(val);
    132                 if (err != 0)
    133                         PyErr_Clear();
    134                 indata->state = PyEval_SaveThread();
    135                 if (err != 0)
    136                         return 1;
    137                 return 0;
    138         }
    139         return 1;
     108    if (instatus == YP_TRUE) {
     109        PyObject *key;
     110        PyObject *val;
     111        int err;
     112
     113        PyEval_RestoreThread(indata->state);
     114        if (indata->fix) {
     115            if (inkeylen > 0 && inkey[inkeylen-1] == '\0')
     116            inkeylen--;
     117            if (invallen > 0 && inval[invallen-1] == '\0')
     118            invallen--;
     119        }
     120        key = PyString_FromStringAndSize(inkey, inkeylen);
     121        val = PyString_FromStringAndSize(inval, invallen);
     122        if (key == NULL || val == NULL) {
     123            /* XXX error -- don't know how to handle */
     124            PyErr_Clear();
     125            Py_XDECREF(key);
     126            Py_XDECREF(val);
     127            indata->state = PyEval_SaveThread();
     128            return 1;
     129        }
     130        err = PyDict_SetItem(indata->dict, key, val);
     131        Py_DECREF(key);
     132        Py_DECREF(val);
     133        if (err != 0)
     134            PyErr_Clear();
     135        indata->state = PyEval_SaveThread();
     136        if (err != 0)
     137            return 1;
     138        return 0;
     139    }
     140    return 1;
    140141}
    141142
    … …  
    143144nis_get_default_domain (PyObject *self)
    144145{
    145         char *domain;
    146         int err;
    147         PyObject *res;
    148 
    149         if ((err = yp_get_default_domain(&domain)) != 0)
    150                 return nis_error(err);
    151 
    152         res = PyString_FromStringAndSize (domain, strlen(domain));
    153         return res;
     146    char *domain;
     147    int err;
     148    PyObject *res;
     149
     150    if ((err = yp_get_default_domain(&domain)) != 0)
     151        return nis_error(err);
     152
     153    res = PyString_FromStringAndSize (domain, strlen(domain));
     154    return res;
    154155}
    155156
    … …  
    157158nis_match (PyObject *self, PyObject *args, PyObject *kwdict)
    158159{
    159         char *match;
    160         char *domain = NULL;
    161         int keylen, len;
    162         char *key, *map;
    163         int err;
    164         PyObject *res;
    165         int fix;
    166         static char *kwlist[] = {"key", "map", "domain", NULL};
    167 
    168         if (!PyArg_ParseTupleAndKeywords(args, kwdict,
    169                                         "t#s|s:match", kwlist,
    170                                         &key, &keylen, &map, &domain))
    171                 return NULL;
    172         if (!domain && ((err = yp_get_default_domain(&domain)) != 0))
    173                 return nis_error(err);
    174         map = nis_mapname (map, &fix);
    175         if (fix)
    176             keylen++;
    177         Py_BEGIN_ALLOW_THREADS
    178         err = yp_match (domain, map, key, keylen, &match, &len);
    179         Py_END_ALLOW_THREADS
    180         if (fix)
    181             len--;
    182         if (err != 0)
    183                 return nis_error(err);
    184         res = PyString_FromStringAndSize (match, len);
    185         free (match);
    186         return res;
     160    char *match;
     161    char *domain = NULL;
     162    int keylen, len;
     163    char *key, *map;
     164    int err;
     165    PyObject *res;
     166    int fix;
     167    static char *kwlist[] = {"key", "map", "domain", NULL};
     168
     169    if (!PyArg_ParseTupleAndKeywords(args, kwdict,
     170                                    "t#s|s:match", kwlist,
     171                                    &key, &keylen, &map, &domain))
     172        return NULL;
     173    if (!domain && ((err = yp_get_default_domain(&domain)) != 0))
     174        return nis_error(err);
     175    map = nis_mapname (map, &fix);
     176    if (fix)
     177        keylen++;
     178    Py_BEGIN_ALLOW_THREADS
     179    err = yp_match (domain, map, key, keylen, &match, &len);
     180    Py_END_ALLOW_THREADS
     181    if (fix)
     182        len--;
     183    if (err != 0)
     184        return nis_error(err);
     185    res = PyString_FromStringAndSize (match, len);
     186    free (match);
     187    return res;
    187188}
    188189
    … …  
    190191nis_cat (PyObject *self, PyObject *args, PyObject *kwdict)
    191192{
    192         char *domain = NULL;
    193         char *map;
    194         struct ypall_callback cb;
    195         struct ypcallback_data data;
    196         PyObject *dict;
    197         int err;
    198         static char *kwlist[] = {"map", "domain", NULL};
    199 
    200         if (!PyArg_ParseTupleAndKeywords(args, kwdict, "s|s:cat",
    201                                          kwlist, &map, &domain))
    202                 return NULL;
    203         if (!domain && ((err = yp_get_default_domain(&domain)) != 0))
    204                 return nis_error(err);
    205         dict = PyDict_New ();
    206         if (dict == NULL)
    207                 return NULL;
    208         cb.foreach = (foreachfunc)nis_foreach;
    209         data.dict = dict;
    210         map = nis_mapname (map, &data.fix);
    211         cb.data = (char *)&data;
    212         data.state = PyEval_SaveThread();
    213         err = yp_all (domain, map, &cb);
    214         PyEval_RestoreThread(data.state);
    215         if (err != 0) {
    216                 Py_DECREF(dict);
    217                 return nis_error(err);
    218         }
    219         return dict;
     193    char *domain = NULL;
     194    char *map;
     195    struct ypall_callback cb;
     196    struct ypcallback_data data;
     197    PyObject *dict;
     198    int err;
     199    static char *kwlist[] = {"map", "domain", NULL};
     200
     201    if (!PyArg_ParseTupleAndKeywords(args, kwdict, "s|s:cat",
     202                                     kwlist, &map, &domain))
     203        return NULL;
     204    if (!domain && ((err = yp_get_default_domain(&domain)) != 0))
     205        return nis_error(err);
     206    dict = PyDict_New ();
     207    if (dict == NULL)
     208        return NULL;
     209    cb.foreach = (foreachfunc)nis_foreach;
     210    data.dict = dict;
     211    map = nis_mapname (map, &data.fix);
     212    cb.data = (char *)&data;
     213    data.state = PyEval_SaveThread();
     214    err = yp_all (domain, map, &cb);
     215    PyEval_RestoreThread(data.state);
     216    if (err != 0) {
     217        Py_DECREF(dict);
     218        return nis_error(err);
     219    }
     220    return dict;
    220221}
    221222
    … …  
    223224   This is not portable to machines with 16-bit ints and no prototypes */
    224225#ifndef YPPROC_MAPLIST
    225 #define YPPROC_MAPLIST  11
     226#define YPPROC_MAPLIST  11
    226227#endif
    227228#ifndef YPPROG
    228 #define YPPROG          100004
     229#define YPPROG          100004
    229230#endif
    230231#ifndef YPVERS
    231 #define YPVERS          2
     232#define YPVERS          2
    232233#endif
    233234
    … …  
    236237
    237238enum nisstat {
    238         NIS_TRUE = 1,
    239         NIS_NOMORE = 2,
    240         NIS_FALSE = 0,
    241         NIS_NOMAP = -1,
    242         NIS_NODOM = -2,
    243         NIS_NOKEY = -3,
    244         NIS_BADOP = -4,
    245         NIS_BADDB = -5,
    246         NIS_YPERR = -6,
    247         NIS_BADARGS = -7,
    248         NIS_VERS = -8
     239    NIS_TRUE = 1,
     240    NIS_NOMORE = 2,
     241    NIS_FALSE = 0,
     242    NIS_NOMAP = -1,
     243    NIS_NODOM = -2,
     244    NIS_NOKEY = -3,
     245    NIS_BADOP = -4,
     246    NIS_BADDB = -5,
     247    NIS_YPERR = -6,
     248    NIS_BADARGS = -7,
     249    NIS_VERS = -8
    249250};
    250251typedef enum nisstat nisstat;
    251252
    252253struct nismaplist {
    253         mapname map;
    254         struct nismaplist *next;
     254    mapname map;
     255    struct nismaplist *next;
    255256};
    256257typedef struct nismaplist nismaplist;
    257258
    258259struct nisresp_maplist {
    259         nisstat stat;
    260         nismaplist *maps;
     260    nisstat stat;
     261    nismaplist *maps;
    261262};
    262263typedef struct nisresp_maplist nisresp_maplist;
    … …  
    268269nis_xdr_domainname(XDR *xdrs, domainname *objp)
    269270{
    270         if (!xdr_string(xdrs, objp, YPMAXDOMAIN)) {
    271                 return (FALSE);
    272         }
    273         return (TRUE);
     271    if (!xdr_string(xdrs, objp, YPMAXDOMAIN)) {
     272        return (FALSE);
     273    }
     274    return (TRUE);
    274275}
    275276
    … …  
    278279nis_xdr_mapname(XDR *xdrs, mapname *objp)
    279280{
    280         if (!xdr_string(xdrs, objp, YPMAXMAP)) {
    281                 return (FALSE);
    282         }
    283         return (TRUE);
     281    if (!xdr_string(xdrs, objp, YPMAXMAP)) {
     282        return (FALSE);
     283    }
     284    return (TRUE);
    284285}
    285286
    … …  
    288289nis_xdr_ypmaplist(XDR *xdrs, nismaplist *objp)
    289290{
    290         if (!nis_xdr_mapname(xdrs, &objp->map)) {
    291                 return (FALSE);
    292         }
    293         if (!xdr_pointer(xdrs, (char **)&objp->next,
    294                         sizeof(nismaplist), (xdrproc_t)nis_xdr_ypmaplist))
    295         {
    296                 return (FALSE);
    297         }
    298         return (TRUE);
     291    if (!nis_xdr_mapname(xdrs, &objp->map)) {
     292        return (FALSE);
     293    }
     294    if (!xdr_pointer(xdrs, (char **)&objp->next,
     295                    sizeof(nismaplist), (xdrproc_t)nis_xdr_ypmaplist))
     296    {
     297        return (FALSE);
     298    }
     299    return (TRUE);
    299300}
    300301
    … …  
    303304nis_xdr_ypstat(XDR *xdrs, nisstat *objp)
    304305{
    305         if (!xdr_enum(xdrs, (enum_t *)objp)) {
    306                 return (FALSE);
    307         }
    308         return (TRUE);
     306    if (!xdr_enum(xdrs, (enum_t *)objp)) {
     307        return (FALSE);
     308    }
     309    return (TRUE);
    309310}
    310311
    … …  
    314315nis_xdr_ypresp_maplist(XDR *xdrs, nisresp_maplist *objp)
    315316{
    316         if (!nis_xdr_ypstat(xdrs, &objp->stat)) {
    317                 return (FALSE);
    318         }
    319         if (!xdr_pointer(xdrs, (char **)&objp->maps,
    320                         sizeof(nismaplist), (xdrproc_t)nis_xdr_ypmaplist))
    321         {
    322                 return (FALSE);
    323         }
    324         return (TRUE);
     317    if (!nis_xdr_ypstat(xdrs, &objp->stat)) {
     318        return (FALSE);
     319    }
     320    if (!xdr_pointer(xdrs, (char **)&objp->maps,
     321                    sizeof(nismaplist), (xdrproc_t)nis_xdr_ypmaplist))
     322    {
     323        return (FALSE);
     324    }
     325    return (TRUE);
    325326}
    326327
    … …  
    330331nisproc_maplist_2(domainname *argp, CLIENT *clnt)
    331332{
    332         static nisresp_maplist res;
    333 
    334         memset(&res, 0, sizeof(res));
    335         if (clnt_call(clnt, YPPROC_MAPLIST,
    336                       (xdrproc_t)nis_xdr_domainname, (caddr_t)argp,
    337                       (xdrproc_t)nis_xdr_ypresp_maplist, (caddr_t)&res,
    338                       TIMEOUT) != RPC_SUCCESS)
    339         {
    340                 return (NULL);
    341         }
    342         return (&res);
     333    static nisresp_maplist res;
     334
     335    memset(&res, 0, sizeof(res));
     336    if (clnt_call(clnt, YPPROC_MAPLIST,
     337                  (xdrproc_t)nis_xdr_domainname, (caddr_t)argp,
     338                  (xdrproc_t)nis_xdr_ypresp_maplist, (caddr_t)&res,
     339                  TIMEOUT) != RPC_SUCCESS)
     340    {
     341        return (NULL);
     342    }
     343    return (&res);
    343344}
    344345
    … …  
    347348nis_maplist (char *dom)
    348349{
    349         nisresp_maplist *list;
    350         CLIENT *cl;
    351         char *server = NULL;
    352         int mapi = 0;
    353 
    354         while (!server && aliases[mapi].map != 0L) {
    355                 yp_master (dom, aliases[mapi].map, &server);
    356                 mapi++;
    357         }
    358         if (!server) {
    359             PyErr_SetString(NisError, "No NIS master found for any map");
    360             return NULL;
    361         }
    362         cl = clnt_create(server, YPPROG, YPVERS, "tcp");
    363         if (cl == NULL) {
    364                 PyErr_SetString(NisError, clnt_spcreateerror(server));
    365                 goto finally;
    366         }
    367         list = nisproc_maplist_2 (&dom, cl);
    368         clnt_destroy(cl);
    369         if (list == NULL)
    370                 goto finally;
    371         if (list->stat != NIS_TRUE)
    372                 goto finally;
    373 
    374         free(server);
    375         return list->maps;
     350    nisresp_maplist *list;
     351    CLIENT *cl;
     352    char *server = NULL;
     353    int mapi = 0;
     354
     355    while (!server && aliases[mapi].map != 0L) {
     356        yp_master (dom, aliases[mapi].map, &server);
     357        mapi++;
     358    }
     359    if (!server) {
     360        PyErr_SetString(NisError, "No NIS master found for any map");
     361        return NULL;
     362    }
     363    cl = clnt_create(server, YPPROG, YPVERS, "tcp");
     364    if (cl == NULL) {
     365        PyErr_SetString(NisError, clnt_spcreateerror(server));
     366        goto finally;
     367    }
     368    list = nisproc_maplist_2 (&dom, cl);
     369    clnt_destroy(cl);
     370    if (list == NULL)
     371        goto finally;
     372    if (list->stat != NIS_TRUE)
     373        goto finally;
     374
     375    free(server);
     376    return list->maps;
    376377
    377378  finally:
    378         free(server);
    379         return NULL;
     379    free(server);
     380    return NULL;
    380381}
    381382
    … …  
    383384nis_maps (PyObject *self, PyObject *args, PyObject *kwdict)
    384385{
    385         char *domain = NULL;
    386         nismaplist *maps;
    387         PyObject *list;
    388         int err;
    389         static char *kwlist[] = {"domain", NULL};
    390 
    391         if (!PyArg_ParseTupleAndKeywords(args, kwdict,
    392                                         "|s:maps", kwlist, &domain))
    393                 return NULL;
    394         if (!domain && ((err = yp_get_default_domain (&domain)) != 0)) {
    395                 nis_error(err);
    396                 return NULL;
    397         }
    398 
    399         if ((maps = nis_maplist (domain)) == NULL)
    400                 return NULL;
    401         if ((list = PyList_New(0)) == NULL)
    402                 return NULL;
    403         for (maps = maps; maps; maps = maps->next) {
    404                 PyObject *str = PyString_FromString(maps->map);
    405                 if (!str || PyList_Append(list, str) < 0)
    406                 {
    407                         Py_DECREF(list);
    408                         list = NULL;
    409                         break;
    410                 }
    411                 Py_DECREF(str);
    412         }
    413         /* XXX Shouldn't we free the list of maps now? */
    414         return list;
     386    char *domain = NULL;
     387    nismaplist *maps;
     388    PyObject *list;
     389    int err;
     390    static char *kwlist[] = {"domain", NULL};
     391
     392    if (!PyArg_ParseTupleAndKeywords(args, kwdict,
     393                                    "|s:maps", kwlist, &domain))
     394        return NULL;
     395    if (!domain && ((err = yp_get_default_domain (&domain)) != 0)) {
     396        nis_error(err);
     397        return NULL;
     398    }
     399
     400    if ((maps = nis_maplist (domain)) == NULL)
     401        return NULL;
     402    if ((list = PyList_New(0)) == NULL)
     403        return NULL;
     404    for (maps = maps; maps; maps = maps->next) {
     405        PyObject *str = PyString_FromString(maps->map);
     406        if (!str || PyList_Append(list, str) < 0)
     407        {
     408            Py_DECREF(list);
     409            list = NULL;
     410            break;
     411        }
     412        Py_DECREF(str);
     413    }
     414    /* XXX Shouldn't we free the list of maps now? */
     415    return list;
    415416}
    416417
    417418static PyMethodDef nis_methods[] = {
    418         {"match",               (PyCFunction)nis_match,
    419                                         METH_VARARGS | METH_KEYWORDS,
    420                                         match__doc__},
    421         {"cat",                 (PyCFunction)nis_cat,
    422                                         METH_VARARGS | METH_KEYWORDS,
    423                                         cat__doc__},
    424         {"maps",                (PyCFunction)nis_maps,
    425                                         METH_VARARGS | METH_KEYWORDS,
    426                                         maps__doc__},
    427         {"get_default_domain",  (PyCFunction)nis_get_default_domain,
    428                                         METH_NOARGS,
    429                                         get_default_domain__doc__},
    430         {NULL,                  NULL}            /* Sentinel */
     419    {"match",                   (PyCFunction)nis_match,
     420                                    METH_VARARGS | METH_KEYWORDS,
     421                                    match__doc__},
     422    {"cat",                     (PyCFunction)nis_cat,
     423                                    METH_VARARGS | METH_KEYWORDS,
     424                                    cat__doc__},
     425    {"maps",                    (PyCFunction)nis_maps,
     426                                    METH_VARARGS | METH_KEYWORDS,
     427                                    maps__doc__},
     428    {"get_default_domain",      (PyCFunction)nis_get_default_domain,
     429                                    METH_NOARGS,
     430                                    get_default_domain__doc__},
     431    {NULL,                      NULL}            /* Sentinel */
    431432};
    432433
    … …  
    437438initnis (void)
    438439{
    439         PyObject *m, *d;
    440         m = Py_InitModule3("nis", nis_methods, nis__doc__);
    441         if (m == NULL)
    442                 return;
    443         d = PyModule_GetDict(m);
    444         NisError = PyErr_NewException("nis.error", NULL, NULL);
    445         if (NisError != NULL)
    446                 PyDict_SetItemString(d, "error", NisError);
    447 }
     440    PyObject *m, *d;
     441    m = Py_InitModule3("nis", nis_methods, nis__doc__);
     442    if (m == NULL)
     443        return;
     444    d = PyModule_GetDict(m);
     445    NisError = PyErr_NewException("nis.error", NULL, NULL);
     446    if (NisError != NULL)
     447        PyDict_SetItemString(d, "error", NisError);
     448}
Note: See TracChangeset for help on using the changeset viewer.