strepsirrhini/office-gobmx
9
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
office-gobmx/sal/android/lo-bootstrap.c
Tor Lillqvist 2c619267d6 Detach thread before returning from android_main() 
Change-Id: I593e94e90971b6be681de48dce74f7df2293c10e
2012-09-05 16:12:13 +03:00

2016 lines
55 KiB
C
Raw Blame History

/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* Version: MPL 1.1 / GPLv3+ / LGPLv3+
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License or as specified alternatively below. You may obtain a copy of
* the License at http: *www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* Major Contributor(s):
* Copyright (C) 2011 Tor Lillqvist <tml@iki.fi> (initial developer)
* Copyright (C) 2011 SUSE Linux http://suse.com (initial developer's employer)
*
* Zip parsing code lifted from Mozilla's other-licenses/android/APKOpen.cpp,
* by Michael Wu <mwu@mozilla.com>.
*
* All Rights Reserved.
*
* For minor contributions see the git repository.
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 3 or later (the "GPLv3+"), or
* the GNU Lesser General Public License Version 3 or later (the "LGPLv3+"),
* in which case the provisions of the GPLv3+ or the LGPLv3+ are applicable
* instead of those above.
*/
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <unistd.h>
#include <fcntl.h>
#include <dlfcn.h>
#include <sys/mman.h>
#include <jni.h>
#include <linux/elf.h>
#include <android/log.h>
#include "uthash.h"
#include "osl/detail/android-bootstrap.h"
#pragma GCC diagnostic ignored "-Wdeclaration-after-statement"
#include "android_native_app_glue.c"
#pragma GCC diagnostic warning "-Wdeclaration-after-statement"
#undef LOGI
#undef LOGW
#define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "lo-bootstrap", __VA_ARGS__))
#define LOGW(...) ((void)__android_log_print(ANDROID_LOG_WARN, "lo-bootstrap", __VA_ARGS__))
#define LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR, "lo-bootstrap", __VA_ARGS__))
#define LOGF(...) ((void)__android_log_print(ANDROID_LOG_FATAL, "lo-bootstrap", __VA_ARGS__))
#define ROUND_DOWN(ptr,multiple) (void *)(((unsigned) (ptr)) & ~((multiple)-1))
#define MAX(a,b) ((a) > (b) ? (a) : (b))
struct engine {
int dummy;
};
/* These vars are valid / used only when this library is used from
* NativeActivity-based apps.
*/
static struct android_app *app;
static int (*lo_main)(int, const char **);
static int lo_main_argc;
static const char **lo_main_argv;
static int sleep_time = 0;
/* These are valid / used in all apps. */
static const char *data_dir;
static const char **library_locations;
static void *apk_file;
static int apk_file_size;
static JavaVM *the_java_vm;
/* Zip data structures */
/* compression methods */
#define STORE 0
#define DEFLATE 8
#define LZMA 14
struct local_file_header {
uint32_t signature;
uint16_t min_version;
uint16_t general_flag;
uint16_t compression;
uint16_t lastmod_time;
uint16_t lastmod_date;
uint32_t crc32;
uint32_t compressed_size;
uint32_t uncompressed_size;
uint16_t filename_size;
uint16_t extra_field_size;
char data[0];
} __attribute__((__packed__));
struct cdir_entry {
uint32_t signature;
uint16_t creator_version;
uint16_t min_version;
uint16_t general_flag;
uint16_t compression;
uint16_t lastmod_time;
uint16_t lastmod_date;
uint32_t crc32;
uint32_t compressed_size;
uint32_t uncompressed_size;
uint16_t filename_size;
uint16_t extra_field_size;
uint16_t file_comment_size;
uint16_t disk_num;
uint16_t internal_attr;
uint32_t external_attr;
uint32_t offset;
char data[0];
} __attribute__((__packed__));
#define CDIR_END_SIG 0x06054b50
struct cdir_end {
uint32_t signature;
uint16_t disk_num;
uint16_t cdir_disk;
uint16_t disk_entries;
uint16_t cdir_entries;
uint32_t cdir_size;
uint32_t cdir_offset;
uint16_t comment_size;
char comment[0];
} __attribute__((__packed__));
/* End of Zip data structures */
static struct cdir_entry *cdir_start;
static uint16_t cdir_entries;
/* Data structure to turn Zip's list in arbitrary order of
* hierarchical pathnames (not necessarily including entries for
* directories) into an actual hierarchical directory tree, so that we
* can iterate over directory entries properly in the dirent style
* functions.
*/
typedef struct direntry *direntry;
struct direntry {
UT_hash_handle hh;
enum { REGULAR, DIRECTORY } kind;
int ino;
union {
struct cdir_entry *file;
direntry subdir;
};
};
struct lo_apk_dir {
direntry cur;
};
static direntry assets = NULL;
static uint32_t
cdir_entry_size(struct cdir_entry *entry)
{
return sizeof(*entry) +
letoh16(entry->filename_size) +
letoh16(entry->extra_field_size) +
letoh16(entry->file_comment_size);
}
static int
setup_cdir(void)
{
struct cdir_end *dirend = (struct cdir_end *)((char *) apk_file + apk_file_size - sizeof(*dirend));
uint32_t cdir_offset;
while ((void *)dirend > apk_file &&
letoh32(dirend->signature) != CDIR_END_SIG)
dirend = (struct cdir_end *)((char *)dirend - 1);
if (letoh32(dirend->signature) != CDIR_END_SIG) {
LOGE("setup_cdir: Could not find end of central directory record");
return 0;
}
cdir_offset = letoh32(dirend->cdir_offset);
cdir_entries = letoh16(dirend->cdir_entries);
cdir_start = (struct cdir_entry *)((char *)apk_file + cdir_offset);
return 1;
}
static struct cdir_entry *
find_cdir_entry(struct cdir_entry *entry, int count, const char *name)
{
size_t name_size = strlen(name);
while (count--) {
if (letoh16(entry->filename_size) == name_size &&
!memcmp(entry->data, name, name_size))
return entry;
entry = (struct cdir_entry *)((char *)entry + cdir_entry_size(entry));
}
return NULL;
}
static void
handle_one_asset(struct cdir_entry *entry)
{
/* In the .apk there are no initial slashes */
const char *p = entry->data + sizeof("assets/")-1;
const char *z = entry->data + entry->filename_size;
direntry *dir = &assets;
static int ino = 1;
while (p < z) {
const char *q = p;
direntry old, new;
while (q < z && *q != '/')
q++;
HASH_FIND(hh, *dir, p, (unsigned)(q - p), old);
if (*q == '/') {
if (old == NULL) {
new = malloc(sizeof(*new));
new->ino = ino++;
new->kind = DIRECTORY;
new->subdir = NULL;
HASH_ADD_KEYPTR(hh, *dir, p, (unsigned)(q - p), new);
dir = &new->subdir;
} else {
dir = &old->subdir;
}
p = q + 1;
} else {
if (old == NULL) {
new = malloc(sizeof(*new));
new->ino = ino++;
new->kind = REGULAR;
new->file = entry;
HASH_ADD_KEYPTR(hh, *dir, p, (unsigned)(q - p), new);
} else {
LOGE("duplicate entry in apk: %.*s", entry->filename_size, entry->data);
}
p = q;
}
(void) dir;
}
}
static int
setup_assets_tree(void)
{
int count = cdir_entries;
struct cdir_entry *entry = cdir_start;
while (count--) {
if (letoh16(entry->filename_size) >= sizeof("assets/")-1 &&
memcmp(entry->data, "assets/", sizeof("assets/")-1) == 0)
handle_one_asset(entry);
entry = (struct cdir_entry *)((char *)entry + cdir_entry_size(entry));
}
return 1;
}
static void
engine_handle_cmd(struct android_app* state,
int32_t cmd)
{
(void) state;
switch (cmd) {
case APP_CMD_SAVE_STATE:
break;
case APP_CMD_INIT_WINDOW:
break;
case APP_CMD_TERM_WINDOW:
break;
case APP_CMD_GAINED_FOCUS:
break;
case APP_CMD_LOST_FOCUS:
break;
}
}
static char *
read_section(int fd,
Elf32_Shdr *shdr)
{
char *result;
result = malloc(shdr->sh_size);
if (lseek(fd, shdr->sh_offset, SEEK_SET) < 0) {
close(fd);
free(result);
return NULL;
}
if (read(fd, result, shdr->sh_size) < (int) shdr->sh_size) {
close(fd);
free(result);
return NULL;
}
return result;
}
static void
free_ptrarray(void **pa)
{
void **rover = pa;
while (*rover != NULL)
free(*rover++);
free(pa);
}
/* The lo-bootstrap shared library is always loaded from Java, so
* this is always called by JNI first.
*/
__attribute__ ((visibility("default")))
jint
JNI_OnLoad(JavaVM* vm, void* reserved)
{
(void) reserved;
the_java_vm = vm;
return JNI_VERSION_1_2;
}
__attribute__ ((visibility("default")))
jobjectArray
Java_org_libreoffice_android_Bootstrap_dlneeds(JNIEnv* env,
jobject clazz,
jstring library)
{
char **needed;
int n_needed;
const char *libName;
jclass String;
jobjectArray result;
(void) clazz;
libName = (*env)->GetStringUTFChars(env, library, NULL);
needed = lo_dlneeds(libName);
(*env)->ReleaseStringUTFChars(env, library, libName);
if (needed == NULL)
return NULL;
n_needed = 0;
while (needed[n_needed] != NULL)
n_needed++;
/* Allocate return value */
String = (*env)->FindClass(env, "java/lang/String");
if (String == NULL) {
LOGE("Could not find the String class");
free_ptrarray((void **) needed);
return NULL;
}
result = (*env)->NewObjectArray(env, n_needed, String, NULL);
if (result == NULL) {
LOGE("Could not create the String array");
free_ptrarray((void **) needed);
return NULL;
}
for (n_needed = 0; needed[n_needed] != NULL; n_needed++)
(*env)->SetObjectArrayElement(env, result, n_needed, (*env)->NewStringUTF(env, needed[n_needed]));
free_ptrarray((void **) needed);
return result;
}
__attribute__ ((visibility("default")))
jint
Java_org_libreoffice_android_Bootstrap_dlopen(JNIEnv* env,
jobject clazz,
jstring library)
{
const char *libName;
void *p;
(void) clazz;
libName = (*env)->GetStringUTFChars(env, library, NULL);
p = lo_dlopen (libName);
(*env)->ReleaseStringUTFChars(env, library, libName);
return (jint) p;
}
__attribute__ ((visibility("default")))
jint
Java_org_libreoffice_android_Bootstrap_dlsym(JNIEnv* env,
jobject clazz,
jint handle,
jstring symbol)
{
const char *symName;
void *p;
(void) clazz;
symName = (*env)->GetStringUTFChars(env, symbol, NULL);
p = lo_dlsym ((void *) handle, symName);
(*env)->ReleaseStringUTFChars(env, symbol, symName);
return (jint) p;
}
__attribute__ ((visibility("default")))
jint
Java_org_libreoffice_android_Bootstrap_dlcall(JNIEnv* env,
jobject clazz,
jint function,
jobject argument)
{
jclass StringArray;
(void) clazz;
StringArray = (*env)->FindClass(env, "[Ljava/lang/String;");
if (StringArray == NULL) {
LOGE("Could not find String[] class");
return 0;
}
if ((*env)->IsInstanceOf(env, argument, StringArray)) {
int argc = (*env)->GetArrayLength(env, argument);
const char **argv = malloc(sizeof(char *) * (argc+1));
int i, result;
for (i = 0; i < argc; i++) {
argv[i] = (*env)->GetStringUTFChars(env, (*env)->GetObjectArrayElement(env, argument, i), NULL);
/* LOGI("argv[%d] = %s", i, argv[i]); */
}
argv[argc] = NULL;
result = lo_dlcall_argc_argv((void *) function, argc, argv);
for (i = 0; i < argc; i++)
(*env)->ReleaseStringUTFChars(env, (*env)->GetObjectArrayElement(env, argument, i), argv[i]);
free(argv);
return result;
}
return 0;
}
// public static native boolean setup(String dataDir,
// String apkFile,
// String[] ld_library_path);
__attribute__ ((visibility("default")))
jboolean
Java_org_libreoffice_android_Bootstrap_setup__Ljava_lang_String_2Ljava_lang_String_2_3Ljava_lang_String_2
(JNIEnv* env,
jobject clazz,
jstring dataDir,
jstring apkFile,
jobjectArray ld_library_path)
{
struct stat st;
int i, n, fd;
const char *dataDirPath;
const char *apkFilePath;
char *lib_dir;
(void) clazz;
n = (*env)->GetArrayLength(env, ld_library_path);
library_locations = malloc((n+2) * sizeof(char *));
dataDirPath = (*env)->GetStringUTFChars(env, dataDir, NULL);
data_dir = strdup(dataDirPath);
lib_dir = malloc(strlen(dataDirPath) + 5);
strcpy(lib_dir, dataDirPath);
strcat(lib_dir, "/lib");
(*env)->ReleaseStringUTFChars(env, dataDir, dataDirPath);
library_locations[0] = lib_dir;
for (i = 0; i < n; i++) {
const char *s = (*env)->GetStringUTFChars(env, (*env)->GetObjectArrayElement(env, ld_library_path, i), NULL);
library_locations[i+1] = strdup(s);
(*env)->ReleaseStringUTFChars(env, (*env)->GetObjectArrayElement(env, ld_library_path, i), s);
}
library_locations[n+1] = NULL;
for (n = 0; library_locations[n] != NULL; n++)
LOGI("library_locations[%d] = %s", n, library_locations[n]);
apkFilePath = (*env)->GetStringUTFChars(env, apkFile, NULL);
fd = open(apkFilePath, O_RDONLY);
if (fd == -1) {
LOGE("Could not open %s", apkFilePath);
(*env)->ReleaseStringUTFChars(env, apkFile, apkFilePath);
return JNI_FALSE;
}
if (fstat(fd, &st) == -1) {
LOGE("Could not fstat %s", apkFilePath);
close(fd);
(*env)->ReleaseStringUTFChars(env, apkFile, apkFilePath);
return JNI_FALSE;
}
apk_file = mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
close(fd);
if (apk_file == MAP_FAILED) {
LOGE("Could not mmap %s", apkFilePath);
(*env)->ReleaseStringUTFChars(env, apkFile, apkFilePath);
return JNI_FALSE;
}
apk_file_size = st.st_size;
(*env)->ReleaseStringUTFChars(env, apkFile, apkFilePath);
if (!setup_cdir())
return JNI_FALSE;
if (!setup_assets_tree())
return JNI_FALSE;
return JNI_TRUE;
}
static jboolean
get_jni_string_array(JNIEnv *env,
const char *function_and_parameter_name,
jobject strv,
int *argc,
const char ***argv)
{
jclass StringArray;
int i;
StringArray = (*env)->FindClass(env, "[Ljava/lang/String;");
if (StringArray == NULL) {
LOGE("Could not find String[] class");
return JNI_FALSE;
}
if (!(*env)->IsInstanceOf(env, strv, StringArray)) {
LOGE("%s is not a String[]?", function_and_parameter_name);
return JNI_FALSE;
}
*argc = (*env)->GetArrayLength(env, strv);
*argv = malloc(sizeof(char *) * (*argc+1));
for (i = 0; i < *argc; i++) {
const char *s = (*env)->GetStringUTFChars(env, (*env)->GetObjectArrayElement(env, strv, i), NULL);
(*argv)[i] = strdup(s);
(*env)->ReleaseStringUTFChars(env, (*env)->GetObjectArrayElement(env, strv, i), s);
/* LOGI("argv[%d] = %s", i, lo_main_argv[i]); */
}
(*argv)[*argc] = NULL;
return JNI_TRUE;
}
// public static native boolean setup(int lo_main_ptr,
// Object lo_main_argument,
// int lo_main_delay);
__attribute__ ((visibility("default")))
jboolean
Java_org_libreoffice_android_Bootstrap_setup__ILjava_lang_Object_2I(JNIEnv* env,
jobject clazz,
void *lo_main_ptr,
jobject lo_main_argument,
jint lo_main_delay)
{
(void) clazz;
lo_main = lo_main_ptr;
if (!get_jni_string_array(env, "setup: lo_main_argument", lo_main_argument, &lo_main_argc, &lo_main_argv))
return JNI_FALSE;
sleep_time = lo_main_delay;
return JNI_TRUE;
}
// public static native int getpid();
__attribute__ ((visibility("default")))
jint
Java_org_libreoffice_android_Bootstrap_getpid(JNIEnv* env,
jobject clazz)
{
(void) env;
(void) clazz;
return getpid();
}
// public static native void system(String cmdline);
__attribute__ ((visibility("default")))
void
Java_org_libreoffice_android_Bootstrap_system(JNIEnv* env,
jobject clazz,
jstring cmdline)
{
const char *s;
(void) clazz;
s = (*env)->GetStringUTFChars(env, cmdline, NULL);
LOGI("system(%s)", s);
system(s);
(*env)->ReleaseStringUTFChars(env, cmdline, s);
}
// public static native void putenv(String string);
__attribute__ ((visibility("default")))
void
Java_org_libreoffice_android_Bootstrap_putenv(JNIEnv* env,
jobject clazz,
jstring string)
{
const char *s;
(void) clazz;
s = (*env)->GetStringUTFChars(env, string, NULL);
LOGI("putenv(%s)", s);
putenv(s);
(*env)->ReleaseStringUTFChars(env, string, s);
}
__attribute__ ((visibility("default")))
char **
lo_dlneeds(const char *library)
{
int i, fd;
int n_needed;
char **result;
char *shstrtab;
char *dynstr = NULL;
Elf32_Ehdr hdr;
Elf32_Shdr shdr;
Elf32_Dyn dyn;
/* Open library and read ELF header */
fd = open(library, O_RDONLY);
if (fd == -1) {
LOGE("lo_dlneeds: Could not open library %s: %s", library, strerror(errno));
return NULL;
}
if (read(fd, &hdr, sizeof(hdr)) < (int) sizeof(hdr)) {
LOGE("lo_dlneeds: Could not read ELF header of %s", library);
close(fd);
return NULL;
}
/* Read in .shstrtab */
if (lseek(fd, hdr.e_shoff + hdr.e_shstrndx * sizeof(shdr), SEEK_SET) < 0) {
LOGE("lo_dlneeds: Could not seek to .shstrtab section header of %s", library);
close(fd);
return NULL;
}
if (read(fd, &shdr, sizeof(shdr)) < (int) sizeof(shdr)) {
LOGE("lo_dlneeds: Could not read section header of %s", library);
close(fd);
return NULL;
}
shstrtab = read_section(fd, &shdr);
if (shstrtab == NULL)
return NULL;
/* Read section headers, looking for .dynstr section */
if (lseek(fd, hdr.e_shoff, SEEK_SET) < 0) {
LOGE("lo_dlneeds: Could not seek to section headers of %s", library);
close(fd);
return NULL;
}
for (i = 0; i < hdr.e_shnum; i++) {
if (read(fd, &shdr, sizeof(shdr)) < (int) sizeof(shdr)) {
LOGE("lo_dlneeds: Could not read section header of %s", library);
close(fd);
return NULL;
}
if (shdr.sh_type == SHT_STRTAB &&
strcmp(shstrtab + shdr.sh_name, ".dynstr") == 0) {
dynstr = read_section(fd, &shdr);
if (dynstr == NULL) {
free(shstrtab);
return NULL;
}
break;
}
}
if (i == hdr.e_shnum) {
LOGE("lo_dlneeds: No .dynstr section in %s", library);
close(fd);
return NULL;
}
/* Read section headers, looking for .dynamic section */
if (lseek(fd, hdr.e_shoff, SEEK_SET) < 0) {
LOGE("lo_dlneeds: Could not seek to section headers of %s", library);
close(fd);
return NULL;
}
for (i = 0; i < hdr.e_shnum; i++) {
if (read(fd, &shdr, sizeof(shdr)) < (int) sizeof(shdr)) {
LOGE("lo_dlneeds: Could not read section header of %s", library);
close(fd);
return NULL;
}
if (shdr.sh_type == SHT_DYNAMIC) {
size_t dynoff;
/* Count number of DT_NEEDED entries */
n_needed = 0;
if (lseek(fd, shdr.sh_offset, SEEK_SET) < 0) {
LOGE("lo_dlneeds: Could not seek to .dynamic section of %s", library);
close(fd);
return NULL;
}
for (dynoff = 0; dynoff < shdr.sh_size; dynoff += sizeof(dyn)) {
if (read(fd, &dyn, sizeof(dyn)) < (int) sizeof(dyn)) {
LOGE("lo_dlneeds: Could not read .dynamic entry of %s", library);
close(fd);
return NULL;
}
if (dyn.d_tag == DT_NEEDED)
n_needed++;
}
/* LOGI("Found %d DT_NEEDED libs", n_needed); */
result = malloc((n_needed+1) * sizeof(char *));
n_needed = 0;
if (lseek(fd, shdr.sh_offset, SEEK_SET) < 0) {
LOGE("lo_dlneeds: Could not seek to .dynamic section of %s", library);
close(fd);
free(result);
return NULL;
}
for (dynoff = 0; dynoff < shdr.sh_size; dynoff += sizeof(dyn)) {
if (read(fd, &dyn, sizeof(dyn)) < (int) sizeof(dyn)) {
LOGE("lo_dlneeds: Could not read .dynamic entry in %s", library);
close(fd);
free(result);
return NULL;
}
if (dyn.d_tag == DT_NEEDED) {
/* LOGI("needs: %s\n", dynstr + dyn.d_un.d_val); */
result[n_needed] = strdup(dynstr + dyn.d_un.d_val);
n_needed++;
}
}
close(fd);
if (dynstr)
free(dynstr);
free(shstrtab);
result[n_needed] = NULL;
return result;
}
}
LOGE("lo_dlneeds: Could not find .dynamic section in %s", library);
close(fd);
return NULL;
}
__attribute__ ((visibility("default")))
void *
lo_dlopen(const char *library)
{
/*
* We should *not* try to just dlopen() the bare library name
* first, as the stupid dynamic linker remembers for each library
* basename if loading it has failed. Thus if you try loading it
* once, and it fails because of missing needed libraries, and
* your load those, and then try again, it fails with an
* infuriating message "failed to load previously" in the log.
*
* We *must* first dlopen() all needed libraries, recursively. It
* shouldn't matter if we dlopen() a library that already is
* loaded, dlopen() just returns the same value then.
*/
typedef struct loadedLib {
const char *name;
void *handle;
struct loadedLib *next;
} *loadedLib;
static loadedLib loaded_libraries = NULL;
loadedLib rover;
loadedLib new_loaded_lib;
struct stat st;
void *p;
char *full_name;
char **needed;
int i;
int found;
struct timeval tv0, tv1, tvdiff;
rover = loaded_libraries;
while (rover != NULL &&
strcmp(rover->name, library) != 0)
rover = rover->next;
if (rover != NULL)
return rover->handle;
/* LOGI("lo_dlopen(%s)", library); */
found = 0;
if (library[0] == '/') {
full_name = strdup(library);
if (stat(full_name, &st) == 0 &&
S_ISREG(st.st_mode))
found = 1;
else
free(full_name);
} else {
for (i = 0; !found && library_locations[i] != NULL; i++) {
full_name = malloc(strlen(library_locations[i]) + 1 + strlen(library) + 1);
strcpy(full_name, library_locations[i]);
strcat(full_name, "/");
strcat(full_name, library);
if (stat(full_name, &st) == 0 &&
S_ISREG(st.st_mode))
found = 1;
else
free(full_name);
}
}
if (!found) {
LOGE("lo_dlopen: Library %s not found", library);
return NULL;
}
needed = lo_dlneeds(full_name);
if (needed == NULL) {
free(full_name);
return NULL;
}
for (i = 0; needed[i] != NULL; i++) {
if (lo_dlopen(needed[i]) == NULL) {
free_ptrarray((void **) needed);
free(full_name);
return NULL;
}
}
free_ptrarray((void **) needed);
gettimeofday(&tv0, NULL);
p = dlopen(full_name, RTLD_LOCAL);
gettimeofday(&tv1, NULL);
timersub(&tv1, &tv0, &tvdiff);
LOGI("dlopen(%s) = %p, %ld.%03lds",
full_name, p,
(long) tvdiff.tv_sec, (long) tvdiff.tv_usec / 1000);
free(full_name);
if (p == NULL)
LOGE("lo_dlopen: Error from dlopen(%s): %s", library, dlerror());
new_loaded_lib = malloc(sizeof(*new_loaded_lib));
new_loaded_lib->name = strdup(library);
new_loaded_lib->handle = p;
new_loaded_lib->next = loaded_libraries;
loaded_libraries = new_loaded_lib;
return p;
}
__attribute__ ((visibility("default")))
void *
lo_dlsym(void *handle,
const char *symbol)
{
void *p = dlsym(handle, symbol);
/* LOGI("dlsym(%p, %s) = %p", handle, symbol, p); */
if (p == NULL)
LOGE("lo_dlsym: %s", dlerror());
return p;
}
__attribute__ ((visibility("default")))
int
lo_dladdr(void *addr,
Dl_info *info)
{
FILE *maps;
char line[200];
int result;
int found;
result = dladdr(addr, info);
if (result == 0) {
/* LOGI("dladdr(%p) = 0", addr); */
return 0;
}
maps = fopen("/proc/self/maps", "r");
if (maps == NULL) {
LOGE("lo_dladdr: Could not open /proc/self/maps: %s", strerror(errno));
return 0;
}
found = 0;
while (fgets(line, sizeof(line), maps) != NULL &&
line[strlen(line)-1] == '\n') {
void *lo, *hi;
char file[sizeof(line)];
file[0] = '\0';
if (sscanf(line, "%x-%x %*s %*x %*x:%*x %*d %[^\n]", (unsigned *) &lo, (unsigned *) &hi, file) == 3) {
/* LOGI("got %p-%p: %s", lo, hi, file); */
if (addr >= lo && addr < hi) {
if (info->dli_fbase != lo) {
LOGE("lo_dladdr: Base for %s in /proc/self/maps %p doesn't match what dladdr() said", file, lo);
fclose(maps);
return 0;
}
/* LOGI("dladdr(%p) = { %s:%p, %s:%p }: %s",
addr,
info->dli_fname, info->dli_fbase,
info->dli_sname ? info->dli_sname : "(none)", info->dli_saddr,
file); */
info->dli_fname = strdup(file);
found = 1;
break;
}
}
}
if (!found)
LOGE("lo_dladdr: Did not find %p in /proc/self/maps", addr);
fclose(maps);
return result;
}
__attribute__ ((visibility("default")))
int
lo_dlclose(void *handle)
{
/* As we don't know when the reference count for a dlopened shared
* object drops to zero, we wouldn't know when to remove it from
* our list, so we can't call dlclose().
*/
LOGI("lo_dlclose(%p)", handle);
return 0;
}
__attribute__ ((visibility("default")))
void *
lo_apkentry(const char *filename,
size_t *size)
{
struct cdir_entry *entry;
struct local_file_header *file;
void *data;
if (*filename == '/')
filename++;
entry = find_cdir_entry(cdir_start, cdir_entries, filename);
if (entry == NULL) {
LOGE("lo_apkentry: Could not find %s", filename);
return NULL;
}
file = (struct local_file_header *)((char *)apk_file + letoh32(entry->offset));
if (letoh16(file->compression) != STORE) {
LOGE("lo_apkentry: File %s is compressed", filename);
return NULL;
}
data = ((char *)&file->data) + letoh16(file->filename_size) + letoh16(file->extra_field_size);
*size = file->uncompressed_size;
/* LOGI("lo_apkentry(%s): %p, %d", filename, data, *size); */
return data;
}
__attribute__ ((visibility("default")))
lo_apk_dir *
lo_apk_opendir(const char *dirname)
{
/* In the .apk there are no initial slashes, but the parameter passed to
* us does have it.
*/
const char *p = dirname + sizeof("/assets/")-1;
direntry dir = assets;
if (!*p) {
lo_apk_dir *result = malloc(sizeof(*result));
result->cur = assets;
return result;
}
while (1) {
const char *q = p;
direntry entry;
while (*q && *q != '/')
q++;
HASH_FIND(hh, dir, p, (unsigned)(q - p), entry);
if (entry == NULL && *q == '/') {
errno = ENOENT;
return NULL;
} else if (entry == NULL) {
/* Empty directories, or directories containing only "hidden"
* files (like the .gitignore in sc/qa/unit/qpro/indeterminate)
* are not present in the .apk. So we need to pretend that any
* directory that doesn't exist as a parent of an entry in the
* .apk *does* exist but is empty.
*/
lo_apk_dir *result = malloc(sizeof(*result));
result->cur = NULL;
return result;
}
if (entry->kind != DIRECTORY) {
errno = ENOTDIR;
return NULL;
}
if (!q[0] || !q[1]) {
lo_apk_dir *result = malloc(sizeof(*result));
result->cur = entry->subdir;
return result;
}
dir = entry->subdir;
p = q + 1;
}
}
__attribute__ ((visibility("default")))
struct dirent *
lo_apk_readdir(lo_apk_dir *dirp)
{
static struct dirent result;
if (dirp->cur == NULL) {
/* LOGI("lo_apk_readdir(%p) = NULL", dirp); */
return NULL;
}
result.d_ino = dirp->cur->ino;
result.d_off = 0;
result.d_reclen = 0;
if (dirp->cur->kind == DIRECTORY)
result.d_type = DT_DIR;
else
result.d_type = DT_REG;
memcpy(result.d_name, dirp->cur->hh.key, dirp->cur->hh.keylen);
result.d_name[dirp->cur->hh.keylen] = '\0';
dirp->cur = dirp->cur->hh.next;
/* LOGI("lo_apk_readdir(%p) = %s:%s", dirp, result.d_type == DT_DIR ? "DIR" : "REG", result.d_name); */
return &result;
}
__attribute__ ((visibility("default")))
int
lo_apk_closedir(lo_apk_dir *dirp)
{
free(dirp);
/* LOGI("lo_apk_closedir(%p)", dirp); */
return 0;
}
static int
new_stat(const char *path,
struct stat *statp,
struct cdir_entry *entry,
int mode,
int fake_ino)
{
struct tm tm;
memset(statp, 0, sizeof(*statp));
statp->st_mode = mode | S_IRUSR;
statp->st_nlink = 1;
statp->st_uid = getuid();
statp->st_gid = getgid();
if (entry != NULL)
statp->st_size = entry->uncompressed_size;
else
statp->st_size = 0;
statp->st_blksize = 512;
if (statp->st_size == 0)
statp->st_blocks = 0;
else
statp->st_blocks = (statp->st_size - 1) / statp->st_blksize + 1;
statp->st_atime = time(NULL);
memset(&tm, 0, sizeof(tm));
tm.tm_sec = (letoh16(entry->lastmod_time) & 0x1F) * 2;
tm.tm_min = (letoh16(entry->lastmod_time) >> 5) & 0x3F;
tm.tm_hour = (letoh16(entry->lastmod_time) >> 11) & 0x1F;
tm.tm_mday = letoh16(entry->lastmod_date) & 0x1F;
tm.tm_mon = ((letoh16(entry->lastmod_date) >> 5) & 0x0F) - 1;
tm.tm_year = ((letoh16(entry->lastmod_date) >> 9) & 0x7F) + 80;
statp->st_mtime = mktime(&tm);
statp->st_ctime = statp->st_mtime;
statp->st_ino = fake_ino;
(void) path;
/* LOGI("lo_apk_lstat(%s) = { mode=%o, size=%lld, ino=%lld mtime=%.24s }",
path, statp->st_mode, statp->st_size, statp->st_ino,
ctime((const time_t *) &statp->st_mtime)); */
return 0;
}
__attribute__ ((visibility("default")))
int
lo_apk_lstat(const char *path,
struct stat *statp)
{
const char *pn = path;
int count = cdir_entries;
struct cdir_entry *entry = cdir_start;
size_t name_size;
if (*pn == '/') {
pn++;
if (!pn[0])
return new_stat(path, statp, NULL, S_IFDIR | S_IXUSR, 1);
}
name_size = strlen(pn);
while (count--)
{
if (letoh16(entry->filename_size) >= name_size &&
!memcmp(entry->data, pn, name_size) &&
(letoh16(entry->filename_size) == name_size || entry->data[name_size] == '/'))
break;
entry = (struct cdir_entry *)((char *)entry + cdir_entry_size(entry));
}
if (count >= 0) {
if (letoh16(entry->filename_size) == name_size)
return new_stat(path, statp, entry, S_IFREG, cdir_entries - count + 1);
else
return new_stat(path, statp, entry, S_IFDIR | S_IXUSR, cdir_entries - count + 1);
}
errno = ENOENT;
return -1;
}
__attribute__ ((visibility("default")))
int
lo_dlcall_argc_argv(void *function,
int argc,
const char **argv)
{
int (*fp)(int, const char **) = function;
int result = fp(argc, argv);
return result;
}
#ifdef ARM
/* There is a bug in std::type_info::operator== and
* std::type_info::before() in libgnustl_shared.so in NDK r7 at
* least. They compare the type name pointers instead of comparing the
* type name strings. See
* http://code.google.com/p/android/issues/detail?id=22165 . So patch
* that, poke in jumps to our own code snippets below instead.
*/
/* Replacement std::type_info::operator== */
__asm(" .arm\n"
" .global replacement_operator_equals_arm\n"
"replacement_operator_equals_arm:\n"
" push {lr}\n"
/* Load name pointers into r0 and r1 */
" ldr r0, [r0, #4]\n"
" ldr r1, [r1, #4]\n"
/* First compare pointers */
" cmp r0, r1\n"
/* If equal, return true */
" beq .L.equals.1\n"
/* Otherwise call strcmp */
" bl strcmp\n"
/* And return true or false */
" cmp r0, #0\n"
" moveq r0, #1\n"
" movne r0, #0\n"
" b .L.equals.9\n"
".L.equals.1:\n"
" mov r0, #1\n"
".L.equals.9:\n"
" pop {pc}\n"
);
extern unsigned int replacement_operator_equals_arm;
/* The ARM (not Thumb) code of the operator== in NDK r7 */
static unsigned int expected_operator_equals_r7_code[] = {
0xe5903004, /* ldr r3, [r0, #4] */
0xe5910004, /* ldr r0, [r1, #4] */
0xe1530000, /* cmp r3, r0 */
0x13a00000, /* movne, #0 */
0x03a00001, /* moveq r0, #1 */
0xe12fff1e /* bx lr */
};
/* Ditto for std::type_info::before() */
__asm(" .arm\n"
" .global replacement_method_before_arm\n"
"replacement_method_before_arm:\n"
" push {lr}\n"
/* Load name pointers into r0 and r1 */
" ldr r0, [r0, #4]\n"
" ldr r1, [r1, #4]\n"
/* First compare pointers */
" cmp r0, r1\n"
/* If equal, return false */
" beq .L.before.1\n"
/* Otherwise call strcmp */
" bl strcmp\n"
/* And return true or false */
" cmp r0, #0\n"
" movlt r0, #1\n"
" movge r0, #0\n"
" b .L.before.9\n"
".L.before.1:\n"
" mov r0, #0\n"
".L.before.9:\n"
" pop {pc}\n"
);
extern unsigned int replacement_method_before_arm;
static unsigned int expected_method_before_r7_code[] = {
0xe5903004, /* ldr r3, [r0, #4] */
0xe5910004, /* ldr r0, [r1, #4] */
0xe1530000, /* cmp r3, r0 */
0x23a00000, /* movcs r0, #0 */
0x33a00001, /* movcc r0, #1 */
0xe12fff1e /* bx lr */
};
static void
patch(const char *symbol,
const char *plaintext,
unsigned *expected_code,
size_t expected_code_size,
unsigned *replacement_code)
{
void *libgnustl_shared;
void *code;
void *base;
size_t size;
/* libgnustl_shared.so should be already loaded as we build
* all LO code against it, so as we have loaded the .so
* containing lo_main() already, libgnustl_shared.so will have
* been brought in, too.
*/
libgnustl_shared = dlopen("libgnustl_shared.so", RTLD_LOCAL);
if (libgnustl_shared == NULL) {
LOGF("android_main: libgnustl_shared.so not mapped??");
exit(0);
}
code = dlsym(libgnustl_shared, symbol);
if (code == NULL) {
LOGF("android_main: %s not found!?", plaintext);
exit(0);
}
/* LOGI("%s is at %p", plaintext, operator_equals); */
if ((((unsigned) code) & 0x03) != 0) {
LOGE("android_main: Address of %s is not at word boundary, huh?", plaintext);
return;
}
if ((((unsigned) &replacement_code) & 0x03) != 0) {
LOGE("android_main: Address of replacement %s is not at word boundary, huh?", plaintext);
return;
}
if (memcmp(code, expected_code, expected_code_size) != 0) {
LOGI("android_main: Code for %s does not match that in NDK r7; not patching it", plaintext);
return;
}
base = ROUND_DOWN(code, getpagesize());
size = code + sizeof(expected_code_size) - ROUND_DOWN(code, getpagesize());
if (mprotect(base, size, PROT_READ|PROT_WRITE|PROT_EXEC) == -1) {
LOGE("android_main: mprotect() failed: %s", strerror(errno));
return;
}
/* Poke in a jump to replacement_code instead */
((unsigned *) code)[0] = 0xe51ff004; /* ldr pc, [pc, #-4] */
((unsigned *) code)[1] = (unsigned) replacement_code;
}
static void
patch_libgnustl_shared(void)
{
patch("_ZNKSt9type_infoeqERKS_",
"std::type_info::operator==",
expected_operator_equals_r7_code,
sizeof(expected_operator_equals_r7_code),
&replacement_operator_equals_arm);
patch("_ZNKSt9type_info6beforeERKS_",
"std::type_info::before()",
expected_method_before_r7_code,
sizeof(expected_method_before_r7_code),
&replacement_method_before_arm);
}
#endif // ARM
// static native void patch_libgnustl_shared();
__attribute__ ((visibility("default")))
void
Java_org_libreoffice_android_Bootstrap_patch_1libgnustl_1shared(JNIEnv* env,
jobject clazz)
{
(void) env;
(void) clazz;
#ifdef ARM
patch_libgnustl_shared();
#endif
}
#define UNPACK_TREE "/assets/unpack"
static int
mkdir_p(const char *dirname)
{
char *p = malloc(strlen(dirname) + 1);
const char *q = dirname + 1;
const char *slash;
do {
slash = strchr(q, '/');
if (slash == NULL)
slash = q + strlen(q);
memcpy(p, dirname, slash-dirname);
p[slash-dirname] = '\0';
if (mkdir(p, 0700) == -1 && errno != EEXIST) {
LOGE("mkdir_p: Could not create %s: %s", p, strerror(errno));
free(p);
return 0;
}
if (*slash)
q = slash + 1;
} while (*slash);
free(p);
return 1;
}
static void
extract_files(const char *prefix)
{
lo_apk_dir *tree = lo_apk_opendir(prefix);
struct dirent *dent;
if (tree == NULL)
return;
while ((dent = lo_apk_readdir(tree)) != NULL) {
if (strcmp(dent->d_name, ".") == 0 ||
strcmp(dent->d_name, "..") == 0)
continue;
if (dent->d_type == DT_DIR) {
char *subdir = malloc(strlen(prefix) + 1 + strlen(dent->d_name) + 1);
strcpy(subdir, prefix);
strcat(subdir, "/");
strcat(subdir, dent->d_name);
extract_files(subdir);
free(subdir);
} else {
char *filename;
char *newfilename;
const char *apkentry;
size_t size;
struct stat st;
FILE *f;
filename = malloc(strlen(prefix) + 1 + strlen(dent->d_name) + 1);
strcpy(filename, prefix);
strcat(filename, "/");
strcat(filename, dent->d_name);
apkentry = lo_apkentry(filename, &size);
if (apkentry == NULL) {
LOGE("extract_files: Could not find %s in .apk", filename);
free(filename);
continue;
}
newfilename = malloc(strlen(data_dir) + 1 + strlen(prefix) - sizeof(UNPACK_TREE) + 1 + strlen(dent->d_name) + 1);
strcpy(newfilename, data_dir);
strcat(newfilename, "/");
strcat(newfilename, prefix + sizeof(UNPACK_TREE));
if (!mkdir_p(newfilename)) {
free(filename);
free(newfilename);
continue;
}
strcat(newfilename, "/");
strcat(newfilename, dent->d_name);
if (stat(newfilename, &st) == 0 &&
st.st_size == size) {
free(filename);
free(newfilename);
continue;
}
f = fopen(newfilename, "w");
if (f == NULL) {
LOGE("extract_files: Could not open %s for writing: %s", newfilename, strerror(errno));
free(filename);
free(newfilename);
continue;
}
if (fwrite(apkentry, size, 1, f) != 1) {
LOGE("extract_files: Could not write %d bytes to %s: %s", size, newfilename, strerror(errno));
}
LOGI("extract_files: Copied %s to %s: %d bytes", filename, newfilename, size);
fclose(f);
free(filename);
free(newfilename);
}
}
lo_apk_closedir(tree);
}
// static native void extract_files();
__attribute__ ((visibility("default")))
void
Java_org_libreoffice_android_Bootstrap_extract_1files(JNIEnv* env,
jobject clazz)
{
(void) env;
(void) clazz;
extract_files(UNPACK_TREE);
}
/* Android's JNI works only to libraries loaded through Java's
* System.loadLibrary(), it seems. Not to functions loaded by a dlopen() call
* in native code. For instance, to call a function in libvcllo.so, we need to
* have its JNI wrapper here, and then call the VCL function from it. Oh well,
* one could say it's clean to have all the Android-specific JNI functions
* here in this file.
*/
// public static native void initVCL();
__attribute__ ((visibility("default")))
void
Java_org_libreoffice_android_Bootstrap_initVCL(JNIEnv* env,
jobject clazz)
{
void (*InitVCLWrapper)(void);
(void) env;
(void) clazz;
/* This obviously should be called only after libvcllo.so has been loaded */
InitVCLWrapper = dlsym(RTLD_DEFAULT, "InitVCLWrapper");
if (InitVCLWrapper == NULL) {
LOGE("InitVCL: InitVCLWrapper not found");
return;
}
(*InitVCLWrapper)();
}
__attribute__ ((visibility("default")))
void
Java_org_libreoffice_android_Bootstrap_setCommandArgs(JNIEnv* env,
jobject clazz,
jobject argv)
{
char **c_argv;
int c_argc;
Dl_info lo_bootstrap_info;
void (*osl_setCommandArgs)(int, char **);
(void) clazz;
if (!get_jni_string_array(env, "setCommandArgs :argv", argv, &c_argc, (const char ***) &c_argv))
return;
if (lo_dladdr(Java_org_libreoffice_android_Bootstrap_setCommandArgs, &lo_bootstrap_info) != 0) {
char *new_argv0 = malloc(strlen(lo_bootstrap_info.dli_fname) + strlen(c_argv[0]));
char *slash;
strcpy(new_argv0, lo_bootstrap_info.dli_fname);
slash = strrchr(new_argv0, '/');
if (slash != NULL)
*slash = '\0';
slash = strrchr(new_argv0, '/');
strcpy(slash+1, c_argv[0]);
free(c_argv[0]);
c_argv[0] = new_argv0;
}
osl_setCommandArgs = dlsym(RTLD_DEFAULT, "osl_setCommandArgs");
if (osl_setCommandArgs == NULL) {
LOGE("setCommandArgs: osl_setCommandArgs not found");
return;
}
(*osl_setCommandArgs)(c_argc, c_argv);
}
// public static native void initUCBhelper();
__attribute__ ((visibility("default")))
void
Java_org_libreoffice_android_Bootstrap_initUCBHelper(JNIEnv* env,
jobject clazz)
{
void (*InitUCBHelper)(void);
(void) env;
(void) clazz;
/* This obviously should be called only after the ucbhelper so has been loaded */
InitUCBHelper = dlsym(RTLD_DEFAULT, "InitUCBHelper");
if (InitUCBHelper == NULL) {
LOGE("InitUCBHelper: InitUCBHelper not found");
return;
}
(*InitUCBHelper)();
}
__attribute__ ((visibility("default")))
jint
Java_org_libreoffice_android_Bootstrap_createWindowFoo(JNIEnv* env,
jobject clazz)
{
int (*createWindowFoo)(void);
(void) env;
(void) clazz;
lo_dlopen("libvcllo.so");
createWindowFoo = dlsym(RTLD_DEFAULT, "createWindowFoo");
if (createWindowFoo == NULL) {
LOGE("createWindowFoo: createWindowFoo not found");
return 0;
}
return (*createWindowFoo)();
}
/* Code for reading lines from the pipe based on the (Apache-licensed) Android
* logwrapper.c
*/
static int
read_from(int fd, const char *tag, char *buffer, int *sz, int *a, int *b, size_t sizeof_buffer)
{
int nread;
nread = read(fd, buffer+*b, sizeof_buffer - 1 - *b);
*sz = nread;
if (nread == -1) {
LOGE("redirect_thread: Reading from %d failed: %s", fd, strerror(errno));
close(fd);
return -1;
}
if (nread == 0) {
LOGI("redirect_thread: EOF from fd %d", fd);
close(fd);
return 0;
}
*sz += *b;
for (*b = 0; *b < *sz; (*b)++) {
if (buffer[*b] == '\n') {
buffer[*b] = '\0';
__android_log_print(ANDROID_LOG_INFO, tag, "%s", &buffer[*a]);
*a = *b + 1;
}
}
if (*a == 0 && *b == (int) sizeof_buffer - 1) {
// buffer is full, flush
buffer[*b] = '\0';
__android_log_print(ANDROID_LOG_INFO, tag, "%s", &buffer[*a]);
*b = 0;
} else if (*a != *b) {
// Keep left-overs
*b -= *a;
memmove(buffer, &buffer[*a], *b);
*a = 0;
} else {
*a = 0;
*b = 0;
}
return nread;
}
static int stdout_pipe[2], stderr_pipe[2];
static void *
redirect_thread(void *arg)
{
char buffer[2][4096];
int a[2] = { 0, 0 };
int b[2] = { 0, 0 };
int sz[2];
(void) arg;
while (1) {
fd_set readfds;
int nfds = 0;
FD_ZERO(&readfds);
if (stdout_pipe[0] != -1) {
FD_SET(stdout_pipe[0], &readfds);
nfds = MAX(nfds, stdout_pipe[0] + 1);
}
if (stderr_pipe[0] != -1) {
FD_SET(stderr_pipe[0], &readfds);
nfds = MAX(nfds, stderr_pipe[0] + 1);
}
if (nfds == 0) {
LOGI("redirect_thread: Nothing to read any more, thread exiting");
return NULL;
}
if (select(nfds, &readfds, NULL, NULL, NULL) == -1) {
LOGE("redirect_thread: select failed: %s, thread exiting", strerror(errno));
close(stdout_pipe[0]);
stdout_pipe[0] = -1;
close(stderr_pipe[0]);
stderr_pipe[0] = -1;
return NULL;
}
if (stdout_pipe[0] != -1 &&
FD_ISSET(stdout_pipe[0], &readfds)) {
if (read_from(stdout_pipe[0], "stdout", buffer[0], &sz[0], &a[0], &b[0], sizeof(buffer[0])) <= 0) {
stdout_pipe[0] = -1;
}
}
if (stderr_pipe[0] != -1 &&
FD_ISSET(stderr_pipe[0], &readfds)) {
if (read_from(stderr_pipe[0], "stderr", buffer[1], &sz[1], &a[1], &b[1], sizeof(buffer[1])) <= 0) {
stderr_pipe[0] = -1;
}
}
}
}
static int
redirect_to_null(void)
{
int null = open("/dev/null", O_WRONLY);
if (null == -1) {
LOGE("redirect_stdio: Could not open /dev/null: %s", strerror(errno));
/* If we can't redirect stdout or stderr to /dev/null, just close them
* then instead. Huh?
*/
close(1);
close(2);
return 0;
}
if (dup2(null, 1) == -1) {
LOGE("redirect_stdio: Could not dup2 %d to 1: %s", null, strerror(errno));
close(null);
close(1);
close(2);
return 0;
}
if (dup2(null, 2) == -1) {
LOGE("redirect_stdio: Could not dup2 %d to 2: %s", null, strerror(errno));
close(null);
close(1);
close(2);
return 0;
}
close(null);
return 1;
}
__attribute__ ((visibility("default")))
jboolean
Java_org_libreoffice_android_Bootstrap_redirect_1stdio(JNIEnv* env,
jobject clazz,
jboolean state)
{
static jboolean current = JNI_FALSE;
pthread_t thread;
pthread_attr_t attr;
(void) env;
(void) clazz;
if (state == current)
return current;
if (state == JNI_FALSE) {
if (!redirect_to_null())
return current;
} else {
if (pipe(stdout_pipe) == -1) {
LOGE("redirect_stdio: Could not create pipes: %s", strerror(errno));
return current;
}
if (pipe(stderr_pipe) == -1) {
LOGE("redirect_stdio: Could not create pipes: %s", strerror(errno));
close(stdout_pipe[0]);
close(stdout_pipe[1]);
return current;
}
LOGI("redirect_stdio: stdout pipe: [%d,%d], stderr pipe: [%d,%d]",
stdout_pipe[0], stdout_pipe[1], stderr_pipe[0], stderr_pipe[1]);
if (dup2(stdout_pipe[1], 1) == -1) {
LOGE("redirect_stdio: Could not dup2 %d to 1: %s", stdout_pipe[1], strerror(errno));
close(stdout_pipe[0]);
close(stdout_pipe[1]);
close(stderr_pipe[0]);
close(stderr_pipe[1]);
return current;
}
if (dup2(stderr_pipe[1], 2) == -1) {
LOGE("redirect_stdio: Could not dup2 %d to 2: %s", stdout_pipe[1], strerror(errno));
/* stdout has already been redirected to its pipe, so redirect
* it back to /dev/null
*/
redirect_to_null();
close(stdout_pipe[0]);
close(stdout_pipe[1]);
close(stderr_pipe[0]);
close(stderr_pipe[1]);
return current;
}
close(stdout_pipe[1]);
close(stderr_pipe[1]);
if (pthread_attr_init(&attr) != 0 ||
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) != 0 ||
pthread_create(&thread, &attr, redirect_thread, NULL) != 0) {
LOGE("redirect_stdio: Could not create thread: %s", strerror(errno));
redirect_to_null();
close(stdout_pipe[0]);
close(stderr_pipe[0]);
return current;
}
}
current = state;
return current;
}
__attribute__ ((visibility("default")))
void
Java_org_libreoffice_android_Bootstrap_twiddle_1BGR_1to_1RGBA(JNIEnv* env,
jobject clazz,
jbyteArray source,
jint offset,
jint width,
jint height,
jobject destination)
{
jbyte *dst = (jbyte*) (*env)->GetDirectBufferAddress(env, destination);
void *a = (*env)->GetPrimitiveArrayCritical(env, source, NULL);
jbyte *src = ((jbyte *) a) + offset;
jbyte *srcp;
jbyte *dstp = dst;
int step = ((((width * 3) - 1) / 4) + 1) * 4;
int i, j;
(void) clazz;
if (height > 0) {
srcp = src + step * (height - 1);
step = -step;
} else {
srcp = src;
}
LOGI("twiddle: src=%p, srcp=%p, dstp=%p, step=%d", src, srcp, dstp, step);
for (i = 0; i < height; i++) {
for (j = 0; j < width; j++) {
*dstp++ = srcp[j*3+2];
*dstp++ = srcp[j*3+1];
*dstp++ = srcp[j*3+0];
*dstp++ = 0xFF;
}
srcp += step;
}
(*env)->ReleasePrimitiveArrayCritical(env, source, a, 0);
}
__attribute__ ((visibility("default")))
void
Java_org_libreoffice_android_Bootstrap_force_1full_1alpha_1array(JNIEnv* env,
jobject clazz,
jbyteArray array,
jint offset,
jint length)
{
void *a = (*env)->GetPrimitiveArrayCritical(env, array, NULL);
jbyte *p = ((jbyte *) a) + offset;
int i;
(void) clazz;
for (i = 0; i < length; i += 4) {
p[3] = 0xFF;
p += 4;
}
(*env)->ReleasePrimitiveArrayCritical(env, array, a, 0);
}
__attribute__ ((visibility("default")))
void
Java_org_libreoffice_android_Bootstrap_force_1full_1alpha_1bb(JNIEnv* env,
jobject clazz,
jobject buffer,
jint offset,
jint length)
{
jbyte *p = (*env)->GetDirectBufferAddress(env, buffer) + offset;
int i;
(void) clazz;
for (i = 0; i < length; i += 4) {
p[3] = 0xFF;
p += 4;
}
}
__attribute__ ((visibility("default")))
jlong
Java_org_libreoffice_android_Bootstrap_address_1of_1direct_1byte_1buffer(JNIEnv *env,
jobject bbuffer)
{
return (jlong) (intptr_t) (*env)->GetDirectBufferAddress(env, bbuffer);
}
__attribute__ ((visibility("default")))
JavaVM *
lo_get_javavm(void)
{
return the_java_vm;
}
__attribute__ ((visibility("default")))
struct android_app *
lo_get_app(void)
{
return app;
}
__attribute__ ((visibility("default")))
void
android_main(struct android_app* state)
{
jint nRet;
JNIEnv *pEnv = NULL;
struct engine engine;
Dl_info lo_main_info;
JavaVMAttachArgs aArgs = {
JNI_VERSION_1_2,
"LibreOfficeThread",
NULL
};
fprintf (stderr, "android_main in thread: %d\n", (int)pthread_self());
if (sleep_time != 0) {
LOGI("android_main: Sleeping for %d seconds, start ndk-gdb NOW if that is your intention", sleep_time);
sleep(sleep_time);
}
nRet = (*(*state->activity->vm)->AttachCurrentThreadAsDaemon)(state->activity->vm, &pEnv, &aArgs);
fprintf (stderr, "attach thread returned %d %p\n", nRet, pEnv);
app = state;
memset(&engine, 0, sizeof(engine));
state->userData = &engine;
state->onAppCmd = engine_handle_cmd;
if (lo_dladdr(lo_main, &lo_main_info) != 0) {
lo_main_argv[0] = lo_main_info.dli_fname;
}
lo_main(lo_main_argc, lo_main_argv);
nRet = (*(*state->activity->vm)->DetachCurrentThread)(state->activity->vm);
fprintf (stderr, "exit android_main\n");
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
Reference in a new issue View git blame Copy permalink