nss/nss_files/files-alias.c

   1 /* Mail alias file parser in nss_files module.
   2    Copyright (C) 1996-2016 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, see
  18    <http://www.gnu.org/licenses/>.  */
  19
  20 #include <aliases.h>
  21 #include <ctype.h>
  22 #include <errno.h>
  23 #include <fcntl.h>
  24 #include <libc-lock.h>
  25 #include <stdlib.h>
  26 #include <stdio.h>
  27 #include <string.h>
  28
  29 #include <kernel-features.h>
  30
  31 #include "nsswitch.h"
  32
  33 /* Locks the static variables in this file.  */
  34 __libc_lock_define_initialized (static, lock)
  35 \f
  36 /* Maintenance of the stream open on the database file.  For getXXent
  37    operations the stream needs to be held open across calls, the other
  38    getXXbyYY operations all use their own stream.  */
  39
  40 static FILE *stream;
  41
  42
  43 static enum nss_status
  44 internal_setent (FILE **stream)
  45 {
  46   enum nss_status status = NSS_STATUS_SUCCESS;
  47
  48   if (*stream == NULL)
  49     {
  50       *stream = fopen ("/etc/aliases", "rce");
  51
  52       if (*stream == NULL)
  53         status = errno == EAGAIN ? NSS_STATUS_TRYAGAIN : NSS_STATUS_UNAVAIL;
  54       else
  55         {
  56 #if !defined O_CLOEXEC || !defined __ASSUME_O_CLOEXEC
  57 # ifdef O_CLOEXEC
  58           if (__have_o_cloexec <= 0)
  59 # endif
  60             {
  61               /* We have to make sure the file is  `closed on exec'.  */
  62               int result;
  63               int flags;
  64
  65               result = flags = fcntl (fileno (*stream), F_GETFD, 0);
  66               if (result >= 0)
  67                 {
  68 # ifdef O_CLOEXEC
  69                   if (__have_o_cloexec == 0)
  70                     __have_o_cloexec = (flags & FD_CLOEXEC) == 0 ? -1 : 1;
  71                   if (__have_o_cloexec < 0)
  72 # endif
  73                     {
  74                       flags |= FD_CLOEXEC;
  75                       result = fcntl (fileno (*stream), F_SETFD, flags);
  76                     }
  77                 }
  78               if (result < 0)
  79                 {
  80                   /* Something went wrong.  Close the stream and return a
  81                      failure.  */
  82                   fclose (*stream);
  83                   stream = NULL;
  84                   status = NSS_STATUS_UNAVAIL;
  85                 }
  86             }
  87 #endif
  88         }
  89     }
  90   else
  91     rewind (*stream);
  92
  93   return status;
  94 }
  95
  96
  97 /* Thread-safe, exported version of that.  */
  98 enum nss_status
  99 _nss_files_setaliasent (void)
 100 {
 101   enum nss_status status;
 102
 103   __libc_lock_lock (lock);
 104
 105   status = internal_setent (&stream);
 106
 107   __libc_lock_unlock (lock);
 108
 109   return status;
 110 }
 111
 112
 113 /* Close the database file.  */
 114 static void
 115 internal_endent (FILE **stream)
 116 {
 117   if (*stream != NULL)
 118     {
 119       fclose (*stream);
 120       *stream = NULL;
 121     }
 122 }
 123
 124
 125 /* Thread-safe, exported version of that.  */
 126 enum nss_status
 127 _nss_files_endaliasent (void)
 128 {
 129   __libc_lock_lock (lock);
 130
 131   internal_endent (&stream);
 132
 133   __libc_lock_unlock (lock);
 134
 135   return NSS_STATUS_SUCCESS;
 136 }
 137 \f
 138 /* Parsing the database file into `struct aliasent' data structures.  */
 139 static enum nss_status
 140 get_next_alias (FILE *stream, const char *match, struct aliasent *result,
 141                 char *buffer, size_t buflen, int *errnop)
 142 {
 143   enum nss_status status = NSS_STATUS_NOTFOUND;
 144   int ignore = 0;
 145
 146   result->alias_members_len = 0;
 147
 148   while (1)
 149     {
 150       /* Now we are ready to process the input.  We have to read a
 151          line and all its continuations and construct the array of
 152          string pointers.  This pointers and the names itself have to
 153          be placed in BUFFER.  */
 154       char *first_unused = buffer;
 155       size_t room_left = buflen - (buflen % __alignof__ (char *));
 156       char *line;
 157
 158       /* Check whether the buffer is large enough for even trying to
 159          read something.  */
 160       if (room_left < 2)
 161         goto no_more_room;
 162
 163       /* Read the first line.  It must contain the alias name and
 164          possibly some alias names.  */
 165       first_unused[room_left - 1] = '\xff';
 166       line = fgets_unlocked (first_unused, room_left, stream);
 167       if (line == NULL)
 168         /* Nothing to read.  */
 169         break;
 170       else if (first_unused[room_left - 1] != '\xff')
 171         {
 172           /* The line is too long for our buffer.  */
 173         no_more_room:
 174           *errnop = ERANGE;
 175           status = NSS_STATUS_TRYAGAIN;
 176           break;
 177         }
 178       else
 179         {
 180           char *cp;
 181
 182           /* If we are in IGNORE mode and the first character in the
 183              line is a white space we ignore the line and start
 184              reading the next.  */
 185           if (ignore && isspace (*first_unused))
 186             continue;
 187
 188           /* Terminate the line for any case.  */
 189           cp = strpbrk (first_unused, "#\n");
 190           if (cp != NULL)
 191             *cp = '\0';
 192
 193           /* Skip leading blanks.  */
 194           while (isspace (*line))
 195             ++line;
 196
 197           result->alias_name = first_unused;
 198           while (*line != '\0' && *line != ':')
 199             *first_unused++ = *line++;
 200           if (*line == '\0' || result->alias_name == first_unused)
 201             /* No valid name.  Ignore the line.  */
 202             continue;
 203
 204           *first_unused++ = '\0';
 205           if (room_left < (size_t) (first_unused - result->alias_name))
 206             goto no_more_room;
 207           room_left -= first_unused - result->alias_name;
 208           ++line;
 209
 210           /* When we search for a specific alias we can avoid all the
 211              difficult parts and compare now with the name we are
 212              looking for.  If it does not match we simply ignore all
 213              lines until the next line containing the start of a new
 214              alias is found.  */
 215           ignore = (match != NULL
 216                     && __strcasecmp (result->alias_name, match) != 0);
 217
 218           while (! ignore)
 219             {
 220               while (isspace (*line))
 221                 ++line;
 222
 223               cp = first_unused;
 224               while (*line != '\0' && *line != ',')
 225                 *first_unused++ = *line++;
 226
 227               if (first_unused != cp)
 228                 {
 229                   /* OK, we can have a regular entry or an include
 230                      request.  */
 231                   if (*line != '\0')
 232                     ++line;
 233                   *first_unused++ = '\0';
 234
 235                   if (strncmp (cp, ":include:", 9) != 0)
 236                     {
 237                       if (room_left < (first_unused - cp) + sizeof (char *))
 238                         goto no_more_room;
 239                       room_left -= (first_unused - cp) + sizeof (char *);
 240
 241                       ++result->alias_members_len;
 242                     }
 243                   else
 244                     {
 245                       /* Oh well, we have to read the addressed file.  */
 246                       FILE *listfile;
 247                       char *old_line = NULL;
 248
 249                       first_unused = cp;
 250
 251                       listfile = fopen (&cp[9], "rce");
 252                       /* If the file does not exist we simply ignore
 253                          the statement.  */
 254                       if (listfile != NULL
 255                           && (old_line = strdup (line)) != NULL)
 256                         {
 257                           while (! feof_unlocked (listfile))
 258                             {
 259                               first_unused[room_left - 1] = '\xff';
 260                               line = fgets_unlocked (first_unused, room_left,
 261                                                      listfile);
 262                               if (line == NULL)
 263                                 break;
 264                               if (first_unused[room_left - 1] != '\xff')
 265                                 {
 266                                   free (old_line);
 267                                   goto no_more_room;
 268                                 }
 269
 270                               /* Parse the line.  */
 271                               cp = strpbrk (line, "#\n");
 272                               if (cp != NULL)
 273                                 *cp = '\0';
 274
 275                               do
 276                                 {
 277                                   while (isspace (*line))
 278                                     ++line;
 279
 280                                   cp = first_unused;
 281                                   while (*line != '\0' && *line != ',')
 282                                     *first_unused++ = *line++;
 283
 284                                   if (*line != '\0')
 285                                     ++line;
 286
 287                                   if (first_unused != cp)
 288                                     {
 289                                       *first_unused++ = '\0';
 290                                       if (room_left < ((first_unused - cp)
 291                                                        + __alignof__ (char *)))
 292                                         {
 293                                           free (old_line);
 294                                           goto no_more_room;
 295                                         }
 296                                       room_left -= ((first_unused - cp)
 297                                                     + __alignof__ (char *));
 298                                       ++result->alias_members_len;
 299                                     }
 300                                 }
 301                               while (*line != '\0');
 302                             }
 303                           fclose (listfile);
 304
 305                           first_unused[room_left - 1] = '\0';
 306                           strncpy (first_unused, old_line, room_left);
 307
 308                           free (old_line);
 309                           line = first_unused;
 310
 311                           if (first_unused[room_left - 1] != '\0')
 312                             goto no_more_room;
 313                         }
 314                     }
 315                 }
 316
 317               if (*line == '\0')
 318                 {
 319                   /* Get the next line.  But we must be careful.  We
 320                      must not read the whole line at once since it
 321                      might belong to the current alias.  Simply read
 322                      the first character.  If it is a white space we
 323                      have a continuation line.  Otherwise it is the
 324                      beginning of a new alias and we can push back the
 325                      just read character.  */
 326                   int ch;
 327
 328                   ch = fgetc_unlocked (stream);
 329                   if (ch == EOF || ch == '\n' || !isspace (ch))
 330                     {
 331                       size_t cnt;
 332
 333                       /* Now prepare the return.  Provide string
 334                          pointers for the currently selected aliases.  */
 335                       if (ch != EOF)
 336                         ungetc (ch, stream);
 337
 338                       /* Adjust the pointer so it is aligned for
 339                          storing pointers.  */
 340                       first_unused += __alignof__ (char *) - 1;
 341                       first_unused -= ((first_unused - (char *) 0)
 342                                        % __alignof__ (char *));
 343                       result->alias_members = (char **) first_unused;
 344
 345                       /* Compute addresses of alias entry strings.  */
 346                       cp = result->alias_name;
 347                       for (cnt = 0; cnt < result->alias_members_len; ++cnt)
 348                         {
 349                           cp = strchr (cp, '\0') + 1;
 350                           result->alias_members[cnt] = cp;
 351                         }
 352
 353                       status = (result->alias_members_len == 0
 354                                 ? NSS_STATUS_RETURN : NSS_STATUS_SUCCESS);
 355                       break;
 356                     }
 357
 358                   /* The just read character is a white space and so
 359                      can be ignored.  */
 360                   first_unused[room_left - 1] = '\xff';
 361                   line = fgets_unlocked (first_unused, room_left, stream);
 362                   if (first_unused[room_left - 1] != '\xff')
 363                     goto no_more_room;
 364                   cp = strpbrk (line, "#\n");
 365                   if (cp != NULL)
 366                     *cp = '\0';
 367                 }
 368             }
 369         }
 370
 371       if (status != NSS_STATUS_NOTFOUND)
 372         /* We read something.  In any case break here.  */
 373         break;
 374     }
 375
 376   return status;
 377 }
 378
 379
 380 enum nss_status
 381 _nss_files_getaliasent_r (struct aliasent *result, char *buffer, size_t buflen,
 382                           int *errnop)
 383 {
 384   /* Return next entry in host file.  */
 385   enum nss_status status = NSS_STATUS_SUCCESS;
 386
 387   __libc_lock_lock (lock);
 388
 389   /* Be prepared that the set*ent function was not called before.  */
 390   if (stream == NULL)
 391     status = internal_setent (&stream);
 392
 393   if (status == NSS_STATUS_SUCCESS)
 394     {
 395       result->alias_local = 1;
 396
 397       /* Read lines until we get a definite result.  */
 398       do
 399         status = get_next_alias (stream, NULL, result, buffer, buflen, errnop);
 400       while (status == NSS_STATUS_RETURN);
 401     }
 402
 403   __libc_lock_unlock (lock);
 404
 405   return status;
 406 }
 407
 408
 409 enum nss_status
 410 _nss_files_getaliasbyname_r (const char *name, struct aliasent *result,
 411                              char *buffer, size_t buflen, int *errnop)
 412 {
 413   /* Return next entry in host file.  */
 414   enum nss_status status = NSS_STATUS_SUCCESS;
 415   FILE *stream = NULL;
 416
 417   if (name == NULL)
 418     {
 419       __set_errno (EINVAL);
 420       return NSS_STATUS_UNAVAIL;
 421     }
 422
 423   /* Open the stream.  */
 424   status = internal_setent (&stream);
 425
 426   if (status == NSS_STATUS_SUCCESS)
 427     {
 428       result->alias_local = 1;
 429
 430       /* Read lines until we get a definite result.  */
 431       do
 432         status = get_next_alias (stream, name, result, buffer, buflen, errnop);
 433       while (status == NSS_STATUS_RETURN);
 434     }
 435
 436   internal_endent (&stream);
 437
 438   return status;
 439 }