git.cworth.org Git - tar/blob - lib/chdir-long.c

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