gnulib/lib/chdir-long.c

   1 /* provide a chdir function that tries not to fail due to ENAMETOOLONG
   2    Copyright (C) 2004-2011 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  16
  17 /* written by Jim Meyering */
  18
  19 #include <config.h>
  20
  21 #include "chdir-long.h"
  22
  23 #include <assert.h>
  24 #include <errno.h>
  25 #include <fcntl.h>
  26 #include <stdlib.h>
  27 #include <stdbool.h>
  28 #include <string.h>
  29 #include <stdio.h>
  30
  31 #ifndef PATH_MAX
  32 # error "compile this file only if your system defines PATH_MAX"
  33 #endif
  34
  35 /* The results of openat() in this file are not leaked to any
  36    single-threaded code that could use stdio.
  37    FIXME - if the kernel ever adds support for multi-thread safety for
  38    avoiding standard fds, then we should use openat_safer.  */
  39
  40 struct cd_buf
  41 {
  42   int fd;
  43 };
  44
  45 static inline void
  46 cdb_init (struct cd_buf *cdb)
  47 {
  48   cdb->fd = AT_FDCWD;
  49 }
  50
  51 static inline int
  52 cdb_fchdir (struct cd_buf const *cdb)
  53 {
  54   return fchdir (cdb->fd);
  55 }
  56
  57 static inline void
  58 cdb_free (struct cd_buf const *cdb)
  59 {
  60   if (0 <= cdb->fd)
  61     {
  62       bool close_fail = close (cdb->fd);
  63       assert (! close_fail);
  64     }
  65 }
  66
  67 /* Given a file descriptor of an open directory (or AT_FDCWD), CDB->fd,
  68    try to open the CDB->fd-relative directory, DIR.  If the open succeeds,
  69    update CDB->fd with the resulting descriptor, close the incoming file
  70    descriptor, and return zero.  Upon failure, return -1 and set errno.  */
  71 static int
  72 cdb_advance_fd (struct cd_buf *cdb, char const *dir)
  73 {
  74   int new_fd = openat (cdb->fd, dir,
  75                        O_SEARCH | O_DIRECTORY | O_NOCTTY | O_NONBLOCK);
  76   if (new_fd < 0)
  77     return -1;
  78
  79   cdb_free (cdb);
  80   cdb->fd = new_fd;
  81
  82   return 0;
  83 }
  84
  85 /* Return a pointer to the first non-slash in S.  */
  86 static inline char *
  87 find_non_slash (char const *s)
  88 {
  89   size_t n_slash = strspn (s, "/");
  90   return (char *) s + n_slash;
  91 }
  92
  93 /* This is a function much like chdir, but without the PATH_MAX limitation
  94    on the length of the directory name.  A significant difference is that
  95    it must be able to modify (albeit only temporarily) the directory
  96    name.  It handles an arbitrarily long directory name by operating
  97    on manageable portions of the name.  On systems without the openat
  98    syscall, this means changing the working directory to more and more
  99    `distant' points along the long directory name and then restoring
 100    the working directory.  If any of those attempts to save or restore
 101    the working directory fails, this function exits nonzero.
 102
 103    Note that this function may still fail with errno == ENAMETOOLONG, but
 104    only if the specified directory name contains a component that is long
 105    enough to provoke such a failure all by itself (e.g. if the component
 106    has length PATH_MAX or greater on systems that define PATH_MAX).  */
 107
 108 int
 109 chdir_long (char *dir)
 110 {
 111   int e = chdir (dir);
 112   if (e == 0 || errno != ENAMETOOLONG)
 113     return e;
 114
 115   {
 116     size_t len = strlen (dir);
 117     char *dir_end = dir + len;
 118     struct cd_buf cdb;
 119     size_t n_leading_slash;
 120
 121     cdb_init (&cdb);
 122
 123     /* If DIR is the empty string, then the chdir above
 124        must have failed and set errno to ENOENT.  */
 125     assert (0 < len);
 126     assert (PATH_MAX <= len);
 127
 128     /* Count leading slashes.  */
 129     n_leading_slash = strspn (dir, "/");
 130
 131     /* Handle any leading slashes as well as any name that matches
 132        the regular expression, m!^//hostname[/]*! .  Handling this
 133        prefix separately usually results in a single additional
 134        cdb_advance_fd call, but it's worthwhile, since it makes the
 135        code in the following loop cleaner.  */
 136     if (n_leading_slash == 2)
 137       {
 138         int err;
 139         /* Find next slash.
 140            We already know that dir[2] is neither a slash nor '\0'.  */
 141         char *slash = memchr (dir + 3, '/', dir_end - (dir + 3));
 142         if (slash == NULL)
 143           {
 144             errno = ENAMETOOLONG;
 145             return -1;
 146           }
 147         *slash = '\0';
 148         err = cdb_advance_fd (&cdb, dir);
 149         *slash = '/';
 150         if (err != 0)
 151           goto Fail;
 152         dir = find_non_slash (slash + 1);
 153       }
 154     else if (n_leading_slash)
 155       {
 156         if (cdb_advance_fd (&cdb, "/") != 0)
 157           goto Fail;
 158         dir += n_leading_slash;
 159       }
 160
 161     assert (*dir != '/');
 162     assert (dir <= dir_end);
 163
 164     while (PATH_MAX <= dir_end - dir)
 165       {
 166         int err;
 167         /* Find a slash that is PATH_MAX or fewer bytes away from dir.
 168            I.e. see if there is a slash that will give us a name of
 169            length PATH_MAX-1 or less.  */
 170         char *slash = memrchr (dir, '/', PATH_MAX);
 171         if (slash == NULL)
 172           {
 173             errno = ENAMETOOLONG;
 174             return -1;
 175           }
 176
 177         *slash = '\0';
 178         assert (slash - dir < PATH_MAX);
 179         err = cdb_advance_fd (&cdb, dir);
 180         *slash = '/';
 181         if (err != 0)
 182           goto Fail;
 183
 184         dir = find_non_slash (slash + 1);
 185       }
 186
 187     if (dir < dir_end)
 188       {
 189         if (cdb_advance_fd (&cdb, dir) != 0)
 190           goto Fail;
 191       }
 192
 193     if (cdb_fchdir (&cdb) != 0)
 194       goto Fail;
 195
 196     cdb_free (&cdb);
 197     return 0;
 198
 199    Fail:
 200     {
 201       int saved_errno = errno;
 202       cdb_free (&cdb);
 203       errno = saved_errno;
 204       return -1;
 205     }
 206   }
 207 }
 208
 209 #if TEST_CHDIR
 210
 211 # include "closeout.h"
 212 # include "error.h"
 213
 214 char *program_name;
 215
 216 int
 217 main (int argc, char *argv[])
 218 {
 219   char *line = NULL;
 220   size_t n = 0;
 221   int len;
 222
 223   program_name = argv[0];
 224   atexit (close_stdout);
 225
 226   len = getline (&line, &n, stdin);
 227   if (len < 0)
 228     {
 229       int saved_errno = errno;
 230       if (feof (stdin))
 231         exit (0);
 232
 233       error (EXIT_FAILURE, saved_errno,
 234              "reading standard input");
 235     }
 236   else if (len == 0)
 237     exit (0);
 238
 239   if (line[len-1] == '\n')
 240     line[len-1] = '\0';
 241
 242   if (chdir_long (line) != 0)
 243     error (EXIT_FAILURE, errno,
 244            "chdir_long failed: %s", line);
 245
 246   if (argc <= 1)
 247     {
 248       /* Using `pwd' here makes sense only if it is a robust implementation,
 249          like the one in coreutils after the 2004-04-19 changes.  */
 250       char const *cmd = "pwd";
 251       execlp (cmd, (char *) NULL);
 252       error (EXIT_FAILURE, errno, "%s", cmd);
 253     }
 254
 255   fclose (stdin);
 256   fclose (stderr);
 257
 258   exit (EXIT_SUCCESS);
 259 }
 260 #endif
 261
 262 /*
 263 Local Variables:
 264 compile-command: "gcc -DTEST_CHDIR=1 -g -O -W -Wall chdir-long.c libcoreutils.a"
 265 End:
 266 */