nis/nss_nis/nis-service.c

   1 /* Copyright (C) 1996, 1997 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Thorsten Kukuk <kukuk@vt.uni-paderborn.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 <libc-lock.h>
  26 #include <rpcsvc/yp.h>
  27 #include <rpcsvc/ypclnt.h>
  28
  29 #include "nss-nis.h"
  30
  31
  32 /* The parser is defined in a different module.  */
  33 extern int _nss_files_parse_servent (char *line, struct servent *result,
  34                                      char *data, size_t datalen);
  35
  36
  37
  38 __libc_lock_define_initialized (static, lock)
  39
  40 struct response_t
  41 {
  42   char *val;
  43   struct response_t *next;
  44 };
  45
  46 struct intern_t
  47 {
  48   struct response_t *start;
  49   struct response_t *next;
  50 };
  51 typedef struct intern_t intern_t;
  52
  53 static intern_t intern = { NULL, NULL };
  54
  55 static int
  56 saveit (int instatus, char *inkey, int inkeylen, char *inval,
  57         int invallen, char *indata)
  58 {
  59   intern_t *intern = (intern_t *) indata;
  60
  61   if (instatus != YP_TRUE)
  62     return instatus;
  63
  64   if (inkey && inkeylen > 0 && inval && invallen > 0)
  65     {
  66       if (intern->start == NULL)
  67         {
  68           intern->start = malloc (sizeof (struct response_t));
  69           intern->next = intern->start;
  70         }
  71       else
  72         {
  73           intern->next->next = malloc (sizeof (struct response_t));
  74           intern->next = intern->next->next;
  75         }
  76       intern->next->next = NULL;
  77       intern->next->val = malloc (invallen + 1);
  78       strncpy (intern->next->val, inval, invallen);
  79       intern->next->val[invallen] = '\0';
  80     }
  81
  82   return 0;
  83 }
  84
  85 static enum nss_status
  86 internal_nis_setservent (intern_t *intern)
  87 {
  88   char *domainname;
  89   struct ypall_callback ypcb;
  90   enum nss_status status;
  91
  92   if (yp_get_default_domain (&domainname))
  93     return NSS_STATUS_UNAVAIL;
  94
  95   while (intern->start != NULL)
  96     {
  97       if (intern->start->val != NULL)
  98         free (intern->start->val);
  99       intern->next = intern->start;
 100       intern->start = intern->start->next;
 101       free (intern->next);
 102     }
 103   intern->start = NULL;
 104
 105   ypcb.foreach = saveit;
 106   ypcb.data = (char *) intern;
 107   status = yperr2nss (yp_all (domainname, "services.byname", &ypcb));
 108   intern->next = intern->start;
 109
 110   return status;
 111 }
 112 enum nss_status
 113 _nss_nis_setservent (void)
 114 {
 115   enum nss_status status;
 116
 117   __libc_lock_lock (lock);
 118
 119   status = internal_nis_setservent (&intern);
 120
 121   __libc_lock_unlock (lock);
 122
 123   return status;
 124 }
 125
 126 static enum nss_status
 127 internal_nis_endservent (intern_t * intern)
 128 {
 129   while (intern->start != NULL)
 130     {
 131       if (intern->start->val != NULL)
 132         free (intern->start->val);
 133       intern->next = intern->start;
 134       intern->start = intern->start->next;
 135       free (intern->next);
 136     }
 137   intern->start = NULL;
 138
 139   return NSS_STATUS_SUCCESS;
 140 }
 141
 142 enum nss_status
 143 _nss_nis_endservent (void)
 144 {
 145   enum nss_status status;
 146
 147   __libc_lock_lock (lock);
 148
 149   status = internal_nis_endservent (&intern);
 150
 151   __libc_lock_unlock (lock);
 152
 153   return status;
 154 }
 155
 156 static enum nss_status
 157 internal_nis_getservent_r (struct servent *serv, char *buffer,
 158                            size_t buflen, intern_t *data)
 159 {
 160   int parse_res;
 161   char *p;
 162
 163   if (data->start == NULL)
 164     internal_nis_setservent (data);
 165
 166   /* Get the next entry until we found a correct one. */
 167   do
 168     {
 169       if (data->next == NULL)
 170         return NSS_STATUS_NOTFOUND;
 171       p = strncpy (buffer, data->next->val, buflen);
 172       data->next = data->next->next;
 173       while (isspace (*p))
 174         ++p;
 175
 176       parse_res = _nss_files_parse_servent (p, serv, buffer, buflen);
 177       if (!parse_res && errno == ERANGE)
 178         return NSS_STATUS_TRYAGAIN;
 179     }
 180   while (!parse_res);
 181
 182   return NSS_STATUS_SUCCESS;
 183 }
 184
 185 enum nss_status
 186 _nss_nis_getservent_r (struct servent *serv, char *buffer, size_t buflen)
 187 {
 188   enum nss_status status;
 189
 190   __libc_lock_lock (lock);
 191
 192   status = internal_nis_getservent_r (serv, buffer, buflen, &intern);
 193
 194   __libc_lock_unlock (lock);
 195
 196   return status;
 197 }
 198
 199 enum nss_status
 200 _nss_nis_getservbyname_r (const char *name, char *protocol,
 201                           struct servent *serv, char *buffer, size_t buflen)
 202 {
 203   intern_t data = { NULL, NULL };
 204   enum nss_status status;
 205   int found;
 206
 207   if (name == NULL)
 208     {
 209       __set_errno (EINVAL);
 210       return NSS_STATUS_UNAVAIL;
 211     }
 212
 213   status = internal_nis_setservent (&data);
 214   if (status != NSS_STATUS_SUCCESS)
 215     return status;
 216
 217   found = 0;
 218   while (!found &&
 219          ((status = internal_nis_getservent_r (serv, buffer, buflen, &data))
 220           == NSS_STATUS_SUCCESS))
 221     {
 222       if (protocol == NULL || strcmp (serv->s_proto, protocol) == 0)
 223         {
 224           char **cp;
 225
 226           if (strcmp (serv->s_name, name) == 0)
 227             found = 1;
 228           else
 229             for (cp = serv->s_aliases; *cp; cp++)
 230               if (strcmp (name, *cp) == 0)
 231                 found = 1;
 232         }
 233     }
 234
 235   internal_nis_endservent (&data);
 236
 237   if (!found && status == NSS_STATUS_SUCCESS)
 238     return NSS_STATUS_NOTFOUND;
 239   else
 240     return status;
 241 }
 242
 243 enum nss_status
 244 _nss_nis_getservbyport_r (int port, char *protocol, struct servent *serv,
 245                           char *buffer, size_t buflen)
 246 {
 247   intern_t data = { NULL, NULL };
 248   enum nss_status status;
 249   int found;
 250
 251   if (protocol == NULL)
 252     {
 253       __set_errno (EINVAL);
 254       return NSS_STATUS_UNAVAIL;
 255     }
 256
 257   status = internal_nis_setservent (&data);
 258   if (status != NSS_STATUS_SUCCESS)
 259     return status;
 260
 261   found = 0;
 262   while (!found &&
 263          ((status = internal_nis_getservent_r (serv, buffer, buflen, &data))
 264           == NSS_STATUS_SUCCESS))
 265     {
 266       if (htons (serv->s_port) == port)
 267         {
 268           if  (strcmp (serv->s_proto, protocol) == 0)
 269             {
 270               found = 1;
 271             }
 272         }
 273     }
 274
 275   internal_nis_endservent (&data);
 276
 277   if (!found && status == NSS_STATUS_SUCCESS)
 278     return NSS_STATUS_NOTFOUND;
 279   else
 280     return status;
 281 }