1 /* Provide relocatable programs.
2 Copyright (C) 2003-2023 Free Software Foundation, Inc.
3 Written by Bruno Haible <bruno@clisp.org>, 2003.
4
5 This program is free software: you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation, either version 3 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program. If not, see <https://www.gnu.org/licenses/>. */
17
18
19 #define _GL_USE_STDLIB_ALLOC 1
20 #include <config.h>
21
22 /* Specification. */
23 #include "progname.h"
24
25 #include <errno.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <fcntl.h>
30 #include <unistd.h>
31 #include <sys/stat.h>
32
33 /* Get declaration of _NSGetExecutablePath on Mac OS X 10.2 or newer. */
34 #if HAVE_MACH_O_DYLD_H
35 # include <mach-o/dyld.h>
36 #endif
37
38 #if defined _WIN32 && !defined __CYGWIN__
39 # define WINDOWS_NATIVE
40 #endif
41
42 #ifdef WINDOWS_NATIVE
43 # define WIN32_LEAN_AND_MEAN
44 # include <windows.h>
45 #endif
46
47 #ifdef __EMX__
48 # define INCL_DOS
49 # include <os2.h>
50 #endif
51
52 #include "relocatable.h"
53
54 #ifdef NO_XMALLOC
55 # include "areadlink.h"
56 # define xreadlink areadlink
57 #else
58 # include "xreadlink.h"
59 #endif
60
61 #ifdef NO_XMALLOC
62 # define xmalloc malloc
63 # define xstrdup strdup
64 #else
65 # include "xalloc.h"
66 #endif
67
68 #ifndef O_EXEC
69 # define O_EXEC O_RDONLY /* This is often close enough in older systems. */
70 #endif
71
72 #if defined IN_RELOCWRAPPER && (!defined O_CLOEXEC || GNULIB_defined_O_CLOEXEC)
73 # undef O_CLOEXEC
74 # define O_CLOEXEC 0
75 #endif
76
77 /* Declare canonicalize_file_name.
78 The <stdlib.h> included above may be the system's one, not the gnulib
79 one. */
80 extern char * canonicalize_file_name (const char *name);
81
82 #if defined WINDOWS_NATIVE
83 /* Don't assume that UNICODE is not defined. */
84 # undef GetModuleFileName
85 # define GetModuleFileName GetModuleFileNameA
86 #endif
87
88 /* Pathname support.
89 ISSLASH(C) tests whether C is a directory separator character.
90 IS_FILE_NAME_WITH_DIR(P) tests whether P contains a directory specification.
91 */
92 #if (defined _WIN32 && !defined __CYGWIN__) || defined __EMX__ || defined __DJGPP__
93 /* Native Windows, OS/2, DOS */
94 # define ISSLASH(C) ((C) == '/' || (C) == '\\')
95 # define HAS_DEVICE(P) \
96 ((((P)[0] >= 'A' && (P)[0] <= 'Z') || ((P)[0] >= 'a' && (P)[0] <= 'z')) \
97 && (P)[1] == ':')
98 # define IS_FILE_NAME_WITH_DIR(P) \
99 (strchr (P, '/') != NULL || strchr (P, '\\') != NULL || HAS_DEVICE (P))
100 # define FILE_SYSTEM_PREFIX_LEN(P) (HAS_DEVICE (P) ? 2 : 0)
101 #else
102 /* Unix */
103 # define ISSLASH(C) ((C) == '/')
104 # define IS_FILE_NAME_WITH_DIR(P) (strchr (P, '/') != NULL)
105 # define FILE_SYSTEM_PREFIX_LEN(P) 0
106 #endif
107
108 /* Use the system functions, not the gnulib overrides in this file. */
109 #undef sprintf
110
111 #undef set_program_name
112
113
114 #if ENABLE_RELOCATABLE
115
116 #ifdef __sun
117
118 /* Helper function, from gnulib module 'safe-read'. */
119 static size_t
120 safe_read (int fd, void *buf, size_t count)
121 {
122 for (;;)
123 {
124 ssize_t result = read (fd, buf, count);
125
126 if (0 <= result || errno != EINTR)
127 return result;
128 }
129 }
130
131 /* Helper function, from gnulib module 'full-read'. */
132 static size_t
133 full_read (int fd, void *buf, size_t count)
134 {
135 size_t total = 0;
136 char *ptr = (char *) buf;
137
138 while (count > 0)
139 {
140 size_t n = safe_read (fd, ptr, count);
141 if (n == (size_t) -1)
142 break;
143 if (n == 0)
144 {
145 errno = 0;
146 break;
147 }
148 total += n;
149 ptr += n;
150 count -= n;
151 }
152
153 return total;
154 }
155
156 #endif
157
158 #if defined __linux__ || defined __CYGWIN__
159 /* File descriptor of the executable.
160 (Only used to verify that we find the correct executable.) */
161 static int executable_fd = -1;
162 #endif
163
164 /* Define this function only when it's needed. */
165 #if !(defined WINDOWS_NATIVE || defined __EMX__)
166
167 /* Tests whether a given filename may belong to the executable. */
168 static bool
169 maybe_executable (const char *filename)
170 {
171 /* The native Windows API lacks the access() function. */
172 # if !defined WINDOWS_NATIVE
173 if (access (filename, X_OK) < 0)
174 return false;
175 # endif
176
177 # if defined __linux__ || defined __CYGWIN__
178 if (executable_fd >= 0)
179 {
180 /* If we already have an executable_fd, check that filename points to
181 the same inode. */
182 struct stat statexe;
183 struct stat statfile;
184
185 if (fstat (executable_fd, &statexe) >= 0)
186 return (stat (filename, &statfile) >= 0
187 && statfile.st_dev
188 && statfile.st_dev == statexe.st_dev
189 && statfile.st_ino == statexe.st_ino);
190 }
191 # endif
192
193 /* Check that the filename does not point to a directory. */
194 {
195 struct stat statfile;
196
197 return (stat (filename, &statfile) >= 0
198 && ! S_ISDIR (statfile.st_mode));
199 }
200 }
201
202 #endif
203
204 /* Determine the full pathname of the current executable, freshly allocated.
205 Return NULL if unknown.
206 Guaranteed to work on Linux and native Windows. Likely to work on the
207 other Unixes (maybe except BeOS), under most conditions. */
208 static char *
209 find_executable (const char *argv0)
210 {
211 #if defined WINDOWS_NATIVE
212 /* Native Windows only.
213 On Cygwin, it is better to use the Cygwin provided /proc interface, than
214 to use native Windows API and cygwin_conv_to_posix_path, because it
215 supports longer file names
216 (see <https://cygwin.com/ml/cygwin/2011-01/msg00410.html>). */
217 char location[MAX_PATH];
218 int length = GetModuleFileName (NULL, location, sizeof (location));
219 if (length < 0)
220 return NULL;
221 if (!IS_FILE_NAME_WITH_DIR (location))
222 /* Shouldn't happen. */
223 return NULL;
224 return xstrdup (location);
225 #elif defined __EMX__
226 PPIB ppib;
227 char location[CCHMAXPATH];
228
229 /* See http://cyberkinetica.homeunix.net/os2tk45/cp1/619_L2H_DosGetInfoBlocksSynt.html
230 for specification of DosGetInfoBlocks(). */
231 if (DosGetInfoBlocks (NULL, &ppib))
232 return NULL;
233
234 /* See http://cyberkinetica.homeunix.net/os2tk45/cp1/1247_L2H_DosQueryModuleNameSy.html
235 for specification of DosQueryModuleName(). */
236 if (DosQueryModuleName (ppib->pib_hmte, sizeof (location), location))
237 return NULL;
238
239 _fnslashify (location);
240
241 return xstrdup (location);
242 #else /* Unix */
243 # if defined __linux__
244 /* The executable is accessible as /proc/<pid>/exe. In newer Linux
245 versions, also as /proc/self/exe. Linux >= 2.1 provides a symlink
246 to the true pathname; older Linux versions give only device and ino,
247 enclosed in brackets, which we cannot use here. */
248 {
249 char *link;
250
251 link = xreadlink ("/proc/self/exe");
252 if (link != NULL && link[0] != '[')
253 return link;
254 if (executable_fd < 0)
255 executable_fd = open ("/proc/self/exe", O_EXEC | O_CLOEXEC, 0);
256
257 {
258 char buf[6+10+5];
259 sprintf (buf, "/proc/%d/exe", getpid ());
260 link = xreadlink (buf);
261 if (link != NULL && link[0] != '[')
262 return link;
263 if (executable_fd < 0)
264 executable_fd = open (buf, O_EXEC | O_CLOEXEC, 0);
265 }
266 }
267 # endif
268 # if defined __ANDROID__ || defined __FreeBSD_kernel__
269 /* On Android and GNU/kFreeBSD, the executable is accessible as
270 /proc/<pid>/exe and /proc/self/exe. */
271 {
272 char *link;
273
274 link = xreadlink ("/proc/self/exe");
275 if (link != NULL)
276 return link;
277 }
278 # endif
279 # if defined __FreeBSD__ || defined __DragonFly__
280 /* In FreeBSD >= 5.0, the executable is accessible as /proc/<pid>/file and
281 /proc/curproc/file. */
282 {
283 char *link;
284
285 link = xreadlink ("/proc/curproc/file");
286 if (link != NULL)
287 {
288 if (strcmp (link, "unknown") != 0)
289 return link;
290 free (link);
291 }
292 }
293 # endif
294 # if defined __NetBSD__
295 /* In NetBSD >= 4.0, the executable is accessible as /proc/<pid>/exe and
296 /proc/curproc/exe. */
297 {
298 char *link;
299
300 link = xreadlink ("/proc/curproc/exe");
301 if (link != NULL)
302 return link;
303 }
304 # endif
305 # if defined __sun
306 /* On Solaris >= 11.4, /proc/<pid>/execname and /proc/self/execname contains
307 the name of the executable, either as an absolute file name or relative to
308 the current directory. */
309 {
310 char namebuf[4096];
311 int fd = open ("/proc/self/execname", O_RDONLY | O_CLOEXEC, 0);
312 if (fd >= 0)
313 {
314 size_t len = full_read (fd, namebuf, sizeof (namebuf));
315 close (fd);
316 if (len > 0 && len < sizeof (namebuf))
317 {
318 namebuf[len] = '\0';
319 return canonicalize_file_name (namebuf);
320 }
321 }
322 }
323 # endif
324 # if defined __CYGWIN__
325 /* The executable is accessible as /proc/<pid>/exe, at least in
326 Cygwin >= 1.5. */
327 {
328 char *link;
329
330 link = xreadlink ("/proc/self/exe");
331 if (link != NULL)
332 return link;
333 if (executable_fd < 0)
334 executable_fd = open ("/proc/self/exe", O_EXEC | O_CLOEXEC, 0);
335 }
336 # endif
337 # if HAVE_MACH_O_DYLD_H && HAVE__NSGETEXECUTABLEPATH
338 /* On Mac OS X 10.2 or newer, the function
339 int _NSGetExecutablePath (char *buf, uint32_t *bufsize);
340 can be used to retrieve the executable's full path. */
341 char location[4096];
342 unsigned int length = sizeof (location);
343 if (_NSGetExecutablePath (location, &length) == 0
344 && location[0] == '/')
345 return canonicalize_file_name (location);
346 # endif
347 /* Guess the executable's full path. We assume the executable has been
348 called via execlp() or execvp() with properly set up argv[0]. The
349 login(1) convention to add a '-' prefix to argv[0] is not supported. */
350 {
351 bool has_slash = false;
352 {
353 const char *p;
354 for (p = argv0; *p; p++)
355 if (*p == '/')
356 {
357 has_slash = true;
358 break;
359 }
360 }
361 if (!has_slash)
362 {
363 /* exec searches paths without slashes in the directory list given
364 by $PATH. */
365 const char *path = getenv ("PATH");
366
367 if (path != NULL)
368 {
369 const char *p;
370 const char *p_next;
371
372 for (p = path; *p; p = p_next)
373 {
374 const char *q;
375 size_t p_len;
376 char *concat_name;
377
378 for (q = p; *q; q++)
379 if (*q == ':')
380 break;
381 p_len = q - p;
382 p_next = (*q == '\0' ? q : q + 1);
383
384 /* We have a path item at p, of length p_len.
385 Now concatenate the path item and argv0. */
386 concat_name = (char *) xmalloc (p_len + strlen (argv0) + 2);
387 # ifdef NO_XMALLOC
388 if (concat_name == NULL)
389 return NULL;
390 # endif
391 if (p_len == 0)
392 /* An empty PATH element designates the current directory. */
393 strcpy (concat_name, argv0);
394 else
395 {
396 memcpy (concat_name, p, p_len);
397 concat_name[p_len] = '/';
398 strcpy (concat_name + p_len + 1, argv0);
399 }
400 if (maybe_executable (concat_name))
401 return canonicalize_file_name (concat_name);
402 free (concat_name);
403 }
404 }
405 /* Not found in the PATH, assume the current directory. */
406 }
407 /* exec treats paths containing slashes as relative to the current
408 directory. */
409 if (maybe_executable (argv0))
410 return canonicalize_file_name (argv0);
411 }
412 /* No way to find the executable. */
413 return NULL;
414 #endif
415 }
416
417 /* Full pathname of executable, or NULL. */
418 static char *executable_fullname;
419
420 static void
421 prepare_relocate (const char *orig_installprefix, const char *orig_installdir,
422 const char *argv0)
423 {
424 char *curr_prefix;
425
426 /* Determine the full pathname of the current executable. */
427 executable_fullname = find_executable (argv0);
428
429 /* Determine the current installation prefix from it. */
430 curr_prefix = compute_curr_prefix (orig_installprefix, orig_installdir,
431 executable_fullname);
432 if (curr_prefix != NULL)
433 {
434 /* Now pass this prefix to all copies of the relocate.c source file. */
435 set_relocation_prefix (orig_installprefix, curr_prefix);
436
437 free (curr_prefix);
438 }
439 }
440
441 /* Set program_name, based on argv[0], and original installation prefix and
442 directory, for relocatability. */
443 void
444 set_program_name_and_installdir (const char *argv0,
445 const char *orig_installprefix,
446 const char *orig_installdir)
447 {
448 const char *argv0_stripped = argv0;
449
450 /* Relocatable programs are renamed to .bin by install-reloc. Or, more
451 generally, their suffix is changed from $exeext to .bin$exeext.
452 Remove the ".bin" here. */
453 {
454 size_t argv0_len = strlen (argv0);
455 const size_t exeext_len = sizeof (EXEEXT) - sizeof ("");
456 if (argv0_len > 4 + exeext_len)
457 if (memcmp (argv0 + argv0_len - exeext_len - 4, ".bin", 4) == 0)
458 {
459 if (sizeof (EXEEXT) > sizeof (""))
460 {
461 /* Compare using an inlined copy of c_strncasecmp(), because
462 the filenames may have undergone a case conversion since
463 they were packaged. In other words, EXEEXT may be ".exe"
464 on one system and ".EXE" on another. */
465 static const char exeext[] = EXEEXT;
466 const char *s1 = argv0 + argv0_len - exeext_len;
467 const char *s2 = exeext;
468 for (; *s1 != '\0'; s1++, s2++)
469 {
470 unsigned char c1 = *s1;
471 unsigned char c2 = *s2;
472 if ((c1 >= 'A' && c1 <= 'Z' ? c1 - 'A' + 'a' : c1)
473 != (c2 >= 'A' && c2 <= 'Z' ? c2 - 'A' + 'a' : c2))
474 goto done_stripping;
475 }
476 }
477 /* Remove ".bin" before EXEEXT or its equivalent. */
478 {
479 char *shorter = (char *) xmalloc (argv0_len - 4 + 1);
480 #ifdef NO_XMALLOC
481 if (shorter != NULL)
482 #endif
483 {
484 memcpy (shorter, argv0, argv0_len - exeext_len - 4);
485 if (sizeof (EXEEXT) > sizeof (""))
486 memcpy (shorter + argv0_len - exeext_len - 4,
487 argv0 + argv0_len - exeext_len - 4,
488 exeext_len);
489 shorter[argv0_len - 4] = '\0';
490 argv0_stripped = shorter;
491 }
492 }
493 done_stripping: ;
494 }
495 }
496
497 set_program_name (argv0_stripped);
498
499 prepare_relocate (orig_installprefix, orig_installdir, argv0);
500 }
501
502 /* Return the full pathname of the current executable, based on the earlier
503 call to set_program_name_and_installdir. Return NULL if unknown. */
504 char *
505 get_full_program_name (void)
506 {
507 return executable_fullname;
508 }
509
510 #endif