Fix preload-rw update

Add version, type information at ".all_preload_rw_list" to update
preload-rw packages during Tizen platform upgrade.

Change-Id: Ifaa629ed4b8a591f03a22bdcfb70cd471e99fd94
Signed-off-by: Sangyoon Jang <jeremy.jang@samsung.com>

diff --git a/src/install_preload_pkg.c b/src/install_preload_pkg.c
index 48576cc..d73894d 100644 (file)
--- a/src/install_preload_pkg.c
+++ b/src/install_preload_pkg.c
@@ -59,11 +59,27 @@
 #define WGT_RW_DIR tzplatform_mkpath(TZ_SYS_RO_APP, ".preload-rw-wgt")
 #define ALL_PRELOAD_RW_PKG_LIST "/opt/usr/share/.all_preload_rw_list"
 
+struct pkginfo {
+       char *pkgid;
+       char *version;
+       char *type;
+};
+
+static void __free_pkginfo(gpointer data)
+{
+       struct pkginfo *info = (struct pkginfo *)data;
+       free(info->pkgid);
+       free(info->version);
+       free(info->type);
+       free(info);
+}
+
 static void __make_preload_rw_list(GList *pkg_list)
 {
        FILE *file;
        char err_buf[BUFSZE];
        char pkg_info[BUFSZE];
+       struct pkginfo *info;
 
        if (pkg_list == NULL)
                return;
@@ -76,14 +92,12 @@ static void __make_preload_rw_list(GList *pkg_list)
        }
 
        for (; pkg_list != NULL; pkg_list = pkg_list->next) {
-               char *pkgid = pkg_list->data;
-               if (pkgid == NULL) {
-                       _E("pkgid is null\n");
-                       continue;
-               }
-
-               _D("Add [%s] to preload-rw list", pkgid);
-               snprintf(pkg_info, BUFSZE, "package=\"%s\":\n", pkgid);
+               info = (struct pkginfo *)pkg_list->data;
+               _D("Add [%s][%s][%s] to preload-rw list", info->pkgid,
+                               info->version, info->type);
+               snprintf(pkg_info, BUFSZE, "package=\"%s\"\tversion=\"%s\"\t"
+                               "type=\"%s\":\n",
+                               info->pkgid, info->version, info->type);
                fwrite(pkg_info, 1, strlen(pkg_info), file);
        }
 
@@ -100,7 +114,7 @@ static int _install_preload_pkg(const char *backend, const char *directory,
        char err_buf[BUFSZE];
        GList *preload_rw_pkg_list = NULL;
        package_manager_pkg_detail_info_t *pkg_info;
-       char *pkgid;
+       struct pkginfo *info;
 
        dir = opendir(directory);
        if (!dir) {
@@ -135,7 +149,7 @@ static int _install_preload_pkg(const char *backend, const char *directory,
                } else if (pid < 0) {
                        _E("failed to fork and execute %s!", backend);
                        closedir(dir);
-                       g_list_free_full(preload_rw_pkg_list, free);
+                       g_list_free_full(preload_rw_pkg_list, __free_pkginfo);
                        return -1;
                }
 
@@ -152,8 +166,35 @@ static int _install_preload_pkg(const char *backend, const char *directory,
                                continue;
                        }
 
-                       pkgid = strdup(pkg_info->pkgid);
-                       preload_rw_pkg_list = g_list_append(preload_rw_pkg_list, pkgid);
+                       info = calloc(1, sizeof(struct pkginfo));
+                       if (info == NULL) {
+                               _E("out of memory");
+                               pkgmgr_client_free_pkginfo(pkg_info);
+                               continue;
+                       }
+                       info->pkgid = strdup(pkg_info->pkgid);
+                       if (info->pkgid == NULL) {
+                               _E("out of memory");
+                               __free_pkginfo((struct pkginfo *)info);
+                               pkgmgr_client_free_pkginfo(pkg_info);
+                               continue;
+                       }
+                       info->version = strdup(pkg_info->version);
+                       if (info->version == NULL) {
+                               _E("out of memory");
+                               __free_pkginfo((struct pkginfo *)info);
+                               pkgmgr_client_free_pkginfo(pkg_info);
+                               continue;
+                       }
+                       info->type = strdup(pkg_info->pkg_type);
+                       if (info->type == NULL) {
+                               _E("out of memory");
+                               __free_pkginfo((struct pkginfo *)info);
+                               pkgmgr_client_free_pkginfo(pkg_info);
+                               continue;
+                       }
+                       preload_rw_pkg_list = g_list_append(preload_rw_pkg_list,
+                                       info);
                        pkgmgr_client_free_pkginfo(pkg_info);
                        pkg_info = NULL;
                }
@@ -173,7 +214,7 @@ static int _install_preload_pkg(const char *backend, const char *directory,
        closedir(dir);
 
        __make_preload_rw_list(preload_rw_pkg_list);
-       g_list_free_full(preload_rw_pkg_list, free);
+       g_list_free_full(preload_rw_pkg_list, __free_pkginfo);
        return 0;
 }
 

diff --git a/src/pkg_upgrade.c b/src/pkg_upgrade.c
index a5c484e..115b8a0 100644 (file)
--- a/src/pkg_upgrade.c
+++ b/src/pkg_upgrade.c
@@ -52,18 +52,33 @@
        tzplatform_mkpath(TZ_SYS_GLOBALUSER_DATA, \
        "pkgmgr/fota/pkgid_list_from_xml.txt")
 #define PRELOAD_RW_PKG_LIST \
-       tzplatform_mkpath(TZ_SYS_RO_APP, \
-       ".preload_rw_pkg_list")
+       tzplatform_mkpath(TZ_SYS_GLOBALUSER_DATA, \
+       "pkgmgr/fota/.all_preload_rw_list")
 #define DBPATH tzplatform_mkpath(TZ_SYS_DB, "/.pkgmgr_parser.db")
 #define OPT_ZIP_FILE                   "/usr/system/RestoreDir/opt.zip"
 #define ALL_PRELOAD_RW_PKG_LIST "/opt/usr/share/.all_preload_rw_list"
 
+struct pkginfo {
+       char *pkgid;
+       char *version;
+       char *type;
+};
+
 static char *unzip_path[BUF_SIZE] = {
        "opt/usr/globalapps",
        "opt/etc/skel/apps_rw",
        NULL
 };
 
+static void __free_pkginfo(gpointer data)
+{
+       struct pkginfo *info = (struct pkginfo *)data;
+       free(info->pkgid);
+       free(info->version);
+       free(info->type);
+       free(info);
+}
+
 float __get_elapsed_time()
 {
        static long start_time = 0;
@@ -141,15 +156,37 @@ static void __iter_cb(gpointer key, gpointer value, gpointer user_data)
 
        FILE *file;
        char *pkgid;
+       char *version;
+       char *type;
        char pkg_info[BUF_SIZE];
+       pkgmgrinfo_pkginfo_h info;
 
        if (user_data == NULL || key == NULL)
                return;
 
        file = user_data;
        pkgid = key;
-       snprintf(pkg_info, BUF_SIZE, "package=\"%s\":\n", pkgid);
+
+       if (pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &info)) {
+               _LOGE("failed to get pkginfo of %s\n", pkgid);
+               return;
+       }
+
+       if (pkgmgrinfo_pkginfo_get_version(info, &version)) {
+               pkgmgrinfo_pkginfo_destroy_pkginfo(info);
+               return;
+       }
+
+       if (pkgmgrinfo_pkginfo_get_type(info, &type)) {
+               pkgmgrinfo_pkginfo_destroy_pkginfo(info);
+               return;
+       }
+
+       snprintf(pkg_info, BUF_SIZE,
+                       "package=\"%s\"\tversion=\"%s\"\ttype=\"%s\":\n",
+                       pkgid, version, type);
        fwrite(pkg_info, 1, strlen(pkg_info), file);
+       pkgmgrinfo_pkginfo_destroy_pkginfo(info);
 }
 
 static void __make_preload_rw_list(GHashTable *preload_rw_table)
@@ -288,14 +325,57 @@ static int __make_pkgid_list(const char *file_path, char *pkgid,
 }
 
 static int __insert_preload_rw_table(GHashTable *preload_rw_table,
-               const char *pkgid)
+               const char *pkgid, const char *version, const char *type)
 {
-       char *package = strdup(pkgid);
-       retvm_if(package == NULL, -1, "strdup failed\n");
-       g_hash_table_insert(preload_rw_table, package, NULL);
+       struct pkginfo *info;
+       char *package;
+
+       info = calloc(1, sizeof(struct pkginfo));
+       if (info == NULL) {
+               _LOGE("out of memory");
+               return -1;
+       }
+
+       info->pkgid = strdup(pkgid);
+       if (info->pkgid == NULL) {
+               _LOGE("out of memory");
+               __free_pkginfo((struct pkginfo *)info);
+               return -1;
+       }
+
+       info->version = strdup(version);
+       if (info->version == NULL) {
+               _LOGE("out of memory");
+               __free_pkginfo((struct pkginfo *)info);
+               return -1;
+       }
+
+       info->type = strdup(type);
+       if (info->type == NULL) {
+               _LOGE("out of memory");
+               __free_pkginfo((struct pkginfo *)info);
+               return -1;
+       }
+
+       package = strdup(pkgid);
+       if (info->type == NULL) {
+               _LOGE("out of memory");
+               __free_pkginfo((struct pkginfo *)info);
+               return -1;
+       }
+
+       g_hash_table_insert(preload_rw_table, package, info);
        return 0;
 }
 
+static int __delete_preload_rw_table(GHashTable *preload_rw_table,
+               const char *pkgid)
+{
+       gboolean removed;
+       removed = g_hash_table_remove(preload_rw_table, pkgid);
+       return removed ? 0 : -1;
+}
+
 static int __pkgid_list_cb(const pkgmgrinfo_pkginfo_h handle, void *user_data)
 {
        int ret = -1;
@@ -326,13 +406,34 @@ static int __preload_rw_pkgid_list_cb(const pkgmgrinfo_pkginfo_h handle,
 {
        int ret;
        char *pkgid;
+       char *version;
+       char *type;
        GHashTable *preload_rw_table = (GHashTable *)user_data;
 
        ret = pkgmgrinfo_pkginfo_get_pkgid(handle, &pkgid);
-       retvm_if(ret < 0, -1, "pkgmgrinfo_pkginfo_get_pkgid failed");
+       if (ret < 0) {
+               _LOGE("pkgmgrinfo_pkginfo_get_pkgid failed\n");
+               return -1;
+       }
+
+       ret = pkgmgrinfo_pkginfo_get_version(handle, &version);
+       if (ret < 0) {
+               _LOGE("pkgmgrinfo_pkginfo_get_version failed\n");
+               return -1;
+       }
+
+       ret = pkgmgrinfo_pkginfo_get_type(handle, &type);
+       if (ret < 0) {
+               _LOGE("pkgmgrinfo_pkginfo_get_type failed\n");
+               return -1;
+       }
+
+       ret = __insert_preload_rw_table(preload_rw_table, pkgid, version, type);
+       if (ret < 0) {
+               _LOGE("__insert_preload_rw_table failed\n");
+               return -1;
+       }
 
-       ret = __insert_preload_rw_table(preload_rw_table, pkgid);
-       retvm_if(ret < 0, -1, "__insert_preload_rw_table fail\n");
        return 0;
 }
 
@@ -934,6 +1035,15 @@ static bool __find_pkgid_from_rw_list(const char *pkgid)
        return ret;
 }
 
+static int __unzip_file_only_to_path(char *dest_path, char *unzip_to)
+{
+       const char *unzip_argv[] = { "/usr/bin/unzip", "-joXqq",
+                       OPT_ZIP_FILE, dest_path, "-d", unzip_to, NULL };
+       int ret = __xsystem(unzip_argv);
+
+       return ret;
+}
+
 static int __unzip_files(char *dest_path)
 {
        const char *unzip_argv[] = { "/usr/bin/unzip", "-oXqq",
@@ -943,10 +1053,10 @@ static int __unzip_files(char *dest_path)
        return ret;
 }
 
-static int __install_preload_rw(const char *pkgid, const char *pkgtype,
-               GHashTable *preload_rw_table)
+static int __install_preload_rw(const char *pkgid, const char *version,
+               const char *pkgtype, GHashTable *preload_rw_table)
 {
-       if (pkgid == NULL || pkgtype == NULL)
+       if (pkgid == NULL || version == NULL || pkgtype == NULL)
                return -1;
 
        int index;
@@ -984,17 +1094,18 @@ static int __install_preload_rw(const char *pkgid, const char *pkgtype,
                }
        }
 
-       ret = __insert_preload_rw_table(preload_rw_table, pkgid);
+       ret = __insert_preload_rw_table(preload_rw_table, pkgid, version,
+                       pkgtype);
        retvm_if(ret < 0, -1, "__insert_preload_rw_table fail\n");
 
        __send_args_to_backend(pkgid, pkgtype, PKG_NEED_PRELOADRW_INSTALL);
        return ret;
 }
 
-static void __convert_preload_to_rw(const char *pkgid, const char *pkgtype,
-               GHashTable *preload_rw_table)
+static void __convert_preload_to_rw(const char *pkgid, const char *version,
+               const char *pkgtype, GHashTable *preload_rw_table)
 {
-       if (pkgid == NULL || pkgtype == NULL)
+       if (pkgid == NULL || version == NULL || pkgtype == NULL)
                return;
        char buf[BUF_SIZE] = {0};
        int ret;
@@ -1007,7 +1118,7 @@ static void __convert_preload_to_rw(const char *pkgid, const char *pkgtype,
        if (ret != 0)
                _LOG("Failed to remove directory[%s]\n", buf);
 
-       ret = __install_preload_rw(pkgid, pkgtype, preload_rw_table);
+       ret = __install_preload_rw(pkgid, version, pkgtype, preload_rw_table);
        if (ret != 0) {
                _LOG("Failed install preload rw pkg[%s]\n", pkgid);
                return;
@@ -1067,7 +1178,7 @@ static int __find_deleted_pkgid_from_list(const char *source_file,
 
                        if (!strncmp(update, "false", strlen("false"))) {
                                if (is_preload_rw_pkg) {
-                                       __convert_preload_to_rw(pkgid,
+                                       __convert_preload_to_rw(pkgid, version,
                                                        pkgtype,
                                                        preload_rw_table);
                                        modified_pkg_cnt++;
@@ -1083,7 +1194,7 @@ static int __find_deleted_pkgid_from_list(const char *source_file,
                                if (is_preload_rw_pkg) {
                                        __send_args_to_backend(pkgid, pkgtype,
                                                        PKG_NEED_RWUNINSTALL);
-                                       __install_preload_rw(pkgid,
+                                       __install_preload_rw(pkgid, version,
                                                        pkgtype,
                                                        preload_rw_table);
                                }
@@ -1117,6 +1228,7 @@ static int __get_pkgid_list_from_db_and_xml()
        _LOG("=======================================================\n");
 
        int ret = 0;
+       char updated_preload_rw_list[BUF_SIZE];
 
        /*get pkg info on pkgmgr db, it means old version */
        ret = __find_preload_pkgid_from_db(PKGID_LIST_FROM_DB_FILE);
@@ -1131,6 +1243,20 @@ static int __get_pkgid_list_from_db_and_xml()
 
        _LOG("Make pkgid list from xml success!! \n");
 
+
+       /*get preload rw pkg info on xml from opt.zip, it means new version */
+       snprintf(updated_preload_rw_list, sizeof(updated_preload_rw_list), "%s",
+                       ALL_PRELOAD_RW_PKG_LIST);
+       ret = __unzip_file_only_to_path(updated_preload_rw_list + 1,
+                       (char *)PKGMGR_FOTA_PATH);
+       if (ret != 0) {
+               _LOG("Failed to unzip file from backup[%s]\n",
+                               updated_preload_rw_list);
+               return ret;
+       }
+
+       _LOG("Make rw pkgid list from xml success!! \n");
+
        return 0;
 }
 
@@ -1177,6 +1303,7 @@ static int __process_rw_fota(GHashTable *preload_rw_table)
        char *list_version = NULL;
        char *db_stored_version = NULL;
        char *pkgtype = NULL;
+       char *version = NULL;
        pkgmgrinfo_pkginfo_h handle = NULL;
        int compare = PMINFO_VERSION_SAME;
        long total_time = 0;
@@ -1224,45 +1351,36 @@ static int __process_rw_fota(GHashTable *preload_rw_table)
 
                        if (compare != PMINFO_VERSION_NEW) {
                                /* package version is not update on FOTA. */
-                               _LOG("pkg is not updated\n");
+                               _LOG("pkgid[%s] is not updated\n", pkgid);
                                pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
                                handle = NULL;
-
-                               gettimeofday(&tv, NULL);
-                               endtime = tv.tv_sec * 1000l +
-                                       tv.tv_usec / 1000l;
-                               total_time += (int)(endtime - starttime);
-                               _LOG("finish request [time : %d ms]\n",
-                                       (int)(endtime - starttime));
-                               ret = __insert_preload_rw_table(preload_rw_table, pkgid);
-                               if (ret < 0) {
-                                       _LOG("__insert_preload_rw_table fail\n");
-                                       free(pkgid);
-                                       free(list_version);
-                                       fclose(fp);
-                                       return -1;
-                               }
                                FREE_AND_NULL(pkgid);
                                FREE_AND_NULL(list_version);
                                continue;
                        }
 
-                       _LOG("pkg is updated, need to upgrade\n");
+                       _LOG("pkgid[%s] is updated, need to upgrade "
+                                       "from version [%s] to [%s]\n",
+                                       pkgid, db_stored_version, list_version);
                } else {
                        is_deleted_pkg = __check_deleted_pkg(preload_rw_table, pkgid);
                        if (is_deleted_pkg) {
                                _LOG("pkgid[%s] is deleted pkg\n", pkgid);
+                               __delete_preload_rw_table(preload_rw_table,
+                                               pkgid);
                                FREE_AND_NULL(pkgid);
                                continue;
                        }
                        _LOG("pkgid[%s] is new\n", pkgid);
                }
 
+               version = __getvalue(buf, TOKEN_VERSION_STR, 1);
                pkgtype = __getvalue(buf, TOKEN_TYPE_STR, 1);
-               __install_preload_rw(pkgid, pkgtype, preload_rw_table);
+               __install_preload_rw(pkgid, version, pkgtype, preload_rw_table);
 
                FREE_AND_NULL(pkgid);
                FREE_AND_NULL(pkgtype);
+               FREE_AND_NULL(version);
 
                if (handle)
                        pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
@@ -1298,6 +1416,8 @@ static int __fill_preload_rw_table(GHashTable *preload_rw_table)
        FILE *fp;
        char buf[BUF_SIZE];
        char *pkgid;
+       char *version;
+       char *type;
 
        fp = fopen(ALL_PRELOAD_RW_PKG_LIST, "r");
        retvm_if(fp == NULL, -1, "Fail get : %s\n", ALL_PRELOAD_RW_PKG_LIST);
@@ -1311,8 +1431,34 @@ static int __fill_preload_rw_table(GHashTable *preload_rw_table)
                        continue;
                }
 
-               __insert_preload_rw_table(preload_rw_table, pkgid);
+               version = __getvalue(buf, TOKEN_VERSION_STR, 1);
+               if (version == NULL) {
+                       _LOG("version is null\n");
+                       version = strdup("");
+                       if (version == NULL) {
+                               _LOGE("out of memory\n");
+                               FREE_AND_NULL(pkgid);
+                               continue;
+                       }
+               }
+
+               type = __getvalue(buf, TOKEN_TYPE_STR, 1);
+               if (type == NULL) {
+                       _LOG("type is null\n");
+                       type = strdup("");
+                       if (type == NULL) {
+                               _LOGE("out of memory\n");
+                               FREE_AND_NULL(version);
+                               FREE_AND_NULL(pkgid);
+                               continue;
+                       }
+               }
+
+               __insert_preload_rw_table(preload_rw_table, pkgid, version,
+                               type);
                FREE_AND_NULL(pkgid);
+               FREE_AND_NULL(version);
+               FREE_AND_NULL(type);
        }
        fclose(fp);
 
@@ -1343,7 +1489,7 @@ int main(int argc, char *argv[])
                        "__check_tmp_all_preload_rw_pkg_list is failed.\n");
 
        preload_rw_table = g_hash_table_new_full(
-                               g_str_hash, g_str_equal, free, NULL);
+                               g_str_hash, g_str_equal, free, __free_pkginfo);
        if (__fill_preload_rw_table(preload_rw_table) < 0) {
                ret = __find_preload_rw_pkgid_from_db(preload_rw_table);
                retvm_if(ret < 0, -1, "__find_preload_rw_pkgid_from_db is failed\n");