src/pwd.c

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