preload.c

/* -*- Mode: C; indent-tabs-mode: nil; tab-width: 4 -*-
 *
 * Copyright (C) 2015 Canonical, Ltd.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; version 3.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#define _GNU_SOURCE
#define __USE_GNU

#include <dirent.h>
#include <dlfcn.h>
#include <errno.h>
#include <fcntl.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/inotify.h>
#include <sys/socket.h>
#include <sys/statvfs.h>
#include <sys/un.h>
#include <sys/vfs.h>
#include <unistd.h>

#define LD_PRELOAD "LD_PRELOAD"
#define SNAPPY_PRELOAD "SNAPPY_PRELOAD"
static char **saved_ld_preloads = NULL;
static size_t num_saved_ld_preloads = 0;
static char *saved_snappy_preload = NULL;
static char *saved_tmpdir = NULL;
static char *saved_varlib = NULL;

static void constructor() __attribute__((constructor));

static char *
getenvdup (const char *varname)
{
    char *envvar = secure_getenv (varname);
    if (envvar == NULL || envvar[0] == 0) // identical for our purposes
        return NULL;
    else
        return strdup (envvar);
}

void constructor()
{
    char *ld_preload_copy, *p, *savedptr = NULL;
    size_t libnamelen;

    // We need to save LD_PRELOAD and SNAPPY_PRELOAD in case we need to
    // propagate the values to an exec'd program.
    ld_preload_copy = getenvdup (LD_PRELOAD);
    if (ld_preload_copy == NULL) {
        return;
    }

    saved_snappy_preload = getenvdup (SNAPPY_PRELOAD);
    if (saved_snappy_preload == NULL) {
        free (ld_preload_copy);
        return;
    }

    saved_tmpdir = getenvdup ("SNAP_APP_TMPDIR");
    if (!saved_tmpdir) {
        saved_tmpdir = getenvdup ("TMPDIR");
    }

    saved_varlib = getenvdup ("SNAP_APP_DATA_PATH");
    if (!saved_varlib) {
        saved_varlib = getenvdup ("SNAPP_APP_DATA_PATH");
    }

    // Pull out each absolute-pathed libsnappypreload.so we find.  Better to
    // accidentally include some other libsnappypreload than not propagate
    // ourselves.
    libnamelen = strlen (SNAPPY_LIBNAME);
    for (p = strtok_r (ld_preload_copy, " :", &savedptr);
         p;
         p = strtok_r (NULL, " :", &savedptr)) {
        size_t plen = strlen (p);
        if (plen > libnamelen && p[0] == '/' && strcmp (p + strlen (p) - strlen (SNAPPY_LIBNAME) - 1, "/" SNAPPY_LIBNAME) == 0) {
            num_saved_ld_preloads++;
            saved_ld_preloads = realloc (saved_ld_preloads, (num_saved_ld_preloads + 1) * sizeof (char *));
            saved_ld_preloads[num_saved_ld_preloads - 1] = strdup (p);
            saved_ld_preloads[num_saved_ld_preloads] = NULL;
        }
    }
    free (ld_preload_copy);
}

static char *
redirect_writable_path (const char *pathname, const char *basepath)
{
    char *redirected_pathname;
    int chop = 0;

    if (pathname[0] == 0) {
        return strdup (basepath);
    }

    redirected_pathname = malloc (PATH_MAX);
    
    if (basepath[strlen (basepath) - 1] == '/') {
        chop = 1;
    }
    strncpy (redirected_pathname, basepath, PATH_MAX - 1 - chop);

    strncat (redirected_pathname, pathname, PATH_MAX - 1 - strlen (redirected_pathname));

    // No need to see if it already exists -- app can only be in TMPDIR, not /tmp
    return redirected_pathname;
}

static char *
redirect_path_full (const char *pathname, int check_parent, int only_if_absolute)
{
    int (*_access) (const char *pathname, int mode);
    char *redirected_pathname;
    char *preload_dir;
    int ret;
    int chop = 0;
    char *slash = 0;

    if (pathname == NULL) {
        return NULL;
    }

    preload_dir = saved_snappy_preload;
    if (preload_dir == NULL) {
        return strdup (pathname);
    }

    // Do not redirect when accessing /dev
    if (strcmp (pathname, "/dev") == 0 || strncmp (pathname, "/dev/", 5) == 0) {
        return strdup (pathname);
    }

    if (only_if_absolute && pathname[0] != '/') {
        return strdup (pathname);
    }

    // Sometimes programs will hardcode /tmp (like Xorg does for its lock file).
    // In that case, let's redirect to TMPDIR.
    if (strcmp (pathname, "/tmp") == 0 || strncmp (pathname, "/tmp/", 5) == 0) {
        if (saved_tmpdir && strncmp (pathname, saved_tmpdir, strlen (saved_tmpdir)) != 0) {
            return redirect_writable_path (pathname + 4, saved_tmpdir);
        } else {
            return strdup (pathname);
        }
    }

    _access = (int (*)(const char *pathname, int mode)) dlsym (RTLD_NEXT, "access");

    // And each app should have its own /var/lib writable tree.  Here, we want
    // to support reading the base system's files if they exist, else let the app
    // play in /var/lib themselves.  So we reverse the normal check: first see if
    // it exists in root, else do our redirection.
    if (strcmp (pathname, "/var/lib") == 0 || strncmp (pathname, "/var/lib/", 9) == 0) {
        if (saved_varlib && strncmp (pathname, saved_varlib, strlen (saved_varlib)) != 0 && _access (pathname, F_OK) != 0) {
            return redirect_writable_path (pathname + 8, saved_varlib);
        } else {
            return strdup (pathname);
        }
    }

    redirected_pathname = malloc (PATH_MAX);

    if (preload_dir[strlen (preload_dir) - 1] == '/') {
        chop = 1;
    }
    strncpy (redirected_pathname, preload_dir, PATH_MAX - 1 - chop);

    if (pathname[0] != '/') {
        size_t cursize = strlen (redirected_pathname);
        if (getcwd (redirected_pathname + cursize, PATH_MAX - cursize) == NULL) {
            free (redirected_pathname);
            return strdup (pathname);
        }
        strncat (redirected_pathname, "/", PATH_MAX - 1 - strlen (redirected_pathname));
    }

    strncat (redirected_pathname, pathname, PATH_MAX - 1 - strlen (redirected_pathname));

    if (check_parent) {
        slash = strrchr (redirected_pathname, '/');
        if (slash) { // should always be true
            *slash = 0;
        }
    }

    ret = _access (redirected_pathname, F_OK);

    if (check_parent && slash) {
        *slash = '/';
    }

    if (ret == 0 || errno == ENOTDIR) { // ENOTDIR is OK because it exists at least
        return redirected_pathname;
    } else {
        free (redirected_pathname);
        return strdup (pathname);
    }
}

static char *
redirect_path (const char *pathname)
{
    return redirect_path_full (pathname, 0, 0);
}

static char *
redirect_path_target (const char *pathname)
{
    return redirect_path_full (pathname, 1, 0);
}

static char *
redirect_path_if_absolute (const char *pathname)
{
    return redirect_path_full (pathname, 0, 1);
}

#define REDIRECT_1_1(RET, NAME) \
RET \
NAME (const char *path) \
{ \
    RET (*_NAME) (const char *path); \
    char *new_path = NULL; \
    RET result; \
    _NAME = (RET (*)(const char *path)) dlsym (RTLD_NEXT, #NAME); \
    new_path = redirect_path (path); \
    result = _NAME (new_path); \
    free (new_path); \
    return result; \
}

#define REDIRECT_1_2(RET, NAME, T2) \
RET \
NAME (const char *path, T2 A2) \
{ \
    RET (*_NAME) (const char *path, T2 A2); \
    char *new_path = NULL; \
    RET result; \
    _NAME = (RET (*)(const char *path, T2 A2)) dlsym (RTLD_NEXT, #NAME); \
    new_path = redirect_path (path); \
    result = _NAME (new_path, A2); \
    free (new_path); \
    return result; \
}

#define REDIRECT_1_3(RET, NAME, T2, T3) \
RET \
NAME (const char *path, T2 A2, T3 A3) \
{ \
    RET (*_NAME) (const char *path, T2 A2, T3 A3); \
    char *new_path = NULL; \
    RET result; \
    _NAME = (RET (*)(const char *path, T2 A2, T3 A3)) dlsym (RTLD_NEXT, #NAME); \
    new_path = redirect_path (path); \
    result = _NAME (new_path, A2, A3); \
    free (new_path); \
    return result; \
}

#define REDIRECT_2_2(RET, NAME, T1) \
RET \
NAME (T1 A1, const char *path) \
{ \
    RET (*_NAME) (T1 A1, const char *path); \
    char *new_path = NULL; \
    RET result; \
    _NAME = (RET (*)(T1 A1, const char *path)) dlsym (RTLD_NEXT, #NAME); \
    new_path = redirect_path (path); \
    result = _NAME (A1, new_path); \
    free (new_path); \
    return result; \
}

#define REDIRECT_2_3(RET, NAME, T1, T3) \
RET \
NAME (T1 A1, const char *path, T3 A3) \
{ \
    RET (*_NAME) (T1 A1, const char *path, T3 A3); \
    char *new_path = NULL; \
    RET result; \
    _NAME = (RET (*)(T1 A1, const char *path, T3 A3)) dlsym (RTLD_NEXT, #NAME); \
    new_path = redirect_path (path); \
    result = _NAME (A1, new_path, A3); \
    free (new_path); \
    return result; \
}

#define REDIRECT_2_3_AT(RET, NAME, T1, T3) \
RET \
NAME (T1 A1, const char *path, T3 A3) \
{ \
    RET (*_NAME) (T1 A1, const char *path, T3 A3); \
    char *new_path = NULL; \
    RET result; \
    _NAME = (RET (*)(T1 A1, const char *path, T3 A3)) dlsym (RTLD_NEXT, #NAME); \
    new_path = redirect_path_if_absolute (path); \
    result = _NAME (A1, new_path, A3); \
    free (new_path); \
    return result; \
}

#define REDIRECT_2_4_AT(RET, NAME, T1, T3, T4) \
RET \
NAME (T1 A1, const char *path, T3 A3, T4 A4) \
{ \
    RET (*_NAME) (T1 A1, const char *path, T3 A3, T4 A4); \
    char *new_path = NULL; \
    RET result; \
    _NAME = (RET (*)(T1 A1, const char *path, T3 A3, T4 A4)) dlsym (RTLD_NEXT, #NAME); \
    new_path = redirect_path_if_absolute (path); \
    result = _NAME (A1, new_path, A3, A4); \
    free (new_path); \
    return result; \
}

#define REDIRECT_3_5(RET, NAME, T1, T2, T4, T5) \
RET \
NAME (T1 A1, T2 A2, const char *path, T4 A4, T5 A5) \
{ \
    RET (*_NAME) (T1 A1, T2 A2, const char *path, T4 A4, T5 A5); \
    char *new_path = NULL; \
    RET result; \
    _NAME = (RET (*)(T1 A1, T2 A2, const char *path, T4 A4, T5 A5)) dlsym (RTLD_NEXT, #NAME); \
    new_path = redirect_path (path); \
    result = _NAME (A1, A2, new_path, A4, A5); \
    free (new_path); \
    return result; \
}

#define REDIRECT_TARGET(RET, NAME) \
RET \
NAME (const char *path, const char *target) \
{ \
    RET (*_NAME) (const char *path, const char *target); \
    char *new_path = NULL; \
    char *new_target = NULL; \
    RET result; \
    _NAME = (RET (*)(const char *path, const char *target)) dlsym (RTLD_NEXT, #NAME); \
    new_path = redirect_path (path); \
    new_target = redirect_path_target (target); \
    result = _NAME (new_path, new_target); \
    free (new_path); \
    free (new_target); \
    return result; \
}

#define REDIRECT_OPEN(NAME) \
int \
NAME (const char *path, int flags, ...) \
{ \
    int mode = 0; \
    int (*_NAME) (const char *path, int flags, mode_t mode); \
    char *new_path = NULL; \
    int result; \
    if (flags & (O_CREAT|O_TMPFILE)) \
    { \
        va_list ap; \
        va_start (ap, flags); \
        mode = va_arg (ap, mode_t); \
        va_end (ap); \
    } \
    _NAME = (int (*)(const char *path, int flags, mode_t mode)) dlsym (RTLD_NEXT, #NAME); \
    new_path = redirect_path (path); \
    result = _NAME (new_path, flags, mode); \
    free (new_path); \
    return result; \
}

#define REDIRECT_OPEN_AT(NAME) \
int \
NAME (int dirfp, const char *path, int flags, ...) \
{ \
    int mode = 0; \
    int (*_NAME) (int dirfp, const char *path, int flags, mode_t mode); \
    char *new_path = NULL; \
    int result; \
    if (flags & (O_CREAT|O_TMPFILE)) \
    { \
        va_list ap; \
        va_start (ap, flags); \
        mode = va_arg (ap, mode_t); \
        va_end (ap); \
    } \
    _NAME = (int (*)(int dirfp, const char *path, int flags, mode_t mode)) dlsym (RTLD_NEXT, #NAME); \
    new_path = redirect_path_if_absolute (path); \
    result = _NAME (dirfp, new_path, flags, mode); \
    free (new_path); \
    return result; \
}

REDIRECT_1_2(FILE *, fopen, const char *)
REDIRECT_1_2(FILE *, fopen64, const char *)
REDIRECT_1_1(int, unlink)
REDIRECT_2_3_AT(int, unlinkat, int, int)
REDIRECT_1_2(int, access, int)
REDIRECT_1_2(int, eaccess, int)
REDIRECT_1_2(int, euidaccess, int)
REDIRECT_2_4_AT(int, faccessat, int, int, int)
REDIRECT_1_2(int, stat, struct stat *)
REDIRECT_1_2(int, stat64, struct stat64 *)
REDIRECT_1_2(int, lstat, struct stat *)
REDIRECT_1_2(int, lstat64, struct stat64 *)
REDIRECT_1_2(int, creat, mode_t)
REDIRECT_1_2(int, creat64, mode_t)
REDIRECT_1_2(int, truncate, off_t)
REDIRECT_2_2(char *, bindtextdomain, const char *)
REDIRECT_2_3(int, __xstat, int, struct stat *)
REDIRECT_2_3(int, __xstat64, int, struct stat64 *)
REDIRECT_2_3(int, __lxstat, int, struct stat *)
REDIRECT_2_3(int, __lxstat64, int, struct stat64 *)
REDIRECT_3_5(int, __fxstatat, int, int, struct stat *, int)
REDIRECT_3_5(int, __fxstatat64, int, int, struct stat64 *, int)
REDIRECT_1_2(int, statfs, struct statfs *)
REDIRECT_1_2(int, statfs64, struct statfs64 *)
REDIRECT_1_2(int, statvfs, struct statvfs *)
REDIRECT_1_2(int, statvfs64, struct statvfs64 *)
REDIRECT_1_2(long, pathconf, int)
REDIRECT_1_1(DIR *, opendir)
REDIRECT_1_2(int, mkdir, mode_t)
REDIRECT_1_1(int, rmdir)
REDIRECT_1_3(int, chown, uid_t, gid_t)
REDIRECT_1_3(int, lchown, uid_t, gid_t)
REDIRECT_1_2(int, chmod, mode_t)
REDIRECT_1_2(int, lchmod, mode_t)
REDIRECT_1_1(int, chdir)
REDIRECT_1_3(ssize_t, readlink, char *, size_t)
REDIRECT_1_2(char *, realpath, char *)
REDIRECT_TARGET(int, link)
REDIRECT_TARGET(int, rename)
REDIRECT_OPEN(open)
REDIRECT_OPEN(open64)
REDIRECT_OPEN_AT(openat)
REDIRECT_OPEN_AT(openat64)
REDIRECT_2_3(int, inotify_add_watch, int, uint32_t)

int
scandir (const char *dirp, struct dirent ***namelist, int (*filter)(const struct dirent *), int (*compar)(const struct dirent **, const struct dirent **))
{
    int (*_scandir) (const char *dirp, struct dirent ***namelist, int (*filter)(const struct dirent *), int (*compar)(const struct dirent **, const struct dirent **));
    char *new_path = NULL;
    int ret;

    _scandir = (int (*)(const char *dirp, struct dirent ***namelist, int (*filter)(const struct dirent *), int (*compar)(const struct dirent **, const struct dirent **))) dlsym (RTLD_NEXT, "scandir");

    new_path = redirect_path (dirp);
    ret = _scandir (new_path, namelist, filter, compar);
    free (new_path);

    return ret;
}

int
scandir64 (const char *dirp, struct dirent64 ***namelist,
           int (*filter)(const struct dirent64 *),
           int (*compar)(const struct dirent64 **, const struct dirent64 **))
{
    int (*_scandir64) (const char *dirp, struct dirent64 ***namelist,
                       int (*filter)(const struct dirent64 *),
                       int (*compar)(const struct dirent64 **, const struct dirent64 **));
    char *new_path = NULL;
    int ret;

    _scandir64 = (int (*)(const char *dirp, struct dirent64 ***namelist,
                          int (*filter)(const struct dirent64 *),
                          int (*compar)(const struct dirent64 **, const struct dirent64 **)))
        dlsym (RTLD_NEXT, "scandir64");

    new_path = redirect_path (dirp);
    ret = _scandir64 (new_path, namelist, filter, compar);
    free (new_path);

    return ret;
}


int
scandirat (int dirfd, const char *dirp, struct dirent ***namelist, int (*filter)(const struct dirent *), int (*compar)(const struct dirent **, const struct dirent **))
{
    int (*_scandirat) (int dirfd, const char *dirp, struct dirent ***namelist, int (*filter)(const struct dirent *), int (*compar)(const struct dirent **, const struct dirent **));
    char *new_path = NULL;
    int ret;

    _scandirat = (int (*)(int dirfd, const char *dirp, struct dirent ***namelist, int (*filter)(const struct dirent *), int (*compar)(const struct dirent **, const struct dirent **))) dlsym (RTLD_NEXT, "scandirat");

    new_path = redirect_path_if_absolute (dirp);
    ret = _scandirat (dirfd, new_path, namelist, filter, compar);
    free (new_path);

    return ret;
}

int
scandirat64 (int dirfd, const char *dirp, struct dirent64 ***namelist,
             int (*filter)(const struct dirent64 *),
             int (*compar)(const struct dirent64 **, const struct dirent64 **))
{
    int (*_scandirat64) (int dirfd, const char *dirp, struct dirent64 ***namelist,
                         int (*filter)(const struct dirent64 *),
                         int (*compar)(const struct dirent64 **, const struct dirent64 **));
    char *new_path = NULL;
    int ret;

    _scandirat64 = (int (*)(int dirfd, const char *dirp, struct dirent64 ***namelist,
                            int (*filter)(const struct dirent64 *),
                            int (*compar)(const struct dirent64 **, const struct dirent64 **)))
        dlsym (RTLD_NEXT, "scandirat64");

    new_path = redirect_path_if_absolute (dirp);
    ret = _scandirat64 (dirfd, new_path, namelist, filter, compar);
    free (new_path);

    return ret;
}

int
bind (int sockfd, const struct sockaddr *addr, socklen_t addrlen)
{
    int (*_bind) (int sockfd, const struct sockaddr *addr, socklen_t addrlen);
    int result;

    _bind = (int (*)(int sockfd, const struct sockaddr *addr, socklen_t addrlen)) dlsym (RTLD_NEXT, "bind");

    if (addr->sa_family == AF_UNIX && ((const struct sockaddr_un *)addr)->sun_path[0] != 0) { // could be abstract socket
        char *new_path = NULL;
        struct sockaddr_un new_addr;

        new_path = redirect_path (((const struct sockaddr_un *)addr)->sun_path);

        new_addr.sun_family = AF_UNIX;
        strcpy (new_addr.sun_path, new_path);
        free (new_path);

        result = _bind (sockfd, (const struct sockaddr *)&new_addr, sizeof(new_addr));
    } else {
        result = _bind (sockfd, addr, addrlen);
    }

    return result;
}

int
connect (int sockfd, const struct sockaddr *addr, socklen_t addrlen)
{
    int (*_connect) (int sockfd, const struct sockaddr *addr, socklen_t addrlen);

    _connect = (int (*)(int sockfd, const struct sockaddr *addr, socklen_t addrlen)) dlsym (RTLD_NEXT, "connect");

    /* addrlen == sizeof(sa_family_t) is the case of unnamed sockets,
     * and first byte of sun_path is 0 for abstract sockets.
     */
    if (addr->sa_family == AF_UNIX
            && addrlen > sizeof(sa_family_t)
            && ((const struct sockaddr_un *) addr)->sun_path[0] != '\0') {

        const struct sockaddr_un *un_addr = (const struct sockaddr_un *) addr;
        char *new_path = NULL;
        struct sockaddr_un new_addr;

        new_path = redirect_path (un_addr->sun_path);

        new_addr.sun_family = AF_UNIX;
        strcpy (new_addr.sun_path, new_path);
        free (new_path);

        return _connect (sockfd, (const struct sockaddr *)&new_addr, sizeof(new_addr));
    }

    return _connect (sockfd, addr, addrlen);
}

void *
dlopen (const char *path, int mode)
{
    void *(*_dlopen) (const char *path, int mode);
    char *new_path = NULL;
    void *result;

    _dlopen = (void *(*)(const char *path, int mode)) dlsym (RTLD_NEXT, "dlopen");

    if (path && path[0] == '/') {
        new_path = redirect_path (path);
        result = _dlopen (new_path, mode);
        free (new_path);
    } else {
        // non-absolute library paths aren't simply relative paths, they need
        // a whole lookup algorithm
        result = _dlopen (path, mode);
    }

    return result;
}

static char *
ensure_in_ld_preload (char *ld_preload, const char *to_be_added)
{
    if (ld_preload && ld_preload[0] != 0) {
        char *ld_preload_copy;
        char *p, *savedptr = NULL;
        int found = 0;

        // Check if we are already in LD_PRELOAD and thus can bail
        ld_preload_copy = strdup (ld_preload);
        for (p = strtok_r (ld_preload_copy + strlen (LD_PRELOAD) + 1, " :", &savedptr);
             p;
             p = strtok_r (NULL, " :", &savedptr)) {
            if (strcmp (p, to_be_added) == 0) {
                found = 1;
                break;
            }
        }
        free (ld_preload_copy);

        if (!found) {
            ld_preload = realloc (ld_preload, strlen (to_be_added) + strlen (ld_preload) + 2);
            strcat (ld_preload, ":");
            strcat (ld_preload, to_be_added);
        }
    } else {
        ld_preload = realloc (ld_preload, strlen (to_be_added) + strlen (LD_PRELOAD) + 2);
        strcpy (ld_preload, LD_PRELOAD "=");
        strcat (ld_preload, to_be_added);
    }

    return ld_preload;
}

static char **
execve_copy_envp (char *const envp[])
{
    int i, num_elements;
    char **new_envp = NULL;
    char *ld_preload = NULL;
    char *snappy_preload = NULL;

    for (num_elements = 0; envp && envp[num_elements]; num_elements++) {
        // this space intentionally left blank
    }

    new_envp = malloc (sizeof (char *) * (num_elements + 3));

    for (i = 0; i < num_elements; i++) {
        new_envp[i] = strdup (envp[i]);
        if (strncmp (envp[i], LD_PRELOAD "=", strlen (LD_PRELOAD) + 1) == 0) {
            ld_preload = new_envp[i]; // point at last defined LD_PRELOAD
        }
    }

    if (saved_ld_preloads) {
        size_t j;
        char *ld_preload_copy;
        ld_preload_copy = ld_preload ? strdup (ld_preload) : NULL;
        for (j = 0; j < num_saved_ld_preloads; j++) {
            ld_preload_copy = ensure_in_ld_preload(ld_preload_copy, saved_ld_preloads[j]);
        }
        new_envp[i++] = ld_preload_copy;
    }

    if (saved_snappy_preload) {
        snappy_preload = malloc (strlen (saved_snappy_preload) + strlen (SNAPPY_PRELOAD) + 2);
        strcpy (snappy_preload, SNAPPY_PRELOAD "=");
        strcat (snappy_preload, saved_snappy_preload);
        new_envp[i++] = snappy_preload;
    }

    new_envp[i++] = NULL;
    return new_envp;
}

static int
execve32_wrapper (int (*_execve) (const char *path, char *const argv[], char *const envp[]), char *path, char *const argv[], char *const envp[])
{
    char *custom_loader = NULL;
    char **new_argv;
    int i, num_elements, result;

    custom_loader = redirect_path ("/lib/ld-linux.so.2");
    if (strcmp (custom_loader, "/lib/ld-linux.so.2") == 0) {
        free (custom_loader);
        return 0;
    }

    // envp is already adjusted for our needs.  But we need to shift argv
    for (num_elements = 0; argv && argv[num_elements]; num_elements++) {
        // this space intentionally left blank
    }
    new_argv = malloc (sizeof (char *) * (num_elements + 2));
    new_argv[0] = path;
    for (i = 0; i < num_elements; i++) {
        new_argv[i + 1] = argv[i];
    }
    new_argv[num_elements + 1] = 0;

    // Now actually run execve with our loader and adjusted argv
    result = _execve (custom_loader, new_argv, envp);

    // Cleanup on error
    free (new_argv);
    free (custom_loader);
    return result;
}

static int
execve_wrapper (const char *func, const char *path, char *const argv[], char *const envp[])
{
    int (*_execve) (const char *path, char *const argv[], char *const envp[]);
    char *new_path = NULL;
    char **new_envp = NULL;
    int i, result;

    _execve = (int (*)(const char *path, char *const argv[], char *const envp[])) dlsym (RTLD_NEXT, func);

    new_path = redirect_path (path);

    // Make sure we inject our original preload values, can't trust this
    // program to pass them along in envp for us.
    new_envp = execve_copy_envp (envp);

    result = _execve (new_path, argv, new_envp);

    if (result == -1 && errno == ENOENT) {
        // OK, get prepared for gross hacks here.  In order to run 32-bit ELF
        // executables -- which will hardcode /lib/ld-linux.so.2 as their ld.so
        // loader, we must redirect that check to our own version of ld-linux.so.2.
        // But that lookup is done behind the scenes by execve, so we can't
        // intercept it like normal.  Instead, we'll prefix the command by the
        // ld.so loader which will only work if the architecture matches.  So if
        // we failed to run it normally above because the loader couldn't find
        // something, try with our own 32-bit loader.
        int (*_access) (const char *pathname, int mode);
        _access = (int (*)(const char *pathname, int mode)) dlsym (RTLD_NEXT, "access");
        if (_access (new_path, F_OK) == 0) {
            // Only actually try this if the path actually did exist.  That
            // means the ENOENT must have been a missing linked library or the
            // wrong ld.so loader.  Lets assume the latter and try to run as
            // a 32-bit executable.
            result = execve32_wrapper (_execve, new_path, argv, new_envp);
        }
    }

    free (new_path);
    for (i = 0; new_envp[i]; i++) {
        free (new_envp[i]);
    }
    free (new_envp);

    return result;
}

int
execv (const char *path, char *const argv[])
{
    return execve (path, argv, environ);
}

int
execve (const char *path, char *const argv[], char *const envp[])
{
    return execve_wrapper ("execve", path, argv, envp);
}

int
__execve (const char *path, char *const argv[], char *const envp[])
{
    return execve_wrapper ("__execve", path, argv, envp);
}