nss/nss_files/files-netgrp.c

   1 /* Netgroup file parser in nss_files modules.
   2    Copyright (C) 1996, 1997, 2000, 2004, 2005 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, write to the Free
  18    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19    02111-1307 USA.  */
  20
  21 #include <ctype.h>
  22 #include <errno.h>
  23 #include <netdb.h>
  24 #include <stdio.h>
  25 #include <stdio_ext.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include "nsswitch.h"
  29 #include "netgroup.h"
  30
  31 #define DATAFILE        "/etc/netgroup"
  32
  33 libnss_files_hidden_proto (_nss_files_endnetgrent)
  34
  35 #define EXPAND(needed)                                                        \
  36   do                                                                          \
  37     {                                                                         \
  38       size_t old_cursor = result->cursor - result->data;                      \
  39       void *old_data = result->data;                                          \
  40                                                                               \
  41       result->data_size += 512 > 2 * needed ? 512 : 2 * needed;               \
  42       result->data = realloc (result->data, result->data_size);               \
  43                                                                               \
  44       if (result->data == NULL)                                               \
  45         {                                                                     \
  46           free (old_data);                                                    \
  47           status = NSS_STATUS_UNAVAIL;                                        \
  48           goto the_end;                                                       \
  49         }                                                                     \
  50                                                                               \
  51       result->cursor = result->data + old_cursor;                             \
  52     }                                                                         \
  53   while (0)
  54
  55
  56 enum nss_status
  57 _nss_files_setnetgrent (const char *group, struct __netgrent *result)
  58 {
  59   FILE *fp;
  60   enum nss_status status;
  61
  62   if (group[0] == '\0')
  63     return NSS_STATUS_UNAVAIL;
  64
  65   /* Find the netgroups file and open it.  */
  66   fp = fopen (DATAFILE, "r");
  67   if (fp == NULL)
  68     status = errno == EAGAIN ? NSS_STATUS_TRYAGAIN : NSS_STATUS_UNAVAIL;
  69   else
  70     {
  71       /* Read the file line by line and try to find the description
  72          GROUP.  We must take care for long lines.  */
  73       char *line = NULL;
  74       size_t line_len = 0;
  75       const ssize_t group_len = strlen (group);
  76
  77       status = NSS_STATUS_NOTFOUND;
  78       result->cursor = result->data;
  79
  80       __fsetlocking (fp, FSETLOCKING_BYCALLER);
  81
  82       while (!feof_unlocked (fp))
  83         {
  84           ssize_t curlen = getline (&line, &line_len, fp);
  85           int found;
  86
  87           if (curlen < 0)
  88             {
  89               status = NSS_STATUS_NOTFOUND;
  90               break;
  91             }
  92
  93           found = (curlen > group_len && strncmp (line, group, group_len) == 0
  94                    && isspace (line[group_len]));
  95
  96           /* Read the whole line (including continuation) and store it
  97              if FOUND in nonzero.  Otherwise we don't need it.  */
  98           if (found)
  99             {
 100               /* Store the data from the first line.  */
 101               EXPAND (curlen - group_len);
 102               memcpy (result->cursor, &line[group_len + 1],
 103                       curlen - group_len);
 104               result->cursor += (curlen - group_len) - 1;
 105             }
 106
 107           while (line[curlen - 1] == '\n' && line[curlen - 2] == '\\')
 108             {
 109               /* Yes, we have a continuation line.  */
 110               if (found)
 111                 /* Remove these characters from the stored line.  */
 112                 result->cursor -= 2;
 113
 114               /* Get next line.  */
 115               curlen = getline (&line, &line_len, fp);
 116               if (curlen <= 0)
 117                 break;
 118
 119               if (found)
 120                 {
 121                   /* Make sure we have enough room.  */
 122                   EXPAND (1 + curlen + 1);
 123
 124                   /* Add separator in case next line starts immediately.  */
 125                   *result->cursor++ = ' ';
 126
 127                   /* Copy new line.  */
 128                   memcpy (result->cursor, line, curlen + 1);
 129                   result->cursor += curlen;
 130                 }
 131             }
 132
 133           if (found)
 134             {
 135               /* Now we have read the line.  */
 136               status = NSS_STATUS_SUCCESS;
 137               result->cursor = result->data;
 138               result->first = 1;
 139               break;
 140             }
 141         }
 142
 143     the_end:
 144       /* We don't need the file and the line buffer anymore.  */
 145       free (line);
 146       fclose (fp);
 147
 148       if (status != NSS_STATUS_SUCCESS)
 149         _nss_files_endnetgrent (result);
 150     }
 151
 152   return status;
 153 }
 154
 155
 156 enum nss_status
 157 _nss_files_endnetgrent (struct __netgrent *result)
 158 {
 159   /* Free allocated memory for data if some is present.  */
 160   free (result->data);
 161   result->data = NULL;
 162   result->data_size = 0;
 163   result->cursor = NULL;
 164   return NSS_STATUS_SUCCESS;
 165 }
 166 libnss_files_hidden_def (_nss_files_endnetgrent)
 167
 168 static char *
 169 strip_whitespace (char *str)
 170 {
 171   char *cp = str;
 172
 173   /* Skip leading spaces.  */
 174   while (isspace (*cp))
 175     cp++;
 176
 177   str = cp;
 178   while (*cp != '\0' && ! isspace(*cp))
 179     cp++;
 180
 181   /* Null-terminate, stripping off any trailing spaces.  */
 182   *cp = '\0';
 183
 184   return *str == '\0' ? NULL : str;
 185 }
 186
 187 enum nss_status
 188 _nss_netgroup_parseline (char **cursor, struct __netgrent *result,
 189                          char *buffer, size_t buflen, int *errnop)
 190 {
 191   enum nss_status status;
 192   const char *host, *user, *domain;
 193   char *cp = *cursor;
 194
 195   /* Some sanity checks.  */
 196   if (cp == NULL)
 197     return NSS_STATUS_NOTFOUND;
 198
 199   /* First skip leading spaces.  */
 200   while (isspace (*cp))
 201     ++cp;
 202
 203   if (*cp != '(')
 204     {
 205       /* We have a list of other netgroups.  */
 206       char *name = cp;
 207
 208       while (*cp != '\0' && ! isspace (*cp))
 209         ++cp;
 210
 211       if (name != cp)
 212         {
 213           /* It is another netgroup name.  */
 214           int last = *cp == '\0';
 215
 216           result->type = group_val;
 217           result->val.group = name;
 218           *cp = '\0';
 219           if (! last)
 220             ++cp;
 221           *cursor = cp;
 222           result->first = 0;
 223
 224           return NSS_STATUS_SUCCESS;
 225         }
 226
 227       return result->first ? NSS_STATUS_NOTFOUND : NSS_STATUS_RETURN;
 228     }
 229
 230   /* Match host name.  */
 231   host = ++cp;
 232   while (*cp != ',')
 233     if (*cp++ == '\0')
 234       return result->first ? NSS_STATUS_NOTFOUND : NSS_STATUS_RETURN;
 235
 236   /* Match user name.  */
 237   user = ++cp;
 238   while (*cp != ',')
 239     if (*cp++ == '\0')
 240       return result->first ? NSS_STATUS_NOTFOUND : NSS_STATUS_RETURN;
 241
 242   /* Match domain name.  */
 243   domain = ++cp;
 244   while (*cp != ')')
 245     if (*cp++ == '\0')
 246       return result->first ? NSS_STATUS_NOTFOUND : NSS_STATUS_RETURN;
 247   ++cp;
 248
 249
 250   /* When we got here we have found an entry.  Before we can copy it
 251      to the private buffer we have to make sure it is big enough.  */
 252   if (cp - host > buflen)
 253     {
 254       *errnop = ERANGE;
 255       status = NSS_STATUS_UNAVAIL;
 256     }
 257   else
 258     {
 259       memcpy (buffer, host, cp - host);
 260       result->type = triple_val;
 261
 262       buffer[(user - host) - 1] = '\0'; /* Replace ',' with '\0'.  */
 263       result->val.triple.host = strip_whitespace (buffer);
 264
 265       buffer[(domain - host) - 1] = '\0'; /* Replace ',' with '\0'.  */
 266       result->val.triple.user = strip_whitespace (buffer + (user - host));
 267
 268       buffer[(cp - host) - 1] = '\0'; /* Replace ')' with '\0'.  */
 269       result->val.triple.domain = strip_whitespace (buffer + (domain - host));
 270
 271       status = NSS_STATUS_SUCCESS;
 272
 273       /* Remember where we stopped reading.  */
 274       *cursor = cp;
 275
 276       result->first = 0;
 277     }
 278
 279   return status;
 280 }
 281 libnss_files_hidden_def (_nss_netgroup_parseline)
 282
 283
 284 enum nss_status
 285 _nss_files_getnetgrent_r (struct __netgrent *result, char *buffer,
 286                           size_t buflen, int *errnop)
 287 {
 288   enum nss_status status;
 289
 290   status = _nss_netgroup_parseline (&result->cursor, result, buffer, buflen,
 291                                     errnop);
 292
 293   return status;
 294 }