(check_for_running_agent): New.
[gnupg.git] / intl / relocatable.c
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
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