binreloc.c

/*
 * BinReloc - a library for creating relocatable executables
 * Written by: Hongli Lai <[email protected]>
 * 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.
 */

#ifndef __BINRELOC_C__
#define __BINRELOC_C__
#include "config.h"

#ifdef ENABLE_BINRELOC
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#ifdef MAC_INTEGRATION
#include <gtkmacintegration/gtkosxapplication.h>
#endif
#endif /* ENABLE_BINRELOC */
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <string.h>
#include "binreloc.h"
#include <glib.h>

G_BEGIN_DECLS

static char *
_br_find_exe (Gnc_GbrInitError *error)
{
#ifndef ENABLE_BINRELOC
    if (error)
        *error = GNC_GBR_INIT_ERROR_DISABLED;
    return NULL;
#else
#ifdef G_OS_WIN32
    /* I *thought* this program code already included the
       relocation code for windows. Unfortunately this is not
       the case and we have to add this manually. This is only
       one possibility; other ways of looking up the full path
       of gnucash.exe probably exist.*/
    gchar *prefix;
    gchar *result;

    /* From the glib docs: When passed NULL, this function looks
       up installation the directory of the main executable of
       the current process */
    prefix = g_win32_get_package_installation_directory_of_module (NULL);
    result = g_build_filename (prefix,
                               "bin", "gnucash.exe",
                               (char*)NULL);
    g_free (prefix);
    return result;
#elif defined MAC_INTEGRATION
    gchar *path = gtkosx_application_get_executable_path();
    g_print ("Application Path %s\n", path);
    return path;
#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 = (char *) g_try_malloc (buf_size);
    if (path == NULL)
    {
        /* Cannot allocate memory. */
        if (error)
            *error = GNC_GBR_INIT_ERROR_NOMEM;
        return NULL;
    }
    path2 = (char *) g_try_malloc (buf_size);
    if (path2 == NULL)
    {
        /* Cannot allocate memory. */
        if (error)
            *error = GNC_GBR_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 = GNC_GBR_INIT_ERROR_NOMEM;
        return NULL;
    }

    f = fopen ("/proc/self/maps", "r");
    if (f == NULL)
    {
        g_free (line);
        if (error)
            *error = GNC_GBR_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 = GNC_GBR_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 = GNC_GBR_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 = GNC_GBR_INIT_ERROR_INVALID_MAPS;
        return NULL;
    }

    path = g_strdup (path);
    g_free (line);
    fclose (f);
    return path;
#endif /* G_OS_WINDOWS */
#endif /* ENABLE_BINRELOC */
}



static gchar *exe = NULL;

static void set_gerror (GError **error, Gnc_GbrInitError errcode);


void gnc_gbr_set_exe (const gchar* default_exe)
{
    if (exe != NULL)
        g_free(exe);
    exe = NULL;

    if (default_exe != NULL)
        exe = g_strdup(default_exe);
}


gboolean
gnc_gbr_init (GError **error)
{
    Gnc_GbrInitError errcode = 0;

    /* Locate the application's filename. */
    exe = _br_find_exe (&errcode);
    if (exe != NULL)
        /* Success! */
        return TRUE;
    else
    {
        /* Failed :-( */
        set_gerror (error, errcode);
        return FALSE;
    }
}


static void
set_gerror (GError **error, Gnc_GbrInitError errcode)
{
    gchar *error_message;

    if (error == NULL)
        return;

    switch (errcode)
    {
    case GNC_GBR_INIT_ERROR_NOMEM:
        error_message = "Cannot allocate memory.";
        break;
    case GNC_GBR_INIT_ERROR_OPEN_MAPS:
        error_message = "Unable to open /proc/self/maps for reading.";
        break;
    case GNC_GBR_INIT_ERROR_READ_MAPS:
        error_message = "Unable to read from /proc/self/maps.";
        break;
    case GNC_GBR_INIT_ERROR_INVALID_MAPS:
        error_message = "The file format of /proc/self/maps is invalid.";
        break;
    case GNC_GBR_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);
}


gchar *
gnc_gbr_find_exe (const gchar *default_exe)
{
    if (exe == NULL)
    {
        /* BinReloc is not initialized. */
        if (default_exe != NULL)
            return g_strdup (default_exe);
        else
            return NULL;
    }
    return g_strdup (exe);
}


gchar *
gnc_gbr_find_exe_dir (const gchar *default_dir)
{
    if (exe == NULL)
    {
        /* BinReloc not initialized. */
        if (default_dir != NULL)
            return g_strdup (default_dir);
        else
            return NULL;
    }

    return g_path_get_dirname (exe);
}


gchar *
gnc_gbr_find_prefix (const gchar *default_prefix)
{
#if defined ENABLE_BINRELOC && defined MAC_INTEGRATION
    gchar *id = gtkosx_application_get_bundle_id ();
    gchar *path = gtkosx_application_get_resource_path ();
    if (id == NULL)
    {
        gchar *dirname = g_path_get_dirname (path);
        g_free (path);
        g_free (id);
        return dirname;
    }
    g_free (id);
    return path;
#else
    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;
#endif //ENABLE_BINRELOC && defined MAC_INTEGRATION
}


gchar *
gnc_gbr_find_bin_dir (const gchar *default_bin_dir)
{
    gchar *prefix, *dir;
    prefix = gnc_gbr_find_prefix (NULL);
    if (prefix == NULL)
    {
        /* BinReloc not initialized. */
        if (default_bin_dir != NULL)
            return g_strdup (default_bin_dir);
        else
            return NULL;
    }

    dir = g_build_filename (prefix, "bin", NULL);
    g_free (prefix);
    return dir;
}


gchar *
gnc_gbr_find_sbin_dir (const gchar *default_sbin_dir)
{
    gchar *prefix, *dir;

    prefix = gnc_gbr_find_prefix (NULL);
    if (prefix == NULL)
    {
        /* BinReloc not initialized. */
        if (default_sbin_dir != NULL)
            return g_strdup (default_sbin_dir);
        else
            return NULL;
    }

    dir = g_build_filename (prefix, "sbin", NULL);
    g_free (prefix);
    return dir;
}


gchar *
gnc_gbr_find_data_dir (const gchar *default_data_dir)
{
    gchar *prefix, *dir;

    prefix = gnc_gbr_find_prefix (NULL);
    if (prefix == NULL)
    {
        /* BinReloc not initialized. */
        if (default_data_dir != NULL)
            return g_strdup (default_data_dir);
        else
            return NULL;
    }

    dir = g_build_filename (prefix, "share", NULL);
    g_free (prefix);
    return dir;
}


gchar *
gnc_gbr_find_lib_dir (const gchar *default_lib_dir)
{
    gchar *prefix, *dir;

    prefix = gnc_gbr_find_prefix (NULL);
    if (prefix == NULL)
    {
        /* BinReloc not initialized. */
        if (default_lib_dir != NULL)
            return g_strdup (default_lib_dir);
        else
            return NULL;
    }

    dir = g_build_filename (prefix, "lib", NULL);
    g_free (prefix);
    return dir;
}


gchar *
gnc_gbr_find_libexec_dir (const gchar *default_libexec_dir)
{
    gchar *prefix, *dir;

    prefix = gnc_gbr_find_prefix (NULL);
    if (prefix == NULL)
    {
        /* BinReloc not initialized. */
        if (default_libexec_dir != NULL)
            return g_strdup (default_libexec_dir);
        else
            return NULL;
    }

    dir = g_build_filename (prefix, "libexec", NULL);
    g_free (prefix);
    return dir;
}


gchar *
gnc_gbr_find_etc_dir (const gchar *default_etc_dir)
{
    gchar *prefix, *dir;

    prefix = gnc_gbr_find_prefix (NULL);
    if (prefix == NULL)
    {
        /* BinReloc not initialized. */
        if (default_etc_dir != NULL)
            return g_strdup (default_etc_dir);
        else
            return NULL;
    }

    dir = g_build_filename (prefix, "etc", NULL);
    g_free (prefix);
    return dir;
}


G_END_DECLS

#endif /* __BINRELOC_C__ */