From: Sangyoon Jang Date: Thu, 20 Aug 2015 05:55:51 +0000 (+0900) Subject: Fix pkg_getsize.c X-Git-Tag: accepted/tizen/mobile/20150824.134503~2 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=5450fce07e1991a64d2a20721adf9d14dd8cc6c2;p=platform%2Fcore%2Fappfw%2Fslp-pkgmgr.git Fix pkg_getsize.c add comments on getsize_type enums revise pkg_getsize.c add req_key when launch pkg_getsize Change-Id: I7be4db21449f15c80ec7e104d328b4389c56c093 Signed-off-by: Sangyoon Jang --- diff --git a/client/include/package-manager.h b/client/include/package-manager.h index f2843d7..6d756b0 100644 --- a/client/include/package-manager.h +++ b/client/include/package-manager.h @@ -251,12 +251,21 @@ typedef enum { }pkgmgr_request_service_type; typedef enum { + /* sync, get data, total size for one requested pkgid */ PM_GET_TOTAL_SIZE = 0, PM_GET_DATA_SIZE = 1, + + /* async, get total used storage size */ PM_GET_ALL_PKGS = 2, + + /* async, get a pkgid's data, total size for all installed pkg */ PM_GET_SIZE_INFO = 3, + + /* deprecated */ PM_GET_TOTAL_AND_DATA = 4, PM_GET_SIZE_FILE = 5, + + /* async, get data, cache, app size based on "pkg_size_info_t" */ PM_GET_PKG_SIZE_INFO = 6, PM_GET_TOTAL_PKG_SIZE_INFO = 7, PM_GET_MAX diff --git a/client/src/pkgmgr.c b/client/src/pkgmgr.c index 40f9839..4c466cc 100644 --- a/client/src/pkgmgr.c +++ b/client/src/pkgmgr.c @@ -832,6 +832,7 @@ static int __get_size_process(pkgmgr_client * pc, const char *pkgid, uid_t uid, snprintf(buf, 128, "%d", get_type); argv[argcnt++] = strdup(pkgid); argv[argcnt++] = strdup(buf); + argv[argcnt++] = strdup(req_key); /*** add quote in all string for special charactor like '\n'*** FIX */ for (i = 0; i < argcnt; i++) { diff --git a/tool/pkg_getsize.c b/tool/pkg_getsize.c index 6dce1ee..1ac4551 100644 --- a/tool/pkg_getsize.c +++ b/tool/pkg_getsize.c @@ -54,7 +54,9 @@ #define MAX_LONGLONG_LENGTH 32 #define MAX_SIZE_INFO_SIZE 128 -#define APP_BASE_INTERNAL_PATH tzplatform_getenv(TZ_USER_APP) +#define OWNER_ROOT 0 +#define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER) + #if 0 /* installed at external storage is not supported yet */ #define APP_BASE_EXTERNAL_PATH "" #endif @@ -82,61 +84,54 @@ static long long __calculate_directory_size(int dfd, bool include_itself) { long long size = 0; struct stat st; - int subfd = -1; - int res = 0; - - if (include_itself) - { - res = fstat(dfd, &st); - if (res < 0) - { - ERR("fstat() failed, entry: ., errno: %d (%s)", errno, strerror(errno)); + int subfd; + int ret; + DIR *dir; + struct dirent *dent; + const char *entry; + + if (include_itself) { + ret = fstat(dfd, &st); + if (ret < 0) { + ERR("fstat() failed, entry: ., errno: %d (%s)", errno, + strerror(errno)); return -1; } size += __stat_size(&st); } - DIR *dir = fdopendir(dfd); + dir = fdopendir(dfd); if (dir == NULL) { - ERR("fdopendir() failed, errno: %d (%s)", errno, strerror(errno)); + ERR("fdopendir() failed, errno: %d (%s)", errno, + strerror(errno)); return -1; } - struct dirent *dent = NULL; - while ((dent = readdir(dir))) - { - const char *entry = dent->d_name; - if (entry[0] == '.') - { + while ((dent = readdir(dir))) { + entry = dent->d_name; + if (entry[0] == '.') { if (entry[1] == '\0') - { continue; - } if ((entry[1] == '.') && (entry[2] == '\0')) - { continue; - } } - if (dent->d_type == DT_DIR) - { + if (dent->d_type == DT_DIR) { subfd = openat(dfd, entry, O_RDONLY | O_DIRECTORY); - if (subfd < 0) - { - ERR("openat() failed, entry: %s, errno: %d (%s)", entry, errno, strerror(errno)); + if (subfd < 0) { + ERR("openat() failed, entry:%s, errno: %d(%s)", + entry, errno, strerror(errno)); goto error; } DBG("traverse entry: %s", entry); size += __calculate_directory_size(subfd, true); close(subfd); - } - else - { - res = fstatat(dfd, entry, &st, AT_SYMLINK_NOFOLLOW); - if (res < 0) - { - ERR("fstatat() failed, entry: %s, errno: %d (%s)",entry, errno, strerror(errno)); + } else { + ret = fstatat(dfd, entry, &st, AT_SYMLINK_NOFOLLOW); + if (ret < 0) { + ERR("fstatat() failed, entry:%s, errno: %d(%s)", + entry, errno, strerror(errno)); goto error; } size += __stat_size(&st); @@ -151,36 +146,37 @@ error: return -1; } -static long long __calculate_shared_dir_size(int dfd, const char *app_root_dir, long long *data_size, long long *app_size) +static long long __calculate_shared_dir_size(int dfd, const char *app_root_dir, + long long *data_size, long long *app_size) { int fd = -1; int subfd = -1; long long size = 0; + struct stat st; + int ret; - DBG("traverse path: %sshared", app_root_dir); + DBG("traverse path: %s/shared", app_root_dir); fd = openat(dfd, "shared", O_RDONLY | O_DIRECTORY); - if (fd < 0) - { - ERR("openat() failed, path: %sshared, errno: %d (%s)", app_root_dir, errno, strerror(errno)); + if (fd < 0) { + ERR("openat() failed, path: %s/shared, errno: %d (%s)", + app_root_dir, errno, strerror(errno)); return -1; } - struct stat st; - int res = fstat(fd, &st); - if (res < 0) - { - ERR("fstat() failed, path: %sshared, errno: %d (%s)", app_root_dir, errno, strerror(errno)); + ret = fstat(fd, &st); + if (ret < 0) { + ERR("fstat() failed, path: %s/shared, errno: %d (%s)", + app_root_dir, errno, strerror(errno)); goto error; } *app_size += __stat_size(&st); // shared directory DBG("app_size: %lld", *app_size); - DBG("traverse path: %sshared/data", app_root_dir); + DBG("traverse path: %s/shared/data", app_root_dir); subfd = openat(fd, "data", O_RDONLY | O_DIRECTORY); - if (subfd >= 0) - { + if (subfd >= 0) { size = __calculate_directory_size(subfd, true); if (size < 0) { @@ -190,73 +186,63 @@ static long long __calculate_shared_dir_size(int dfd, const char *app_root_dir, *data_size += size; DBG("data_size: %lld", *data_size); close(subfd); - } - else if (subfd < 0 && errno != ENOENT) - { - ERR("openat() failed, entry: data, errno: %d (%s)", errno, strerror(errno)); + } else if (subfd < 0 && errno != ENOENT) { + ERR("openat() failed, entry: data, errno: %d (%s)", + errno, strerror(errno)); goto error; } - DBG("traverse path: %sshared/trusted", app_root_dir); + DBG("traverse path: %s/shared/trusted", app_root_dir); subfd = openat(fd, "trusted", O_RDONLY | O_DIRECTORY); - if (subfd >= 0) - { + if (subfd >= 0) { size = __calculate_directory_size(subfd, true); - if (size < 0) - { + if (size < 0) { ERR("Calculating shared/trusted directory failed."); goto error; } *data_size += size; DBG("data_size: %lld", *data_size); close(subfd); - } - else if (subfd < 0 && errno != ENOENT) - { - DBG("openat() failed, entry: trusted, errno: %d (%s)", errno, strerror(errno)); + } else if (subfd < 0 && errno != ENOENT) { + DBG("openat() failed, entry: trusted, errno: %d (%s)", + errno, strerror(errno)); goto error; } - DBG("traverse path: %sshared/res", app_root_dir); + DBG("traverse path: %s/shared/res", app_root_dir); subfd = openat(fd, "res", O_RDONLY | O_DIRECTORY); - if (subfd >= 0) - { + if (subfd >= 0) { size = __calculate_directory_size(subfd, true); - if (size < 0) - { + if (size < 0) { ERR("Calculating shared/res directory failed."); goto error; } *app_size += size; DBG("app_size: %lld", *app_size); close(subfd); - } - else if (subfd < 0 && errno != ENOENT) - { - ERR("openat() failed, entry: res, errno: %d (%s)", errno, strerror(errno)); + } else if (subfd < 0 && errno != ENOENT) { + ERR("openat() failed, entry: res, errno: %d (%s)", + errno, strerror(errno)); goto error; } - DBG("traverse path: %sshared/cache", app_root_dir); + DBG("traverse path: %s/shared/cache", app_root_dir); subfd = openat(fd, "cache", O_RDONLY | O_DIRECTORY); - if (subfd >= 0) - { + if (subfd >= 0) { size = __calculate_directory_size(subfd, true); - if (size < 0) - { + if (size < 0) { ERR("Calculating shared/cache directory failed."); goto error; } *data_size += size; DBG("data_size: %lld", *data_size); close(subfd); - } - else if (subfd < 0 && errno != ENOENT) - { - ERR("openat() failed, entry: data, errno: %d (%s)", errno, strerror(errno)); + } else if (subfd < 0 && errno != ENOENT) { + ERR("openat() failed, entry: data, errno: %d (%s)", + errno, strerror(errno)); goto error; } @@ -265,169 +251,164 @@ static long long __calculate_shared_dir_size(int dfd, const char *app_root_dir, error: if (fd != -1) - { close(fd); - } if (subfd != -1) - { close(subfd); - } return -1; } -static int __calculate_pkg_size_info(STORAGE_TYPE type, const char *pkgid, long long *data_size, long long *cache_size, long long *app_size) +static int __is_global(uid_t uid) { - char app_root_dir[MAX_PATH_LENGTH] = { 0, }; - if (type == STORAGE_TYPE_INTERNAL) - { - /* TODO: app directory should be fixed */ - snprintf(app_root_dir, MAX_PATH_LENGTH, "%s/%s/%s/", APP_BASE_INTERNAL_PATH, pkgid, pkgid); - } + return (uid == OWNER_ROOT || uid == GLOBAL_USER) ? 1 : 0; +} + +static int __calculate_pkg_size_info(STORAGE_TYPE type, const char *pkgid, + long long *data_size, long long *cache_size, + long long *app_size) +{ + uid_t uid = getuid(); + char app_root_dir[MAX_PATH_LENGTH] = {0, }; + DIR *dir; + int dfd; + int subfd = -1; + struct stat st; + int ret; + struct dirent *ent; + long long size = 0; + + if (type == STORAGE_TYPE_INTERNAL) { + if (!__is_global(uid)) + tzplatform_set_user(uid); + snprintf(app_root_dir, sizeof(app_root_dir), "%s", + tzplatform_mkpath(__is_global(uid) + ? TZ_SYS_RW_APP : TZ_USER_APP, pkgid)); + tzplatform_reset_user(); #if 0 /* installed at external storage is not supported yet */ - else if (type == STORAGE_TYPE_EXTERNAL) - { - snprintf(app_root_dir, MAX_PATH_LENGTH, "%s%s/", APP_BASE_EXTERNAL_PATH, pkgid); - } + } else if (type == STORAGE_TYPE_EXTERNAL) { + snprintf(app_root_dir, MAX_PATH_LENGTH, "%s%s/", + APP_BASE_EXTERNAL_PATH, pkgid); #endif - else - { + } else { ERR("Invalid STORAGE_TYPE"); return -1; } - DIR *dir = opendir(app_root_dir); - if (dir == NULL) - { - ERR("opendir() failed, path: %s, errno: %d (%s)", app_root_dir, errno, strerror(errno)); + dir = opendir(app_root_dir); + if (dir == NULL) { + ERR("opendir() failed, path: %s, errno: %d (%s)", + app_root_dir, errno, strerror(errno)); return -1; } - int dfd = dirfd(dir); - int subfd = -1; - struct stat st; - int res = fstat(dfd, &st); - if (res < 0) - { - ERR("fstat() failed, path: %s, errno: %d (%s)", app_root_dir, errno, strerror(errno)); + dfd = dirfd(dir); + ret = fstat(dfd, &st); + if (ret < 0) { + ERR("fstat() failed, path: %s, errno: %d (%s)", app_root_dir, + errno, strerror(errno)); goto error; } *app_size += __stat_size(&st); - struct dirent *ent = NULL; - long long size = 0; - while ((ent = readdir(dir))) - { + while ((ent = readdir(dir))) { const char *name = ent->d_name; - if (name[0] == '.') - { + if (name[0] == '.') { if (name[1] == '\0') - { continue; - } if ((name[1] == '.') && (name[2] == '\0')) - { continue; - } } - if (ent->d_type == DT_DIR) - { - subfd = openat(dfd, name, O_RDONLY | O_DIRECTORY); - if (subfd >= 0) - { - if (strncmp(name, "data", strlen("data")) == 0) - { - DBG("traverse path: %s%s", app_root_dir, name); - size = __calculate_directory_size(subfd, true); - if (size < 0) - { - ERR("Calculating data directory failed."); - goto error; - } - *data_size += size; - DBG("data_size: %lld", *data_size); - } - else if (strncmp(name, "cache", strlen("cache")) == 0) - { - DBG("traverse path: %s%s", app_root_dir, name); - size = __calculate_directory_size(subfd, true); - if (size < 0) - { - ERR("Calculating cache directory failed."); - goto error; - } - *cache_size += size; - DBG("cache_size: %lld", *cache_size); - } - else if (strncmp(name, "shared", strlen("shared")) == 0) - { - size = __calculate_shared_dir_size(dfd, app_root_dir, data_size, app_size); - if (size < 0) - { - ERR("Calculating shared directory failed."); - goto error; - } - *app_size += size; - DBG("app_size: %lld", *app_size); - } - else - { - DBG("traverse path: %s%s", app_root_dir, name); - size = __calculate_directory_size(subfd, true); - if (size < 0) - { - ERR("Calculating %s directory failed.", name); - goto error; - } - *app_size += size; - DBG("app_size: %lld", *app_size); - } + if (ent->d_type != DT_DIR) + continue; + + subfd = openat(dfd, name, O_RDONLY | O_DIRECTORY); + if (subfd < 0) { + if (errno != ENOENT) { + ERR("openat() failed, errno: %d (%s)", + errno, strerror(errno)); + goto error; } - else if (subfd < 0 && errno != ENOENT) - { - ERR("openat() failed, entry: res, errno: %d (%s)", errno, strerror(errno)); + continue; + } + if (strncmp(name, "data", strlen("data")) == 0) { + DBG("traverse path: %s/%s", app_root_dir, name); + size = __calculate_directory_size(subfd, true); + if (size < 0) { + ERR("Calculating data directory failed."); goto error; } - close(subfd); + *data_size += size; + DBG("data_size: %lld", *data_size); + } else if (strncmp(name, "cache", strlen("cache")) == 0) { + DBG("traverse path: %s/%s", app_root_dir, name); + size = __calculate_directory_size(subfd, true); + if (size < 0) { + ERR("Calculating cache directory failed."); + goto error; + } + *cache_size += size; + DBG("cache_size: %lld", *cache_size); + } else if (strncmp(name, "shared", strlen("shared")) == 0) { + size = __calculate_shared_dir_size(dfd, app_root_dir, + data_size, app_size); + if (size < 0) { + ERR("Calculating shared directory failed."); + goto error; + } + *app_size += size; + DBG("app_size: %lld", *app_size); + } else { + DBG("traverse path: %s/%s", app_root_dir, name); + size = __calculate_directory_size(subfd, true); + if (size < 0) { + ERR("Calculating %s directory failed.", name); + goto error; + } + *app_size += size; + DBG("app_size: %lld", *app_size); } + close(subfd); } closedir(dir); return 0; error: if (dir) - { closedir(dir); - } if (subfd != -1) - { close(subfd); - } return -1; } static char *__get_pkg_size_info_str(const pkg_size_info_t* pkg_size_info) { - char *size_info_str = (char *)malloc(MAX_SIZE_INFO_SIZE); - if (size_info_str == NULL) - { + char *size_info_str; + + size_info_str = (char *)malloc(MAX_SIZE_INFO_SIZE); + if (size_info_str == NULL) { ERR("Out of memory."); return NULL; } - snprintf(size_info_str, MAX_LONGLONG_LENGTH, "%lld", pkg_size_info->data_size); + snprintf(size_info_str, MAX_LONGLONG_LENGTH, "%lld", + pkg_size_info->data_size); strcat(size_info_str, ":"); - snprintf(size_info_str + strlen(size_info_str), MAX_LONGLONG_LENGTH, "%lld", pkg_size_info->cache_size); + snprintf(size_info_str + strlen(size_info_str), MAX_LONGLONG_LENGTH, + "%lld", pkg_size_info->cache_size); strcat(size_info_str, ":"); - snprintf(size_info_str + strlen(size_info_str), MAX_LONGLONG_LENGTH, "%lld", pkg_size_info->app_size); + snprintf(size_info_str + strlen(size_info_str), MAX_LONGLONG_LENGTH, + "%lld", pkg_size_info->app_size); strcat(size_info_str, ":"); - snprintf(size_info_str + strlen(size_info_str), MAX_LONGLONG_LENGTH, "%lld", pkg_size_info->ext_data_size); + snprintf(size_info_str + strlen(size_info_str), MAX_LONGLONG_LENGTH, + "%lld", pkg_size_info->ext_data_size); strcat(size_info_str, ":"); - snprintf(size_info_str + strlen(size_info_str), MAX_LONGLONG_LENGTH, "%lld", pkg_size_info->ext_cache_size); + snprintf(size_info_str + strlen(size_info_str), MAX_LONGLONG_LENGTH, + "%lld", pkg_size_info->ext_cache_size); strcat(size_info_str, ":"); - snprintf(size_info_str + strlen(size_info_str), MAX_LONGLONG_LENGTH, "%lld", pkg_size_info->ext_app_size); + snprintf(size_info_str + strlen(size_info_str), MAX_LONGLONG_LENGTH, + "%lld", pkg_size_info->ext_app_size); strcat(size_info_str, ":"); DBG("size_info_str: %s", size_info_str); @@ -435,35 +416,43 @@ static char *__get_pkg_size_info_str(const pkg_size_info_t* pkg_size_info) return size_info_str; } -static int __get_pkg_size_info(const char *pkgid, pkg_size_info_t* pkg_size_info) +static int __get_pkg_size_info(const char *pkgid, + pkg_size_info_t *pkg_size_info) { - int res = __calculate_pkg_size_info(STORAGE_TYPE_INTERNAL, pkgid, &pkg_size_info->data_size, &pkg_size_info->cache_size, &pkg_size_info->app_size); - if (res < 0) - { - DBG("Calculating internal package size info failed. res: %d", res); - } - DBG("size_info: %lld %lld %lld", pkg_size_info->data_size, pkg_size_info->cache_size, pkg_size_info->app_size); + int ret; + + ret = __calculate_pkg_size_info(STORAGE_TYPE_INTERNAL, pkgid, + &pkg_size_info->data_size, &pkg_size_info->cache_size, + &pkg_size_info->app_size); + if (ret < 0) + DBG("Calculating internal package size info failed: %d", ret); + DBG("size_info: %lld %lld %lld", pkg_size_info->data_size, + pkg_size_info->cache_size, pkg_size_info->app_size); #if 0 - res = __calculate_pkg_size_info(STORAGE_TYPE_EXTERNAL, pkgid, &pkg_size_info->ext_data_size, &pkg_size_info->ext_cache_size, &pkg_size_info->ext_app_size); - if (res < 0) - { - DBG("Calculating external package size info failed. res: %d", res); - } - DBG("size_info(external): %lld %lld %lld", pkg_size_info->ext_data_size, pkg_size_info->ext_cache_size, pkg_size_info->ext_app_size); + ret = __calculate_pkg_size_info(STORAGE_TYPE_EXTERNAL, pkgid, + &pkg_size_info->ext_data_size, + &pkg_size_info->ext_cache_size, + &pkg_size_info->ext_app_size); + if (ret < 0) + DBG("Calculating external package size info failed: %d", ret); + DBG("size_info(external): %lld %lld %lld", pkg_size_info->ext_data_size, + pkg_size_info->ext_cache_size, + pkg_size_info->ext_app_size); #endif - return res; + return ret; } -static int __get_total_pkg_size_info_cb(const pkgmgrinfo_pkginfo_h handle, void *user_data) +static int __get_total_pkg_size_info_cb(const pkgmgrinfo_pkginfo_h handle, + void *user_data) { - int ret = 0; + int ret; char *pkgid; pkg_size_info_t temp_pkg_size_info = {0,}; pkg_size_info_t *pkg_size_info = (void *)user_data; ret = pkgmgrinfo_pkginfo_get_pkgid(handle, &pkgid); - if(ret != PMINFO_R_OK) { + if (ret != PMINFO_R_OK) { ERR("pkgmgrinfo_pkginfo_get_pkgid() failed"); return -1; } @@ -480,250 +469,179 @@ static int __get_total_pkg_size_info_cb(const pkgmgrinfo_pkginfo_h handle, void return 0; } -static int __get_total_pkg_size_info(pkg_size_info_t* pkg_size_info) -{ - int res = pkgmgrinfo_pkginfo_get_list(__get_total_pkg_size_info_cb, pkg_size_info); - if (res != PMINFO_R_OK) - { - return -1; - } - return 0; -} - -static void __send_signal(const char *pkgid, int argc, char *argv[], char *size_info) -{ - pkgmgr_installer *pi = pkgmgr_installer_new(); - if (pi == NULL) - { - DBG("Creating the pkgmgr_installer instance failed."); - } - else - { - pkgmgr_installer_receive_request(pi, argc, argv); - pkgmgr_installer_send_signal(pi, PKGMGR_INSTALLER_GET_SIZE_KEY_STR, pkgid, "-1", size_info); - pkgmgr_installer_free(pi); - } -} - -static int __send_signal_for_pkg_size_info(const char *pkgid, int argc, char *argv[]) -{ - pkg_size_info_t pkg_size_info = {0,}; - __get_pkg_size_info(pkgid, &pkg_size_info); - char *size_info = __get_pkg_size_info_str(&pkg_size_info); - if (size_info == NULL) - { - return -1; - } - __send_signal(pkgid, argc, argv, size_info); - free(size_info); - return 0; -} - -static int __send_signal_for_total_pkg_size_info(int argc, char *argv[]) -{ - pkg_size_info_t pkg_size_info = {0,}; - __get_total_pkg_size_info(&pkg_size_info); - char *size_info = __get_pkg_size_info_str(&pkg_size_info); - if (size_info == NULL) - { - return -1; - } - __send_signal(PKG_SIZE_INFO_TOTAL, argc, argv, size_info); - free(size_info); - return 0; -} - -void __make_size_info_file(char *req_key, int size) +int __make_size_info_file(char *req_key, long long size) { - int ret = 0; - FILE* file = NULL; + FILE *file; int fd = 0; - char buf[MAX_PKG_BUF_LEN] = {0}; - const char* app_info_label = "*"; - char info_file[MAX_PKG_BUF_LEN] = {'\0', }; + char buf[MAX_PKG_BUF_LEN]; + char info_file[MAX_PKG_BUF_LEN]; - if(req_key == NULL) - return; + if (req_key == NULL) + return -1; - snprintf(info_file, MAX_PKG_BUF_LEN, "%s/%s", PKG_SIZE_INFO_PATH, req_key); - ERR("File path = %s\n", info_file); + snprintf(info_file, sizeof(info_file), "%s/%s", PKG_SIZE_INFO_PATH, + req_key); + ERR("File path = %s", info_file); file = fopen(info_file, "w"); if (file == NULL) { - ERR("Couldn't open the file %s \n", info_file); - return; + ERR("Couldn't open the file %s", info_file); + return -1; } - snprintf(buf, 128, "%d\n", size); + snprintf(buf, MAX_LONGLONG_LENGTH, "%lld", size); fwrite(buf, 1, strlen(buf), file); fflush(file); fd = fileno(file); fsync(fd); fclose(file); -} - -void __getsize_send_signal(const char *req_id, const char *pkg_type, const char *pkgid, const char *key, const char *val) -{ - dbus_uint32_t serial = 0; - DBusMessage *msg; - DBusMessageIter args; - DBusError err; - DBusConnection *conn; - const char *values[] = { - req_id, - pkg_type, - pkgid, - key, - val - }; - int i; - - dbus_error_init(&err); - - conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err); - if (dbus_error_is_set(&err)) { - ERR("Connection error: %s", err.message); - } - if (NULL == conn) { - ERR("conn is NULL"); - return; - } - - msg = dbus_message_new_signal(COMM_STATUS_BROADCAST_DBUS_GET_SIZE_PATH, COMM_STATUS_BROADCAST_DBUS_GET_SIZE_INTERFACE, COMM_STATUS_BROADCAST_EVENT_GET_SIZE); - if (NULL == msg) { - ERR("msg is NULL"); - return; - } - - dbus_message_iter_init_append(msg, &args); - for (i = 0; i < 5; i++) { - if (!dbus_message_iter_append_basic - (&args, DBUS_TYPE_STRING, &(values[i]))) { - ERR("dbus_message_iter_append_basic failed:" - " Out of memory"); - return; - } - } - if (!dbus_connection_send(conn, msg, &serial)) { - ERR("dbus_connection_send failed: Out of memory"); - return; - } - dbus_connection_flush(conn); - dbus_message_unref(msg); + return 0; } -static int __send_sizeinfo_cb(const pkgmgrinfo_pkginfo_h handle, void *user_data) +static int __send_sizeinfo_cb(const pkgmgrinfo_pkginfo_h handle, + void *user_data) { - int ret = 0; + int ret; char *pkgid; int data_size = 0; int total_size = 0; - char total_buf[MAX_PKG_BUF_LEN] = {'\0'}; - char data_buf[MAX_PKG_BUF_LEN] = {'\0'}; + char total_buf[MAX_PKG_BUF_LEN]; + char data_buf[MAX_PKG_BUF_LEN]; + pkgmgr_installer *pi = (pkgmgr_installer *)user_data; - pkg_size_info_t temp_pkg_size_info = {0,}; + pkg_size_info_t temp_pkg_size_info = {0, }; ret = pkgmgrinfo_pkginfo_get_pkgid(handle, &pkgid); - if(ret != PMINFO_R_OK) { + if (ret != PMINFO_R_OK) { ERR("pkgmgrinfo_pkginfo_get_pkgid() failed"); return -1; } __get_pkg_size_info(pkgid, &temp_pkg_size_info); - total_size = temp_pkg_size_info.app_size + temp_pkg_size_info.data_size + temp_pkg_size_info.cache_size; - data_size = temp_pkg_size_info.data_size + temp_pkg_size_info.cache_size; + total_size = temp_pkg_size_info.app_size + + temp_pkg_size_info.data_size + temp_pkg_size_info.cache_size; + data_size = temp_pkg_size_info.data_size + + temp_pkg_size_info.cache_size; - /*send size info to client*/ - snprintf(total_buf, MAX_PKG_BUF_LEN - 1, "%d", total_size); - snprintf(data_buf, MAX_PKG_BUF_LEN - 1, "%d", data_size); + /* send size info to client */ + snprintf(total_buf, sizeof(total_buf), "%d", total_size); + snprintf(data_buf, sizeof(data_buf), "%d", data_size); - __getsize_send_signal(PKGMGR_INSTALLER_GET_SIZE_KEY_STR, PKGMGR_INSTALLER_GET_SIZE_KEY_STR, pkgid, data_buf, total_buf); + return pkgmgr_installer_send_signal(pi, + PKGMGR_INSTALLER_GET_SIZE_KEY_STR, + pkgid, data_buf, total_buf); +} - return 0; +static int __send_result_to_signal(pkgmgr_installer *pi, const char *req_key, + const char *pkgid, pkg_size_info_t *info) +{ + int ret; + char *info_str; + + info_str = __get_pkg_size_info_str(info); + if (info_str == NULL) + return -1; + + ret = pkgmgr_installer_send_signal(pi, req_key, pkgid, "get_size", + info_str); + free(info_str); + + return ret; } int main(int argc, char *argv[]) { - int ret = -1; - int data_size = 0; - int total_size = 0; - int get_type = 0; - char *pkgid = NULL; - char *req_key = NULL; - - char data_buf[MAX_PKG_BUF_LEN] = {'\0'}; - char total_buf[MAX_PKG_BUF_LEN] = {'\0'}; - pkgmgr_installer *pi = NULL; - pkg_size_info_t temp_pkg_size_info = {0,}; + int ret; + int get_type; + char *pkgid; + char *req_key; + long long size = 0; + pkgmgr_installer *pi; + pkg_size_info_t info = {0, }; // argv has bellowed meaning // argv[0] = pkgid // argv[1] = get type // argv[2] = req_key - if(argv[0] == NULL) { + if (argv[0] == NULL) { ERR("pkgid is NULL\n"); return -1; } pkgid = argv[0]; get_type = atoi(argv[1]); + req_key = argv[2]; - DBG("start get size : [pkgid = %s, request type = %d] \n", pkgid, get_type); - - if (get_type == PM_GET_SIZE_INFO) { - ret = pkgmgrinfo_pkginfo_get_list(__send_sizeinfo_cb, NULL); - __getsize_send_signal(PKGMGR_INSTALLER_GET_SIZE_KEY_STR, PKGMGR_INSTALLER_GET_SIZE_KEY_STR, "get_size", "get_size", "end"); - } else if (get_type == PM_GET_ALL_PKGS) { - pkg_size_info_t pkg_size_info = {0,}; - ret = __get_total_pkg_size_info(&pkg_size_info); - total_size = pkg_size_info.app_size + pkg_size_info.data_size + pkg_size_info.cache_size; - } else if (get_type == PM_GET_PKG_SIZE_INFO) { - ret = __send_signal_for_pkg_size_info(pkgid, argc, argv); - if (ret < 0) { - ERR("Sending signal for package size info failed."); - return -1; - } - } else if (get_type == PM_GET_TOTAL_PKG_SIZE_INFO) { - ret = __send_signal_for_total_pkg_size_info(argc, argv); - if (ret < 0) { - ERR("Failed to get the total size information of all the pacakges."); - return -1; - } - } else { - ret = __get_pkg_size_info(pkgid, &temp_pkg_size_info); - data_size = temp_pkg_size_info.data_size + temp_pkg_size_info.cache_size; - total_size = temp_pkg_size_info.app_size + temp_pkg_size_info.data_size + temp_pkg_size_info.cache_size; - } - - if (get_type != PM_GET_SIZE_INFO && get_type != PM_GET_PKG_SIZE_INFO) { - pi = pkgmgr_installer_new(); - if (!pi) { - DBG("Failure in creating the pkgmgr_installer object"); - } else { - snprintf(data_buf, MAX_PKG_BUF_LEN - 1, "%d", data_size); - snprintf(total_buf, MAX_PKG_BUF_LEN - 1, "%d", total_size); - pkgmgr_installer_receive_request(pi, argc, argv); - pkgmgr_installer_send_signal(pi, PKGMGR_INSTALLER_GET_SIZE_KEY_STR, pkgid, data_buf, total_buf); - pkgmgr_installer_free(pi); - } - } + DBG("start get size : [pkgid=%s, request type=%d]", pkgid, get_type); - req_key = (char *)calloc(strlen(argv[2])+1, sizeof(char)); - if(req_key == NULL) + pi = pkgmgr_installer_new(); + if (pi == NULL) { + ERR("failed to create installer"); return -1; - strncpy(req_key, argv[2], strlen(argv[2])); - - if (strncmp(req_key, pkgid, strlen(pkgid)) == 0) { - DBG("make a file for sync request [pkgid = %s] \n", pkgid); - __make_size_info_file(req_key , total_size); } + switch (get_type) { + case PM_GET_TOTAL_SIZE: + /* send result to file */ + ret = __get_pkg_size_info(pkgid, &info); + if (ret == 0) + size = info.app_size + info.data_size + info.cache_size; + ret = __make_size_info_file(req_key, size); + break; + case PM_GET_DATA_SIZE: + /* send result to file */ + ret = __get_pkg_size_info(pkgid, &info); + if (ret == 0) + size = info.data_size + info.cache_size; + ret = __make_size_info_file(req_key, size); + break; + case PM_GET_ALL_PKGS: + /* send result to file */ + ret = pkgmgrinfo_pkginfo_get_usr_list( + __get_total_pkg_size_info_cb, &info, getuid()); + if (ret == 0) + size = info.app_size + info.data_size + info.cache_size; + ret = __make_size_info_file(req_key, size); + break; + case PM_GET_SIZE_INFO: + /* send each result to signal */ + ret = pkgmgrinfo_pkginfo_get_usr_list(__send_sizeinfo_cb, pi, + getuid()); + ret = __make_size_info_file(req_key, 0); + break; + case PM_GET_PKG_SIZE_INFO: + /* send result to signal */ + ret = __get_pkg_size_info(pkgid, &info); + if (ret == 0) + ret = __send_result_to_signal(pi, req_key, + pkgid, &info); + ret = __make_size_info_file(req_key, 0); + break; + case PM_GET_TOTAL_PKG_SIZE_INFO: + /* send result to signal */ + ret = pkgmgrinfo_pkginfo_get_usr_list( + __get_total_pkg_size_info_cb, &info, getuid()); + if (ret == 0) + ret = __send_result_to_signal(pi, req_key, + PKG_SIZE_INFO_TOTAL, &info); + __make_size_info_file(req_key, 0); + break; + default: + ret = -1; + ERR("unsupported or depreated type"); + break; + } + + ret = pkgmgr_installer_send_signal(pi, + PKGMGR_INSTALLER_GET_SIZE_KEY_STR, + pkgid, "get_size", (ret == 0) ? "end" : "error"); + pkgmgr_installer_free(pi); + DBG("finish get size : [result = %d] \n", ret); - free(req_key); - return 0; + return ret; }