#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
{
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);
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)
{
*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;
}
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);
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;
}
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;
}
projects / platform / core / appfw / slp-pkgmgr.git / commitdiff