summaryrefslogtreecommitdiffstats
path: root/libgimpbase/gimpreloc.c
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 18:30:19 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 18:30:19 +0000
commit5c1676dfe6d2f3c837a5e074117b45613fd29a72 (patch)
treecbffb45144febf451e54061db2b21395faf94bfe /libgimpbase/gimpreloc.c
parentInitial commit. (diff)
downloadgimp-5c1676dfe6d2f3c837a5e074117b45613fd29a72.tar.xz
gimp-5c1676dfe6d2f3c837a5e074117b45613fd29a72.zip
Adding upstream version 2.10.34.upstream/2.10.34upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'libgimpbase/gimpreloc.c')
-rw-r--r--libgimpbase/gimpreloc.c435
1 files changed, 435 insertions, 0 deletions
diff --git a/libgimpbase/gimpreloc.c b/libgimpbase/gimpreloc.c
new file mode 100644
index 0000000..b9fa4df
--- /dev/null
+++ b/libgimpbase/gimpreloc.c
@@ -0,0 +1,435 @@
+/*
+ * BinReloc - a library for creating relocatable executables
+ * Written by: Hongli Lai <h.lai@chello.nl>
+ * http://autopackage.org/
+ *
+ * This source code is public domain. You can relicense this code
+ * under whatever license you want.
+ *
+ * See http://autopackage.org/docs/binreloc/ for
+ * more information and how to use this.
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <limits.h>
+#include <string.h>
+
+#if defined(ENABLE_RELOCATABLE_RESOURCES) && ! defined(G_OS_WIN32)
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#endif /* ENABLE_RELOCATABLE_RESOURCES && ! G_OS_WIN32 */
+
+#include <glib.h>
+#include <glib/gstdio.h>
+
+#include "gimpreloc.h"
+
+
+/*
+ * Find the canonical filename of the executable. Returns the filename
+ * (which must be freed) or NULL on error. If the parameter 'error' is
+ * not NULL, the error code will be stored there, if an error occurred.
+ */
+static char *
+_br_find_exe (GimpBinrelocInitError *error)
+{
+#if ! defined(ENABLE_RELOCATABLE_RESOURCES) || defined(G_OS_WIN32)
+ if (error)
+ *error = GIMP_RELOC_INIT_ERROR_DISABLED;
+ return NULL;
+#else
+ char *path, *path2, *line, *result;
+ size_t buf_size;
+ ssize_t size;
+ struct stat stat_buf;
+ FILE *f;
+
+ /* Read from /proc/self/exe (symlink) */
+ if (sizeof (path) > SSIZE_MAX)
+ buf_size = SSIZE_MAX - 1;
+ else
+ buf_size = PATH_MAX - 1;
+ path = g_try_new (char, buf_size);
+ if (path == NULL)
+ {
+ /* Cannot allocate memory. */
+ if (error)
+ *error = GIMP_RELOC_INIT_ERROR_NOMEM;
+ return NULL;
+ }
+ path2 = g_try_new (char, buf_size);
+ if (path2 == NULL)
+ {
+ /* Cannot allocate memory. */
+ if (error)
+ *error = GIMP_RELOC_INIT_ERROR_NOMEM;
+ g_free (path);
+ return NULL;
+ }
+
+ strncpy (path2, "/proc/self/exe", buf_size - 1);
+
+ while (1)
+ {
+ int i;
+
+ size = readlink (path2, path, buf_size - 1);
+ if (size == -1)
+ {
+ /* Error. */
+ g_free (path2);
+ break;
+ }
+
+ /* readlink() success. */
+ path[size] = '\0';
+
+ /* Check whether the symlink's target is also a symlink.
+ * We want to get the final target. */
+ i = stat (path, &stat_buf);
+ if (i == -1)
+ {
+ /* Error. */
+ g_free (path2);
+ break;
+ }
+
+ /* stat() success. */
+ if (!S_ISLNK (stat_buf.st_mode))
+ {
+ /* path is not a symlink. Done. */
+ g_free (path2);
+ return path;
+ }
+
+ /* path is a symlink. Continue loop and resolve this. */
+ strncpy (path, path2, buf_size - 1);
+ }
+
+
+ /* readlink() or stat() failed; this can happen when the program is
+ * running in Valgrind 2.2. Read from /proc/self/maps as fallback. */
+
+ buf_size = PATH_MAX + 128;
+ line = (char *) g_try_realloc (path, buf_size);
+ if (line == NULL)
+ {
+ /* Cannot allocate memory. */
+ g_free (path);
+ if (error)
+ *error = GIMP_RELOC_INIT_ERROR_NOMEM;
+ return NULL;
+ }
+
+ f = g_fopen ("/proc/self/maps", "r");
+ if (f == NULL)
+ {
+ g_free (line);
+ if (error)
+ *error = GIMP_RELOC_INIT_ERROR_OPEN_MAPS;
+ return NULL;
+ }
+
+ /* The first entry should be the executable name. */
+ result = fgets (line, (int) buf_size, f);
+ if (result == NULL)
+ {
+ fclose (f);
+ g_free (line);
+ if (error)
+ *error = GIMP_RELOC_INIT_ERROR_READ_MAPS;
+ return NULL;
+ }
+
+ /* Get rid of newline character. */
+ buf_size = strlen (line);
+ if (buf_size == 0)
+ {
+ /* Huh? An empty string? */
+ fclose (f);
+ g_free (line);
+ if (error)
+ *error = GIMP_RELOC_INIT_ERROR_INVALID_MAPS;
+ return NULL;
+ }
+ if (line[buf_size - 1] == 10)
+ line[buf_size - 1] = 0;
+
+ /* Extract the filename; it is always an absolute path. */
+ path = strchr (line, '/');
+
+ /* Sanity check. */
+ if (strstr (line, " r-xp ") == NULL || path == NULL)
+ {
+ fclose (f);
+ g_free (line);
+ if (error)
+ *error = GIMP_RELOC_INIT_ERROR_INVALID_MAPS;
+ return NULL;
+ }
+
+ path = g_strdup (path);
+ g_free (line);
+ fclose (f);
+ return path;
+#endif /* ! ENABLE_RELOCATABLE_RESOURCES || G_OS_WIN32 */
+}
+
+
+/*
+ * Find the canonical filename of the executable which owns symbol.
+ * Returns a filename which must be freed, or NULL on error.
+ */
+static char *
+_br_find_exe_for_symbol (const void *symbol, GimpBinrelocInitError *error)
+{
+#if ! defined(ENABLE_RELOCATABLE_RESOURCES) || defined(G_OS_WIN32)
+ if (error)
+ *error = GIMP_RELOC_INIT_ERROR_DISABLED;
+ return (char *) NULL;
+#else
+#define SIZE PATH_MAX + 100
+ FILE *f;
+ size_t address_string_len;
+ char *address_string, line[SIZE], *found;
+
+ if (symbol == NULL)
+ return (char *) NULL;
+
+ f = g_fopen ("/proc/self/maps", "r");
+ if (f == NULL)
+ return (char *) NULL;
+
+ address_string_len = 4;
+ address_string = g_try_new (char, address_string_len);
+ found = (char *) NULL;
+
+ while (!feof (f))
+ {
+ char *start_addr, *end_addr, *end_addr_end, *file;
+ void *start_addr_p, *end_addr_p;
+ size_t len;
+
+ if (fgets (line, SIZE, f) == NULL)
+ break;
+
+ /* Sanity check. */
+ if (strstr (line, " r-xp ") == NULL || strchr (line, '/') == NULL)
+ continue;
+
+ /* Parse line. */
+ start_addr = line;
+ end_addr = strchr (line, '-');
+ file = strchr (line, '/');
+
+ /* More sanity check. */
+ if (!(file > end_addr && end_addr != NULL && end_addr[0] == '-'))
+ continue;
+
+ end_addr[0] = '\0';
+ end_addr++;
+ end_addr_end = strchr (end_addr, ' ');
+ if (end_addr_end == NULL)
+ continue;
+
+ end_addr_end[0] = '\0';
+ len = strlen (file);
+ if (len == 0)
+ continue;
+ if (file[len - 1] == '\n')
+ file[len - 1] = '\0';
+
+ /* Get rid of "(deleted)" from the filename. */
+ len = strlen (file);
+ if (len > 10 && strcmp (file + len - 10, " (deleted)") == 0)
+ file[len - 10] = '\0';
+
+ /* I don't know whether this can happen but better safe than sorry. */
+ len = strlen (start_addr);
+ if (len != strlen (end_addr))
+ continue;
+
+
+ /* Transform the addresses into a string in the form of 0xdeadbeef,
+ * then transform that into a pointer. */
+ if (address_string_len < len + 3)
+ {
+ address_string_len = len + 3;
+ address_string = (char *) g_try_realloc (address_string, address_string_len);
+ }
+
+ memcpy (address_string, "0x", 2);
+ memcpy (address_string + 2, start_addr, len);
+ address_string[2 + len] = '\0';
+ sscanf (address_string, "%p", &start_addr_p);
+
+ memcpy (address_string, "0x", 2);
+ memcpy (address_string + 2, end_addr, len);
+ address_string[2 + len] = '\0';
+ sscanf (address_string, "%p", &end_addr_p);
+
+
+ if (symbol >= start_addr_p && symbol < end_addr_p)
+ {
+ found = file;
+ break;
+ }
+ }
+
+ g_free (address_string);
+ fclose (f);
+
+ if (found == NULL)
+ return (char *) NULL;
+ else
+ return g_strdup (found);
+#endif /* ! ENABLE_RELOCATABLE_RESOURCES || G_OS_WIN32 */
+}
+
+
+static gchar *exe = NULL;
+
+static void set_gerror (GError **error, GimpBinrelocInitError errcode);
+
+
+/* Initialize the BinReloc library (for applications).
+ *
+ * This function must be called before using any other BinReloc functions.
+ * It attempts to locate the application's canonical filename.
+ *
+ * @note If you want to use BinReloc for a library, then you should call
+ * _gimp_reloc_init_lib() instead.
+ * @note Initialization failure is not fatal. BinReloc functions will just
+ * fallback to the supplied default path.
+ *
+ * @param error If BinReloc failed to initialize, then the error report will
+ * be stored in this variable. Set to NULL if you don't want an
+ * error report. See the #GimpBinrelocInitError for a list of error
+ * codes.
+ *
+ * @returns TRUE on success, FALSE if BinReloc failed to initialize.
+ */
+gboolean
+_gimp_reloc_init (GError **error)
+{
+ GimpBinrelocInitError errcode;
+
+ /* Shut up compiler warning about uninitialized variable. */
+ errcode = GIMP_RELOC_INIT_ERROR_NOMEM;
+
+ /* Locate the application's filename. */
+ exe = _br_find_exe (&errcode);
+ if (exe != NULL)
+ /* Success! */
+ return TRUE;
+ else
+ {
+ /* Failed :-( */
+ set_gerror (error, errcode);
+ return FALSE;
+ }
+}
+
+
+/* Initialize the BinReloc library (for libraries).
+ *
+ * This function must be called before using any other BinReloc functions.
+ * It attempts to locate the calling library's canonical filename.
+ *
+ * @note The BinReloc source code MUST be included in your library, or this
+ * function won't work correctly.
+ * @note Initialization failure is not fatal. BinReloc functions will just
+ * fallback to the supplied default path.
+ *
+ * @returns TRUE on success, FALSE if a filename cannot be found.
+ */
+gboolean
+_gimp_reloc_init_lib (GError **error)
+{
+ GimpBinrelocInitError errcode;
+
+ /* Shut up compiler warning about uninitialized variable. */
+ errcode = GIMP_RELOC_INIT_ERROR_NOMEM;
+
+ exe = _br_find_exe_for_symbol ((const void *) "", &errcode);
+ if (exe != NULL)
+ /* Success! */
+ return TRUE;
+ else
+ {
+ /* Failed :-( */
+ set_gerror (error, errcode);
+ return exe != NULL;
+ }
+}
+
+static void
+set_gerror (GError **error, GimpBinrelocInitError errcode)
+{
+ const gchar *error_message;
+
+ if (error == NULL)
+ return;
+
+ switch (errcode)
+ {
+ case GIMP_RELOC_INIT_ERROR_NOMEM:
+ error_message = "Cannot allocate memory.";
+ break;
+ case GIMP_RELOC_INIT_ERROR_OPEN_MAPS:
+ error_message = "Unable to open /proc/self/maps for reading.";
+ break;
+ case GIMP_RELOC_INIT_ERROR_READ_MAPS:
+ error_message = "Unable to read from /proc/self/maps.";
+ break;
+ case GIMP_RELOC_INIT_ERROR_INVALID_MAPS:
+ error_message = "The file format of /proc/self/maps is invalid.";
+ break;
+ case GIMP_RELOC_INIT_ERROR_DISABLED:
+ error_message = "Binary relocation support is disabled.";
+ break;
+ default:
+ error_message = "Unknown error.";
+ break;
+ };
+ g_set_error (error, g_quark_from_static_string ("GBinReloc"),
+ errcode, "%s", error_message);
+}
+
+
+/* Locate the prefix in which the current application is installed.
+ *
+ * The prefix is generated by the following pseudo-code evaluation:
+ * \code
+ * dirname(dirname(exename))
+ * \endcode
+ *
+ * @param default_prefix A default prefix which will used as fallback.
+ * @return A string containing the prefix, which must be freed when no
+ * longer necessary. If BinReloc is not initialized, or if the
+ * initialization function failed, then a copy of default_prefix
+ * will be returned. If default_prefix is NULL, then NULL will be
+ * returned.
+ */
+gchar *
+_gimp_reloc_find_prefix (const gchar *default_prefix)
+{
+ gchar *dir1, *dir2;
+
+ if (exe == NULL)
+ {
+ /* BinReloc not initialized. */
+ if (default_prefix != NULL)
+ return g_strdup (default_prefix);
+ else
+ return NULL;
+ }
+
+ dir1 = g_path_get_dirname (exe);
+ dir2 = g_path_get_dirname (dir1);
+ g_free (dir1);
+ return dir2;
+}