The Tor Browser: mozglue/android/APKOpen.cpp@6474c204b198

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     1 /* This Source Code Form is subject to the terms of the Mozilla Public

     2  * License, v. 2.0. If a copy of the MPL was not distributed with this

     3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

     5 /*

     6  * This custom library loading code is only meant to be called

     7  * during initialization. As a result, it takes no special

     8  * precautions to be threadsafe. Any of the library loading functions

     9  * like mozload should not be available to other code.

    10  */

    12 #include <jni.h>

    13 #include <android/log.h>

    14 #include <sys/types.h>

    15 #include <sys/stat.h>

    16 #include <sys/mman.h>

    17 #include <sys/limits.h>

    18 #include <errno.h>

    19 #include <string.h>

    20 #include <stdio.h>

    21 #include <stdlib.h>

    22 #include <time.h>

    23 #include <fcntl.h>

    24 #include <unistd.h>

    25 #include <zlib.h>

    26 #include "dlfcn.h"

    27 #include "APKOpen.h"

    28 #include <sys/time.h>

    29 #include <sys/resource.h>

    30 #include <sys/prctl.h>

    31 #include "Zip.h"

    32 #include "sqlite3.h"

    33 #include "SQLiteBridge.h"

    34 #include "NSSBridge.h"

    35 #include "ElfLoader.h"

    36 #include "application.ini.h"

    38 /* Android headers don't define RUSAGE_THREAD */

    39 #ifndef RUSAGE_THREAD

    40 #define RUSAGE_THREAD 1

    41 #endif

    43 #ifndef RELEASE_BUILD

    44 /* Official builds have the debuggable flag set to false, which disables

    45  * the backtrace dumper from bionic. However, as it is useful for native

    46  * crashes happening before the crash reporter is registered, re-enable

    47  * it on non release builds (i.e. nightly and aurora).

    48  * Using a constructor so that it is re-enabled as soon as libmozglue.so

    49  * is loaded.

    50  */

    51 __attribute__((constructor))

    52 void make_dumpable() {

    53   prctl(PR_SET_DUMPABLE, 1);

    54 }

    55 #endif

    57 extern "C" {

    58 /*

    59  * To work around http://code.google.com/p/android/issues/detail?id=23203

    60  * we don't link with the crt objects. In some configurations, this means

    61  * a lack of the __dso_handle symbol because it is defined there, and

    62  * depending on the android platform and ndk versions used, it may or may

    63  * not be defined in libc.so. In the latter case, we fail to link. Defining

    64  * it here as weak makes us provide the symbol when it's not provided by

    65  * the crt objects, making the change transparent for future NDKs that

    66  * would fix the original problem. On older NDKs, it is not a problem

    67  * either because the way __dso_handle was used was already broken (and

    68  * the custom linker works around it).

    69  */

    70   NS_EXPORT __attribute__((weak)) void *__dso_handle;

    71 }

    73 typedef int mozglueresult;

    75 enum StartupEvent {

    76 #define mozilla_StartupTimeline_Event(ev, z) ev,

    77 #include "StartupTimeline.h"

    78 #undef mozilla_StartupTimeline_Event

    79   MAX_STARTUP_EVENT_ID

    80 };

    82 using namespace mozilla;

    84 /**

    85  * Local TimeStamp::Now()-compatible implementation used to record timestamps

    86  * which will be passed to XRE_StartupTimelineRecord().

    87  */

    89 static uint64_t TimeStamp_Now()

    90 {

    91   struct timespec ts;

    92   int rv = clock_gettime(CLOCK_MONOTONIC, &ts);

    94   if (rv != 0) {

    95     return 0;

    96   }

    98   uint64_t baseNs = (uint64_t)ts.tv_sec * 1000000000;

    99   return baseNs + (uint64_t)ts.tv_nsec;

   100 }

   102 static struct mapping_info * lib_mapping = nullptr;

   104 NS_EXPORT const struct mapping_info *

   105 getLibraryMapping()

   106 {

   107   return lib_mapping;

   108 }

   110 void

   111 JNI_Throw(JNIEnv* jenv, const char* classname, const char* msg)

   112 {

   113     __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "Throw\n");

   114     jclass cls = jenv->FindClass(classname);

   115     if (cls == nullptr) {

   116         __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "Couldn't find exception class (or exception pending) %s\n", classname);

   117         exit(FAILURE);

   118     }

   119     int rc = jenv->ThrowNew(cls, msg);

   120     if (rc < 0) {

   121         __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "Error throwing exception %s\n", msg);

   122         exit(FAILURE);

   123     }

   124     jenv->DeleteLocalRef(cls);

   125 }

   127 #define JNI_STUBS

   128 #include "jni-stubs.inc"

   129 #undef JNI_STUBS

   131 static void * xul_handle = nullptr;

   132 #ifndef MOZ_FOLD_LIBS

   133 static void * sqlite_handle = nullptr;

   134 static void * nspr_handle = nullptr;

   135 static void * plc_handle = nullptr;

   136 #else

   137 #define sqlite_handle nss_handle

   138 #define nspr_handle nss_handle

   139 #define plc_handle nss_handle

   140 #endif

   141 static void * nss_handle = nullptr;

   143 template <typename T> inline void

   144 xul_dlsym(const char *symbolName, T *value)

   145 {

   146   *value = (T) (uintptr_t) __wrap_dlsym(xul_handle, symbolName);

   147 }

   149 static int mapping_count = 0;

   151 #define MAX_MAPPING_INFO 32

   153 extern "C" void

   154 report_mapping(char *name, void *base, uint32_t len, uint32_t offset)

   155 {

   156   if (mapping_count >= MAX_MAPPING_INFO)

   157     return;

   159   struct mapping_info *info = &lib_mapping[mapping_count++];

   160   info->name = strdup(name);

   161   info->base = (uintptr_t)base;

   162   info->len = len;

   163   info->offset = offset;

   164 }

   166 static mozglueresult

   167 loadGeckoLibs(const char *apkName)

   168 {

   169   chdir(getenv("GRE_HOME"));

   171   uint64_t t0 = TimeStamp_Now();

   172   struct rusage usage1_thread, usage1;

   173   getrusage(RUSAGE_THREAD, &usage1_thread);

   174   getrusage(RUSAGE_SELF, &usage1);

   176   RefPtr<Zip> zip = ZipCollection::GetZip(apkName);

   178   char *file = new char[strlen(apkName) + sizeof("!/assets/libxul.so")];

   179   sprintf(file, "%s!/assets/libxul.so", apkName);

   180   xul_handle = __wrap_dlopen(file, RTLD_GLOBAL | RTLD_LAZY);

   181   delete[] file;

   183   if (!xul_handle) {

   184     __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "Couldn't get a handle to libxul!");

   185     return FAILURE;

   186   }

   188 #define JNI_BINDINGS

   189 #include "jni-stubs.inc"

   190 #undef JNI_BINDINGS

   192   void (*XRE_StartupTimelineRecord)(int, uint64_t);

   193   xul_dlsym("XRE_StartupTimelineRecord", &XRE_StartupTimelineRecord);

   195   uint64_t t1 = TimeStamp_Now();

   196   struct rusage usage2_thread, usage2;

   197   getrusage(RUSAGE_THREAD, &usage2_thread);

   198   getrusage(RUSAGE_SELF, &usage2);

   200 #define RUSAGE_TIMEDIFF(u1, u2, field) \

   201   ((u2.ru_ ## field.tv_sec - u1.ru_ ## field.tv_sec) * 1000 + \

   202    (u2.ru_ ## field.tv_usec - u1.ru_ ## field.tv_usec) / 1000)

   204   __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "Loaded libs in %lldms total, %ldms(%ldms) user, %ldms(%ldms) system, %ld(%ld) faults",

   205                       (t1 - t0) / 1000000,

   206                       RUSAGE_TIMEDIFF(usage1_thread, usage2_thread, utime),

   207                       RUSAGE_TIMEDIFF(usage1, usage2, utime),

   208                       RUSAGE_TIMEDIFF(usage1_thread, usage2_thread, stime),

   209                       RUSAGE_TIMEDIFF(usage1, usage2, stime),

   210                       usage2_thread.ru_majflt - usage1_thread.ru_majflt,

   211                       usage2.ru_majflt - usage1.ru_majflt);

   213   XRE_StartupTimelineRecord(LINKER_INITIALIZED, t0);

   214   XRE_StartupTimelineRecord(LIBRARIES_LOADED, t1);

   215   return SUCCESS;

   216 }

   218 static mozglueresult loadNSSLibs(const char *apkName);

   220 static mozglueresult

   221 loadSQLiteLibs(const char *apkName)

   222 {

   223   if (sqlite_handle)

   224     return SUCCESS;

   226 #ifdef MOZ_FOLD_LIBS

   227   if (loadNSSLibs(apkName) != SUCCESS)

   228     return FAILURE;

   229 #else

   230   chdir(getenv("GRE_HOME"));

   232   RefPtr<Zip> zip = ZipCollection::GetZip(apkName);

   233   if (!lib_mapping) {

   234     lib_mapping = (struct mapping_info *)calloc(MAX_MAPPING_INFO, sizeof(*lib_mapping));

   235   }

   237   char *file = new char[strlen(apkName) + sizeof("!/assets/libmozsqlite3.so")];

   238   sprintf(file, "%s!/assets/libmozsqlite3.so", apkName);

   239   sqlite_handle = __wrap_dlopen(file, RTLD_GLOBAL | RTLD_LAZY);

   240   delete [] file;

   242   if (!sqlite_handle) {

   243     __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "Couldn't get a handle to libmozsqlite3!");

   244     return FAILURE;

   245   }

   246 #endif

   248   setup_sqlite_functions(sqlite_handle);

   249   return SUCCESS;

   250 }

   252 static mozglueresult

   253 loadNSSLibs(const char *apkName)

   254 {

   255   if (nss_handle && nspr_handle && plc_handle)

   256     return SUCCESS;

   258   chdir(getenv("GRE_HOME"));

   260   RefPtr<Zip> zip = ZipCollection::GetZip(apkName);

   261   if (!lib_mapping) {

   262     lib_mapping = (struct mapping_info *)calloc(MAX_MAPPING_INFO, sizeof(*lib_mapping));

   263   }

   265   char *file = new char[strlen(apkName) + sizeof("!/assets/libnss3.so")];

   266   sprintf(file, "%s!/assets/libnss3.so", apkName);

   267   nss_handle = __wrap_dlopen(file, RTLD_GLOBAL | RTLD_LAZY);

   268   delete [] file;

   270 #ifndef MOZ_FOLD_LIBS

   271   file = new char[strlen(apkName) + sizeof("!/assets/libnspr4.so")];

   272   sprintf(file, "%s!/assets/libnspr4.so", apkName);

   273   nspr_handle = __wrap_dlopen(file, RTLD_GLOBAL | RTLD_LAZY);

   274   delete [] file;

   276   file = new char[strlen(apkName) + sizeof("!/assets/libplc4.so")];

   277   sprintf(file, "%s!/assets/libplc4.so", apkName);

   278   plc_handle = __wrap_dlopen(file, RTLD_GLOBAL | RTLD_LAZY);

   279   delete [] file;

   280 #endif

   282   if (!nss_handle) {

   283     __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "Couldn't get a handle to libnss3!");

   284     return FAILURE;

   285   }

   287 #ifndef MOZ_FOLD_LIBS

   288   if (!nspr_handle) {

   289     __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "Couldn't get a handle to libnspr4!");

   290     return FAILURE;

   291   }

   293   if (!plc_handle) {

   294     __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "Couldn't get a handle to libplc4!");

   295     return FAILURE;

   296   }

   297 #endif

   299   return setup_nss_functions(nss_handle, nspr_handle, plc_handle);

   300 }

   302 extern "C" NS_EXPORT void JNICALL

   303 Java_org_mozilla_gecko_mozglue_GeckoLoader_loadGeckoLibsNative(JNIEnv *jenv, jclass jGeckoAppShellClass, jstring jApkName)

   304 {

   305   const char* str;

   306   // XXX: java doesn't give us true UTF8, we should figure out something

   307   // better to do here

   308   str = jenv->GetStringUTFChars(jApkName, nullptr);

   309   if (str == nullptr)

   310     return;

   312   int res = loadGeckoLibs(str);

   313   if (res != SUCCESS) {

   314     JNI_Throw(jenv, "java/lang/Exception", "Error loading gecko libraries");

   315   }

   316   jenv->ReleaseStringUTFChars(jApkName, str);

   317 }

   319 extern "C" NS_EXPORT void JNICALL

   320 Java_org_mozilla_gecko_mozglue_GeckoLoader_loadSQLiteLibsNative(JNIEnv *jenv, jclass jGeckoAppShellClass, jstring jApkName, jboolean jShouldExtract) {

   321   if (jShouldExtract) {

   322     putenv("MOZ_LINKER_EXTRACT=1");

   323   }

   325   const char* str;

   326   // XXX: java doesn't give us true UTF8, we should figure out something

   327   // better to do here

   328   str = jenv->GetStringUTFChars(jApkName, nullptr);

   329   if (str == nullptr)

   330     return;

   332   __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "Load sqlite start\n");

   333   mozglueresult rv = loadSQLiteLibs(str);

   334   if (rv != SUCCESS) {

   335       JNI_Throw(jenv, "java/lang/Exception", "Error loading sqlite libraries");

   336   }

   337   __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "Load sqlite done\n");

   338   jenv->ReleaseStringUTFChars(jApkName, str);

   339 }

   341 extern "C" NS_EXPORT void JNICALL

   342 Java_org_mozilla_gecko_mozglue_GeckoLoader_loadNSSLibsNative(JNIEnv *jenv, jclass jGeckoAppShellClass, jstring jApkName, jboolean jShouldExtract) {

   343   if (jShouldExtract) {

   344     putenv("MOZ_LINKER_EXTRACT=1");

   345   }

   347   const char* str;

   348   // XXX: java doesn't give us true UTF8, we should figure out something

   349   // better to do here

   350   str = jenv->GetStringUTFChars(jApkName, nullptr);

   351   if (str == nullptr)

   352     return;

   354   __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "Load nss start\n");

   355   mozglueresult rv = loadNSSLibs(str);

   356   if (rv != SUCCESS) {

   357     JNI_Throw(jenv, "java/lang/Exception", "Error loading nss libraries");

   358   }

   359   __android_log_print(ANDROID_LOG_ERROR, "GeckoLibLoad", "Load nss done\n");

   360   jenv->ReleaseStringUTFChars(jApkName, str);

   361 }

   363 typedef void (*GeckoStart_t)(void *, const nsXREAppData *);

   365 extern "C" NS_EXPORT void JNICALL

   366 Java_org_mozilla_gecko_mozglue_GeckoLoader_nativeRun(JNIEnv *jenv, jclass jc, jstring jargs)

   367 {

   368   GeckoStart_t GeckoStart;

   369   xul_dlsym("GeckoStart", &GeckoStart);

   370   if (GeckoStart == nullptr)

   371     return;

   372   // XXX: java doesn't give us true UTF8, we should figure out something

   373   // better to do here

   374   int len = jenv->GetStringUTFLength(jargs);

   375   // GeckoStart needs to write in the args buffer, so we need a copy.

   376   char *args = (char *) malloc(len + 1);

   377   jenv->GetStringUTFRegion(jargs, 0, len, args);

   378   args[len] = '\0';

   379   GeckoStart(args, &sAppData);

   380   free(args);

   381 }

   383 typedef int GeckoProcessType;

   385 extern "C" NS_EXPORT mozglueresult

   386 ChildProcessInit(int argc, char* argv[])

   387 {

   388   int i;

   389   for (i = 0; i < (argc - 1); i++) {

   390     if (strcmp(argv[i], "-greomni"))

   391       continue;

   393     i = i + 1;

   394     break;

   395   }

   397   if (loadNSSLibs(argv[i]) != SUCCESS) {

   398     return FAILURE;

   399   }

   400   if (loadSQLiteLibs(argv[i]) != SUCCESS) {

   401     return FAILURE;

   402   }

   403   if (loadGeckoLibs(argv[i]) != SUCCESS) {

   404     return FAILURE;

   405   }

   407   GeckoProcessType (*fXRE_StringToChildProcessType)(char*);

   408   xul_dlsym("XRE_StringToChildProcessType", &fXRE_StringToChildProcessType);

   410   mozglueresult (*fXRE_InitChildProcess)(int, char**, GeckoProcessType);

   411   xul_dlsym("XRE_InitChildProcess", &fXRE_InitChildProcess);

   413   GeckoProcessType proctype = fXRE_StringToChildProcessType(argv[--argc]);

   415   return fXRE_InitChildProcess(argc, argv, proctype);

   416 }

The Tor Browser / file revision

mozglue/android/APKOpen.cpp@6474c204b198

mozglue/android/APKOpen.cpp