src/pwd.c

   1 /* pwd - print current directory
   2    Copyright (C) 1994-1997, 1999-2005 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 2, or (at your option)
   7    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, write to the Free Software Foundation,
  16    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307, USA.  */
  17
  18 #include <config.h>
  19 #include <getopt.h>
  20 #include <stdio.h>
  21 #include <sys/types.h>
  22
  23 #include "system.h"
  24 #include "dirfd.h"
  25 #include "error.h"
  26 #include "long-options.h"
  27 #include "quote.h"
  28 #include "root-dev-ino.h"
  29 #include "xgetcwd.h"
  30
  31 /* The official name of this program (e.g., no `g' prefix).  */
  32 #define PROGRAM_NAME "pwd"
  33
  34 #define AUTHORS "Jim Meyering"
  35
  36 struct Path
  37 {
  38   char *buf;
  39   size_t n_alloc;
  40   char *start;
  41 };
  42
  43 enum
  44 {
  45   NOT_AN_INODE_NUMBER = 0
  46 };
  47
  48 #ifdef D_INO_IN_DIRENT
  49 # define D_INO(dp) ((dp)->d_ino)
  50 #else
  51 /* Some systems don't have inodes, so fake them to avoid lots of ifdefs.  */
  52 # define D_INO(dp) NOT_AN_INODE_NUMBER
  53 #endif
  54
  55 /* The name this program was run with. */
  56 char *program_name;
  57
  58 void
  59 usage (int status)
  60 {
  61   if (status != EXIT_SUCCESS)
  62     fprintf (stderr, _("Try `%s --help' for more information.\n"),
  63              program_name);
  64   else
  65     {
  66       printf (_("Usage: %s [OPTION]\n"), program_name);
  67       fputs (_("\
  68 Print the full filename of the current working directory.\n\
  69 \n\
  70 "), stdout);
  71       fputs (HELP_OPTION_DESCRIPTION, stdout);
  72       fputs (VERSION_OPTION_DESCRIPTION, stdout);
  73       printf (USAGE_BUILTIN_WARNING, PROGRAM_NAME);
  74       printf (_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
  75     }
  76   exit (status);
  77 }
  78
  79 static void
  80 path_free (struct Path *p)
  81 {
  82   free (p->buf);
  83   free (p);
  84 }
  85
  86 static struct Path *
  87 path_init (void)
  88 {
  89   struct Path *p = xmalloc (sizeof *p);
  90
  91   /* Start with a buffer larger than PATH_MAX, but beware of systems
  92      on which PATH_MAX is very large -- e.g., INT_MAX.  */
  93   p->n_alloc = MIN (2 * PATH_MAX, 32 * 1024);
  94
  95   p->buf = xmalloc (p->n_alloc);
  96   p->start = p->buf + (p->n_alloc - 1);
  97   p->start[0] = '\0';
  98   return p;
  99 }
 100
 101 /* Prepend the name S of length S_LEN, to the growing path, P.  */
 102 static void
 103 path_prepend (struct Path *p, char const *s, size_t s_len)
 104 {
 105   size_t n_free = p->start - p->buf;
 106   if (n_free < 1 + s_len)
 107     {
 108       size_t half = p->n_alloc + 1 + s_len;
 109       /* Use xnmalloc+free rather than xnrealloc, since with the latter
 110          we'd end up copying the data twice: once via realloc, then again
 111          to align it with the end of the new buffer.  With xnmalloc, we
 112          copy it only once.  */
 113       char *q = xnmalloc (2, half);
 114       size_t n_used = p->n_alloc - n_free;
 115       p->start = q + 2 * half - n_used;
 116       memcpy (p->start, p->buf + n_free, n_used);
 117       free (p->buf);
 118       p->buf = q;
 119       p->n_alloc = 2 * half;
 120     }
 121
 122   p->start -= 1 + s_len;
 123   p->start[0] = '/';
 124   memcpy (p->start + 1, s, s_len);
 125 }
 126
 127 /* Return a string (malloc'd) consisting of N `/'-separated ".." components.  */
 128 static char *
 129 nth_parent (size_t n)
 130 {
 131   char *buf = xnmalloc (3, n);
 132   char *p = buf;
 133   size_t i;
 134
 135   for (i = 0; i < n; i++)
 136     {
 137       memcpy (p, "../", 3);
 138       p += 3;
 139     }
 140   p[-1] = '\0';
 141   return buf;
 142 }
 143
 144 /* Determine the basename of the current directory, where DOT_SB is the
 145    result of lstat'ing "." and prepend that to the file name in *PATH.
 146    Find the directory entry in `..' that matches the dev/i-node of DOT_SB.
 147    Upon success, update *DOT_SB with stat information of `..', chdir to `..',
 148    and prepend "/basename" to PATH.
 149    Otherwise, exit with a diagnostic.
 150    PARENT_HEIGHT is the number of levels `..' is above the starting directory.
 151    The first time this function is called (from the initial directory),
 152    PARENT_HEIGHT is 1.  This is solely for diagnostics.
 153    Exit nonzero upon error.  */
 154
 155 static void
 156 find_dir_entry (struct stat *dot_sb, struct Path *path, size_t parent_height)
 157 {
 158   DIR *dirp;
 159   int fd;
 160   struct stat parent_sb;
 161   bool use_lstat;
 162   bool found;
 163
 164   dirp = opendir ("..");
 165   if (dirp == NULL)
 166     error (EXIT_FAILURE, errno, _("cannot open directory %s"),
 167            quote (nth_parent (parent_height)));
 168
 169   fd = dirfd (dirp);
 170   if ((0 <= fd ? fchdir (fd) : chdir ("..")) < 0)
 171     error (EXIT_FAILURE, errno, _("failed to chdir to %s"),
 172            quote (nth_parent (parent_height)));
 173
 174   if ((0 <= fd ? fstat (fd, &parent_sb) : stat (".", &parent_sb)) < 0)
 175     error (EXIT_FAILURE, errno, _("failed to stat %s"),
 176            quote (nth_parent (parent_height)));
 177
 178   /* If parent and child directory are on different devices, then we
 179      can't rely on d_ino for useful i-node numbers; use lstat instead.  */
 180   use_lstat = (parent_sb.st_dev != dot_sb->st_dev);
 181
 182   found = false;
 183   while (1)
 184     {
 185       struct dirent const *dp;
 186       struct stat ent_sb;
 187       ino_t ino;
 188       bool ent_sb_valid;
 189
 190       errno = 0;
 191       if ((dp = readdir_ignoring_dot_and_dotdot (dirp)) == NULL)
 192         {
 193           if (errno)
 194             {
 195               /* Save/restore errno across closedir call.  */
 196               int e = errno;
 197               closedir (dirp);
 198               errno = e;
 199
 200               /* Arrange to give a diagnostic after exiting this loop.  */
 201               dirp = NULL;
 202             }
 203           break;
 204         }
 205
 206       ino = D_INO (dp);
 207
 208       ent_sb_valid = false;
 209       if (ino == NOT_AN_INODE_NUMBER || use_lstat)
 210         {
 211           if (lstat (dp->d_name, &ent_sb) < 0)
 212             {
 213               /* Skip any entry we can't stat.  */
 214               continue;
 215             }
 216           ino = ent_sb.st_ino;
 217           ent_sb_valid = true;
 218         }
 219
 220       if (ino != dot_sb->st_ino)
 221         continue;
 222
 223       /* If we're not crossing a device boundary, then a simple i-node
 224          match is enough.  */
 225       if ( ! use_lstat || ent_sb.st_dev == dot_sb->st_dev)
 226         {
 227           path_prepend (path, dp->d_name, NLENGTH (dp));
 228           found = true;
 229           break;
 230         }
 231     }
 232
 233   if (dirp == NULL || CLOSEDIR (dirp) != 0)
 234     {
 235       /* Note that this diagnostic serves for both readdir
 236          and closedir failures.  */
 237       error (EXIT_FAILURE, errno, _("reading directory %s"),
 238              quote (nth_parent (parent_height)));
 239     }
 240
 241   if ( ! found)
 242     error (EXIT_FAILURE, 0,
 243            _("couldn't find directory entry in %s with matching i-node"),
 244              quote (nth_parent (parent_height)));
 245
 246   *dot_sb = parent_sb;
 247 }
 248
 249 /* Construct the full, absolute name of the current working
 250    directory and store it in *PATH.
 251    The getcwd function performs nearly the same task, but is typically
 252    unable to handle names longer than PATH_MAX.  This function has
 253    no such limitation.  However, this function *can* fail due to
 254    permission problems or a lack of memory, while Linux's getcwd
 255    function works regardless of restricted permissions on parent
 256    directories.  Upon failure, give a diagnostic and exit nonzero.
 257
 258    Note: although this function is similar to getcwd, it has a fundamental
 259    difference in that it gives a diagnostic and exits upon failure.
 260    I would have liked a function that did not exit, and that could be
 261    used as a getcwd replacement.  Unfortunately, considering all of
 262    the information the caller would require in order to produce good
 263    diagnostics, it doesn't seem worth the added complexity.
 264    In any case, any getcwd replacement must *not* exceed the PATH_MAX
 265    limitation.  Otherwise, functions like `chdir' would fail with
 266    ENAMETOOLONG.
 267
 268    FIXME-maybe: if find_dir_entry fails due to permissions, try getcwd,
 269    in case the unreadable directory is close enough to the root that
 270    getcwd works from there.  */
 271
 272 static void
 273 robust_getcwd (struct Path *path)
 274 {
 275   size_t height = 1;
 276   struct dev_ino dev_ino_buf;
 277   struct dev_ino *root_dev_ino = get_root_dev_ino (&dev_ino_buf);
 278   struct stat dot_sb;
 279
 280   if (root_dev_ino == NULL)
 281     error (EXIT_FAILURE, errno, _("failed to get attributes of %s"),
 282            quote ("/"));
 283
 284   if (stat (".", &dot_sb) < 0)
 285     error (EXIT_FAILURE, errno, _("failed to stat %s"), quote ("."));
 286
 287   while (1)
 288     {
 289       /* If we've reached the root, we're done.  */
 290       if (SAME_INODE (dot_sb, *root_dev_ino))
 291         break;
 292
 293       find_dir_entry (&dot_sb, path, height++);
 294     }
 295
 296   if (path->start[0] == '\0')
 297     path_prepend (path, "/", 1);
 298 }
 299
 300 int
 301 main (int argc, char **argv)
 302 {
 303   char *wd;
 304
 305   initialize_main (&argc, &argv);
 306   program_name = argv[0];
 307   setlocale (LC_ALL, "");
 308   bindtextdomain (PACKAGE, LOCALEDIR);
 309   textdomain (PACKAGE);
 310
 311   atexit (close_stdout);
 312
 313   parse_long_options (argc, argv, PROGRAM_NAME, GNU_PACKAGE, VERSION,
 314                       usage, AUTHORS, (char const *) NULL);
 315   if (getopt_long (argc, argv, "", NULL, NULL) != -1)
 316     usage (EXIT_FAILURE);
 317
 318   if (optind < argc)
 319     error (0, 0, _("ignoring non-option arguments"));
 320
 321   wd = xgetcwd ();
 322   if (wd != NULL)
 323     {
 324       puts (wd);
 325       free (wd);
 326     }
 327   else
 328     {
 329       struct Path *path = path_init ();
 330       robust_getcwd (path);
 331       puts (path->start);
 332       path_free (path);
 333     }
 334
 335   exit (EXIT_SUCCESS);
 336 }