misc/mntent_r.c

   1 /* Utilities for reading/writing fstab, mtab, etc.
   2    Copyright (C) 1995-2023 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, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 #include <alloca.h>
  20 #include <mntent.h>
  21 #include <stdbool.h>
  22 #include <stdio.h>
  23 #include <stdio_ext.h>
  24 #include <string.h>
  25 #include <sys/types.h>
  26
  27 #define flockfile(s) _IO_flockfile (s)
  28 #define funlockfile(s) _IO_funlockfile (s)
  29
  30 #undef __setmntent
  31 #undef __endmntent
  32 #undef __getmntent_r
  33
  34 /* Prepare to begin reading and/or writing mount table entries from the
  35    beginning of FILE.  MODE is as for `fopen'.  */
  36 FILE *
  37 __setmntent (const char *file, const char *mode)
  38 {
  39   /* Extend the mode parameter with "c" to disable cancellation in the
  40      I/O functions and "e" to set FD_CLOEXEC.  */
  41   size_t modelen = strlen (mode);
  42   char newmode[modelen + 3];
  43   memcpy (mempcpy (newmode, mode, modelen), "ce", 3);
  44   FILE *result = fopen (file, newmode);
  45
  46   if (result != NULL)
  47     /* We do the locking ourselves.  */
  48     __fsetlocking (result, FSETLOCKING_BYCALLER);
  49
  50   return result;
  51 }
  52 libc_hidden_def (__setmntent)
  53 weak_alias (__setmntent, setmntent)
  54
  55
  56 /* Close a stream opened with `setmntent'.  */
  57 int
  58 __endmntent (FILE *stream)
  59 {
  60   if (stream)           /* SunOS 4.x allows for NULL stream */
  61     fclose (stream);
  62   return 1;             /* SunOS 4.x says to always return 1 */
  63 }
  64 libc_hidden_def (__endmntent)
  65 weak_alias (__endmntent, endmntent)
  66
  67
  68 /* Since the values in a line are separated by spaces, a name cannot
  69    contain a space.  Therefore some programs encode spaces in names
  70    by the strings "\040".  We undo the encoding when reading an entry.
  71    The decoding happens in place.  */
  72 static char *
  73 decode_name (char *buf)
  74 {
  75   char *rp = buf;
  76   char *wp = buf;
  77
  78   do
  79     if (rp[0] == '\\' && rp[1] == '0' && rp[2] == '4' && rp[3] == '0')
  80       {
  81         /* \040 is a SPACE.  */
  82         *wp++ = ' ';
  83         rp += 3;
  84       }
  85     else if (rp[0] == '\\' && rp[1] == '0' && rp[2] == '1' && rp[3] == '1')
  86       {
  87         /* \011 is a TAB.  */
  88         *wp++ = '\t';
  89         rp += 3;
  90       }
  91     else if (rp[0] == '\\' && rp[1] == '0' && rp[2] == '1' && rp[3] == '2')
  92       {
  93         /* \012 is a NEWLINE.  */
  94         *wp++ = '\n';
  95         rp += 3;
  96       }
  97     else if (rp[0] == '\\' && rp[1] == '\\')
  98       {
  99         /* We have to escape \\ to be able to represent all characters.  */
 100         *wp++ = '\\';
 101         rp += 1;
 102       }
 103     else if (rp[0] == '\\' && rp[1] == '1' && rp[2] == '3' && rp[3] == '4')
 104       {
 105         /* \134 is also \\.  */
 106         *wp++ = '\\';
 107         rp += 3;
 108       }
 109     else
 110       *wp++ = *rp;
 111   while (*rp++ != '\0');
 112
 113   return buf;
 114 }
 115
 116 static bool
 117 get_mnt_entry (FILE *stream, struct mntent *mp, char *buffer, int bufsiz)
 118 {
 119   char *cp;
 120   char *head;
 121
 122   do
 123     {
 124       char *end_ptr;
 125
 126       if (__fgets_unlocked (buffer, bufsiz, stream) == NULL)
 127           return false;
 128
 129       end_ptr = strchr (buffer, '\n');
 130       if (end_ptr != NULL)      /* chop newline */
 131         {
 132           /* Do not walk past the start of buffer if it's all whitespace.  */
 133           while (end_ptr != buffer
 134                  && (end_ptr[-1] == ' ' || end_ptr[-1] == '\t'))
 135             end_ptr--;
 136           *end_ptr = '\0';
 137         }
 138       else
 139         {
 140           /* Not the whole line was read.  Do it now but forget it.  */
 141           char tmp[1024];
 142           while (__fgets_unlocked (tmp, sizeof tmp, stream) != NULL)
 143             if (strchr (tmp, '\n') != NULL)
 144               break;
 145         }
 146
 147       head = buffer + strspn (buffer, " \t");
 148       /* skip empty lines and comment lines:  */
 149     }
 150   while (head[0] == '\0' || head[0] == '#');
 151
 152   cp = __strsep (&head, " \t");
 153   mp->mnt_fsname = cp != NULL ? decode_name (cp) : (char *) "";
 154   if (head)
 155     head += strspn (head, " \t");
 156   cp = __strsep (&head, " \t");
 157   mp->mnt_dir = cp != NULL ? decode_name (cp) : (char *) "";
 158   if (head)
 159     head += strspn (head, " \t");
 160   cp = __strsep (&head, " \t");
 161   mp->mnt_type = cp != NULL ? decode_name (cp) : (char *) "";
 162   if (head)
 163     head += strspn (head, " \t");
 164   cp = __strsep (&head, " \t");
 165   mp->mnt_opts = cp != NULL ? decode_name (cp) : (char *) "";
 166   switch (head ? sscanf (head, " %d %d ", &mp->mnt_freq, &mp->mnt_passno) : 0)
 167     {
 168     case 0:
 169       mp->mnt_freq = 0;
 170       /* Fall through.  */
 171     case 1:
 172       mp->mnt_passno = 0;
 173       /* Fall through.  */
 174     case 2:
 175       break;
 176     }
 177
 178   return true;
 179 }
 180
 181 /* Read one mount table entry from STREAM.  Returns a pointer to storage
 182    reused on the next call, or null for EOF or error (use feof/ferror to
 183    check).  */
 184 struct mntent *
 185 __getmntent_r (FILE *stream, struct mntent *mp, char *buffer, int bufsiz)
 186 {
 187   struct mntent *result;
 188
 189   flockfile (stream);
 190   while (true)
 191     if (get_mnt_entry (stream, mp, buffer, bufsiz))
 192       {
 193         /* If the file system is autofs look for a mount option hint
 194            ("ignore") to skip the entry.  */
 195         if (strcmp (mp->mnt_type, "autofs") == 0 && __hasmntopt (mp, "ignore"))
 196           memset (mp, 0, sizeof (*mp));
 197         else
 198           {
 199             result = mp;
 200             break;
 201           }
 202       }
 203     else
 204       {
 205         result = NULL;
 206         break;
 207       }
 208   funlockfile (stream);
 209
 210   return result;
 211 }
 212 libc_hidden_def (__getmntent_r)
 213 weak_alias (__getmntent_r, getmntent_r)
 214
 215 /* Write STR into STREAM, escaping whitespaces as we go.  Do not check for
 216    errors here; we check the stream status in __ADDMNTENT.  */
 217 static void
 218 write_string (FILE *stream, const char *str)
 219 {
 220   char c;
 221   const char *encode_chars = " \t\n\\";
 222
 223   while ((c = *str++) != '\0')
 224     {
 225       if (strchr (encode_chars, c) == NULL)
 226         __putc_unlocked (c, stream);
 227       else
 228         {
 229           __putc_unlocked ('\\', stream);
 230           __putc_unlocked (((c & 0xc0) >> 6) + '0', stream);
 231           __putc_unlocked (((c & 0x38) >> 3) + '0', stream);
 232           __putc_unlocked (((c & 0x07) >> 0) + '0', stream);
 233         }
 234     }
 235   __putc_unlocked (' ', stream);
 236 }
 237
 238 /* Write the mount table entry described by MNT to STREAM.
 239    Return zero on success, nonzero on failure.  */
 240 int
 241 __addmntent (FILE *stream, const struct mntent *mnt)
 242 {
 243   int ret = 1;
 244
 245   if (fseek (stream, 0, SEEK_END))
 246     return ret;
 247
 248   flockfile (stream);
 249
 250   write_string (stream, mnt->mnt_fsname);
 251   write_string (stream, mnt->mnt_dir);
 252   write_string (stream, mnt->mnt_type);
 253   write_string (stream, mnt->mnt_opts);
 254   fprintf (stream, "%d %d\n", mnt->mnt_freq, mnt->mnt_passno);
 255
 256   ret = __ferror_unlocked (stream) != 0 || fflush (stream) != 0;
 257
 258   funlockfile (stream);
 259
 260   return ret;
 261 }
 262 weak_alias (__addmntent, addmntent)
 263
 264
 265 /* Search MNT->mnt_opts for an option matching OPT.
 266    Returns the address of the substring, or null if none found.  */
 267 char *
 268 __hasmntopt (const struct mntent *mnt, const char *opt)
 269 {
 270   const size_t optlen = strlen (opt);
 271   char *rest = mnt->mnt_opts, *p;
 272
 273   while ((p = strstr (rest, opt)) != NULL)
 274     {
 275       if ((p == rest || p[-1] == ',')
 276           && (p[optlen] == '\0' || p[optlen] == '=' || p[optlen] == ','))
 277         return p;
 278
 279       rest = strchr (p, ',');
 280       if (rest == NULL)
 281         break;
 282       ++rest;
 283     }
 284
 285   return NULL;
 286 }
 287 libc_hidden_def (__hasmntopt)
 288 weak_alias (__hasmntopt, hasmntopt)