nss/nss_files/files-XXX.c

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