在Android系统中，PackageManagerService用于管理系统中的所有安装包信息及应用程序的安装卸载，但是应用程序的安装与卸载并非PackageManagerService来完成，而是通过PackageManagerService来访问installd服务来执行程序包的安装与卸载的。
PackageManagerService通过套接字的方式访问installd服务进程，在Android启动脚本init.rc中通过服务配置启动了installd服务进程。
通过以上配置，init进程就会启动installd服务进程了。installd源码位于frameworks/base/cmds/installd
installd服务进程的入口函数：
int main(const int argc, const char *argv[]) {
char buf[BUFFER_MAX];
struct sockaddr addr;
socklen_t alen;
int lsocket, s, count;
//初始化一些全局变量
if (initialize_globals() < 0) {
ALOGE("Could not initialize globals; exiting.\n");
exit(1);
}
//初始化安装目录
if (initialize_directories() < 0) {
ALOGE("Could not create directories; exiting.\n");
exit(1);
}
//取得installd套接字的句柄，系统中的所有socket以ANDROID_SOCKET_[name]为键，socket句柄为值的方式保存在//环境变量中
lsocket = android_get_control_socket(SOCKET_PATH);
if (lsocket < 0) {
ALOGE("Failed to get socket from environment: %s\n", strerror(errno));
exit(1);
}
//监听该socket
if (listen(lsocket, 5)) {
ALOGE("Listen on socket failed: %s\n", strerror(errno));
exit(1);
}
//修改该socket的属性
fcntl(lsocket, F_SETFD, FD_CLOEXEC);
for (;;) {
alen = sizeof(addr);
//循环等待接收客户端的请求
s = accept(lsocket, &addr, &alen);
if (s < 0) {
ALOGE("Accept failed: %s\n", strerror(errno));
continue;
}
//接收到客户端的请求后，修改客户端请求socket属性
fcntl(s, F_SETFD, FD_CLOEXEC);
ALOGI("new connection\n");
//循环读取客户端socket中的内容，直到读取内容为空为止
//客户端发送的数据格式：| 数据长度 | 数据内容 |
for (;;) {
unsigned short count;
//读取数据长度，读取成功返回0，反之返回-1
if (readx(s, &count, sizeof(count))) {
ALOGE("failed to read size\n");
break;
}
//如果读取成功，但是读取的数据长度超出1024字节，同样停止读取
if ((count < 1) || (count >= BUFFER_MAX)) {
ALOGE("invalid size %d\n", count);
break;
}
//读取数据内容，读取成功返回0，反之返回-1
if (readx(s, buf, count)) {
ALOGE("failed to read command\n");
break;
}
buf[count] = 0;
//执行客户端发送过来的命令
if (execute(s, buf)) break;
}
//执行完客户端的请求后，关闭该socket连接，继续进入接收请求模式
ALOGI("closing connection\n");
close(s);
}
return 0;
}该函数首先初始化一些变量就安装目录，然后从环境变量中取得installd套件字的句柄值，然后进入监听此socket，当客户端发送过来请求时，接收客户端的请求，并读取客户端发送过来的命令数据，并根据读取的客户端命令来执行命令操作。
1）变量初始化
int initialize_globals() {
//从环境变量中读取数据存储目录，在Android启动脚本init.rc中配置了ANDROID_DATA
//环境变量，export ANDROID_DATA /data ，因此变量android_data_dir=/data/
if (get_path_from_env(&android_data_dir, "ANDROID_DATA") < 0) {
return -1;
}
// 得到应用程序安装目录android_app_dir=/data/app/
if (copy_and_append(&android_app_dir, &android_data_dir, APP_SUBDIR) < 0) {
return -1;
}
//得到应用程序私有目录android_app_private_dir=/data/app-private/
if (copy_and_append(&android_app_private_dir, &android_data_dir, PRIVATE_APP_SUBDIR) < 0) {
return -1;
}
//从环境变量中取得sd-card ASEC的挂载点，在启动脚本init.rc中也有配置：export ASEC_MOUNTPOINT /mnt/asec
//因此android_asec_dir=/mnt/asec/
if (get_path_from_env(&android_asec_dir, "ASEC_MOUNTPOINT") < 0) {
return -1;
}
//定义android_system_dirs变量并分配存储空间
android_system_dirs.count = 2;
android_system_dirs.dirs = 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 -1;
}
//从环境变量中取得android根目录，在启动脚本init.rc中也有配置：export ANDROID_ROOT /system
// 因此android_system_dirs.dirs[0]=/system/
if (get_path_from_env(&android_system_dirs.dirs[0], "ANDROID_ROOT") < 0) {
free_globals();
return -1;
}
//android_system_dirs.dirs[0]=/system/app/
char *system_app_path = build_string2(android_system_dirs.dirs[0].path, APP_SUBDIR);
android_system_dirs.dirs[0].path = system_app_path;
android_system_dirs.dirs[0].len = strlen(system_app_path);
android_app_preload_dir.path = "/system/preloadapp/";
android_app_preload_dir.len = strlen(android_app_preload_dir.path);
android_system_dirs.dirs[1].path = "/vendor/app/";
android_system_dirs.dirs[1].len = strlen(android_system_dirs.dirs[1].path);
return 0;
}2）初始化目录
int initialize_directories() {
// user_data_dir=/data/user
char *user_data_dir = build_string2(android_data_dir.path, SECONDARY_USER_PREFIX);
// legacy_data_dir=/data/data
char *legacy_data_dir = build_string2(android_data_dir.path, PRIMARY_USER_PREFIX);
// primary_data_dir=/data/user/0
char *primary_data_dir = build_string3(android_data_dir.path, SECONDARY_USER_PREFIX,
"0");
int ret = -1;
if (user_data_dir != NULL && primary_data_dir != NULL && legacy_data_dir != NULL) {
ret = 0;
//如果/data/user目录不存在，则创建该目录
if (access(user_data_dir, R_OK) < 0) {
if (mkdir(user_data_dir, 0711) < 0) {
return -1;
}
//修改目录权限及所有属性
if (chown(user_data_dir, AID_SYSTEM, AID_SYSTEM) < 0) {
return -1;
}
if (chmod(user_data_dir, 0711) < 0) {
return -1;
}
}
// Make the /data/user/0 symlink to /data/data if necessary
if (access(primary_data_dir, R_OK) < 0) {
ret = symlink(legacy_data_dir, primary_data_dir);
}
free(user_data_dir);
free(legacy_data_dir);
free(primary_data_dir);
}
return ret;
}3）执行客户发送过来的请求命令
static int execute(int s, char cmd[BUFFER_MAX])
{
//#define BUFFER_MAX 1024 /* input buffer for commands */
char reply[REPLY_MAX]; //#define REPLY_MAX 256 /* largest reply allowed */
char *arg[TOKEN_MAX+1];//#define TOKEN_MAX 8 /* 命令参数最多8个 */
unsigned i;
unsigned n = 0;
unsigned short count;
int ret = -1;
reply[0] = 0;
//arg[0]为命令名称，命令格式：[name arg1 arg2 arg3 arg4]
arg[0] = cmd;
//计算命令参数个数
while (*cmd) {
if (isspace(*cmd)) {
*cmd++ = 0;
n++;
arg[n] = cmd;
if (n == TOKEN_MAX) {
ALOGE("too many arguments\n");
goto done;
}
}
cmd++;
}
//根据命令名称匹配命令数组cmds中的命令
for (i = 0; i < sizeof(cmds) / sizeof(cmds[0]); i++) {
//命令名称比较
if (!strcmp(cmds[i].name,arg[0])) {
//判断该命令的参数个数是否满足要求
if (n != cmds[i].numargs) {
ALOGE("%s requires %d arguments (%d given)\n",cmds[i].name, cmds[i].numargs, n);
} else {
//调用命令执行函数，执行命令
ret = cmds[i].func(arg + 1, reply);
}
goto done;
}
}
ALOGE("unsupported command '%s'\n", arg[0]);
done:
//格式化返回结果
if (reply[0]) {
n = snprintf(cmd, BUFFER_MAX, "%d %s", ret, reply);
} else {
n = snprintf(cmd, BUFFER_MAX, "%d", ret);
}
if (n > BUFFER_MAX) n = BUFFER_MAX;
//返回结果数据长度
count = n;
//写结果数据长度
if (writex(s, &count, sizeof(count))) return -1;
//写结果数据
if (writex(s, cmd, count)) return -1;
return 0;
}4）installd服务可执行的命令
struct cmdinfo cmds[] = {
// { 命令名称， 参数个数，命令执行函数}
{ "ping", 0, do_ping },
{ "install", 3, do_install },
{ "dexopt", 3, do_dexopt },
{ "movedex", 2, do_move_dex },
{ "rmdex", 1, do_rm_dex },
{ "remove", 2, do_remove },
{ "rename", 2, do_rename },
{ "fixuid", 3, do_fixuid },
{ "freecache", 1, do_free_cache },
{ "rmcache", 1, do_rm_cache },
{ "protect", 2, do_protect },
{ "getsize", 4, do_get_size },
{ "rmuserdata", 2, do_rm_user_data },
{ "movefiles", 0, do_movefiles },
{ "linklib", 2, do_linklib },
{ "unlinklib", 1, do_unlinklib },
{ "mkuserdata", 3, do_mk_user_data },
{ "rmuser", 1, do_rm_user },
{ "cloneuserdata", 3, do_clone_user_data },
};5）应用程序安装
static int do_install(char **arg, char reply[REPLY_MAX])
{
return install(arg[0], atoi(arg[1]), atoi(arg[2])); /* pkgname, uid, gid */
}直接调用frameworks\base\cmds\installd\commands.c中的install函数来安装
int install(const char *pkgname, uid_t uid, gid_t gid)
{
char pkgdir[PKG_PATH_MAX];//程序目录路径最长为256
char libdir[PKG_PATH_MAX];//程序lib路径最长为256
//权限判断
if ((uid < AID_SYSTEM) || (gid < AID_SYSTEM)) {
ALOGE("invalid uid/gid: %d %d\n", uid, gid);
return -1;
}
//组合应用程序安装目录pkgdir=/data/data/应用程序包名
if (create_pkg_path(pkgdir, pkgname, PKG_DIR_POSTFIX, 0)) {
ALOGE("cannot create package path\n");
return -1;
}
//组合应用程序库目录libdir=/data/data/应用程序包名/lib
if (create_pkg_path(libdir, pkgname, PKG_LIB_POSTFIX, 0)) {
ALOGE("cannot create package lib path\n");
return -1;
}
//创建目录pkgdir=/data/data/应用程序包名
if (mkdir(pkgdir, 0751) < 0) {
ALOGE("cannot create dir '%s': %s\n", pkgdir, strerror(errno));
return -errno;
}
//修改/data/data/应用程序包名目录的权限
if (chmod(pkgdir, 0751) < 0) {
ALOGE("cannot chmod dir '%s': %s\n", pkgdir, strerror(errno));
unlink(pkgdir);
return -errno;
}
//创建目录libdir=/data/data/应用程序包名/lib
if (mkdir(libdir, 0755) < 0) {
ALOGE("cannot create dir '%s': %s\n", libdir, strerror(errno));
unlink(pkgdir);
return -errno;
}
//修改/data/data/应用程序包名/lib目录的权限
if (chmod(libdir, 0755) < 0) {
ALOGE("cannot chmod dir '%s': %s\n", libdir, strerror(errno));
unlink(libdir);
unlink(pkgdir);
return -errno;
}
//修改/data/data/应用程序包名目录的所有权限
if (chown(libdir, AID_SYSTEM, AID_SYSTEM) < 0) {
ALOGE("cannot chown dir '%s': %s\n", libdir, strerror(errno));
unlink(libdir);
unlink(pkgdir);
return -errno;
}
//修改/data/data/应用程序包名/lib目录的所有权限
if (chown(pkgdir, uid, gid) < 0) {
ALOGE("cannot chown dir '%s': %s\n", pkgdir, strerror(errno));
unlink(libdir);
unlink(pkgdir);
return -errno;
}
return 0;
}组合应用程序安装目录路径：
int create_pkg_path(char path[PKG_PATH_MAX],
const char *pkgname,
const char *postfix,
uid_t persona)
{
size_t uid_len;
char* persona_prefix;
//postfix=""
//persona=0
if (persona == 0) {
persona_prefix = PRIMARY_USER_PREFIX;// "data/"
uid_len = 0;
} else {
persona_prefix = SECONDARY_USER_PREFIX;// "user/"
uid_len = snprintf(NULL, 0, "%d", persona);
}
// /data/data/
const size_t prefix_len = android_data_dir.len + strlen(persona_prefix) + uid_len + 1 /*slash*/;
char prefix[prefix_len + 1];
char *dst = prefix;
size_t dst_size = sizeof(prefix);
//dst=/data/data/
if (append_and_increment(&dst, android_data_dir.path, &dst_size) < 0
|| append_and_increment(&dst, persona_prefix, &dst_size) < 0) {
ALOGE("Error building prefix for APK path");
return -1;
}
if (persona != 0) {
int ret = snprintf(dst, dst_size, "%d/", persona);
if (ret < 0 || (size_t) ret != uid_len + 1) {
ALOGW("Error appending UID to APK path");
return -1;
}
}
dir_rec_t dir; //设置安装目录，由于uid为0，因此安装目录为/data/data/
dir.path = prefix;
dir.len = prefix_len;
return create_pkg_path_in_dir(path, &dir, pkgname, postfix);
}
int create_pkg_path_in_dir(char path[PKG_PATH_MAX],
const dir_rec_t* dir,
const char* pkgname,
const char* postfix)
{
const size_t postfix_len = strlen(postfix); //postfix_len= 0
const size_t pkgname_len = strlen(pkgname);
//apk包名最长不允许超过128个字符
if (pkgname_len > PKG_NAME_MAX) {
return -1;
}
//检查包名命名是否规范
if (is_valid_package_name(pkgname) < 0) {
return -1;
}
//检查包名和目录路径长度是否超过256个字符
if ((pkgname_len + dir->len + postfix_len) >= PKG_PATH_MAX) {
return -1;
}
char *dst = path;
size_t dst_size = PKG_PATH_MAX;
//最终的安装目录为/data/data/应用程序包名/postfix
if (append_and_increment(&dst, dir->path, &dst_size) < 0
|| append_and_increment(&dst, pkgname, &dst_size) < 0
|| append_and_increment(&dst, postfix, &dst_size) < 0) {
ALOGE("Error building APK path");
return -1;
}
return 0;
}6）应用程序卸载
应用程序卸载过程其实就是删除应用程序安装文件
static int do_remove(char **arg, char reply[REPLY_MAX])
{
return uninstall(arg[0], atoi(arg[1])); /* pkgname, userid */
}
int uninstall(const char *pkgname, uid_t persona)
{
char pkgdir[PKG_PATH_MAX];
//根据包名得到应用程序安装目录路径
if (create_pkg_path(pkgdir, pkgname, PKG_DIR_POSTFIX, persona))
return -1;
/*删除安装目录及目录下的文件 */
return delete_dir_contents(pkgdir, 1, NULL);
}
int delete_dir_contents(const char *pathname,
int also_delete_dir,
const char *ignore)
{
int res = 0;
DIR *d;
//打开应用程序安装目录
d = opendir(pathname);
if (d == NULL) {
ALOGE("Couldn't opendir %s: %s\n", pathname, strerror(errno));
return -errno;
}
//删除安装目录下的文件
res = _delete_dir_contents(d, ignore);
closedir(d);
//删除安装目录
if (also_delete_dir) {
if (rmdir(pathname)) {
ALOGE("Couldn't rmdir %s: %s\n", pathname, strerror(errno));
res = -1;
}
}
return res;
}7）应用程序安装包优化过程
static int do_dexopt(char **arg, char reply[REPLY_MAX])
{
return dexopt(arg[0], atoi(arg[1]), atoi(arg[2])); /* apk_path, uid, is_public */
}直接调用dexopt函数来执行apk文件优化
int dexopt(const char *apk_path, uid_t uid, int is_public)
{
//例如：apk_path=system/app/Music.apk
struct utimbuf ut;
struct stat apk_stat, dex_stat;
char dex_path[PKG_PATH_MAX];//PKG_PATH_MAX=256
char dexopt_flags[PROPERTY_VALUE_MAX];//PKG_PATH_MAX=92
char *end;
int res, zip_fd=-1, odex_fd=-1;
if (strlen(apk_path) >= (PKG_PATH_MAX - 8)) {
return -1;
}
//读取安装包优化标志位
property_get("dalvik.vm.dexopt-flags", dexopt_flags, "");
//dex_path=system/app/Music.apk
strcpy(dex_path, apk_path);
//判断dex_path的后缀
end = strrchr(dex_path, '.');
if (end != NULL) {
strcpy(end, ".odex");
if (stat(dex_path, &dex_stat) == 0) {
return 0;
}
}
//dex_path=/data/dalvik-cache/[system@app@Music.apk]@classes.dex
if (create_cache_path(dex_path, apk_path)) {
return -1;
}
memset(&apk_stat, 0, sizeof(apk_stat));
//获取apk文件信息
stat(apk_path, &apk_stat);
//以只读方式打开apk文件
zip_fd = open(apk_path, O_RDONLY, 0);
if (zip_fd < 0) {
ALOGE("dexopt cannot open '%s' for input\n", apk_path);
return -1;
}
//删除dex文件
unlink(dex_path);
//打开dex文件，如果文件不存在，则自动创建该文件
odex_fd = open(dex_path, O_RDWR | O_CREAT | O_EXCL, 0644);
if (odex_fd < 0) {
ALOGE("dexopt cannot open '%s' for output\n", dex_path);
goto fail;
}
//修改dex文件的所有者属性
if (fchown(odex_fd, AID_SYSTEM, uid) < 0) {
ALOGE("dexopt cannot chown '%s'\n", dex_path);
goto fail;
}
//修改dex文件的权限
if (fchmod(odex_fd,
S_IRUSR|S_IWUSR|S_IRGRP |
(is_public ? S_IROTH : 0)) < 0) {
ALOGE("dexopt cannot chmod '%s'\n", dex_path);
goto fail;
}
ALOGV("DexInv: --- BEGIN '%s' ---\n", apk_path);
pid_t pid;
//创建一个线程来执行apk优化
pid = fork();
if (pid == 0) {
if (setgid(uid) != 0) {
ALOGE("setgid(%d) failed during dexopt\n", uid);
exit(64);
}
if (setuid(uid) != 0) {
ALOGE("setuid(%d) during dexopt\n", uid);
exit(65);
}
if (flock(odex_fd, LOCK_EX | LOCK_NB) != 0) {
ALOGE("flock(%s) failed: %s\n", dex_path, strerror(errno));
exit(66);
}
//优化apk包文件，zip_fd为apk文件句柄，odex_fd为dex文件句柄，dexopt_flags为优化标志位
run_dexopt(zip_fd, odex_fd, apk_path, dexopt_flags);
exit(67); /* only get here on exec failure */
} else {
res = wait_dexopt(pid, apk_path);
if (res != 0) {
ALOGE("dexopt failed on '%s' res = %d\n", dex_path, res);
goto fail;
}
}
ut.actime = apk_stat.st_atime;
ut.modtime = apk_stat.st_mtime;
utime(dex_path, &ut);
close(odex_fd);
close(zip_fd);
return 0;
fail:
if (odex_fd >= 0) {
close(odex_fd);
unlink(dex_path);
}
if (zip_fd >= 0) {
close(zip_fd);
}
return -1;
}创建了一个新的线程来执行安装包优化任务
static void run_dexopt(int zip_fd, int odex_fd, const char* input_file_name,
const char* dexopt_flags)
{
//input_file_name为apk的路径
static const char* DEX_OPT_BIN = "/system/bin/dexopt";
static const int MAX_INT_LEN = 12;
char zip_num[MAX_INT_LEN];
char odex_num[MAX_INT_LEN];
sprintf(zip_num, "%d", zip_fd);//apk文件句柄
sprintf(odex_num, "%d", odex_fd);//dex文件句柄
//调用/system/bin/dexopt工具来优化apk文件
execl(DEX_OPT_BIN, DEX_OPT_BIN, "--zip", zip_num, odex_num, input_file_name,
dexopt_flags, (char*) NULL);
ALOGE("execl(%s) failed: %s\n", DEX_OPT_BIN, strerror(errno));
}整个优化过程是通过system目录下的dexopt工具来完成的。这里直接使用该工具来完成apk优化。优化后的dex文件位于/data/dalvik-cache/目录下：
