i-like-removing-code-not-adding-it-and-i-hate-flags

Change-Id: Ic927306de0ecfa03c4fa7fbab10d69404629ea5e

diff --git a/update-manager/fota/fota-installer.c b/update-manager/fota/fota-installer.c
index 97fc5d08d6c044a94422ec7ca23affbd3311065b..1d5a50c8d095e97a506b6e1963ad64d71fc9e018 100644 (file)
--- a/update-manager/fota/fota-installer.c
+++ b/update-manager/fota/fota-installer.c
@@ -36,60 +36,82 @@ static char *get_sender_appid(pid_t pid)
        return result;
 }
 
-bool check_delta_exist(char *base_dir)
+const char DeltaExtensions[] = {".tar", ".tar.gz" }
+enum DeltaType {
+        DELTA_TYPE_FULL     = 0,
+        DELTA_TYPE_BOOT     = 1,
+        DELTA_TYPE_PLATFORM = 2,
+       _DELTA_TYPE_MAX = DELTA_TYPE_PLATFORM
+};
+
+struct DeltaInfo {
+       enum DeltaType[_DELTA_TYPE_MAX] types;
+        char **delta_paths[_DELTA_TYPE_MAX][G_N_ELEMENTS(DeltaExtensions)]
+};
+
+void deltainfo_init(struct Deltas *deltas)
 {
+       memset(deltas, 0, sizeof(*deltas);
+}
+
+void deltainfo_free(struct Deltas *deltas)
+{
+       assert(deltas);
+
+       for (int i = 0; i < G_N_ELEMENTS(deltas->delta_paths); i++) {
+               for (j = 0 < G_N_ELEMENTS(DeltaExtensions); j++) {
+                       free(delta_paths[i][j]);
+       }
+}
+
+void deltainfo_collect(struct Deltas *deltas, char *base_dir)
+{
+       assert(deltas);
+       assert(deltas->types == 0);
        assert(base_dir);
 
-       const char *delta_files[] = {FOTA_DELTA_BASENAME,
-                                    FOTA_DELTA_BOOT_BASENAME,
-                                    FOTA_DELTA_PLATFORM_BASENAME};
-       const char *extensions[] = {".tar", ".tar.gz"};
-       bool delta_found = false;
-       int check_table[3] = {0, 0, 0};
+       const char *delta_files[] = {FOTA_DELTA_BASENAME, FOTA_DELTA_BOOT_BASENAME, FOTA_DELTA_PLATFORM_BASENAME};
+       const int DeltaType delta_types[] = {DELTA_TYPE_FULL, DELTA_TYPE_BOOT, DELTA_TYPE_PLATFORM};
+       assert(sizeof(delta_files) == sizeof(delta_types))
 
        for (size_t n = 0; n < G_N_ELEMENTS(delta_files); n++) {
                for (size_t e = 0; e < G_N_ELEMENTS(extensions); e++) {
-                       gchar *tmp_file_name = g_strconcat(base_dir, "/", delta_files[n], extensions[e], NULL);
-                       if (tmp_file_name == NULL) {
+                       gchar *delta_path = g_strconcat(base_dir, "/", delta_files[n], extensions[e], NULL);
+                       if (delta_path == NULL) {
                                _FLOGE("Out of memory error");
-                               break;
+                               return false;
                        }
 
-                       _FLOGD("Checking: %s", tmp_file_name);
-                       if (g_file_test(tmp_file_name, G_FILE_TEST_EXISTS)) {
-                               check_table[n]++;
-                               delta_found = true;
+                       _FLOGD("Checking: %s", delta_path);
+                       if (g_file_test(delta_path, G_FILE_TEST_EXISTS)) {
+                               deltas->delta_path[n][e] = delta_path;
+                               ++deltas->delta_type[n];
                        }
-                       free(tmp_file_name);
                }
        }
+}
 
-       if (!delta_found)
-               return false;
+#define EXT_GET(deltas, type) (deltas->delta_path[type][0] != NULL ?: deltas->delta_path[type][1])
 
-       // Check if there is only one version of delta file - tar or tar.gz
-       for (size_t i = 0; i < 3; i++) {
-               if (check_table[i] > 1) {
-                       _FLOGE("There are a tar and tar.gz version of delta file in %s", base_dir);
-                       return false;
-               }
-       }
+enum DeltaType deltainfo_select(struct Deltas *deltas)
+{
+       asset(deltas);
+       bool verify = false;
+       bool check_sha = false; // XXX what is this for?
 
-       // Check if there is complete delta and delta-boot or deta-platform
-       if (check_table[0] > 0) {
-               if (check_table[1] > 0 || check_table[2] > 0) {
-                       _FLOGE("There are complete delta (delta.tar(.gz)) and partial delta (delta-boot or delta-platform) in %s", base_dir);
-                       return false;
-               }
-       }
+       // full type delta is still preferred choice
+       enum DeltaType dt = DELTA_TYPE_FULL;
+       if (deltas->delta_types[dt] == 1)
+               verified = check_is_delta_appropriate(EXT_GET(deltas, dt), &check_sha);
 
-       // Check if there is only delta-boot
-       if (check_table[1] > 0 && check_table[2] == 0) {
-               _FLOGE("There is only delta-boot file, and this is not enough to perfrom the upgrade");
-               return false;
-       }
+       if (verified)
+               return dt;
+
+       if (deltas->delta_types[DELTA_TYPE_BOOT] == 1 && deltas->delta_types[DELTA_TYPE_PLATFORM] == 1)
+               verified =  check_is_delta_appropriate(EXT_GET(deltas, DELTA_TYPE_BOOT), &check_sha)
+                        && check_is_delta_appropriate(EXT_GET(deltas, DELTA_TYPE_PLATFORM), &check_sha);
 
-       return delta_found;
+       return verified ? DELTA_TYPE_BOOT : 0; // XXX would need combined type BOOT|PLATFORM here :(
 }
 
 static char *find_delta_dir(const char *appid)
@@ -116,52 +138,6 @@ static char *find_delta_dir(const char *appid)
        return client_delta_dir;
 }
 
-static char *check_delta_file_exist(char *delta_dir, const char *delta_basename)
-{
-       assert(delta_dir);
-       assert(delta_basename);
-
-       const char *extensions[] = {".tar", ".tar.gz"};
-       for (size_t e = 0; e < G_N_ELEMENTS(extensions); e++) {
-               char *path = g_strconcat(delta_dir, "/", delta_basename, extensions[e], NULL);
-               if (g_file_test(path, G_FILE_TEST_EXISTS)) {
-                       return path;
-               }
-               free(path);
-       }
-       return NULL;
-}
-
-int get_delta_file_names(char *delta_dir, struct deltas *deltas) {
-       assert(delta_dir);
-       assert(deltas);
-
-       // Check if there are a boot and platform delta
-       // We don't need to check if the set of deltas is correnct, because it
-       // has been checked in check_delta_exist()
-       const char *delta_files[] = {FOTA_DELTA_BASENAME,
-                                    FOTA_DELTA_BOOT_BASENAME,
-                                    FOTA_DELTA_PLATFORM_BASENAME};
-
-       size_t count = 0;
-       char **tmp_array[] = {&deltas->first_delta, &deltas->second_delta};
-
-       for (size_t n = 0; n < G_N_ELEMENTS(tmp_array); n++) {
-               *tmp_array[n] = NULL;
-       }
-
-       for (size_t n = 0; n < G_N_ELEMENTS(delta_files); n++) {
-               char *path = check_delta_file_exist(delta_dir, delta_files[n]);;
-               if (path == NULL) {
-                       continue;
-               }
-               _FLOGD("Found delta: %s", path);
-               *tmp_array[count] = path;
-               count++;
-       }
-       return count;
-}
-
 int find_delta_and_prepare_script(pid_t sender_pid, struct deltas *deltas)
 {
        int ret = 0;
@@ -190,24 +166,13 @@ int find_delta_and_prepare_script(pid_t sender_pid, struct deltas *deltas)
                return -1;
        }
 
-       if (get_delta_file_names(delta_dir, deltas) <= 0) {
-               return -1;
-       }
-
-       /* Check client have appropriate delta  */
-
-       // We take scripts from the first delta, so only for it we check
-       // whether the checksum is available
-       if (check_is_delta_appropriate(deltas->first_delta,
-                                      &check_sha) != 0) {
+       struct DeltaInfo di = {0 }
+       if (!deltainfo_collect(&di))
                return -1;
-       }
 
-       if (deltas->second_delta &&
-                 check_is_delta_appropriate(deltas->second_delta,
-                                            NULL) != 0) {
+       enum DeltaType selected = deltainfo_select(&di);
+       if (!selected)
                return -1;
-       }
 
        /* Setup local update flag */
        ret = util_file_mkdir(FOTA_STATUS_DIR);
@@ -220,6 +185,9 @@ int find_delta_and_prepare_script(pid_t sender_pid, struct deltas *deltas)
                return -1;
        }
 
+
+       // ** not touched this **
+
        /* Trigger update */
        ret = util_file_untar(deltas->first_delta, FOTA_DIR, FOTA_TRIGGER_FILE);
        if (ret < 0) {