Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d70d89fd authored by Andreas Gampe's avatar Andreas Gampe Committed by Android (Google) Code Review
Browse files

Merge "Installd: Refactor in preparation for OTA"

parents 0bd49eb4 02d0de56

cmds/installd/Android.mk

+5 −1
Original line number Diff line number Diff line 
LOCAL_PATH := $(call my-dir)



common_src_files := commands.cpp utils.cpp

common_src_files := commands.cpp globals.cpp utils.cpp

common_cflags := -Wall -Werror



#
@@ -41,3 +41,7 @@ LOCAL_ADDITIONAL_DEPENDENCIES += $(LOCAL_PATH)/Android.mk 
LOCAL_INIT_RC := installd.rc

LOCAL_CLANG := true

include $(BUILD_EXECUTABLE)



# Tests.



include $(LOCAL_PATH)/tests/Android.mk
 
 No newline at end of file

cmds/installd/commands.cpp

+68 −183
Original line number Diff line number Diff line
@@ -14,33 +14,40 @@ 
** limitations under the License.

*/



#include "installd.h"

#include "commands.h"



#include <errno.h>

#include <inttypes.h>

#include <stdlib.h>

#include <sys/capability.h>

#include <sys/file.h>

#include <sys/resource.h>

#include <sys/stat.h>

#include <unistd.h>



#include <android-base/stringprintf.h>

#include <android-base/logging.h>

#include <cutils/fs.h>

#include <cutils/log.h>               // TODO: Move everything to base/logging.

#include <cutils/sched_policy.h>

#include <diskusage/dirsize.h>

#include <logwrap/logwrap.h>

#include <system/thread_defs.h>

#include <private/android_filesystem_config.h>

#include <selinux/android.h>

#include <system/thread_defs.h>



#include <inttypes.h>

#include <sys/capability.h>

#include <sys/file.h>

#include <unistd.h>

#include <globals.h>

#include <installd_deps.h>

#include <utils.h>



#ifndef LOG_TAG

#define LOG_TAG "installd"

#endif



using android::base::StringPrintf;



/* Directory records that are used in execution of commands. */

dir_rec_t android_data_dir;

dir_rec_t android_asec_dir;

dir_rec_t android_app_dir;

dir_rec_t android_app_private_dir;

dir_rec_t android_app_ephemeral_dir;

dir_rec_t android_app_lib_dir;

dir_rec_t android_media_dir;

dir_rec_t android_mnt_expand_dir;

dir_rec_array_t android_system_dirs;

namespace android {

namespace installd {



static const char* kCpPath = "/system/bin/cp";
@@ -420,8 +427,8 @@ int move_dex(const char *src, const char *dst, const char *instruction_set) 
        return -1;

    }



    if (create_cache_path(src_dex, src, instruction_set)) return -1;

    if (create_cache_path(dst_dex, dst, instruction_set)) return -1;

    if (!create_cache_path(src_dex, src, instruction_set)) return -1;

    if (!create_cache_path(dst_dex, dst, instruction_set)) return -1;



    ALOGV("move %s -> %s\n", src_dex, dst_dex);

    if (rename(src_dex, dst_dex) < 0) {
@@ -441,7 +448,7 @@ int rm_dex(const char *path, const char *instruction_set) 
        return -1;

    }



    if (create_cache_path(dex_path, path, instruction_set)) return -1;

    if (!create_cache_path(dex_path, path, instruction_set)) return -1;



    ALOGV("unlink %s\n", dex_path);

    if (unlink(dex_path) < 0) {
@@ -495,7 +502,7 @@ int get_size(const char *uuid, const char *pkgname, int userid, const char *apkp 
    }



    /* count the cached dexfile as code */

    if (!create_cache_path(path, apkpath, instruction_set)) {

    if (create_cache_path(path, apkpath, instruction_set)) {

        if (stat(path, &s) == 0) {

            codesize += stat_size(&s);

        }
@@ -589,51 +596,11 @@ int get_size(const char *uuid, const char *pkgname, int userid, const char *apkp 
    return 0;

}



int create_cache_path(char path[PKG_PATH_MAX], const char *src, const char *instruction_set)

{

    char *tmp;

    int srclen;

    int dstlen;



    srclen = strlen(src);



        /* demand that we are an absolute path */

    if ((src == 0) || (src[0] != '/') || strstr(src,"..")) {

        return -1;

    }



    if (srclen > PKG_PATH_MAX) {        // XXX: PKG_NAME_MAX?

        return -1;

    }



    dstlen = srclen + strlen(DALVIK_CACHE_PREFIX) +

        strlen(instruction_set) +

        strlen(DALVIK_CACHE_POSTFIX) + 2;



    if (dstlen > PKG_PATH_MAX) {

        return -1;

    }



    sprintf(path,"%s%s/%s%s",

            DALVIK_CACHE_PREFIX,

            instruction_set,

            src + 1, /* skip the leading / */

            DALVIK_CACHE_POSTFIX);



    for(tmp = path + strlen(DALVIK_CACHE_PREFIX) + strlen(instruction_set) + 1; *tmp; tmp++) {

        if (*tmp == '/') {

            *tmp = '@';

        }

    }



    return 0;

}



static int split_count(const char *str)

{

  char *ctx;

  int count = 0;

  char buf[PROPERTY_VALUE_MAX];

  char buf[kPropertyValueMax];



  strncpy(buf, str, sizeof(buf));

  char *pBuf = buf;
@@ -662,7 +629,7 @@ static int split(char *buf, const char **argv) 
}



static void run_patchoat(int input_fd, int oat_fd, const char* input_file_name,

    const char* output_file_name, const char *pkgname __unused, const char *instruction_set)

    const char* output_file_name, const char *pkgname ATTRIBUTE_UNUSED, const char *instruction_set)

{

    static const int MAX_INT_LEN = 12;      // '-'+10dig+'\0' -OR- 0x+8dig

    static const unsigned int MAX_INSTRUCTION_SET_LEN = 7;
@@ -702,8 +669,8 @@ static void run_patchoat(int input_fd, int oat_fd, const char* input_file_name, 
}



static bool check_boolean_property(const char* property_name, bool default_value = false) {

    char tmp_property_value[PROPERTY_VALUE_MAX];

    bool have_property = property_get(property_name, tmp_property_value, nullptr) > 0;

    char tmp_property_value[kPropertyValueMax];

    bool have_property = get_property(property_name, tmp_property_value, nullptr) > 0;

    if (!have_property) {

        return default_value;

    }
@@ -722,50 +689,50 @@ static void run_dex2oat(int zip_fd, int oat_fd, const char* input_file_name, 
        return;

    }



    char dex2oat_Xms_flag[PROPERTY_VALUE_MAX];

    bool have_dex2oat_Xms_flag = property_get("dalvik.vm.dex2oat-Xms", dex2oat_Xms_flag, NULL) > 0;

    char dex2oat_Xms_flag[kPropertyValueMax];

    bool have_dex2oat_Xms_flag = get_property("dalvik.vm.dex2oat-Xms", dex2oat_Xms_flag, NULL) > 0;



    char dex2oat_Xmx_flag[PROPERTY_VALUE_MAX];

    bool have_dex2oat_Xmx_flag = property_get("dalvik.vm.dex2oat-Xmx", dex2oat_Xmx_flag, NULL) > 0;

    char dex2oat_Xmx_flag[kPropertyValueMax];

    bool have_dex2oat_Xmx_flag = get_property("dalvik.vm.dex2oat-Xmx", dex2oat_Xmx_flag, NULL) > 0;



    char dex2oat_compiler_filter_flag[PROPERTY_VALUE_MAX];

    bool have_dex2oat_compiler_filter_flag = property_get("dalvik.vm.dex2oat-filter",

    char dex2oat_compiler_filter_flag[kPropertyValueMax];

    bool have_dex2oat_compiler_filter_flag = get_property("dalvik.vm.dex2oat-filter",

                                                          dex2oat_compiler_filter_flag, NULL) > 0;



    char dex2oat_threads_buf[PROPERTY_VALUE_MAX];

    bool have_dex2oat_threads_flag = property_get(post_bootcomplete

    char dex2oat_threads_buf[kPropertyValueMax];

    bool have_dex2oat_threads_flag = get_property(post_bootcomplete

                                                      ? "dalvik.vm.dex2oat-threads"

                                                      : "dalvik.vm.boot-dex2oat-threads",

                                                  dex2oat_threads_buf,

                                                  NULL) > 0;

    char dex2oat_threads_arg[PROPERTY_VALUE_MAX + 2];

    char dex2oat_threads_arg[kPropertyValueMax + 2];

    if (have_dex2oat_threads_flag) {

        sprintf(dex2oat_threads_arg, "-j%s", dex2oat_threads_buf);

    }



    char dex2oat_isa_features_key[PROPERTY_KEY_MAX];

    char dex2oat_isa_features_key[kPropertyKeyMax];

    sprintf(dex2oat_isa_features_key, "dalvik.vm.isa.%s.features", instruction_set);

    char dex2oat_isa_features[PROPERTY_VALUE_MAX];

    bool have_dex2oat_isa_features = property_get(dex2oat_isa_features_key,

    char dex2oat_isa_features[kPropertyValueMax];

    bool have_dex2oat_isa_features = get_property(dex2oat_isa_features_key,

                                                  dex2oat_isa_features, NULL) > 0;



    char dex2oat_isa_variant_key[PROPERTY_KEY_MAX];

    char dex2oat_isa_variant_key[kPropertyKeyMax];

    sprintf(dex2oat_isa_variant_key, "dalvik.vm.isa.%s.variant", instruction_set);

    char dex2oat_isa_variant[PROPERTY_VALUE_MAX];

    bool have_dex2oat_isa_variant = property_get(dex2oat_isa_variant_key,

    char dex2oat_isa_variant[kPropertyValueMax];

    bool have_dex2oat_isa_variant = get_property(dex2oat_isa_variant_key,

                                                 dex2oat_isa_variant, NULL) > 0;



    const char *dex2oat_norelocation = "-Xnorelocate";

    bool have_dex2oat_relocation_skip_flag = false;



    char dex2oat_flags[PROPERTY_VALUE_MAX];

    int dex2oat_flags_count = property_get("dalvik.vm.dex2oat-flags",

    char dex2oat_flags[kPropertyValueMax];

    int dex2oat_flags_count = get_property("dalvik.vm.dex2oat-flags",

                                 dex2oat_flags, NULL) <= 0 ? 0 : split_count(dex2oat_flags);

    ALOGV("dalvik.vm.dex2oat-flags=%s\n", dex2oat_flags);



    // If we booting without the real /data, don't spend time compiling.

    char vold_decrypt[PROPERTY_VALUE_MAX];

    bool have_vold_decrypt = property_get("vold.decrypt", vold_decrypt, "") > 0;

    char vold_decrypt[kPropertyValueMax];

    bool have_vold_decrypt = get_property("vold.decrypt", vold_decrypt, "") > 0;

    bool skip_compilation = (have_vold_decrypt &&

                             (strcmp(vold_decrypt, "trigger_restart_min_framework") == 0 ||

                             (strcmp(vold_decrypt, "1") == 0)));
@@ -783,11 +750,11 @@ static void run_dex2oat(int zip_fd, int oat_fd, const char* input_file_name, 
    char oat_fd_arg[strlen("--oat-fd=") + MAX_INT_LEN];

    char oat_location_arg[strlen("--oat-location=") + PKG_PATH_MAX];

    char instruction_set_arg[strlen("--instruction-set=") + MAX_INSTRUCTION_SET_LEN];

    char instruction_set_variant_arg[strlen("--instruction-set-variant=") + PROPERTY_VALUE_MAX];

    char instruction_set_features_arg[strlen("--instruction-set-features=") + PROPERTY_VALUE_MAX];

    char dex2oat_Xms_arg[strlen("-Xms") + PROPERTY_VALUE_MAX];

    char dex2oat_Xmx_arg[strlen("-Xmx") + PROPERTY_VALUE_MAX];

    char dex2oat_compiler_filter_arg[strlen("--compiler-filter=") + PROPERTY_VALUE_MAX];

    char instruction_set_variant_arg[strlen("--instruction-set-variant=") + kPropertyValueMax];

    char instruction_set_features_arg[strlen("--instruction-set-features=") + kPropertyValueMax];

    char dex2oat_Xms_arg[strlen("-Xms") + kPropertyValueMax];

    char dex2oat_Xmx_arg[strlen("-Xmx") + kPropertyValueMax];

    char dex2oat_compiler_filter_arg[strlen("--compiler-filter=") + kPropertyValueMax];

    bool have_dex2oat_swap_fd = false;

    char dex2oat_swap_fd[strlen("--swap-fd=") + MAX_INT_LEN];
@@ -827,9 +794,9 @@ static void run_dex2oat(int zip_fd, int oat_fd, const char* input_file_name, 


    // Check whether all apps should be compiled debuggable.

    if (!debuggable) {

        char prop_buf[PROPERTY_VALUE_MAX];

        char prop_buf[kPropertyValueMax];

        debuggable =

                (property_get("dalvik.vm.always_debuggable", prop_buf, "0") > 0) &&

                (get_property("dalvik.vm.always_debuggable", prop_buf, "0") > 0) &&

                (prop_buf[0] == '1');

    }
@@ -897,32 +864,6 @@ static void run_dex2oat(int zip_fd, int oat_fd, const char* input_file_name, 
    ALOGE("execv(%s) failed: %s\n", DEX2OAT_BIN, strerror(errno));

}



static int wait_child(pid_t pid)

{

    int status;

    pid_t got_pid;



    while (1) {

        got_pid = waitpid(pid, &status, 0);

        if (got_pid == -1 && errno == EINTR) {

            printf("waitpid interrupted, retrying\n");

        } else {

            break;

        }

    }

    if (got_pid != pid) {

        ALOGW("waitpid failed: wanted %d, got %d: %s\n",

            (int) pid, (int) got_pid, strerror(errno));

        return 1;

    }



    if (WIFEXITED(status) && WEXITSTATUS(status) == 0) {

        return 0;

    } else {

        return status;      /* always nonzero */

    }

}



/*

 * Whether dexopt should use a swap file when compiling an APK.

 *
@@ -944,8 +885,8 @@ static bool ShouldUseSwapFileForDexopt() { 
    }



    // Check the "override" property. If it exists, return value == "true".

    char dex2oat_prop_buf[PROPERTY_VALUE_MAX];

    if (property_get("dalvik.vm.dex2oat-swap", dex2oat_prop_buf, "") > 0) {

    char dex2oat_prop_buf[kPropertyValueMax];

    if (get_property("dalvik.vm.dex2oat-swap", dex2oat_prop_buf, "") > 0) {

        if (strcmp(dex2oat_prop_buf, "true") == 0) {

            return true;

        } else {
@@ -969,42 +910,6 @@ static bool ShouldUseSwapFileForDexopt() { 
    return kDefaultProvideSwapFile;

}



/*

 * Computes the odex file for the given apk_path and instruction_set.

 * /system/framework/whatever.jar -> /system/framework/oat/<isa>/whatever.odex

 *

 * Returns false if it failed to determine the odex file path.

 */

static bool calculate_odex_file_path(char path[PKG_PATH_MAX],

                                     const char *apk_path,

                                     const char *instruction_set)

{

    if (strlen(apk_path) + strlen("oat/") + strlen(instruction_set)

        + strlen("/") + strlen("odex") + 1 > PKG_PATH_MAX) {

      ALOGE("apk_path '%s' may be too long to form odex file path.\n", apk_path);

      return false;

    }



    strcpy(path, apk_path);

    char *end = strrchr(path, '/');

    if (end == NULL) {

      ALOGE("apk_path '%s' has no '/'s in it?!\n", apk_path);

      return false;

    }

    const char *apk_end = apk_path + (end - path); // strrchr(apk_path, '/');



    strcpy(end + 1, "oat/");       // path = /system/framework/oat/\0

    strcat(path, instruction_set); // path = /system/framework/oat/<isa>\0

    strcat(path, apk_end);         // path = /system/framework/oat/<isa>/whatever.jar\0

    end = strrchr(path, '.');

    if (end == NULL) {

      ALOGE("apk_path '%s' has no extension.\n", apk_path);

      return false;

    }

    strcpy(end + 1, "odex");

    return true;

}



static void SetDex2OatAndPatchOatScheduling(bool set_to_bg) {

    if (set_to_bg) {

        if (set_sched_policy(0, SP_BACKGROUND) < 0) {
@@ -1051,11 +956,11 @@ int dexopt(const char *apk_path, uid_t uid, const char *pkgname, const char *ins 
            ALOGE("invalid oat_dir '%s'\n", oat_dir);

            return -1;

        }

        if (calculate_oat_file_path(out_path, oat_dir, apk_path, instruction_set)) {

        if (!calculate_oat_file_path(out_path, oat_dir, apk_path, instruction_set)) {

            return -1;

        }

    } else {

        if (create_cache_path(out_path, apk_path, instruction_set)) {

        if (!create_cache_path(out_path, apk_path, instruction_set)) {

            return -1;

        }

    }
@@ -1212,7 +1117,11 @@ fail: 
int mark_boot_complete(const char* instruction_set)

{

  char boot_marker_path[PKG_PATH_MAX];

  sprintf(boot_marker_path,"%s%s/.booting", DALVIK_CACHE_PREFIX, instruction_set);

  sprintf(boot_marker_path,

          "%s/%s/%s/.booting",

          android_data_dir.path,

          DALVIK_CACHE,

          instruction_set);



  ALOGV("mark_boot_complete : %s", boot_marker_path);

  if (unlink(boot_marker_path) != 0) {
@@ -1750,29 +1659,5 @@ int link_file(const char* relative_path, const char* from_base, const char* to_b 
    return 0;

}



int calculate_oat_file_path(char path[PKG_PATH_MAX], const char *oat_dir, const char *apk_path,

        const char *instruction_set) {

    char *file_name_start;

    char *file_name_end;



    file_name_start = strrchr(apk_path, '/');

    if (file_name_start == NULL) {

         ALOGE("apk_path '%s' has no '/'s in it\n", apk_path);

        return -1;

    }

    file_name_end = strrchr(apk_path, '.');

    if (file_name_end < file_name_start) {

        ALOGE("apk_path '%s' has no extension\n", apk_path);

        return -1;

    }



    // Calculate file_name

    int file_name_len = file_name_end - file_name_start - 1;

    char file_name[file_name_len + 1];

    memcpy(file_name, file_name_start + 1, file_name_len);

    file_name[file_name_len] = '\0';



    // <apk_parent_dir>/oat/<isa>/<file_name>.odex

    snprintf(path, PKG_PATH_MAX, "%s/%s/%s.odex", oat_dir, instruction_set, file_name);

    return 0;

}
 
}  // namespace installd

}  // namespace android

cmds/installd/commands.h

0 → 100644
+70 −0
Original line number Diff line number Diff line 
/*

**

** Copyright 2008, The Android Open Source Project

**

** Licensed under the Apache License, Version 2.0 (the "License"); 

** you may not use this file except in compliance with the License. 

** You may obtain a copy of the License at 

**

**     http://www.apache.org/licenses/LICENSE-2.0 

**

** Unless required by applicable law or agreed to in writing, software 

** distributed under the License is distributed on an "AS IS" BASIS, 

** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 

** See the License for the specific language governing permissions and 

** limitations under the License.

*/



#ifndef COMMANDS_H_

#define COMMANDS_H_



#include <inttypes.h>

#include <unistd.h>



#include <cutils/multiuser.h>



#include <installd_constants.h>



namespace android {

namespace installd {



int install(const char *uuid, const char *pkgname, uid_t uid, gid_t gid, const char *seinfo);

int uninstall(const char *uuid, const char *pkgname, userid_t userid);

int renamepkg(const char *oldpkgname, const char *newpkgname);

int fix_uid(const char *uuid, const char *pkgname, uid_t uid, gid_t gid);

int delete_user_data(const char *uuid, const char *pkgname, userid_t userid);

int make_user_data(const char *uuid, const char *pkgname, uid_t uid,

        userid_t userid, const char* seinfo);

int copy_complete_app(const char* from_uuid, const char *to_uuid,

        const char *package_name, const char *data_app_name, appid_t appid,

        const char* seinfo);

int make_user_config(userid_t userid);

int delete_user(const char *uuid, userid_t userid);

int delete_cache(const char *uuid, const char *pkgname, userid_t userid);

int delete_code_cache(const char *uuid, const char *pkgname, userid_t userid);

int move_dex(const char *src, const char *dst, const char *instruction_set);

int rm_dex(const char *path, const char *instruction_set);

int protect(char *pkgname, gid_t gid);

int get_size(const char *uuid, const char *pkgname, int userid,

        const char *apkpath, const char *libdirpath,

        const char *fwdlock_apkpath, const char *asecpath,

        const char *instruction_set, int64_t *codesize, int64_t *datasize,

        int64_t *cachesize, int64_t *asecsize);

int free_cache(const char *uuid, int64_t free_size);

int dexopt(const char *apk_path, uid_t uid, const char *pkgName, const char *instruction_set,

           int dexopt_needed, const char* oat_dir, int dexopt_flags);

int mark_boot_complete(const char *instruction_set);

int movefiles();

int linklib(const char* uuid, const char* pkgname, const char* asecLibDir, int userId);

int idmap(const char *target_path, const char *overlay_path, uid_t uid);

int restorecon_data(const char *uuid, const char* pkgName, const char* seinfo, uid_t uid);

int create_oat_dir(const char* oat_dir, const char *instruction_set);

int rm_package_dir(const char* apk_path);

int move_package_dir(char path[PKG_PATH_MAX], const char *oat_dir, const char *apk_path,

                            const char *instruction_set);

int link_file(const char *relative_path, const char *from_base, const char *to_base);



}  // namespace installd

}  // namespace android



#endif  // COMMANDS_H_

cmds/installd/globals.cpp

0 → 100644
+132 −0
Original line number Diff line number Diff line 
/*

** Copyright 2015, The Android Open Source Project

**

** Licensed under the Apache License, Version 2.0 (the "License");

** you may not use this file except in compliance with the License.

** You may obtain a copy of the License at

**

**     http://www.apache.org/licenses/LICENSE-2.0

**

** Unless required by applicable law or agreed to in writing, software

** distributed under the License is distributed on an "AS IS" BASIS,

** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

** See the License for the specific language governing permissions and

** limitations under the License.

*/



#include <stdlib.h>

#include <string.h>



#include <cutils/log.h>               // TODO: Move everything to base::logging.



#include <globals.h>

#include <installd_constants.h>

#include <utils.h>



#ifndef LOG_TAG

#define LOG_TAG "installd"

#endif



namespace android {

namespace installd {



/* Directory records that are used in execution of commands. */

dir_rec_t android_app_dir;

dir_rec_t android_app_ephemeral_dir;

dir_rec_t android_app_lib_dir;

dir_rec_t android_app_private_dir;

dir_rec_t android_asec_dir;

dir_rec_t android_data_dir;

dir_rec_t android_media_dir;

dir_rec_t android_mnt_expand_dir;



dir_rec_array_t android_system_dirs;



/**

 * Initialize all the global variables that are used elsewhere. Returns 0 upon

 * success and -1 on error.

 */

void free_globals() {

    size_t i;



    for (i = 0; i < android_system_dirs.count; i++) {

        if (android_system_dirs.dirs[i].path != NULL) {

            free(android_system_dirs.dirs[i].path);

        }

    }



    free(android_system_dirs.dirs);

}



bool init_globals_from_data_and_root(const char* data, const char* root) {

    // Get the android data directory.

    if (get_path_from_string(&android_data_dir, data) < 0) {

        return false;

    }



    // Get the android app directory.

    if (copy_and_append(&android_app_dir, &android_data_dir, APP_SUBDIR) < 0) {

        return false;

    }



    // Get the android protected app directory.

    if (copy_and_append(&android_app_private_dir, &android_data_dir, PRIVATE_APP_SUBDIR) < 0) {

        return false;

    }



    // Get the android ephemeral app directory.

    if (copy_and_append(&android_app_ephemeral_dir, &android_data_dir, EPHEMERAL_APP_SUBDIR) < 0) {

        return -1;

    }



    // Get the android app native library directory.

    if (copy_and_append(&android_app_lib_dir, &android_data_dir, APP_LIB_SUBDIR) < 0) {

        return false;

    }



    // Get the sd-card ASEC mount point.

    if (get_path_from_env(&android_asec_dir, "ASEC_MOUNTPOINT") < 0) {

        return false;

    }



    // Get the android media directory.

    if (copy_and_append(&android_media_dir, &android_data_dir, MEDIA_SUBDIR) < 0) {

        return false;

    }



    // Get the android external app directory.

    if (get_path_from_string(&android_mnt_expand_dir, "/mnt/expand/") < 0) {

        return false;

    }



    // Take note of the system and vendor directories.

    android_system_dirs.count = 4;



    android_system_dirs.dirs = (dir_rec_t*) calloc(android_system_dirs.count, sizeof(dir_rec_t));

    if (android_system_dirs.dirs == NULL) {

        ALOGE("Couldn't allocate array for dirs; aborting\n");

        return false;

    }



    dir_rec_t android_root_dir;

    if (get_path_from_string(&android_root_dir, root) < 0) {

        return false;

    }



    android_system_dirs.dirs[0].path = build_string2(android_root_dir.path, APP_SUBDIR);

    android_system_dirs.dirs[0].len = strlen(android_system_dirs.dirs[0].path);



    android_system_dirs.dirs[1].path = build_string2(android_root_dir.path, PRIV_APP_SUBDIR);

    android_system_dirs.dirs[1].len = strlen(android_system_dirs.dirs[1].path);



    android_system_dirs.dirs[2].path = strdup("/vendor/app/");

    android_system_dirs.dirs[2].len = strlen(android_system_dirs.dirs[2].path);



    android_system_dirs.dirs[3].path = strdup("/oem/app/");

    android_system_dirs.dirs[3].len = strlen(android_system_dirs.dirs[3].path);



    return true;

}



}  // namespace installd

}  // namespace android

cmds/installd/globals.h

0 → 100644
+55 −0
Original line number Diff line number Diff line 
/*

**

** Copyright 2008, The Android Open Source Project

**

** Licensed under the Apache License, Version 2.0 (the "License");

** you may not use this file except in compliance with the License.

** You may obtain a copy of the License at

**

**     http://www.apache.org/licenses/LICENSE-2.0

**

** Unless required by applicable law or agreed to in writing, software

** distributed under the License is distributed on an "AS IS" BASIS,

** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

** See the License for the specific language governing permissions and

** limitations under the License.

*/



#ifndef GLOBALS_H_

#define GLOBALS_H_



#include <inttypes.h>



namespace android {

namespace installd {



/* data structures */



struct dir_rec_t {

    char* path;

    size_t len;

};



struct dir_rec_array_t {

    size_t count;

    dir_rec_t* dirs;

};



extern dir_rec_t android_app_dir;

extern dir_rec_t android_app_ephemeral_dir;

extern dir_rec_t android_app_lib_dir;

extern dir_rec_t android_app_private_dir;

extern dir_rec_t android_asec_dir;

extern dir_rec_t android_data_dir;

extern dir_rec_t android_media_dir;

extern dir_rec_t android_mnt_expand_dir;



extern dir_rec_array_t android_system_dirs;



void free_globals();

bool init_globals_from_data_and_root(const char* data, const char* root);



}  // namespace installd

}  // namespace android



#endif  // GLOBALS_H_