nss/nss_files/files-netgrp.c

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