Fixes

Author: marcoSanti

src/posix/utils/cache/consent_request_cache.hpp

@@ -34,18 +34,12 @@ class ConsentRequestCache {
         START_LOG(capio_syscall(SYS_gettid), "call(path=%s, tid=%ld, source=%s)", path.c_str(), tid,
                   source_func.c_str());
 
-        std::string resolved_path;
-        resolved_path.reserve(PATH_MAX);
-        syscall_no_intercept(SYS_readlink, path.c_str(), resolved_path.data(), PATH_MAX);
-        resolved_path = capio_absolute(resolved_path);
-        LOG("Resolved path from %s to %s. Using resolved path for query", path.c_str(),
-            resolved_path.c_str());
-
         /**
          * If entry is not present in cache, then proceed to perform request. othrewise if present,
          * there is no need to perform request to server and can proceed
          */
-        if (available_consent->find(resolved_path) == available_consent->end()) {
+        if (const auto resolved_path = resolve_possible_symlink(path);
+            available_consent->find(resolved_path) == available_consent->end()) {
             LOG("File not present in cache. performing request");
             auto res = _consent_to_proceed_request(resolved_path, tid, source_func);
             LOG("Registering new file for consent to proceed");

src/posix/utils/cache/read_request_cache_fs.hpp

@@ -12,8 +12,11 @@ class ReadRequestCacheFS {
                                        const long tid, const long fd) {
         START_LOG(capio_syscall(SYS_gettid), "call(path=%s, end_of_Read=%ld, tid=%ld, fd=%ld)",
                   path.c_str(), end_of_Read, tid, fd);
+        const auto resolved_path = resolve_possible_symlink(path);
+
         char req[CAPIO_REQ_MAX_SIZE];
-        sprintf(req, "%04d %ld %ld %s %ld", CAPIO_REQUEST_READ, tid, fd, path.c_str(), end_of_Read);
+        sprintf(req, "%04d %ld %ld %s %ld", CAPIO_REQUEST_READ, tid, fd, resolved_path.c_str(),
+                end_of_Read);
         LOG("Sending read request %s", req);
         buf_requests->write(req, CAPIO_REQ_MAX_SIZE);
         const capio_off64_t res = bufs_response->at(tid)->read();

src/posix/utils/filesystem.hpp

@@ -300,4 +300,20 @@ inline void set_current_dir(const std::filesystem::path &cwd) {
     current_dir = std::make_unique<std::filesystem::path>(cwd);
 }
 
+/**
+ * Resolve a possible symbolic link to the absolute path that it points to
+ * @param path
+ * @return
+ */
+[[nodiscard]] static std::string resolve_possible_symlink(const std::filesystem::path &path) {
+    START_LOG(capio_syscall(SYS_gettid), "call(path=%s)", path.c_str());
+
+    std::string resolved_path(PATH_MAX, 0);
+    syscall_no_intercept(SYS_readlink, path.c_str(), resolved_path.data(), PATH_MAX);
+    resolved_path = capio_absolute(resolved_path);
+    LOG("Resolved path from %s to %s. Using resolved path for query", path.c_str(),
+        resolved_path.c_str());
+    return resolved_path;
+}
+
 #endif // CAPIO_POSIX_UTILS_FILESYSTEM_HPP

src/posix/utils/requests.hpp

@@ -88,13 +88,16 @@ inline capio_off64_t posix_directory_committed_request(const long pid,
                                                        const std::filesystem::path &path,
                                                        char *token_path) {
     START_LOG(capio_syscall(SYS_gettid), "call(path=%s)", path.c_str());
+
+    const auto resolved_path = resolve_possible_symlink(path);
+
     char req[CAPIO_REQ_MAX_SIZE];
 
-    sprintf(req, "%04d %ld %s ", CAPIO_REQUEST_POSIX_DIR_COMMITTED, pid, path.c_str());
+    sprintf(req, "%04d %ld %s ", CAPIO_REQUEST_POSIX_DIR_COMMITTED, pid, resolved_path.c_str());
     buf_requests->write(req, CAPIO_REQ_MAX_SIZE);
-    LOG("Sent query for directory committement");
+    LOG("Sent query for directory commitment");
     capio_off64_t path_len = bufs_response->at(pid)->read();
-    LOG("Directory %s has the token length of %llu", path.c_str(), path_len);
+    LOG("Directory %s has the token length of %llu", resolved_path.c_str(), path_len);
 
     stc_queue->read(token_path, path_len);
     LOG("commit token path will exist at %s", token_path);
@@ -105,8 +108,9 @@ inline capio_off64_t posix_directory_committed_request(const long pid,
 inline void close_request(const std::filesystem::path &path, const long tid) {
     START_LOG(capio_syscall(SYS_gettid), "call(path=%s, tid=%ld)", path.c_str(), tid);
     write_request_cache_fs->flush(tid);
+    const auto resolved_path = resolve_possible_symlink(path);
     char req[CAPIO_REQ_MAX_SIZE];
-    sprintf(req, "%04d %ld %s", CAPIO_REQUEST_CLOSE, tid, path.c_str());
+    sprintf(req, "%04d %ld %s", CAPIO_REQUEST_CLOSE, tid, resolved_path.c_str());
     buf_requests->write(req, CAPIO_REQ_MAX_SIZE);
 }
 
@@ -131,9 +135,9 @@ inline void exit_group_request(const long tid) {
 inline void open_request(const int fd, const std::filesystem::path &path, const long tid) {
     START_LOG(capio_syscall(SYS_gettid), "call(fd=%ld, path=%s, tid=%ld)", fd, path.c_str(), tid);
     write_request_cache_fs->flush(tid);
-
+    const auto resolved_path = resolve_possible_symlink(path);
     char req[CAPIO_REQ_MAX_SIZE];
-    sprintf(req, "%04d %ld %d %s", CAPIO_REQUEST_OPEN, tid, fd, path.c_str());
+    sprintf(req, "%04d %ld %d %s", CAPIO_REQUEST_OPEN, tid, fd, resolved_path.c_str());
     buf_requests->write(req, CAPIO_REQ_MAX_SIZE);
     capio_off64_t res = bufs_response->at(tid)->read();
     LOG("Obtained from server %llu", res);