10245
|
1 /*
|
|
2 * BinReloc - a library for creating relocatable executables
|
|
3 * Written by: Mike Hearn <mike@theoretic.com>
|
|
4 * Hongli Lai <h.lai@chello.nl>
|
|
5 * http://autopackage.org/
|
|
6 *
|
|
7 * This source code is public domain. You can relicense this code
|
|
8 * under whatever license you want.
|
|
9 *
|
|
10 * NOTE: if you're using C++ and are getting "undefined reference
|
|
11 * to br_*", try renaming prefix.c to prefix.cpp
|
|
12 */
|
|
13
|
|
14 /* WARNING, BEFORE YOU MODIFY PREFIX.C:
|
|
15 *
|
|
16 * If you make changes to any of the functions in prefix.c, you MUST
|
|
17 * change the BR_NAMESPACE macro (in prefix.h).
|
|
18 * This way you can avoid symbol table conflicts with other libraries
|
|
19 * that also happen to use BinReloc.
|
|
20 *
|
|
21 * Example:
|
|
22 * #define BR_NAMESPACE(funcName) foobar_ ## funcName
|
|
23 * --> expands br_locate to foobar_br_locate
|
|
24 */
|
|
25
|
|
26 #ifndef _PREFIX_C_
|
|
27 #define _PREFIX_C_
|
|
28
|
|
29 #ifdef HAVE_CONFIG_H
|
|
30 #include "config.h"
|
|
31 #endif
|
|
32
|
|
33 #ifndef BR_PTHREADS
|
|
34 /* Change 1 to 0 if you don't want pthread support */
|
|
35 #define BR_PTHREADS 1
|
|
36 #endif /* BR_PTHREADS */
|
|
37
|
|
38 #include <stdlib.h>
|
|
39 #include <stdio.h>
|
|
40 #include <limits.h>
|
|
41 #include <string.h>
|
|
42 #include "prefix.h"
|
|
43
|
|
44 #ifdef __cplusplus
|
|
45 extern "C" {
|
|
46 #endif /* __cplusplus */
|
|
47
|
|
48
|
|
49 #undef NULL
|
|
50 #define NULL ((void *) 0)
|
|
51
|
|
52 #ifdef __GNUC__
|
|
53 #define br_return_val_if_fail(expr,val) if (!(expr)) {fprintf (stderr, "** BinReloc (%s): assertion %s failed\n", __PRETTY_FUNCTION__, #expr); return val;}
|
|
54 #else
|
|
55 #define br_return_val_if_fail(expr,val) if (!(expr)) return val
|
|
56 #endif /* __GNUC__ */
|
|
57
|
|
58
|
|
59 #ifdef ENABLE_BINRELOC
|
|
60 #include <sys/types.h>
|
|
61 #include <sys/stat.h>
|
|
62 #include <sys/param.h>
|
|
63 #include <unistd.h>
|
|
64
|
|
65
|
10251
|
66 static br_locate_fallback_func fallback_func = NULL;
|
|
67 static void *fallback_data = NULL;
|
|
68 /**
|
|
69 * br_set_fallback_function:
|
|
70 * func: A function to call to find the binary.
|
|
71 * data: User data to pass to func.
|
|
72 *
|
|
73 * Sets a function to call to find the path to the binary, in
|
|
74 * case "/proc/self/maps" can't be opened. The function set should
|
|
75 * return a string that is safe to free with free().
|
|
76 */
|
|
77 void
|
|
78 br_set_locate_fallback_func (br_locate_fallback_func func, void *data)
|
|
79 {
|
|
80 fallback_func = func;
|
|
81 fallback_data = data;
|
|
82 }
|
|
83
|
|
84
|
10245
|
85 /**
|
|
86 * br_locate:
|
|
87 * symbol: A symbol that belongs to the app/library you want to locate.
|
|
88 * Returns: A newly allocated string containing the full path of the
|
|
89 * app/library that func belongs to, or NULL on error. This
|
|
90 * string should be freed when not when no longer needed.
|
|
91 *
|
|
92 * Finds out to which application or library symbol belongs, then locate
|
|
93 * the full path of that application or library.
|
|
94 * Note that symbol cannot be a pointer to a function. That will not work.
|
|
95 *
|
|
96 * Example:
|
|
97 * --> main.c
|
|
98 * #include "prefix.h"
|
|
99 * #include "libfoo.h"
|
|
100 *
|
|
101 * int main (int argc, char *argv[]) {
|
|
102 * printf ("Full path of this app: %s\n", br_locate (&argc));
|
|
103 * libfoo_start ();
|
|
104 * return 0;
|
|
105 * }
|
|
106 *
|
|
107 * --> libfoo.c starts here
|
|
108 * #include "prefix.h"
|
|
109 *
|
|
110 * void libfoo_start () {
|
|
111 * --> "" is a symbol that belongs to libfoo (because it's called
|
|
112 * --> from libfoo_start()); that's why this works.
|
|
113 * printf ("libfoo is located in: %s\n", br_locate (""));
|
|
114 * }
|
|
115 */
|
|
116 char *
|
|
117 br_locate (void *symbol)
|
|
118 {
|
|
119 char line[5000];
|
|
120 FILE *f;
|
|
121 char *path;
|
|
122
|
|
123 br_return_val_if_fail (symbol != NULL, NULL);
|
|
124
|
|
125 f = fopen ("/proc/self/maps", "r");
|
10251
|
126 if (!f) {
|
|
127 if (fallback_func)
|
|
128 return fallback_func(symbol, fallback_data);
|
|
129 else
|
|
130 return NULL;
|
|
131 }
|
10245
|
132
|
|
133 while (!feof (f))
|
|
134 {
|
|
135 unsigned long start, end;
|
|
136
|
|
137 if (!fgets (line, sizeof (line), f))
|
|
138 continue;
|
|
139 if (!strstr (line, " r-xp ") || !strchr (line, '/'))
|
|
140 continue;
|
|
141
|
|
142 sscanf (line, "%lx-%lx ", &start, &end);
|
|
143 if (symbol >= (void *) start && symbol < (void *) end)
|
|
144 {
|
|
145 char *tmp;
|
|
146 size_t len;
|
|
147
|
|
148 /* Extract the filename; it is always an absolute path */
|
|
149 path = strchr (line, '/');
|
|
150
|
|
151 /* Get rid of the newline */
|
|
152 tmp = strrchr (path, '\n');
|
|
153 if (tmp) *tmp = 0;
|
|
154
|
|
155 /* Get rid of "(deleted)" */
|
|
156 len = strlen (path);
|
|
157 if (len > 10 && strcmp (path + len - 10, " (deleted)") == 0)
|
|
158 {
|
|
159 tmp = path + len - 10;
|
|
160 *tmp = 0;
|
|
161 }
|
|
162
|
|
163 fclose(f);
|
|
164 return strdup (path);
|
|
165 }
|
|
166 }
|
|
167
|
|
168 fclose (f);
|
|
169 return NULL;
|
|
170 }
|
|
171
|
|
172
|
|
173 /**
|
|
174 * br_locate_prefix:
|
|
175 * symbol: A symbol that belongs to the app/library you want to locate.
|
|
176 * Returns: A prefix. This string should be freed when no longer needed.
|
|
177 *
|
|
178 * Locates the full path of the app/library that symbol belongs to, and return
|
|
179 * the prefix of that path, or NULL on error.
|
|
180 * Note that symbol cannot be a pointer to a function. That will not work.
|
|
181 *
|
|
182 * Example:
|
|
183 * --> This application is located in /usr/bin/foo
|
|
184 * br_locate_prefix (&argc); --> returns: "/usr"
|
|
185 */
|
|
186 char *
|
|
187 br_locate_prefix (void *symbol)
|
|
188 {
|
|
189 char *path, *prefix;
|
|
190
|
|
191 br_return_val_if_fail (symbol != NULL, NULL);
|
|
192
|
|
193 path = br_locate (symbol);
|
|
194 if (!path) return NULL;
|
|
195
|
|
196 prefix = br_extract_prefix (path);
|
|
197 free (path);
|
|
198 return prefix;
|
|
199 }
|
|
200
|
|
201
|
|
202 /**
|
|
203 * br_prepend_prefix:
|
|
204 * symbol: A symbol that belongs to the app/library you want to locate.
|
|
205 * path: The path that you want to prepend the prefix to.
|
|
206 * Returns: The new path, or NULL on error. This string should be freed when no
|
|
207 * longer needed.
|
|
208 *
|
|
209 * Gets the prefix of the app/library that symbol belongs to. Prepend that prefix to path.
|
|
210 * Note that symbol cannot be a pointer to a function. That will not work.
|
|
211 *
|
|
212 * Example:
|
|
213 * --> The application is /usr/bin/foo
|
|
214 * br_prepend_prefix (&argc, "/share/foo/data.png"); --> Returns "/usr/share/foo/data.png"
|
|
215 */
|
|
216 char *
|
|
217 br_prepend_prefix (void *symbol, char *path)
|
|
218 {
|
|
219 char *tmp, *newpath;
|
|
220
|
|
221 br_return_val_if_fail (symbol != NULL, NULL);
|
|
222 br_return_val_if_fail (path != NULL, NULL);
|
|
223
|
|
224 tmp = br_locate_prefix (symbol);
|
|
225 if (!tmp) return NULL;
|
|
226
|
|
227 if (strcmp (tmp, "/") == 0)
|
|
228 newpath = strdup (path);
|
|
229 else
|
|
230 newpath = br_strcat (tmp, path);
|
|
231
|
|
232 /* Get rid of compiler warning ("br_prepend_prefix never used") */
|
|
233 if (0) br_prepend_prefix (NULL, NULL);
|
|
234
|
|
235 free (tmp);
|
|
236 return newpath;
|
|
237 }
|
|
238
|
|
239 #endif /* ENABLE_BINRELOC */
|
|
240
|
|
241
|
|
242 /* Pthread stuff for thread safetiness */
|
|
243 #if BR_PTHREADS
|
|
244
|
|
245 #include <pthread.h>
|
|
246
|
|
247 static pthread_key_t br_thread_key;
|
|
248 static pthread_once_t br_thread_key_once = PTHREAD_ONCE_INIT;
|
|
249
|
|
250
|
|
251 static void
|
|
252 br_thread_local_store_fini ()
|
|
253 {
|
|
254 char *specific;
|
|
255
|
|
256 specific = (char *) pthread_getspecific (br_thread_key);
|
|
257 if (specific)
|
|
258 {
|
|
259 free (specific);
|
|
260 pthread_setspecific (br_thread_key, NULL);
|
|
261 }
|
|
262 pthread_key_delete (br_thread_key);
|
|
263 br_thread_key = 0;
|
|
264 }
|
|
265
|
|
266
|
|
267 static void
|
|
268 br_str_free (void *str)
|
|
269 {
|
|
270 if (str)
|
|
271 free (str);
|
|
272 }
|
|
273
|
|
274
|
|
275 static void
|
|
276 br_thread_local_store_init ()
|
|
277 {
|
|
278 if (pthread_key_create (&br_thread_key, br_str_free) == 0)
|
|
279 atexit (br_thread_local_store_fini);
|
|
280 }
|
|
281
|
|
282 #else /* BR_PTHREADS */
|
|
283
|
|
284 static char *br_last_value = (char *) NULL;
|
|
285
|
|
286 static void
|
|
287 br_free_last_value ()
|
|
288 {
|
|
289 if (br_last_value)
|
|
290 free (br_last_value);
|
|
291 }
|
|
292
|
|
293 #endif /* BR_PTHREADS */
|
|
294
|
|
295
|
|
296 /**
|
|
297 * br_thread_local_store:
|
|
298 * str: A dynamically allocated string.
|
|
299 * Returns: str. This return value must not be freed.
|
|
300 *
|
|
301 * Store str in a thread-local variable and return str. The next
|
|
302 * you run this function, that variable is freed too.
|
|
303 * This function is created so you don't have to worry about freeing
|
|
304 * strings.
|
|
305 *
|
|
306 * Example:
|
|
307 * char *foo;
|
|
308 * foo = thread_local_store (strdup ("hello")); --> foo == "hello"
|
|
309 * foo = thread_local_store (strdup ("world")); --> foo == "world"; "hello" is now freed.
|
|
310 */
|
|
311 const char *
|
|
312 br_thread_local_store (char *str)
|
|
313 {
|
|
314 #if BR_PTHREADS
|
|
315 char *specific;
|
|
316
|
|
317 pthread_once (&br_thread_key_once, br_thread_local_store_init);
|
|
318
|
|
319 specific = (char *) pthread_getspecific (br_thread_key);
|
|
320 br_str_free (specific);
|
|
321 pthread_setspecific (br_thread_key, str);
|
|
322
|
|
323 #else /* BR_PTHREADS */
|
|
324 static int initialized = 0;
|
|
325
|
|
326 if (!initialized)
|
|
327 {
|
|
328 atexit (br_free_last_value);
|
|
329 initialized = 1;
|
|
330 }
|
|
331
|
|
332 if (br_last_value)
|
|
333 free (br_last_value);
|
|
334 br_last_value = str;
|
|
335 #endif /* BR_PTHREADS */
|
|
336
|
|
337 return (const char *) str;
|
|
338 }
|
|
339
|
|
340
|
|
341 /**
|
|
342 * br_strcat:
|
|
343 * str1: A string.
|
|
344 * str2: Another string.
|
|
345 * Returns: A newly-allocated string. This string should be freed when no longer needed.
|
|
346 *
|
|
347 * Concatenate str1 and str2 to a newly allocated string.
|
|
348 */
|
|
349 char *
|
|
350 br_strcat (const char *str1, const char *str2)
|
|
351 {
|
|
352 char *result;
|
|
353 size_t len1, len2;
|
|
354
|
|
355 if (!str1) str1 = "";
|
|
356 if (!str2) str2 = "";
|
|
357
|
|
358 len1 = strlen (str1);
|
|
359 len2 = strlen (str2);
|
|
360
|
|
361 result = (char *) malloc (len1 + len2 + 1);
|
|
362 memcpy (result, str1, len1);
|
|
363 memcpy (result + len1, str2, len2);
|
|
364 result[len1 + len2] = '\0';
|
|
365
|
|
366 return result;
|
|
367 }
|
|
368
|
|
369
|
|
370 /* Emulates glibc's strndup() */
|
|
371 static char *
|
|
372 br_strndup (char *str, size_t size)
|
|
373 {
|
|
374 char *result = (char *) NULL;
|
|
375 size_t len;
|
|
376
|
|
377 br_return_val_if_fail (str != (char *) NULL, (char *) NULL);
|
|
378
|
|
379 len = strlen (str);
|
|
380 if (!len) return strdup ("");
|
|
381 if (size > len) size = len;
|
|
382
|
|
383 result = (char *) calloc (sizeof (char), len + 1);
|
|
384 memcpy (result, str, size);
|
|
385 return result;
|
|
386 }
|
|
387
|
|
388
|
|
389 /**
|
|
390 * br_extract_dir:
|
|
391 * path: A path.
|
|
392 * Returns: A directory name. This string should be freed when no longer needed.
|
|
393 *
|
|
394 * Extracts the directory component of path. Similar to g_dirname() or the dirname
|
|
395 * commandline application.
|
|
396 *
|
|
397 * Example:
|
|
398 * br_extract_dir ("/usr/local/foobar"); --> Returns: "/usr/local"
|
|
399 */
|
|
400 char *
|
|
401 br_extract_dir (const char *path)
|
|
402 {
|
|
403 char *end, *result;
|
|
404
|
|
405 br_return_val_if_fail (path != (char *) NULL, (char *) NULL);
|
|
406
|
|
407 end = strrchr (path, '/');
|
|
408 if (!end) return strdup (".");
|
|
409
|
|
410 while (end > path && *end == '/')
|
|
411 end--;
|
|
412 result = br_strndup ((char *) path, end - path + 1);
|
|
413 if (!*result)
|
|
414 {
|
|
415 free (result);
|
|
416 return strdup ("/");
|
|
417 } else
|
|
418 return result;
|
|
419 }
|
|
420
|
|
421
|
|
422 /**
|
|
423 * br_extract_prefix:
|
|
424 * path: The full path of an executable or library.
|
|
425 * Returns: The prefix, or NULL on error. This string should be freed when no longer needed.
|
|
426 *
|
|
427 * Extracts the prefix from path. This function assumes that your executable
|
|
428 * or library is installed in an LSB-compatible directory structure.
|
|
429 *
|
|
430 * Example:
|
|
431 * br_extract_prefix ("/usr/bin/gnome-panel"); --> Returns "/usr"
|
|
432 * br_extract_prefix ("/usr/local/lib/libfoo.so"); --> Returns "/usr/local"
|
|
433 * br_extract_prefix ("/usr/local/libfoo.so"); --> Returns "/usr"
|
|
434 */
|
|
435 char *
|
|
436 br_extract_prefix (const char *path)
|
|
437 {
|
|
438 char *end, *tmp, *result;
|
|
439
|
|
440 br_return_val_if_fail (path != (char *) NULL, (char *) NULL);
|
|
441
|
|
442 if (!*path) return strdup ("/");
|
|
443 end = strrchr (path, '/');
|
|
444 if (!end) return strdup (path);
|
|
445
|
|
446 tmp = br_strndup ((char *) path, end - path);
|
|
447 if (!*tmp)
|
|
448 {
|
|
449 free (tmp);
|
|
450 return strdup ("/");
|
|
451 }
|
|
452 end = strrchr (tmp, '/');
|
|
453 if (!end) return tmp;
|
|
454
|
|
455 result = br_strndup (tmp, end - tmp);
|
|
456 free (tmp);
|
|
457
|
|
458 if (!*result)
|
|
459 {
|
|
460 free (result);
|
|
461 result = strdup ("/");
|
|
462 }
|
|
463
|
|
464 return result;
|
|
465 }
|
|
466
|
|
467
|
|
468 #ifdef __cplusplus
|
|
469 }
|
|
470 #endif /* __cplusplus */
|
|
471
|
|
472 #endif /* _PREFIX_C */
|