feat: detect file ownership conflicts in trans_prepare before

installation

Author: AnmiTaliDev

include/apg/package.h

@@ -121,6 +121,20 @@ bool install_package(struct package *pkg);
  */
 bool install_package_in_root(struct package *pkg, const char *root_path);
 
+/**
+ * @brief Extract a package archive and collect its file list without
+ *        installing any files.
+ *
+ * Populates @p pkg->package_files so callers can inspect which paths the
+ * package would install before committing to a transaction. Safe to call
+ * multiple times — existing file list is replaced.
+ *
+ * @param pkg       Package whose archive to inspect.
+ * @param root_path Filesystem root used to locate the temporary work area.
+ * @return true on success, false if the archive could not be extracted.
+ */
+bool package_collect_files(struct package *pkg, const char *root_path);
+
 /**
  * @brief Parse a package from disk.
  *

include/apg/transaction.h

@@ -52,6 +52,7 @@ typedef enum
     TRANS_ERR_INSTALL_FAILED,    /**< One or more packages failed to install. */
     TRANS_ERR_UNSIGNED,          /**< Package rejected by signature policy. */
     TRANS_ERR_HAS_DEPENDENTS, /**< Removal blocked by installed dependents. */
+    TRANS_ERR_FILE_CONFLICT,  /**< File already owned by another package. */
 } trans_error_t;
 
 /**
@@ -78,6 +79,18 @@ struct trans_conflict
     char *conflicts_with; /**< Existing package that conflicts with it. */
 };
 
+/**
+ * @brief A file conflict between a package being installed and an existing one.
+ *
+ * The array is owned by the transaction and valid until trans_free().
+ */
+struct trans_file_conflict
+{
+    char *path;         /**< Conflicting file path. */
+    char *requested_by; /**< Package being installed that claims the file. */
+    char *owned_by;     /**< Currently installed package that owns the file. */
+};
+
 /**
  * @brief A removal blocked by installed dependents.
  *
@@ -212,6 +225,20 @@ const struct trans_conflict *trans_get_conflicts(const struct apg_trans *trans,
 const struct trans_blocked_remove *
 trans_get_blocked_removes(const struct apg_trans *trans, size_t *count);
 
+/**
+ * @brief Retrieve file conflicts detected by trans_prepare().
+ *
+ * Valid after a trans_prepare() call that returned
+ * @ref TRANS_ERR_FILE_CONFLICT. The returned array is owned by the transaction
+ * and valid until trans_free().
+ *
+ * @param trans Transaction after trans_prepare().
+ * @param count Output parameter set to the number of conflicts.
+ * @return Pointer to the first entry, or NULL if none.
+ */
+const struct trans_file_conflict *
+trans_get_file_conflicts(const struct apg_trans *trans, size_t *count);
+
 /**
  * @brief Execute the prepared plan.
  *

src/package.c

@@ -156,6 +156,38 @@ install_package_in_root(struct package *pkg, const char *root_path)
     return true;
 }
 
+bool
+package_collect_files(struct package *pkg, const char *root_path)
+{
+    if (!pkg || !pkg->pkg_path)
+        return false;
+
+    char *real_tmp = concat_dirs(root_path, tmp_path);
+    if (!real_tmp)
+        return false;
+    create_dir(real_tmp);
+
+    if (!unarchive_package_in_root(pkg, real_tmp))
+    {
+        free(real_tmp);
+        return false;
+    }
+
+    char *data_src = concat_dirs(real_tmp, "data");
+    free(real_tmp);
+    if (!data_src)
+        return false;
+
+    int file_count = 0;
+    char **files = collect_files(data_src, &file_count);
+    free(data_src);
+
+    str_list_free(&pkg->package_files);
+    pkg->package_files.items = files;
+    pkg->package_files.count = file_count;
+    return true;
+}
+
 struct package *
 parse_package(const char *path, const char *root_path)
 {

src/transaction/prepare.c

@@ -7,6 +7,7 @@
 #include "trans_priv.h"
 #include "../../include/apg/graph.h"
 #include "../../include/apg/db.h"
+#include "../../include/apg/package.h"
 
 static bool
 in_strarray(const char **arr, size_t count, const char *name)
@@ -311,7 +312,72 @@ trans_prepare(struct apg_trans *trans)
         }
     }
 
-    if (trans->blocked_remove_count > 0)
+    for (size_t i = 0; i < trans->install_count; i++)
+    {
+        struct package *pkg = trans->install_pkgs[i];
+        if (!pkg->meta || !pkg->meta->name)
+            continue;
+
+        if (pkg->package_files.count == 0)
+            package_collect_files(pkg, "/");
+
+        for (int j = 0; j < pkg->package_files.count; j++)
+        {
+            const char *path = pkg->package_files.items[j];
+            if (!path)
+                continue;
+            char *owner = db_owner(trans->db, path);
+            if (!owner)
+                continue;
+            if (strcmp(owner, pkg->meta->name) == 0)
+            {
+                free(owner);
+                continue;
+            }
+
+            if (!trans->file_conflicts)
+            {
+                trans->file_conflicts =
+                    malloc(4 * sizeof(*trans->file_conflicts));
+                if (!trans->file_conflicts)
+                {
+                    free(owner);
+                    ret = TRANS_ERR_NOMEM;
+                    goto cleanup;
+                }
+                trans->file_conflict_cap = 4;
+            }
+            else if (trans->file_conflict_count == trans->file_conflict_cap)
+            {
+                size_t new_cap = trans->file_conflict_cap * 2;
+                struct trans_file_conflict *tmp =
+                    realloc(trans->file_conflicts, new_cap * sizeof(*tmp));
+                if (!tmp)
+                {
+                    free(owner);
+                    ret = TRANS_ERR_NOMEM;
+                    goto cleanup;
+                }
+                trans->file_conflicts = tmp;
+                trans->file_conflict_cap = new_cap;
+            }
+
+            struct trans_file_conflict *fc =
+                &trans->file_conflicts[trans->file_conflict_count++];
+            fc->path = strdup(path);
+            fc->requested_by = strdup(pkg->meta->name);
+            fc->owned_by = owner;
+            if (!fc->path || !fc->requested_by)
+            {
+                ret = TRANS_ERR_NOMEM;
+                goto cleanup;
+            }
+        }
+    }
+
+    if (trans->file_conflict_count > 0)
+        ret = TRANS_ERR_FILE_CONFLICT;
+    else if (trans->blocked_remove_count > 0)
         ret = TRANS_ERR_HAS_DEPENDENTS;
     else if (trans->conflict_count > 0)
         ret = TRANS_ERR_CONFLICT;

src/transaction/trans_priv.h

@@ -37,6 +37,10 @@ struct apg_trans
     size_t blocked_remove_count;
     size_t blocked_remove_cap;
 
+    struct trans_file_conflict *file_conflicts;
+    size_t file_conflict_count;
+    size_t file_conflict_cap;
+
     bool prepared;
     bool committed;
 

src/transaction/transaction.c

@@ -102,6 +102,14 @@ trans_free(struct apg_trans *trans)
     }
     free(trans->blocked_removes);
 
+    for (size_t i = 0; i < trans->file_conflict_count; i++)
+    {
+        free(trans->file_conflicts[i].path);
+        free(trans->file_conflicts[i].requested_by);
+        free(trans->file_conflicts[i].owned_by);
+    }
+    free(trans->file_conflicts);
+
     free(trans);
 }
 
@@ -179,6 +187,15 @@ trans_get_plan(const struct apg_trans *trans, size_t *count)
     return trans->plan;
 }
 
+const struct trans_file_conflict *
+trans_get_file_conflicts(const struct apg_trans *trans, size_t *count)
+{
+    if (!trans || !count)
+        return NULL;
+    *count = trans->file_conflict_count;
+    return trans->file_conflicts;
+}
+
 const struct trans_blocked_remove *
 trans_get_blocked_removes(const struct apg_trans *trans, size_t *count)
 {