nss/nss_files/files-XXX.c

   1 /* Common code for file-based databases in nss_files module.
   2    Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   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 <stdio.h>
  21 #include <ctype.h>
  22 #include <assert.h>
  23 #include <errno.h>
  24 #include <fcntl.h>
  25 #include <bits/libc-lock.h>
  26 #include "nsswitch.h"
  27
  28 /* These symbols are defined by the including source file:
  29
  30    ENTNAME -- database name of the structure and functions (hostent, pwent).
  31    STRUCTURE -- struct name, define only if not ENTNAME (passwd, group).
  32    DATABASE -- string of the database file's name ("hosts", "passwd").
  33
  34    NEED_H_ERRNO - defined iff an arg `int *herrnop' is used.
  35
  36    Also see files-parse.c.
  37 */
  38
  39 #define ENTNAME_r       CONCAT(ENTNAME,_r)
  40
  41 #define DATAFILE        "/etc/" DATABASE
  42
  43 #ifdef NEED_H_ERRNO
  44 # include <netdb.h>
  45 # define H_ERRNO_PROTO  , int *herrnop
  46 # define H_ERRNO_ARG    , herrnop
  47 # define H_ERRNO_SET(val) (*herrnop = (val))
  48 #else
  49 # define H_ERRNO_PROTO
  50 # define H_ERRNO_ARG
  51 # define H_ERRNO_SET(val) ((void) 0)
  52 #endif
  53
  54 /* Locks the static variables in this file.  */
  55 __libc_lock_define_initialized (static, lock)
  56 \f
  57 /* Maintenance of the shared stream open on the database file.  */
  58
  59 static FILE *stream;
  60 static fpos_t position;
  61 static enum { none, getent, getby } last_use;
  62 static int keep_stream;
  63
  64 /* Open database file if not already opened.  */
  65 static enum nss_status
  66 internal_setent (int stayopen)
  67 {
  68   enum nss_status status = NSS_STATUS_SUCCESS;
  69
  70   if (stream == NULL)
  71     {
  72       stream = fopen (DATAFILE, "r");
  73
  74       if (stream == NULL)
  75         status = errno == EAGAIN ? NSS_STATUS_TRYAGAIN : NSS_STATUS_UNAVAIL;
  76       else
  77         {
  78           /* We have to make sure the file is  `closed on exec'.  */
  79           int result, flags;
  80
  81           result = flags = fcntl (fileno (stream), F_GETFD, 0);
  82           if (result >= 0)
  83             {
  84               flags |= FD_CLOEXEC;
  85               result = fcntl (fileno (stream), F_SETFD, flags);
  86             }
  87           if (result < 0)
  88             {
  89               /* Something went wrong.  Close the stream and return a
  90                  failure.  */
  91               fclose (stream);
  92               stream = NULL;
  93               status = NSS_STATUS_UNAVAIL;
  94             }
  95         }
  96     }
  97   else
  98     rewind (stream);
  99
 100   /* Remember STAYOPEN flag.  */
 101   if (stream != NULL)
 102     keep_stream |= stayopen;
 103
 104   return status;
 105 }
 106
 107
 108 /* Thread-safe, exported version of that.  */
 109 enum nss_status
 110 CONCAT(_nss_files_set,ENTNAME) (int stayopen)
 111 {
 112   enum nss_status status;
 113
 114   __libc_lock_lock (lock);
 115
 116   status = internal_setent (stayopen);
 117
 118   if (status == NSS_STATUS_SUCCESS && fgetpos (stream, &position) < 0)
 119     {
 120       fclose (stream);
 121       stream = NULL;
 122       status = NSS_STATUS_UNAVAIL;
 123     }
 124
 125   last_use = getent;
 126
 127   __libc_lock_unlock (lock);
 128
 129   return status;
 130 }
 131
 132
 133 /* Close the database file.  */
 134 static void
 135 internal_endent (void)
 136 {
 137   if (stream != NULL)
 138     {
 139       fclose (stream);
 140       stream = NULL;
 141     }
 142 }
 143
 144
 145 /* Thread-safe, exported version of that.  */
 146 enum nss_status
 147 CONCAT(_nss_files_end,ENTNAME) (void)
 148 {
 149   __libc_lock_lock (lock);
 150
 151   internal_endent ();
 152
 153   /* Reset STAYOPEN flag.  */
 154   keep_stream = 0;
 155
 156   __libc_lock_unlock (lock);
 157
 158   return NSS_STATUS_SUCCESS;
 159 }
 160 \f
 161 /* Parsing the database file into `struct STRUCTURE' data structures.  */
 162
 163 static enum nss_status
 164 internal_getent (struct STRUCTURE *result,
 165                  char *buffer, int buflen, int *errnop H_ERRNO_PROTO)
 166 {
 167   char *p;
 168   struct parser_data *data = (void *) buffer;
 169   int linebuflen = buffer + buflen - data->linebuffer;
 170   int parse_result;
 171
 172   if (buflen < (int) sizeof *data + 1)
 173     {
 174       *errnop = ERANGE;
 175       H_ERRNO_SET (NETDB_INTERNAL);
 176       return NSS_STATUS_TRYAGAIN;
 177     }
 178
 179   do
 180     {
 181       /* Terminate the line so that we can test for overflow.  */
 182       data->linebuffer[linebuflen - 1] = '\xff';
 183
 184       p = fgets (data->linebuffer, linebuflen, stream);
 185       if (p == NULL)
 186         {
 187           /* End of file or read error.  */
 188           *errnop = errno;
 189           H_ERRNO_SET (HOST_NOT_FOUND);
 190           return NSS_STATUS_NOTFOUND;
 191         }
 192       else if (data->linebuffer[linebuflen - 1] != '\xff')
 193         {
 194           /* The line is too long.  Give the user the opportunity to
 195              enlarge the buffer.  */
 196           *errnop = ERANGE;
 197           H_ERRNO_SET (NETDB_INTERNAL);
 198           return NSS_STATUS_TRYAGAIN;
 199         }
 200
 201       /* Skip leading blanks.  */
 202       while (isspace (*p))
 203         ++p;
 204     }
 205   while (*p == '\0' || *p == '#' /* Ignore empty and comment lines.  */
 206          /* Parse the line.  If it is invalid, loop to get the next
 207             line of the file to parse.  */
 208          || ! (parse_result = parse_line (p, result, data, buflen, errnop)));
 209
 210   /* Filled in RESULT with the next entry from the database file.  */
 211   return parse_result == -1 ? NSS_STATUS_TRYAGAIN : NSS_STATUS_SUCCESS;
 212 }
 213
 214
 215 /* Return the next entry from the database file, doing locking.  */
 216 enum nss_status
 217 CONCAT(_nss_files_get,ENTNAME_r) (struct STRUCTURE *result, char *buffer,
 218                                   size_t buflen, int *errnop H_ERRNO_PROTO)
 219 {
 220   /* Return next entry in host file.  */
 221   enum nss_status status = NSS_STATUS_SUCCESS;
 222
 223   __libc_lock_lock (lock);
 224
 225   /* Be prepared that the set*ent function was not called before.  */
 226   if (stream == NULL)
 227     status = internal_setent (0);
 228
 229   if (status == NSS_STATUS_SUCCESS)
 230     {
 231       /* If the last use was not by the getent function we need the
 232          position the stream.  */
 233       if (last_use != getent)
 234         if (fsetpos (stream, &position) < 0)
 235           status = NSS_STATUS_UNAVAIL;
 236         else
 237           last_use = getent;
 238
 239       if (status == NSS_STATUS_SUCCESS)
 240         {
 241           status = internal_getent (result, buffer, buflen, errnop
 242                                     H_ERRNO_ARG);
 243
 244           /* Remember this position if we were successful.  If the
 245              operation failed we give the user a chance to repeat the
 246              operation (perhaps the buffer was too small).  */
 247           if (status == NSS_STATUS_SUCCESS)
 248             fgetpos (stream, &position);
 249           else
 250             /* We must make sure we reposition the stream the next call.  */
 251             last_use = none;
 252         }
 253     }
 254
 255   __libc_lock_unlock (lock);
 256
 257   return status;
 258 }
 259 \f
 260 /* Macro for defining lookup functions for this file-based database.
 261
 262    NAME is the name of the lookup; e.g. `hostbyname'.
 263
 264    KEYSIZE and KEYPATTERN are ignored here but used by ../nss_db/db-XXX.c.
 265
 266    PROTO describes the arguments for the lookup key;
 267    e.g. `const char *hostname'.
 268
 269    BREAK_IF_MATCH is a block of code which compares `struct STRUCTURE *result'
 270    to the lookup key arguments and does `break;' if they match.  */
 271
 272 #define DB_LOOKUP(name, keysize, keypattern, break_if_match, proto...)        \
 273 enum nss_status                                                               \
 274 _nss_files_get##name##_r (proto,                                              \
 275                           struct STRUCTURE *result, char *buffer,             \
 276                           size_t buflen, int *errnop H_ERRNO_PROTO)           \
 277 {                                                                             \
 278   enum nss_status status;                                                     \
 279                                                                               \
 280   __libc_lock_lock (lock);                                                    \
 281                                                                               \
 282   /* Reset file pointer to beginning or open file.  */                        \
 283   status = internal_setent (keep_stream);                                     \
 284                                                                               \
 285   if (status == NSS_STATUS_SUCCESS)                                           \
 286     {                                                                         \
 287       /* Tell getent function that we have repositioned the file pointer.  */ \
 288       last_use = getby;                                                       \
 289                                                                               \
 290       while ((status = internal_getent (result, buffer, buflen, errnop        \
 291                                         H_ERRNO_ARG))                         \
 292              == NSS_STATUS_SUCCESS)                                           \
 293         { break_if_match }                                                    \
 294                                                                               \
 295       if (! keep_stream)                                                      \
 296         internal_endent ();                                                   \
 297     }                                                                         \
 298                                                                               \
 299   __libc_lock_unlock (lock);                                                  \
 300                                                                               \
 301   return status;                                                              \
 302 }