|
0
|
1 /* Provide relocatable packages.
|
|
|
2 Copyright (C) 2003 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 it
|
|
|
6 under the terms of the GNU Library General Public License as published
|
|
|
7 by the Free Software Foundation; either version 2, or (at your option)
|
|
|
8 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 GNU
|
|
|
13 Library General Public License for more details.
|
|
|
14
|
|
|
15 You should have received a copy of the GNU Library General Public
|
|
|
16 License along with this program; if not, write to the Free Software
|
|
|
17 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301,
|
|
|
18 USA. */
|
|
|
19
|
|
|
20
|
|
|
21 /* Tell glibc's <stdio.h> to provide a prototype for getline().
|
|
|
22 This must come before <config.h> because <config.h> may include
|
|
|
23 <features.h>, and once <features.h> has been included, it's too late. */
|
|
|
24 #ifndef _GNU_SOURCE
|
|
|
25 # define _GNU_SOURCE 1
|
|
|
26 #endif
|
|
|
27
|
|
|
28 #ifdef HAVE_CONFIG_H
|
|
|
29 # include "config.h"
|
|
|
30 #endif
|
|
|
31
|
|
|
32 /* Specification. */
|
|
|
33 #include "relocatable.h"
|
|
|
34
|
|
|
35 #if ENABLE_RELOCATABLE
|
|
|
36
|
|
|
37 #include <stddef.h>
|
|
|
38 #include <stdio.h>
|
|
|
39 #include <stdlib.h>
|
|
|
40 #include <string.h>
|
|
|
41
|
|
|
42 #ifdef NO_XMALLOC
|
|
|
43 # define xmalloc malloc
|
|
|
44 #else
|
|
|
45 # include "xmalloc.h"
|
|
|
46 #endif
|
|
|
47
|
|
|
48 #if DEPENDS_ON_LIBCHARSET
|
|
|
49 # include <libcharset.h>
|
|
|
50 #endif
|
|
|
51 #if DEPENDS_ON_LIBICONV && HAVE_ICONV
|
|
|
52 # include <iconv.h>
|
|
|
53 #endif
|
|
|
54 #if DEPENDS_ON_LIBINTL && ENABLE_NLS
|
|
|
55 # include <libintl.h>
|
|
|
56 #endif
|
|
|
57
|
|
|
58 /* Faked cheap 'bool'. */
|
|
|
59 #undef bool
|
|
|
60 #undef false
|
|
|
61 #undef true
|
|
|
62 #define bool int
|
|
|
63 #define false 0
|
|
|
64 #define true 1
|
|
|
65
|
|
|
66 /* Pathname support.
|
|
|
67 ISSLASH(C) tests whether C is a directory separator character.
|
|
|
68 IS_PATH_WITH_DIR(P) tests whether P contains a directory specification.
|
|
|
69 */
|
|
|
70 #if defined _WIN32 || defined __WIN32__ || defined __EMX__ || defined __DJGPP__
|
|
|
71 /* Win32, OS/2, DOS */
|
|
|
72 # define ISSLASH(C) ((C) == '/' || (C) == '\\')
|
|
|
73 # define HAS_DEVICE(P) \
|
|
|
74 ((((P)[0] >= 'A' && (P)[0] <= 'Z') || ((P)[0] >= 'a' && (P)[0] <= 'z')) \
|
|
|
75 && (P)[1] == ':')
|
|
|
76 # define IS_PATH_WITH_DIR(P) \
|
|
|
77 (strchr (P, '/') != NULL || strchr (P, '\\') != NULL || HAS_DEVICE (P))
|
|
|
78 # define FILESYSTEM_PREFIX_LEN(P) (HAS_DEVICE (P) ? 2 : 0)
|
|
|
79 #else
|
|
|
80 /* Unix */
|
|
|
81 # define ISSLASH(C) ((C) == '/')
|
|
|
82 # define IS_PATH_WITH_DIR(P) (strchr (P, '/') != NULL)
|
|
|
83 # define FILESYSTEM_PREFIX_LEN(P) 0
|
|
|
84 #endif
|
|
|
85
|
|
|
86 /* Original installation prefix. */
|
|
|
87 static char *orig_prefix;
|
|
|
88 static size_t orig_prefix_len;
|
|
|
89 /* Current installation prefix. */
|
|
|
90 static char *curr_prefix;
|
|
|
91 static size_t curr_prefix_len;
|
|
|
92 /* These prefixes do not end in a slash. Anything that will be concatenated
|
|
|
93 to them must start with a slash. */
|
|
|
94
|
|
|
95 /* Sets the original and the current installation prefix of this module.
|
|
|
96 Relocation simply replaces a pathname starting with the original prefix
|
|
|
97 by the corresponding pathname with the current prefix instead. Both
|
|
|
98 prefixes should be directory names without trailing slash (i.e. use ""
|
|
|
99 instead of "/"). */
|
|
|
100 static void
|
|
|
101 set_this_relocation_prefix (const char *orig_prefix_arg,
|
|
|
102 const char *curr_prefix_arg)
|
|
|
103 {
|
|
|
104 if (orig_prefix_arg != NULL && curr_prefix_arg != NULL
|
|
|
105 /* Optimization: if orig_prefix and curr_prefix are equal, the
|
|
|
106 relocation is a nop. */
|
|
|
107 && strcmp (orig_prefix_arg, curr_prefix_arg) != 0)
|
|
|
108 {
|
|
|
109 /* Duplicate the argument strings. */
|
|
|
110 char *memory;
|
|
|
111
|
|
|
112 orig_prefix_len = strlen (orig_prefix_arg);
|
|
|
113 curr_prefix_len = strlen (curr_prefix_arg);
|
|
|
114 memory = (char *) xmalloc (orig_prefix_len + 1 + curr_prefix_len + 1);
|
|
|
115 #ifdef NO_XMALLOC
|
|
|
116 if (memory != NULL)
|
|
|
117 #endif
|
|
|
118 {
|
|
|
119 memcpy (memory, orig_prefix_arg, orig_prefix_len + 1);
|
|
|
120 orig_prefix = memory;
|
|
|
121 memory += orig_prefix_len + 1;
|
|
|
122 memcpy (memory, curr_prefix_arg, curr_prefix_len + 1);
|
|
|
123 curr_prefix = memory;
|
|
|
124 return;
|
|
|
125 }
|
|
|
126 }
|
|
|
127 orig_prefix = NULL;
|
|
|
128 curr_prefix = NULL;
|
|
|
129 /* Don't worry about wasted memory here - this function is usually only
|
|
|
130 called once. */
|
|
|
131 }
|
|
|
132
|
|
|
133 /* Sets the original and the current installation prefix of the package.
|
|
|
134 Relocation simply replaces a pathname starting with the original prefix
|
|
|
135 by the corresponding pathname with the current prefix instead. Both
|
|
|
136 prefixes should be directory names without trailing slash (i.e. use ""
|
|
|
137 instead of "/"). */
|
|
|
138 void
|
|
|
139 set_relocation_prefix (const char *orig_prefix_arg, const char *curr_prefix_arg)
|
|
|
140 {
|
|
|
141 set_this_relocation_prefix (orig_prefix_arg, curr_prefix_arg);
|
|
|
142
|
|
|
143 /* Now notify all dependent libraries. */
|
|
|
144 #if DEPENDS_ON_LIBCHARSET
|
|
|
145 libcharset_set_relocation_prefix (orig_prefix_arg, curr_prefix_arg);
|
|
|
146 #endif
|
|
|
147 #if DEPENDS_ON_LIBICONV && HAVE_ICONV && _LIBICONV_VERSION >= 0x0109
|
|
|
148 libiconv_set_relocation_prefix (orig_prefix_arg, curr_prefix_arg);
|
|
|
149 #endif
|
|
|
150 #if DEPENDS_ON_LIBINTL && ENABLE_NLS && defined libintl_set_relocation_prefix
|
|
|
151 libintl_set_relocation_prefix (orig_prefix_arg, curr_prefix_arg);
|
|
|
152 #endif
|
|
|
153 }
|
|
|
154
|
|
|
155 /* Convenience function:
|
|
|
156 Computes the current installation prefix, based on the original
|
|
|
157 installation prefix, the original installation directory of a particular
|
|
|
158 file, and the current pathname of this file. Returns NULL upon failure. */
|
|
|
159 #ifdef IN_LIBRARY
|
|
|
160 #define compute_curr_prefix local_compute_curr_prefix
|
|
|
161 static
|
|
|
162 #endif
|
|
|
163 const char *
|
|
|
164 compute_curr_prefix (const char *orig_installprefix,
|
|
|
165 const char *orig_installdir,
|
|
|
166 const char *curr_pathname)
|
|
|
167 {
|
|
|
168 const char *curr_installdir;
|
|
|
169 const char *rel_installdir;
|
|
|
170
|
|
|
171 if (curr_pathname == NULL)
|
|
|
172 return NULL;
|
|
|
173
|
|
|
174 /* Determine the relative installation directory, relative to the prefix.
|
|
|
175 This is simply the difference between orig_installprefix and
|
|
|
176 orig_installdir. */
|
|
|
177 if (strncmp (orig_installprefix, orig_installdir, strlen (orig_installprefix))
|
|
|
178 != 0)
|
|
|
179 /* Shouldn't happen - nothing should be installed outside $(prefix). */
|
|
|
180 return NULL;
|
|
|
181 rel_installdir = orig_installdir + strlen (orig_installprefix);
|
|
|
182
|
|
|
183 /* Determine the current installation directory. */
|
|
|
184 {
|
|
|
185 const char *p_base = curr_pathname + FILESYSTEM_PREFIX_LEN (curr_pathname);
|
|
|
186 const char *p = curr_pathname + strlen (curr_pathname);
|
|
|
187 char *q;
|
|
|
188
|
|
|
189 while (p > p_base)
|
|
|
190 {
|
|
|
191 p--;
|
|
|
192 if (ISSLASH (*p))
|
|
|
193 break;
|
|
|
194 }
|
|
|
195
|
|
|
196 q = (char *) xmalloc (p - curr_pathname + 1);
|
|
|
197 #ifdef NO_XMALLOC
|
|
|
198 if (q == NULL)
|
|
|
199 return NULL;
|
|
|
200 #endif
|
|
|
201 memcpy (q, curr_pathname, p - curr_pathname);
|
|
|
202 q[p - curr_pathname] = '\0';
|
|
|
203 curr_installdir = q;
|
|
|
204 }
|
|
|
205
|
|
|
206 /* Compute the current installation prefix by removing the trailing
|
|
|
207 rel_installdir from it. */
|
|
|
208 {
|
|
|
209 const char *rp = rel_installdir + strlen (rel_installdir);
|
|
|
210 const char *cp = curr_installdir + strlen (curr_installdir);
|
|
|
211 const char *cp_base =
|
|
|
212 curr_installdir + FILESYSTEM_PREFIX_LEN (curr_installdir);
|
|
|
213
|
|
|
214 while (rp > rel_installdir && cp > cp_base)
|
|
|
215 {
|
|
|
216 bool same = false;
|
|
|
217 const char *rpi = rp;
|
|
|
218 const char *cpi = cp;
|
|
|
219
|
|
|
220 while (rpi > rel_installdir && cpi > cp_base)
|
|
|
221 {
|
|
|
222 rpi--;
|
|
|
223 cpi--;
|
|
|
224 if (ISSLASH (*rpi) || ISSLASH (*cpi))
|
|
|
225 {
|
|
|
226 if (ISSLASH (*rpi) && ISSLASH (*cpi))
|
|
|
227 same = true;
|
|
|
228 break;
|
|
|
229 }
|
|
|
230 #if defined _WIN32 || defined __WIN32__ || defined __EMX__ || defined __DJGPP__
|
|
|
231 /* Win32, OS/2, DOS - case insignificant filesystem */
|
|
|
232 if ((*rpi >= 'a' && *rpi <= 'z' ? *rpi - 'a' + 'A' : *rpi)
|
|
|
233 != (*cpi >= 'a' && *cpi <= 'z' ? *cpi - 'a' + 'A' : *cpi))
|
|
|
234 break;
|
|
|
235 #else
|
|
|
236 if (*rpi != *cpi)
|
|
|
237 break;
|
|
|
238 #endif
|
|
|
239 }
|
|
|
240 if (!same)
|
|
|
241 break;
|
|
|
242 /* The last pathname component was the same. opi and cpi now point
|
|
|
243 to the slash before it. */
|
|
|
244 rp = rpi;
|
|
|
245 cp = cpi;
|
|
|
246 }
|
|
|
247
|
|
|
248 if (rp > rel_installdir)
|
|
|
249 /* Unexpected: The curr_installdir does not end with rel_installdir. */
|
|
|
250 return NULL;
|
|
|
251
|
|
|
252 {
|
|
|
253 size_t curr_prefix_len = cp - curr_installdir;
|
|
|
254 char *curr_prefix;
|
|
|
255
|
|
|
256 curr_prefix = (char *) xmalloc (curr_prefix_len + 1);
|
|
|
257 #ifdef NO_XMALLOC
|
|
|
258 if (curr_prefix == NULL)
|
|
|
259 return NULL;
|
|
|
260 #endif
|
|
|
261 memcpy (curr_prefix, curr_installdir, curr_prefix_len);
|
|
|
262 curr_prefix[curr_prefix_len] = '\0';
|
|
|
263
|
|
|
264 return curr_prefix;
|
|
|
265 }
|
|
|
266 }
|
|
|
267 }
|
|
|
268
|
|
|
269 #if defined PIC && defined INSTALLDIR
|
|
|
270
|
|
|
271 /* Full pathname of shared library, or NULL. */
|
|
|
272 static char *shared_library_fullname;
|
|
|
273
|
|
|
274 #if defined _WIN32 || defined __WIN32__
|
|
|
275
|
|
|
276 /* Determine the full pathname of the shared library when it is loaded. */
|
|
|
277
|
|
|
278 BOOL WINAPI
|
|
|
279 DllMain (HINSTANCE module_handle, DWORD event, LPVOID reserved)
|
|
|
280 {
|
|
|
281 (void) reserved;
|
|
|
282
|
|
|
283 if (event == DLL_PROCESS_ATTACH)
|
|
|
284 {
|
|
|
285 /* The DLL is being loaded into an application's address range. */
|
|
|
286 static char location[MAX_PATH];
|
|
|
287
|
|
|
288 if (!GetModuleFileName (module_handle, location, sizeof (location)))
|
|
|
289 /* Shouldn't happen. */
|
|
|
290 return FALSE;
|
|
|
291
|
|
|
292 if (!IS_PATH_WITH_DIR (location))
|
|
|
293 /* Shouldn't happen. */
|
|
|
294 return FALSE;
|
|
|
295
|
|
|
296 shared_library_fullname = strdup (location);
|
|
|
297 }
|
|
|
298
|
|
|
299 return TRUE;
|
|
|
300 }
|
|
|
301
|
|
|
302 #else /* Unix */
|
|
|
303
|
|
|
304 static void
|
|
|
305 find_shared_library_fullname ()
|
|
|
306 {
|
|
|
307 #ifdef __linux__
|
|
|
308 FILE *fp;
|
|
|
309
|
|
|
310 /* Open the current process' maps file. It describes one VMA per line. */
|
|
|
311 fp = fopen ("/proc/self/maps", "r");
|
|
|
312 if (fp)
|
|
|
313 {
|
|
|
314 unsigned long address = (unsigned long) &find_shared_library_fullname;
|
|
|
315 for (;;)
|
|
|
316 {
|
|
|
317 unsigned long start, end;
|
|
|
318 int c;
|
|
|
319
|
|
|
320 if (fscanf (fp, "%lx-%lx", &start, &end) != 2)
|
|
|
321 break;
|
|
|
322 if (address >= start && address <= end - 1)
|
|
|
323 {
|
|
|
324 /* Found it. Now see if this line contains a filename. */
|
|
|
325 while (c = getc (fp), c != EOF && c != '\n' && c != '/')
|
|
|
326 continue;
|
|
|
327 if (c == '/')
|
|
|
328 {
|
|
|
329 size_t size;
|
|
|
330 int len;
|
|
|
331
|
|
|
332 ungetc (c, fp);
|
|
|
333 shared_library_fullname = NULL; size = 0;
|
|
|
334 len = getline (&shared_library_fullname, &size, fp);
|
|
|
335 if (len >= 0)
|
|
|
336 {
|
|
|
337 /* Success: filled shared_library_fullname. */
|
|
|
338 if (len > 0 && shared_library_fullname[len - 1] == '\n')
|
|
|
339 shared_library_fullname[len - 1] = '\0';
|
|
|
340 }
|
|
|
341 }
|
|
|
342 break;
|
|
|
343 }
|
|
|
344 while (c = getc (fp), c != EOF && c != '\n')
|
|
|
345 continue;
|
|
|
346 }
|
|
|
347 fclose (fp);
|
|
|
348 }
|
|
|
349 #endif
|
|
|
350 }
|
|
|
351
|
|
|
352 #endif /* WIN32 / Unix */
|
|
|
353
|
|
|
354 /* Return the full pathname of the current shared library.
|
|
|
355 Return NULL if unknown.
|
|
|
356 Guaranteed to work only on Linux and Woe32. */
|
|
|
357 static char *
|
|
|
358 get_shared_library_fullname ()
|
|
|
359 {
|
|
|
360 #if !(defined _WIN32 || defined __WIN32__)
|
|
|
361 static bool tried_find_shared_library_fullname;
|
|
|
362 if (!tried_find_shared_library_fullname)
|
|
|
363 {
|
|
|
364 find_shared_library_fullname ();
|
|
|
365 tried_find_shared_library_fullname = true;
|
|
|
366 }
|
|
|
367 #endif
|
|
|
368 return shared_library_fullname;
|
|
|
369 }
|
|
|
370
|
|
|
371 #endif /* PIC */
|
|
|
372
|
|
|
373 /* Returns the pathname, relocated according to the current installation
|
|
|
374 directory. */
|
|
|
375 const char *
|
|
|
376 relocate (const char *pathname)
|
|
|
377 {
|
|
|
378 #if defined PIC && defined INSTALLDIR
|
|
|
379 static int initialized;
|
|
|
380
|
|
|
381 /* Initialization code for a shared library. */
|
|
|
382 if (!initialized)
|
|
|
383 {
|
|
|
384 /* At this point, orig_prefix and curr_prefix likely have already been
|
|
|
385 set through the main program's set_program_name_and_installdir
|
|
|
386 function. This is sufficient in the case that the library has
|
|
|
387 initially been installed in the same orig_prefix. But we can do
|
|
|
388 better, to also cover the cases that 1. it has been installed
|
|
|
389 in a different prefix before being moved to orig_prefix and (later)
|
|
|
390 to curr_prefix, 2. unlike the program, it has not moved away from
|
|
|
391 orig_prefix. */
|
|
|
392 const char *orig_installprefix = INSTALLPREFIX;
|
|
|
393 const char *orig_installdir = INSTALLDIR;
|
|
|
394 const char *curr_prefix_better;
|
|
|
395
|
|
|
396 curr_prefix_better =
|
|
|
397 compute_curr_prefix (orig_installprefix, orig_installdir,
|
|
|
398 get_shared_library_fullname ());
|
|
|
399 if (curr_prefix_better == NULL)
|
|
|
400 curr_prefix_better = curr_prefix;
|
|
|
401
|
|
|
402 set_relocation_prefix (orig_installprefix, curr_prefix_better);
|
|
|
403
|
|
|
404 initialized = 1;
|
|
|
405 }
|
|
|
406 #endif
|
|
|
407
|
|
|
408 /* Note: It is not necessary to perform case insensitive comparison here,
|
|
|
409 even for DOS-like filesystems, because the pathname argument was
|
|
|
410 typically created from the same Makefile variable as orig_prefix came
|
|
|
411 from. */
|
|
|
412 if (orig_prefix != NULL && curr_prefix != NULL
|
|
|
413 && strncmp (pathname, orig_prefix, orig_prefix_len) == 0)
|
|
|
414 {
|
|
|
415 if (pathname[orig_prefix_len] == '\0')
|
|
|
416 /* pathname equals orig_prefix. */
|
|
|
417 return curr_prefix;
|
|
|
418 if (ISSLASH (pathname[orig_prefix_len]))
|
|
|
419 {
|
|
|
420 /* pathname starts with orig_prefix. */
|
|
|
421 const char *pathname_tail = &pathname[orig_prefix_len];
|
|
|
422 char *result =
|
|
|
423 (char *) xmalloc (curr_prefix_len + strlen (pathname_tail) + 1);
|
|
|
424
|
|
|
425 #ifdef NO_XMALLOC
|
|
|
426 if (result != NULL)
|
|
|
427 #endif
|
|
|
428 {
|
|
|
429 memcpy (result, curr_prefix, curr_prefix_len);
|
|
|
430 strcpy (result + curr_prefix_len, pathname_tail);
|
|
|
431 return result;
|
|
|
432 }
|
|
|
433 }
|
|
|
434 }
|
|
|
435 /* Nothing to relocate. */
|
|
|
436 return pathname;
|
|
|
437 }
|
|
|
438
|
|
|
439 #endif
|
