grc-iit · iameneko · May 6, 2026
diff --git a/ChronoVisor/include/ClientPortalService.h b/ChronoVisor/include/ClientPortalService.h
@@ -141,16 +141,15 @@ class ClientPortalService: public thallium::provider<ClientPortalService>
     void ShowChronicles(tl::request const& request, ClientId const& client_id)
     {
         std::vector<std::string> chronicles;
-        theVisorClientPortal.ShowChronicles(client_id, chronicles);
-        request.respond(chronicles);
+        int return_code = theVisorClientPortal.ShowChronicles(client_id, chronicles);
+        request.respond(std::make_pair(return_code, std::move(chronicles)));
     }
 
     void ShowStories(tl::request const& request, ClientId const& client_id, const std::string& chronicle_name)
     {
         std::vector<std::string> stories;
-        theVisorClientPortal.ShowStories(client_id, chronicle_name, stories);
-
-        request.respond(stories);
+        int return_code = theVisorClientPortal.ShowStories(client_id, chronicle_name, stories);
+        request.respond(std::make_pair(return_code, std::move(stories)));
     }
 
 private:

diff --git a/ChronoVisor/src/VisorClientPortal.cpp b/ChronoVisor/src/VisorClientPortal.cpp
@@ -366,10 +366,15 @@ int chronolog::VisorClientPortal::ShowChronicles(chl::ClientId const& client_id,
 {
     LOG_DEBUG("[VisorClientPortal] Show Chronicles: PID={}, ClientID={}", getpid(), client_id);
 
-    // TODO: add client_id authorization check : if ( chronicle_action_is_authorized())
-    chronicleMetaDirectory.show_chronicles(chronicles);
+    // Listing chronicles is a client-scoped metadata read; route through the
+    // chronicle authorization predicate with no specific chronicle name. All
+    // authorization predicates currently return true (tracked in #637).
+    if(!chronicle_action_is_authorized(client_id, ""))
+    {
+        return chronolog::CL_ERR_NOT_AUTHORIZED;
+    }
 
-    return chronolog::CL_SUCCESS;
+    return chronicleMetaDirectory.show_chronicles(chronicles);
 }
 
 int chronolog::VisorClientPortal::ShowStories(chl::ClientId const& client_id,
@@ -380,12 +385,10 @@ int chronolog::VisorClientPortal::ShowStories(chl::ClientId const& client_id,
 
     if(!chronicle_action_is_authorized(client_id, chronicle_name))
     {
-        return chronolog::CL_ERR_UNKNOWN;
+        return chronolog::CL_ERR_NOT_AUTHORIZED;
     }
 
-    chronicleMetaDirectory.show_stories(chronicle_name, stories);
-
-    return chronolog::CL_SUCCESS;
+    return chronicleMetaDirectory.show_stories(chronicle_name, stories);
 }
 
 

diff --git a/Client/cpp/include/chronolog_client.h b/Client/cpp/include/chronolog_client.h
@@ -147,9 +147,9 @@ class Client
 
     int EditChronicleAttr(std::string const& chronicle_name, const std::string& key, const std::string& value);
 
-    std::vector<std::string>& ShowChronicles(std::vector<std::string>&);
+    int ShowChronicles(std::vector<std::string>& chronicles);
 
-    std::vector<std::string>& ShowStories(std::string const& chronicle_name, std::vector<std::string>&);
+    int ShowStories(std::string const& chronicle_name, std::vector<std::string>& stories);
 
     int ReplayStory(std::string const& chronicle,
                     std::string const& story,

diff --git a/Client/cpp/src/ChronologClient.cpp b/Client/cpp/src/ChronologClient.cpp
@@ -1,83 +1,85 @@
 #include "ChronologClientImpl.h"
 
-chronolog::Client::Client(chronolog::ClientPortalServiceConf const &visorClientPortalServiceConf)
+chronolog::Client::Client(chronolog::ClientPortalServiceConf const& visorClientPortalServiceConf)
 {
-    chronologClientImpl = chronolog::ChronologClientImpl::GetClientImplInstance(visorClientPortalServiceConf, chronolog::WRITER_MODE, chronolog::ClientQueryServiceConf{"","",0,0});
+    chronologClientImpl =
+            chronolog::ChronologClientImpl::GetClientImplInstance(visorClientPortalServiceConf,
+                                                                  chronolog::WRITER_MODE,
+                                                                  chronolog::ClientQueryServiceConf{"", "", 0, 0});
 }
 
-chronolog::Client::Client(chronolog::ClientPortalServiceConf const &visorClientPortalServiceConf, chronolog::ClientQueryServiceConf const& clientQueryServiceConf)
+chronolog::Client::Client(chronolog::ClientPortalServiceConf const& visorClientPortalServiceConf,
+                          chronolog::ClientQueryServiceConf const& clientQueryServiceConf)
 {
-    chronologClientImpl = chronolog::ChronologClientImpl::GetClientImplInstance(visorClientPortalServiceConf, chronolog::READER_MODE, clientQueryServiceConf);
+    chronologClientImpl = chronolog::ChronologClientImpl::GetClientImplInstance(visorClientPortalServiceConf,
+                                                                                chronolog::READER_MODE,
+                                                                                clientQueryServiceConf);
 }
 
-chronolog::Client::~Client()
-{
-    delete chronologClientImpl;
-}
+chronolog::Client::~Client() { delete chronologClientImpl; }
 
-int chronolog::Client::Connect()
-{
-    return chronologClientImpl->Connect();
-}
+int chronolog::Client::Connect() { return chronologClientImpl->Connect(); }
 
-int chronolog::Client::Disconnect()
-{
-    return chronologClientImpl->Disconnect();
-}
+int chronolog::Client::Disconnect() { return chronologClientImpl->Disconnect(); }
 
-int chronolog::Client::CreateChronicle(std::string const &chronicle_name
-                                       , std::map <std::string, std::string> const &attrs, int &flags)
+int chronolog::Client::CreateChronicle(std::string const& chronicle_name,
+                                       std::map<std::string, std::string> const& attrs,
+                                       int& flags)
 {
     return chronologClientImpl->CreateChronicle(chronicle_name, attrs, flags);
 }
 
-int chronolog::Client::DestroyChronicle(std::string const &chronicle_name)
+int chronolog::Client::DestroyChronicle(std::string const& chronicle_name)
 {
     return chronologClientImpl->DestroyChronicle(chronicle_name);
 }
 
-std::pair <int, chronolog::StoryHandle*>
-chronolog::Client::AcquireStory(std::string const &chronicle_name, std::string const &story_name
-                                , const std::map <std::string, std::string> &attrs, int &flags)
+std::pair<int, chronolog::StoryHandle*> chronolog::Client::AcquireStory(std::string const& chronicle_name,
+                                                                        std::string const& story_name,
+                                                                        const std::map<std::string, std::string>& attrs,
+                                                                        int& flags)
 {
     return chronologClientImpl->AcquireStory(chronicle_name, story_name, attrs, flags);
 }
 
-int chronolog::Client::ReleaseStory(std::string const &chronicle_name, std::string const &story_name)
+int chronolog::Client::ReleaseStory(std::string const& chronicle_name, std::string const& story_name)
 {
     return chronologClientImpl->ReleaseStory(chronicle_name, story_name);
 }
 
-int chronolog::Client::DestroyStory(std::string const &chronicle_name, std::string const &story_name)
+int chronolog::Client::DestroyStory(std::string const& chronicle_name, std::string const& story_name)
 {
     return chronologClientImpl->DestroyStory(chronicle_name, story_name);
 }
 
-int chronolog::Client::GetChronicleAttr(std::string const &chronicle_name, const std::string &key, std::string &value)
+int chronolog::Client::GetChronicleAttr(std::string const& chronicle_name, const std::string& key, std::string& value)
 {
     return chronologClientImpl->GetChronicleAttr(chronicle_name, key, value);
 }
 
-int chronolog::Client::EditChronicleAttr(std::string const &chronicle_name, const std::string &key
-                                         , const std::string &value)
+int chronolog::Client::EditChronicleAttr(std::string const& chronicle_name,
+                                         const std::string& key,
+                                         const std::string& value)
 {
     return chronologClientImpl->EditChronicleAttr(chronicle_name, key, value);
 }
 
-std::vector <std::string> &chronolog::Client::ShowChronicles(std::vector <std::string> &chronicles)
+int chronolog::Client::ShowChronicles(std::vector<std::string>& chronicles)
 {
     return chronologClientImpl->ShowChronicles(chronicles);
 }
 
-std::vector <std::string> &
-chronolog::Client::ShowStories(std::string const &chronicle_name, std::vector <std::string> &stories)
+int chronolog::Client::ShowStories(std::string const& chronicle_name, std::vector<std::string>& stories)
 {
     return chronologClientImpl->ShowStories(chronicle_name, stories);
 }
 
 
-int chronolog::Client::ReplayStory(std::string const & chronicle_name, std::string const & story_name, uint64_t start_time, uint64_t end_time
-                , std::vector<chronolog::Event> & event_series)
+int chronolog::Client::ReplayStory(std::string const& chronicle_name,
+                                   std::string const& story_name,
+                                   uint64_t start_time,
+                                   uint64_t end_time,
+                                   std::vector<chronolog::Event>& event_series)
 {
     return chronologClientImpl->replay_story(chronicle_name, story_name, start_time, end_time, event_series);
 }
diff --git a/Client/cpp/src/ChronologClientImpl.cpp b/Client/cpp/src/ChronologClientImpl.cpp
@@ -537,38 +537,28 @@ int chronolog::ChronologClientImpl::EditChronicleAttr(std::string const& chronic
     return editStatus;
 }
 
-std::vector<std::string>& chronolog::ChronologClientImpl::ShowChronicles(std::vector<std::string>& chronicles)
+int chronolog::ChronologClientImpl::ShowChronicles(std::vector<std::string>& chronicles)
 {
+    chronicles.clear();
     std::lock_guard<std::mutex> lock_client(chronologClientMutex);
 
     if((clientState == UNKNOWN) || (clientState == SHUTTING_DOWN))
     {
         LOG_ERROR("[ChronoLogClientImpl] Failed to fetch chronicles: Client is in an unknown or shutting down state.");
-        return chronicles;
+        return chronolog::CL_ERR_UNKNOWN;
     }
 
-    // Fetch the list of chronicles from the Visor using the RPC call.
-    chronicles = rpcVisorClient->ShowChronicles(clientId);
-
-    // Log the number of chronicles fetched and return the list.
-    if(!chronicles.empty())
-    {
-        LOG_INFO("[ChronoLogClientImpl] Successfully fetched {} chronicles.", chronicles.size());
-    }
-    else
-    {
-        LOG_WARNING("[ChronoLogClientImpl] No chronicles found for the client.");
-    }
-    return chronicles;
+    return rpcVisorClient->ShowChronicles(clientId, chronicles);
 }
 
-std::vector<std::string>& chronolog::ChronologClientImpl::ShowStories(std::string const& chronicle_name,
-                                                                      std::vector<std::string>& stories)
+int chronolog::ChronologClientImpl::ShowStories(std::string const& chronicle_name, std::vector<std::string>& stories)
 {
+    stories.clear();
+
     if(chronicle_name.empty())
     {
         LOG_ERROR("[ChronoLogClientImpl] Failed to fetch stories: Empty chronicle name provided.");
-        return stories;
+        return chronolog::CL_ERR_INVALID_ARG;
     }
 
     std::lock_guard<std::mutex> lock_client(chronologClientMutex);
@@ -578,24 +568,10 @@ std::vector<std::string>& chronolog::ChronologClientImpl::ShowStories(std::strin
         LOG_ERROR("[ChronoLogClientImpl] Failed to fetch stories for chronicle '{}': Client is in an unknown or "
                   "shutting down state.",
                   chronicle_name);
-        return stories;
+        return chronolog::CL_ERR_UNKNOWN;
     }
 
-    // Fetch stories for the given chronicle name using the RPC call.
-    stories = rpcVisorClient->ShowStories(clientId, chronicle_name);
-
-    // Log the number of stories fetched and return the list.
-    if(!stories.empty())
-    {
-        LOG_INFO("[ChronoLogClientImpl] Successfully fetched {} stories for chronicle '{}'.",
-                 stories.size(),
-                 chronicle_name);
-    }
-    else
-    {
-        LOG_WARNING("[ChronoLogClientImpl] No stories found for chronicle '{}'.", chronicle_name);
-    }
-    return stories;
+    return rpcVisorClient->ShowStories(clientId, chronicle_name, stories);
 }
 
 ////////////////////////////

diff --git a/Client/cpp/src/ChronologClientImpl.h b/Client/cpp/src/ChronologClientImpl.h
@@ -77,8 +77,8 @@ class ChronologClientImpl
 
     int EditChronicleAttr(std::string const& chronicle_name, const std::string& key, const std::string& value);
 
-    std::vector<std::string>& ShowChronicles(std::vector<std::string>&);
-    std::vector<std::string>& ShowStories(const std::string& chronicle_name, std::vector<std::string>&);
+    int ShowChronicles(std::vector<std::string>& chronicles);
+    int ShowStories(const std::string& chronicle_name, std::vector<std::string>& stories);
 
     int
     replay_story(ChronicleName const&, StoryName const&, uint64_t start, uint64_t end, std::vector<Event>& eventSeries);

diff --git a/Client/cpp/src/rpcVisorClient.h b/Client/cpp/src/rpcVisorClient.h
@@ -344,58 +344,59 @@ class RpcVisorClient
         return (chronolog::CL_ERR_UNKNOWN);
     }
 
-    std::vector<std::string> ShowChronicles(ClientId const& client_id) //, std::vector<std::string> & chronicles)
+    int ShowChronicles(ClientId const& client_id, std::vector<std::string>& chronicles)
     {
         LOG_INFO("[RPCVisorClient] Attempting to retrieve list of chronicles for ClientID={}", client_id);
         try
         {
-            std::vector<std::string> chronicleList = show_chronicles.on(service_ph)(client_id);
+            std::pair<int, std::vector<std::string>> response = show_chronicles.on(service_ph)(client_id);
+            chronicles = std::move(response.second);
 
-            if(!chronicleList.empty())
+            if(response.first == chronolog::CL_SUCCESS)
             {
-                LOG_INFO("[RPCVisorClient] Successfully fetched {} chronicles for ClientID={}",
-                         chronicleList.size(),
-                         client_id);
+                LOG_INFO("[RPCVisorClient] Fetched {} chronicles for ClientID={}", chronicles.size(), client_id);
             }
             else
             {
-                LOG_WARNING("[RPCVisorClient] Retrieved an empty list of chronicles for ClientID={}", client_id);
+                LOG_WARNING("[RPCVisorClient] ShowChronicles returned status {} for ClientID={}",
+                            response.first,
+                            client_id);
             }
-            return chronicleList;
+            return response.first;
         }
         catch(tl::exception const&)
         {
             LOG_ERROR("[RPCVisorClient] Failed to fetch chronicles for ClientID {}. Thallium exception encountered.",
                       client_id);
         }
-        return (std::vector<std::string>{});
+        return chronolog::CL_ERR_UNKNOWN;
     }
 
-    std::vector<std::string> ShowStories(ClientId const& client_id,
-                                         std::string const& chronicle_name) //, std::vector<std::string> & stories )
+    int ShowStories(ClientId const& client_id, std::string const& chronicle_name, std::vector<std::string>& stories)
     {
         LOG_INFO("[RPCVisorClient] Attempting to retrieve stories for ClientID={}, ChronicleName={}",
                  client_id,
                  chronicle_name);
         try
         {
-            std::vector<std::string> storyList = show_stories.on(service_ph)(client_id, chronicle_name);
+            std::pair<int, std::vector<std::string>> response = show_stories.on(service_ph)(client_id, chronicle_name);
+            stories = std::move(response.second);
 
-            if(!storyList.empty())
+            if(response.first == chronolog::CL_SUCCESS)
             {
-                LOG_INFO("[RPCVisorClient] Successfully fetched {} stories for ClientID={} from ChronicleName={}",
-                         storyList.size(),
+                LOG_INFO("[RPCVisorClient] Fetched {} stories for ClientID={} from ChronicleName={}",
+                         stories.size(),
                          client_id,
                          chronicle_name);
             }
             else
             {
-                LOG_WARNING("[RPCVisorClient] Retrieved an empty list of stories for ClientID={} from ChronicleName={}",
+                LOG_WARNING("[RPCVisorClient] ShowStories returned status {} for ClientID={}, ChronicleName={}",
+                            response.first,
                             client_id,
                             chronicle_name);
             }
-
-            return storyList;
+            return response.first;
         }
         catch(tl::exception const&)
         {
@@ -404,7 +405,7 @@ class RpcVisorClient
                       client_id,
                       chronicle_name);
         }
-        return (std::vector<std::string>{});
+        return chronolog::CL_ERR_UNKNOWN;
     }
 
     ~RpcVisorClient()

diff --git a/test/integration/client/client_metadata_rpc_test.cpp b/test/integration/client/client_metadata_rpc_test.cpp
@@ -104,7 +104,7 @@ int main(int argc, char** argv)
 
     t1 = std::chrono::steady_clock::now();
     std::vector<std::string> chronicle_names_retrieved;
-    chronicle_names_retrieved = client.ShowChronicles(chronicle_names_retrieved);
+    client.ShowChronicles(chronicle_names_retrieved);
     t2 = std::chrono::steady_clock::now();
     duration_show_chronicles += (t2 - t1);
     //std::sort(chronicle_names_retrieved.begin(), chronicle_names_retrieved.end());