1 /* pwd - print current directory
2    Copyright (C) 1994-2023 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 <https://www.gnu.org/licenses/>.  */
16 
17 #include <config.h>
18 #include <getopt.h>
19 #include <stdio.h>
20 #include <sys/types.h>
21 
22 #include "system.h"
23 #include "quote.h"
24 #include "root-dev-ino.h"
25 #include "xgetcwd.h"
26 
27 /* The official name of this program (e.g., no 'g' prefix).  */
28 #define PROGRAM_NAME "pwd"
29 
30 #define AUTHORS proper_name ("Jim Meyering")
31 
32 struct file_name
33 {
34   char *buf;
35   size_t n_alloc;
36   char *start;
37 };
38 
39 static struct option const longopts[] =
40 {
41   {"logical", no_argument, nullptr, 'L'},
42   {"physical", no_argument, nullptr, 'P'},
43   {GETOPT_HELP_OPTION_DECL},
44   {GETOPT_VERSION_OPTION_DECL},
45   {nullptr, 0, nullptr, 0}
46 };
47 
48 void
usage(int status)49 usage (int status)
50 {
51   if (status != EXIT_SUCCESS)
52     emit_try_help ();
53   else
54     {
55       printf (_("Usage: %s [OPTION]...\n"), program_name);
56       fputs (_("\
57 Print the full filename of the current working directory.\n\
58 \n\
59 "), stdout);
60       fputs (_("\
61   -L, --logical   use PWD from environment, even if it contains symlinks\n\
62   -P, --physical  avoid all symlinks\n\
63 "), stdout);
64       fputs (HELP_OPTION_DESCRIPTION, stdout);
65       fputs (VERSION_OPTION_DESCRIPTION, stdout);
66       fputs (_("\n\
67 If no option is specified, -P is assumed.\n\
68 "), stdout);
69       printf (USAGE_BUILTIN_WARNING, PROGRAM_NAME);
70       emit_ancillary_info (PROGRAM_NAME);
71     }
72   exit (status);
73 }
74 
75 static void
file_name_free(struct file_name * p)76 file_name_free (struct file_name *p)
77 {
78   free (p->buf);
79   free (p);
80 }
81 
82 static struct file_name *
file_name_init(void)83 file_name_init (void)
84 {
85   struct file_name *p = xmalloc (sizeof *p);
86 
87   /* Start with a buffer larger than PATH_MAX, but beware of systems
88      on which PATH_MAX is very large -- e.g., INT_MAX.  */
89   p->n_alloc = MIN (2 * PATH_MAX, 32 * 1024);
90 
91   p->buf = xmalloc (p->n_alloc);
92   p->start = p->buf + (p->n_alloc - 1);
93   p->start[0] = '\0';
94   return p;
95 }
96 
97 /* Prepend the name S of length S_LEN, to the growing file_name, P.  */
98 static void
file_name_prepend(struct file_name * p,char const * s,size_t s_len)99 file_name_prepend (struct file_name *p, char const *s, size_t s_len)
100 {
101   size_t n_free = p->start - p->buf;
102   if (n_free < 1 + s_len)
103     {
104       size_t half = p->n_alloc + 1 + s_len;
105       /* Use xnmalloc+free rather than xnrealloc, since with the latter
106          we'd end up copying the data twice: once via realloc, then again
107          to align it with the end of the new buffer.  With xnmalloc, we
108          copy it only once.  */
109       char *q = xnmalloc (2, half);
110       size_t n_used = p->n_alloc - n_free;
111       p->start = q + 2 * half - n_used;
112       memcpy (p->start, p->buf + n_free, n_used);
113       free (p->buf);
114       p->buf = q;
115       p->n_alloc = 2 * half;
116     }
117 
118   p->start -= 1 + s_len;
119   p->start[0] = '/';
120   memcpy (p->start + 1, s, s_len);
121 }
122 
123 /* Return a string (malloc'd) consisting of N '/'-separated ".." components.  */
124 static char *
nth_parent(size_t n)125 nth_parent (size_t n)
126 {
127   char *buf = xnmalloc (3, n);
128   char *p = buf;
129 
130   for (size_t i = 0; i < n; i++)
131     {
132       memcpy (p, "../", 3);
133       p += 3;
134     }
135   p[-1] = '\0';
136   return buf;
137 }
138 
139 /* Determine the basename of the current directory, where DOT_SB is the
140    result of lstat'ing "." and prepend that to the file name in *FILE_NAME.
141    Find the directory entry in '..' that matches the dev/i-node of DOT_SB.
142    Upon success, update *DOT_SB with stat information of '..', chdir to '..',
143    and prepend "/basename" to FILE_NAME.
144    Otherwise, exit with a diagnostic.
145    PARENT_HEIGHT is the number of levels '..' is above the starting directory.
146    The first time this function is called (from the initial directory),
147    PARENT_HEIGHT is 1.  This is solely for diagnostics.
148    Exit nonzero upon error.  */
149 
150 static void
find_dir_entry(struct stat * dot_sb,struct file_name * file_name,size_t parent_height)151 find_dir_entry (struct stat *dot_sb, struct file_name *file_name,
152                 size_t parent_height)
153 {
154   DIR *dirp;
155   int fd;
156   struct stat parent_sb;
157   bool use_lstat;
158   bool found;
159 
160   dirp = opendir ("..");
161   if (dirp == nullptr)
162     error (EXIT_FAILURE, errno, _("cannot open directory %s"),
163            quote (nth_parent (parent_height)));
164 
165   fd = dirfd (dirp);
166   if ((0 <= fd ? fchdir (fd) : chdir ("..")) < 0)
167     error (EXIT_FAILURE, errno, _("failed to chdir to %s"),
168            quote (nth_parent (parent_height)));
169 
170   if ((0 <= fd ? fstat (fd, &parent_sb) : stat (".", &parent_sb)) < 0)
171     error (EXIT_FAILURE, errno, _("failed to stat %s"),
172            quote (nth_parent (parent_height)));
173 
174   /* If parent and child directory are on different devices, then we
175      can't rely on d_ino for useful i-node numbers; use lstat instead.  */
176   use_lstat = (parent_sb.st_dev != dot_sb->st_dev);
177 
178   found = false;
179   while (true)
180     {
181       struct dirent const *dp;
182       struct stat ent_sb;
183       ino_t ino;
184 
185       errno = 0;
186       if ((dp = readdir_ignoring_dot_and_dotdot (dirp)) == nullptr)
187         {
188           if (errno)
189             {
190               /* Save/restore errno across closedir call.  */
191               int e = errno;
192               closedir (dirp);
193               errno = e;
194 
195               /* Arrange to give a diagnostic after exiting this loop.  */
196               dirp = nullptr;
197             }
198           break;
199         }
200 
201       ino = D_INO (dp);
202 
203       if (ino == NOT_AN_INODE_NUMBER || use_lstat)
204         {
205           if (lstat (dp->d_name, &ent_sb) < 0)
206             {
207               /* Skip any entry we can't stat.  */
208               continue;
209             }
210           ino = ent_sb.st_ino;
211         }
212 
213       if (ino != dot_sb->st_ino)
214         continue;
215 
216       /* If we're not crossing a device boundary, then a simple i-node
217          match is enough.  */
218       if ( ! use_lstat || ent_sb.st_dev == dot_sb->st_dev)
219         {
220           file_name_prepend (file_name, dp->d_name, _D_EXACT_NAMLEN (dp));
221           found = true;
222           break;
223         }
224     }
225 
226   if (dirp == nullptr || closedir (dirp) != 0)
227     {
228       /* Note that this diagnostic serves for both readdir
229          and closedir failures.  */
230       error (EXIT_FAILURE, errno, _("reading directory %s"),
231              quote (nth_parent (parent_height)));
232     }
233 
234   if ( ! found)
235     error (EXIT_FAILURE, 0,
236            _("couldn't find directory entry in %s with matching i-node"),
237            quote (nth_parent (parent_height)));
238 
239   *dot_sb = parent_sb;
240 }
241 
242 /* Construct the full, absolute name of the current working
243    directory and store it in *FILE_NAME.
244    The getcwd function performs nearly the same task, but is typically
245    unable to handle names longer than PATH_MAX.  This function has
246    no such limitation.  However, this function *can* fail due to
247    permission problems or a lack of memory, while GNU/Linux's getcwd
248    function works regardless of restricted permissions on parent
249    directories.  Upon failure, give a diagnostic and exit nonzero.
250 
251    Note: although this function is similar to getcwd, it has a fundamental
252    difference in that it gives a diagnostic and exits upon failure.
253    I would have liked a function that did not exit, and that could be
254    used as a getcwd replacement.  Unfortunately, considering all of
255    the information the caller would require in order to produce good
256    diagnostics, it doesn't seem worth the added complexity.
257    In any case, any getcwd replacement must *not* exceed the PATH_MAX
258    limitation.  Otherwise, functions like 'chdir' would fail with
259    ENAMETOOLONG.
260 
261    FIXME-maybe: if find_dir_entry fails due to permissions, try getcwd,
262    in case the unreadable directory is close enough to the root that
263    getcwd works from there.  */
264 
265 static void
robust_getcwd(struct file_name * file_name)266 robust_getcwd (struct file_name *file_name)
267 {
268   size_t height = 1;
269   struct dev_ino dev_ino_buf;
270   struct dev_ino *root_dev_ino = get_root_dev_ino (&dev_ino_buf);
271   struct stat dot_sb;
272 
273   if (root_dev_ino == nullptr)
274     error (EXIT_FAILURE, errno, _("failed to get attributes of %s"),
275            quoteaf ("/"));
276 
277   if (stat (".", &dot_sb) < 0)
278     error (EXIT_FAILURE, errno, _("failed to stat %s"), quoteaf ("."));
279 
280   while (true)
281     {
282       /* If we've reached the root, we're done.  */
283       if (PSAME_INODE (&dot_sb, root_dev_ino))
284         break;
285 
286       find_dir_entry (&dot_sb, file_name, height++);
287     }
288 
289   /* See if a leading slash is needed; file_name_prepend adds one.  */
290   if (file_name->start[0] == '\0')
291     file_name_prepend (file_name, "", 0);
292 }
293 
294 
295 /* Return PWD from the environment if it is acceptable for 'pwd -L'
296    output, otherwise nullptr.  */
297 static char *
logical_getcwd(void)298 logical_getcwd (void)
299 {
300   struct stat st1;
301   struct stat st2;
302   char *wd = getenv ("PWD");
303   char *p;
304 
305   /* Textual validation first.  */
306   if (!wd || wd[0] != '/')
307     return nullptr;
308   p = wd;
309   while ((p = strstr (p, "/.")))
310     {
311       if (!p[2] || p[2] == '/'
312           || (p[2] == '.' && (!p[3] || p[3] == '/')))
313         return nullptr;
314       p++;
315     }
316 
317   /* System call validation.  */
318   if (stat (wd, &st1) == 0 && stat (".", &st2) == 0 && psame_inode (&st1, &st2))
319     return wd;
320   return nullptr;
321 }
322 
323 
324 int
main(int argc,char ** argv)325 main (int argc, char **argv)
326 {
327   char *wd;
328   /* POSIX requires a default of -L, but most scripts expect -P.
329      Currently shells default to -L, while stand-alone
330      pwd implementations default to -P.  */
331   bool logical = (getenv ("POSIXLY_CORRECT") != nullptr);
332 
333   initialize_main (&argc, &argv);
334   set_program_name (argv[0]);
335   setlocale (LC_ALL, "");
336   bindtextdomain (PACKAGE, LOCALEDIR);
337   textdomain (PACKAGE);
338 
339   atexit (close_stdout);
340 
341   while (true)
342     {
343       int c = getopt_long (argc, argv, "LP", longopts, nullptr);
344       if (c == -1)
345         break;
346       switch (c)
347         {
348         case 'L':
349           logical = true;
350           break;
351         case 'P':
352           logical = false;
353           break;
354 
355         case_GETOPT_HELP_CHAR;
356 
357         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
358 
359         default:
360           usage (EXIT_FAILURE);
361         }
362     }
363 
364   if (optind < argc)
365     error (0, 0, _("ignoring non-option arguments"));
366 
367   if (logical)
368     {
369       wd = logical_getcwd ();
370       if (wd)
371         {
372           puts (wd);
373           return EXIT_SUCCESS;
374         }
375     }
376 
377   wd = xgetcwd ();
378   if (wd != nullptr)
379     {
380       puts (wd);
381       free (wd);
382     }
383   else
384     {
385       struct file_name *file_name = file_name_init ();
386       robust_getcwd (file_name);
387       puts (file_name->start);
388       file_name_free (file_name);
389     }
390 
391   return EXIT_SUCCESS;
392 }
393