src/prefix.c

   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
  15 #ifdef HAVE_CONFIG_H
  16 # include "config.h"
  17 #endif
  18
  19
  20 /*
  21  * enrico - all the code below is only compiled and used if ENABLE_BINRELOC is set in config.h,
  22  *          this only happens if configure option --enable-binreloc was used
  23  */
  24 #ifdef ENABLE_BINRELOC
  25
  26
  27
  28 #include <stdlib.h>
  29 #include <stdio.h>
  30 #include <limits.h>
  31 #include <string.h>
  32 #include <glib.h>
  33 #include "prefix.h"
  34
  35
  36 #undef NULL
  37 #define NULL ((void *) 0)
  38
  39 #ifdef __GNUC__
  40         #define br_return_val_if_fail(expr,val) if (!(expr)) {fprintf (stderr, "** BinReloc (%s): assertion %s failed\n", __PRETTY_FUNCTION__, #expr); return val;}
  41 #else
  42         #define br_return_val_if_fail(expr, val) if (!(expr)) return val
  43 #endif /* __GNUC__ */
  44
  45
  46 #include <sys/types.h>
  47 #include <sys/stat.h>
  48 #include <sys/param.h>
  49 #include <unistd.h>
  50
  51
  52 static char *br_last_value = (char*)NULL;
  53
  54
  55 static void
  56 br_free_last_value ()
  57 {
  58         if (br_last_value)
  59                 free (br_last_value);
  60 }
  61
  62
  63 /**
  64  * br_thread_local_store:
  65  * str: A dynamically allocated string.
  66  * Returns: str. This return value must not be freed.
  67  *
  68  * Store str in a thread-local variable and return str. The next
  69  * you run this function, that variable is freed too.
  70  * This function is created so you don't have to worry about freeing
  71  * strings.
  72  *
  73  * Example:
  74  * char *foo;
  75  * foo = thread_local_store (strdup ("hello")); --> foo == "hello"
  76  * foo = thread_local_store (strdup ("world")); --> foo == "world"; "hello" is now freed.
  77  */
  78 const char *
  79 br_thread_local_store (char *str)
  80 {
  81         static int initialized = 0;
  82
  83
  84         if (!initialized)
  85         {
  86                 atexit (br_free_last_value);
  87                 initialized = 1;
  88         }
  89
  90         if (br_last_value)
  91                 free (br_last_value);
  92         br_last_value = str;
  93
  94         return (const char *) str;
  95 }
  96
  97
  98 /**
  99  * br_locate:
 100  * symbol: A symbol that belongs to the app/library you want to locate.
 101  * Returns: A newly allocated string containing the full path of the
 102  *          app/library that func belongs to, or NULL on error. This
 103  *          string should be freed when not when no longer needed.
 104  *
 105  * Finds out to which application or library symbol belongs, then locate
 106  * the full path of that application or library.
 107  * Note that symbol cannot be a pointer to a function. That will not work.
 108  *
 109  * Example:
 110  * --> main.c
 111  * #include "prefix.h"
 112  * #include "libfoo.h"
 113  *
 114  * int main (int argc, char *argv[]) {
 115  *      printf ("Full path of this app: %s\n", br_locate (&argc));
 116  *      libfoo_start ();
 117  *      return 0;
 118  * }
 119  *
 120  * --> libfoo.c starts here
 121  * #include "prefix.h"
 122  *
 123  * void libfoo_start () {
 124  *      --> "" is a symbol that belongs to libfoo (because it's called
 125  *      --> from libfoo_start()); that's why this works.
 126  *      printf ("libfoo is located in: %s\n", br_locate (""));
 127  * }
 128  */
 129 char *
 130 br_locate (void *symbol)
 131 {
 132         char line[5000];
 133         FILE *f;
 134         char *path;
 135
 136         br_return_val_if_fail (symbol != NULL, NULL);
 137
 138         f = fopen ("/proc/self/maps", "r");
 139         if (!f)
 140                 return NULL;
 141
 142         while (!feof (f))
 143         {
 144                 unsigned long start, end;
 145
 146                 if (!fgets (line, sizeof (line), f))
 147                         continue;
 148                 if (!strstr (line, " r-xp ") || !strchr (line, '/'))
 149                         continue;
 150
 151                 sscanf (line, "%lx-%lx ", &start, &end);
 152                 if (symbol >= (void *) start && symbol < (void *) end)
 153                 {
 154                         char *tmp;
 155                         gsize len;
 156
 157                         /* Extract the filename; it is always an absolute path */
 158                         path = strchr (line, '/');
 159
 160                         /* Get rid of the newline */
 161                         tmp = strrchr (path, '\n');
 162                         if (tmp) *tmp = 0;
 163
 164                         /* Get rid of "(deleted)" */
 165                         len = strlen (path);
 166                         if (len > 10 && strcmp (path + len - 10, " (deleted)") == 0)
 167                         {
 168                                 tmp = path + len - 10;
 169                                 *tmp = 0;
 170                         }
 171
 172                         fclose(f);
 173                         return strdup (path);
 174                 }
 175         }
 176
 177         fclose (f);
 178         return NULL;
 179 }
 180
 181
 182 /**
 183  * br_extract_prefix:
 184  * path: The full path of an executable or library.
 185  * Returns: The prefix, or NULL on error. This string should be freed when no longer needed.
 186  *
 187  * Extracts the prefix from path. This function assumes that your executable
 188  * or library is installed in an LSB-compatible directory structure.
 189  *
 190  * Example:
 191  * br_extract_prefix ("/usr/bin/gnome-panel");       --> Returns "/usr"
 192  * br_extract_prefix ("/usr/local/lib/libfoo.so");   --> Returns "/usr/local"
 193  * br_extract_prefix ("/usr/local/libfoo.so");       --> Returns "/usr"
 194  */
 195 char *
 196 br_extract_prefix (const char *path)
 197 {
 198         char *end, *tmp, *result;
 199
 200         br_return_val_if_fail (path != (char*)NULL, (char*)NULL);
 201
 202         if (!*path) return strdup ("/");
 203         end = strrchr (path, '/');
 204         if (!end) return strdup (path);
 205
 206         tmp = g_strndup ((char *) path, end - path);
 207         if (!*tmp)
 208         {
 209                 g_free (tmp);
 210                 return strdup ("/");
 211         }
 212         end = strrchr (tmp, '/');
 213         if (!end) return tmp;
 214
 215         result = g_strndup (tmp, end - tmp);
 216         g_free (tmp);
 217
 218         if (!*result)
 219         {
 220                 g_free (result);
 221                 result = strdup ("/");
 222         }
 223
 224         return result;
 225 }
 226
 227
 228 /**
 229  * br_locate_prefix:
 230  * symbol: A symbol that belongs to the app/library you want to locate.
 231  * Returns: A prefix. This string should be freed when no longer needed.
 232  *
 233  * Locates the full path of the app/library that symbol belongs to, and return
 234  * the prefix of that path, or NULL on error.
 235  * Note that symbol cannot be a pointer to a function. That will not work.
 236  *
 237  * Example:
 238  * --> This application is located in /usr/bin/foo
 239  * br_locate_prefix (&argc);   --> returns: "/usr"
 240  */
 241 char *
 242 br_locate_prefix (void *symbol)
 243 {
 244         char *path, *prefix;
 245
 246         br_return_val_if_fail (symbol != NULL, NULL);
 247
 248         path = br_locate (symbol);
 249         if (!path) return NULL;
 250
 251         prefix = br_extract_prefix (path);
 252         free (path);
 253         return prefix;
 254 }
 255
 256
 257 /**
 258  * br_prepend_prefix:
 259  * symbol: A symbol that belongs to the app/library you want to locate.
 260  * path: The path that you want to prepend the prefix to.
 261  * Returns: The new path, or NULL on error. This string should be freed when no
 262  *          longer needed.
 263  *
 264  * Gets the prefix of the app/library that symbol belongs to. Prepend that prefix to path.
 265  * Note that symbol cannot be a pointer to a function. That will not work.
 266  *
 267  * Example:
 268  * --> The application is /usr/bin/foo
 269  * br_prepend_prefix (&argc, "/share/foo/data.png");   --> Returns "/usr/share/foo/data.png"
 270  */
 271 char *
 272 br_prepend_prefix (void *symbol, char *path)
 273 {
 274         char *tmp, *newpath;
 275
 276         br_return_val_if_fail (symbol != NULL, NULL);
 277         br_return_val_if_fail (path != NULL, NULL);
 278
 279         tmp = br_locate_prefix (symbol);
 280         if (!tmp) return NULL;
 281
 282         if (strcmp (tmp, "/") == 0)
 283                 newpath = strdup (path);
 284         else
 285                 newpath = g_strconcat (tmp, path, NULL);
 286
 287         free (tmp);
 288         return newpath;
 289 }
 290
 291
 292 #else /* ENABLE_BINRELOC */
 293
 294 typedef int iso_c_forbids_an_empty_source_file;
 295
 296 #endif /* ENABLE_BINRELOC */