nis/nss_nis/nis-service.c

   1 /* Copyright (C) 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Thorsten Kukuk <kukuk@suse.de>, 1996.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Library General Public License as
   7    published by the Free Software Foundation; either version 2 of the
   8    License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Library General Public License for more details.
  14
  15    You should have received a copy of the GNU Library General Public
  16    License along with the GNU C Library; see the file COPYING.LIB.  If not,
  17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18    Boston, MA 02111-1307, USA.  */
  19
  20 #include <nss.h>
  21 #include <netdb.h>
  22 #include <ctype.h>
  23 #include <errno.h>
  24 #include <string.h>
  25 #include <bits/libc-lock.h>
  26 #include <rpcsvc/yp.h>
  27 #include <rpcsvc/ypclnt.h>
  28
  29 #include "nss-nis.h"
  30
  31
  32 /* Get the declaration of the parser function.  */
  33 #define ENTNAME servent
  34 #define EXTERN_PARSER
  35 #include <nss/nss_files/files-parse.c>
  36
  37 __libc_lock_define_initialized (static, lock)
  38
  39 struct response_t
  40 {
  41   char *val;
  42   struct response_t *next;
  43 };
  44
  45 struct intern_t
  46 {
  47   struct response_t *start;
  48   struct response_t *next;
  49 };
  50 typedef struct intern_t intern_t;
  51
  52 static intern_t intern = { NULL, NULL };
  53
  54 static int
  55 saveit (int instatus, char *inkey, int inkeylen, char *inval,
  56         int invallen, char *indata)
  57 {
  58   intern_t *intern = (intern_t *) indata;
  59
  60   if (instatus != YP_TRUE)
  61     return instatus;
  62
  63   if (inkey && inkeylen > 0 && inval && invallen > 0)
  64     {
  65       if (intern->start == NULL)
  66         {
  67           intern->start = malloc (sizeof (struct response_t));
  68           if (intern->start == NULL)
  69             return YP_FALSE; /* We have no error code for out of memory */
  70           intern->next = intern->start;
  71         }
  72       else
  73         {
  74           intern->next->next = malloc (sizeof (struct response_t));
  75           if (intern->next->next == NULL)
  76             return YP_FALSE; /* We have no error code for out of memory */
  77           intern->next = intern->next->next;
  78         }
  79       intern->next->next = NULL;
  80       intern->next->val = malloc (invallen + 1);
  81       if (intern->next->val == NULL)
  82         return YP_FALSE; /* We have no error code for out of memory */
  83       strncpy (intern->next->val, inval, invallen);
  84       intern->next->val[invallen] = '\0';
  85     }
  86
  87   return 0;
  88 }
  89
  90 static enum nss_status
  91 internal_nis_setservent (intern_t *intern)
  92 {
  93   char *domainname;
  94   struct ypall_callback ypcb;
  95   enum nss_status status;
  96
  97   if (yp_get_default_domain (&domainname))
  98     return NSS_STATUS_UNAVAIL;
  99
 100   while (intern->start != NULL)
 101     {
 102       if (intern->start->val != NULL)
 103         free (intern->start->val);
 104       intern->next = intern->start;
 105       intern->start = intern->start->next;
 106       free (intern->next);
 107     }
 108   intern->start = NULL;
 109
 110   ypcb.foreach = saveit;
 111   ypcb.data = (char *) intern;
 112   status = yperr2nss (yp_all (domainname, "services.byname", &ypcb));
 113   intern->next = intern->start;
 114
 115   return status;
 116 }
 117 enum nss_status
 118 _nss_nis_setservent (int stayopen)
 119 {
 120   enum nss_status status;
 121
 122   __libc_lock_lock (lock);
 123
 124   status = internal_nis_setservent (&intern);
 125
 126   __libc_lock_unlock (lock);
 127
 128   return status;
 129 }
 130
 131 static enum nss_status
 132 internal_nis_endservent (intern_t * intern)
 133 {
 134   while (intern->start != NULL)
 135     {
 136       if (intern->start->val != NULL)
 137         free (intern->start->val);
 138       intern->next = intern->start;
 139       intern->start = intern->start->next;
 140       free (intern->next);
 141     }
 142   intern->start = NULL;
 143
 144   return NSS_STATUS_SUCCESS;
 145 }
 146
 147 enum nss_status
 148 _nss_nis_endservent (void)
 149 {
 150   enum nss_status status;
 151
 152   __libc_lock_lock (lock);
 153
 154   status = internal_nis_endservent (&intern);
 155
 156   __libc_lock_unlock (lock);
 157
 158   return status;
 159 }
 160
 161 static enum nss_status
 162 internal_nis_getservent_r (struct servent *serv, char *buffer,
 163                            size_t buflen, int *errnop, intern_t *data)
 164 {
 165   struct parser_data *pdata = (void *) buffer;
 166   int parse_res;
 167   char *p;
 168
 169   if (data->start == NULL)
 170     internal_nis_setservent (data);
 171
 172   /* Get the next entry until we found a correct one. */
 173   do
 174     {
 175       if (data->next == NULL)
 176         {
 177           *errnop = ENOENT;
 178           return NSS_STATUS_NOTFOUND;
 179         }
 180       p = strncpy (buffer, data->next->val, buflen);
 181       while (isspace (*p))
 182         ++p;
 183
 184       parse_res = _nss_files_parse_servent (p, serv, pdata, buflen, errnop);
 185       if (parse_res == -1)
 186         return NSS_STATUS_TRYAGAIN;
 187       data->next = data->next->next;
 188     }
 189   while (!parse_res);
 190
 191   return NSS_STATUS_SUCCESS;
 192 }
 193
 194 enum nss_status
 195 _nss_nis_getservent_r (struct servent *serv, char *buffer, size_t buflen,
 196                        int *errnop)
 197 {
 198   enum nss_status status;
 199
 200   __libc_lock_lock (lock);
 201
 202   status = internal_nis_getservent_r (serv, buffer, buflen, errnop, &intern);
 203
 204   __libc_lock_unlock (lock);
 205
 206   return status;
 207 }
 208
 209 enum nss_status
 210 _nss_nis_getservbyname_r (const char *name, const char *protocol,
 211                           struct servent *serv, char *buffer, size_t buflen,
 212                           int *errnop)
 213 {
 214   intern_t data = { NULL, NULL };
 215   enum nss_status status;
 216   int found;
 217
 218   if (name == NULL)
 219     {
 220       *errnop = EINVAL;
 221       return NSS_STATUS_UNAVAIL;
 222     }
 223
 224   /* If the protocol is given, we could try if our NIS server knows
 225      about services.byservicename map. If yes, we only need one query */
 226   if (protocol != NULL)
 227     {
 228       char key[strlen (name) + strlen (protocol) + 2];
 229       char *cp, *domain, *result;
 230       size_t keylen, len;
 231
 232       /* If this fails, the other solution will also fail. */
 233       if (yp_get_default_domain (&domain))
 234         return NSS_STATUS_UNAVAIL;
 235
 236       /* key is: "name/protocol" */
 237       cp = stpcpy (key, name);
 238       *cp++ = '/';
 239       stpcpy (cp, protocol);
 240       keylen = strlen (key);
 241       status = yperr2nss (yp_match (domain, "services.byservicename", key,
 242                                     keylen, &result, &len));
 243
 244       /* If we found the key, it's ok and parse the result. If not,
 245          fall through and parse the complete table. */
 246       if (status == NSS_STATUS_SUCCESS)
 247         {
 248           struct parser_data *pdata = (void *) buffer;
 249           int parse_res;
 250           char *p;
 251
 252           if ((size_t) (len + 1) > buflen)
 253             {
 254               free (result);
 255               *errnop = ERANGE;
 256               return NSS_STATUS_TRYAGAIN;
 257             }
 258
 259           p = strncpy (buffer, result, len);
 260           buffer[len] = '\0';
 261           while (isspace (*p))
 262             ++p;
 263           free (result);
 264           parse_res = _nss_files_parse_servent (p, serv, pdata,
 265                                                 buflen, errnop);
 266           if (parse_res < 0)
 267             {
 268               if (parse_res == -1)
 269                 return NSS_STATUS_TRYAGAIN;
 270               else
 271                 {
 272                   *errnop = ENOENT;
 273                   return NSS_STATUS_NOTFOUND;
 274                 }
 275             }
 276           else
 277             return NSS_STATUS_SUCCESS;
 278         }
 279     }
 280
 281   status = internal_nis_setservent (&data);
 282   if (status != NSS_STATUS_SUCCESS)
 283     return status;
 284
 285   found = 0;
 286   while (!found &&
 287          ((status = internal_nis_getservent_r (serv, buffer, buflen, errnop,
 288                                                &data)) == NSS_STATUS_SUCCESS))
 289     {
 290       if (protocol == NULL || strcmp (serv->s_proto, protocol) == 0)
 291         {
 292           char **cp;
 293
 294           if (strcmp (serv->s_name, name) == 0)
 295             found = 1;
 296           else
 297             for (cp = serv->s_aliases; *cp; cp++)
 298               if (strcmp (name, *cp) == 0)
 299                 found = 1;
 300         }
 301     }
 302
 303   internal_nis_endservent (&data);
 304
 305   if (!found && status == NSS_STATUS_SUCCESS)
 306     {
 307       *errnop = ENOENT;
 308       return NSS_STATUS_NOTFOUND;
 309     }
 310   else
 311     return status;
 312 }
 313
 314 enum nss_status
 315 _nss_nis_getservbyport_r (int port, const char *protocol,
 316                           struct servent *serv, char *buffer,
 317                           size_t buflen, int *errnop)
 318 {
 319   intern_t data = { NULL, NULL };
 320   enum nss_status status;
 321   int found;
 322
 323   /* If the protocol is given, we only need one query */
 324   if (protocol != NULL)
 325     {
 326       char key[100 + strlen (protocol) + 2];
 327       char *domain, *result;
 328       size_t keylen, len;
 329       int int_len;
 330
 331       /* If this fails, the other solution will also fail. */
 332       if (yp_get_default_domain (&domain))
 333         return NSS_STATUS_UNAVAIL;
 334
 335       /* key is: "port/protocol" */
 336       keylen = snprintf (key, sizeof (key), "%d/%s", port, protocol);
 337       status = yperr2nss (yp_match (domain, "services.byname", key,
 338                                     keylen, &result, &int_len));
 339       len = int_len;
 340
 341       /* If we found the key, it's ok and parse the result. If not,
 342          fall through and parse the complete table. */
 343       if (status == NSS_STATUS_SUCCESS)
 344         {
 345           struct parser_data *pdata = (void *) buffer;
 346           int parse_res;
 347           char *p;
 348
 349           if ((size_t) (len + 1) > buflen)
 350             {
 351               free (result);
 352               *errnop = ERANGE;
 353               return NSS_STATUS_TRYAGAIN;
 354             }
 355
 356           p = strncpy (buffer, result, len);
 357           buffer[len] = '\0';
 358           while (isspace (*p))
 359             ++p;
 360           free (result);
 361           parse_res = _nss_files_parse_servent (p, serv, pdata,
 362                                                 buflen, errnop);
 363           if (parse_res < 0)
 364             {
 365               if (parse_res == -1)
 366                 return NSS_STATUS_TRYAGAIN;
 367               else
 368                 {
 369                   *errnop = ENOENT;
 370                   return NSS_STATUS_NOTFOUND;
 371                 }
 372             }
 373           else
 374             return NSS_STATUS_SUCCESS;
 375         }
 376     }
 377
 378   status = internal_nis_setservent (&data);
 379   if (status != NSS_STATUS_SUCCESS)
 380     return status;
 381
 382   found = 0;
 383   while (!found &&
 384          ((status = internal_nis_getservent_r (serv, buffer, buflen, errnop,
 385                                                &data)) == NSS_STATUS_SUCCESS))
 386     if (serv->s_port == port &&
 387         (protocol == NULL || strcmp (serv->s_proto, protocol) == 0))
 388       found = 1;
 389
 390   internal_nis_endservent (&data);
 391
 392   if (!found && status == NSS_STATUS_SUCCESS)
 393     {
 394       *errnop = ENOENT;
 395       return NSS_STATUS_NOTFOUND;
 396     }
 397   else
 398     return status;
 399 }