Implement cynara_admin_list_policies in admin-api layer

Implementation is complete on admin-api layer.
ApiInterface of libcynara-admin is enhanced by listPolicies method.
Its implementation in Logic layer of admin library is stubbed.

Change-Id: I25f2d4dbc8616717c7e19835c676b218615df9eb

diff --git a/src/admin/api/ApiInterface.h b/src/admin/api/ApiInterface.h
index 4f7eed0..6628b2c 100644 (file)
--- a/src/admin/api/ApiInterface.h
+++ b/src/admin/api/ApiInterface.h
@@ -52,6 +52,8 @@ public:
     virtual int removeBucket(const PolicyBucketId &bucket) = 0;
     virtual int adminCheck(const PolicyBucketId &startBucket, bool recursive,
                            const PolicyKey &key, PolicyResult &result) = 0;
+    virtual int listPolicies(const PolicyBucketId &bucket, const PolicyKey &filter,
+                             std::vector<Policy> &policies) = 0;
 
 };
 

diff --git a/src/admin/api/admin-api.cpp b/src/admin/api/admin-api.cpp
index 1e73ff7..c2a5212 100644 (file)
--- a/src/admin/api/admin-api.cpp
+++ b/src/admin/api/admin-api.cpp
@@ -20,7 +20,9 @@
  * @brief       Implementation of external libcynara-admin API
  */
 
+#include <functional>
 #include <map>
+#include <memory>
 #include <new>
 #include <stdexcept>
 #include <string>
@@ -219,3 +221,93 @@ int cynara_admin_check(struct cynara_admin *p_cynara_admin,
         return CYNARA_API_SUCCESS;
     });
 }
+
+static int createPoliciesArray(const char *bucket,
+                               const std::vector<Cynara::Policy> &policiesVector,
+                               struct cynara_admin_policy ***policies) {
+    typedef struct cynara_admin_policy Elem;
+    size_t elems = policiesVector.size();
+
+    Elem **tab = reinterpret_cast<Elem**>(calloc(elems + 1U, sizeof(Elem*)));
+    if (!tab)
+        return CYNARA_API_OUT_OF_MEMORY;
+    std::unique_ptr<Elem*, std::function<void(Elem**)>> plumber(tab,
+        [](Elem **tab) {
+            Elem *elem = *tab;
+            while (elem) {
+                free(elem->bucket);
+                free(elem->client);
+                free(elem->user);
+                free(elem->privilege);
+                free(elem->result_extra);
+                free(elem++);
+            }
+            free(tab);
+        });
+
+    for (size_t i = 0U; i < elems; ++i) {
+        tab[i] = reinterpret_cast<Elem*>(calloc(1U, sizeof(Elem)));
+        if (!tab[i])
+            return CYNARA_API_OUT_OF_MEMORY;
+
+        tab[i]->bucket = strdup(bucket);
+        if (!tab[i]->bucket)
+            return CYNARA_API_OUT_OF_MEMORY;
+
+        tab[i]->client = strdup(policiesVector[i].key().client().value().c_str());
+        if (!tab[i]->client)
+            return CYNARA_API_OUT_OF_MEMORY;
+        tab[i]->user = strdup(policiesVector[i].key().user().value().c_str());
+        if (!tab[i]->user)
+            return CYNARA_API_OUT_OF_MEMORY;
+        tab[i]->privilege = strdup(policiesVector[i].key().privilege().value().c_str());
+        if (!tab[i]->privilege)
+            return CYNARA_API_OUT_OF_MEMORY;
+
+        tab[i]->result = static_cast<int>(policiesVector[i].result().policyType());
+        if (!policiesVector[i].result().metadata().empty()) {
+            tab[i]->result_extra = strdup(policiesVector[i].result().metadata().c_str());
+            if (!tab[i]->result_extra)
+                return CYNARA_API_OUT_OF_MEMORY;
+        }
+    }
+    *policies = tab;
+    plumber.release();
+    return CYNARA_API_SUCCESS;
+}
+
+CYNARA_API
+int cynara_admin_list_policies(struct cynara_admin *p_cynara_admin, const char *bucket,
+                               const char *client, const char *user, const char *privilege,
+                               struct cynara_admin_policy ***policies) {
+    if (!p_cynara_admin || !p_cynara_admin->impl)
+        return CYNARA_API_INVALID_PARAM;
+    if (!bucket || !client || !user || !privilege)
+        return CYNARA_API_INVALID_PARAM;
+    if (!policies)
+        return CYNARA_API_INVALID_PARAM;
+
+    return Cynara::tryCatch([&]() {
+        Cynara::PolicyKeyFeature::ValueType clientStr;
+        Cynara::PolicyKeyFeature::ValueType userStr;
+        Cynara::PolicyKeyFeature::ValueType privilegeStr;
+        Cynara::PolicyBucketId bucketId;
+        try {
+            clientStr = client;
+            userStr = user;
+            privilegeStr = privilege;
+            bucketId = bucket;
+        } catch (const std::length_error &e) {
+            LOGE("%s", e.what());
+            return CYNARA_API_INVALID_PARAM;
+        }
+
+        std::vector<Cynara::Policy> policiesVector;
+        int ret = p_cynara_admin->impl->listPolicies(bucket, Cynara::PolicyKey(clientStr, userStr,
+                                                     privilegeStr), policiesVector);
+        if (ret != CYNARA_API_SUCCESS)
+            return ret;
+
+        return createPoliciesArray(bucket, policiesVector, policies);
+    });
+}

diff --git a/src/admin/logic/Logic.cpp b/src/admin/logic/Logic.cpp
index 67f7172..1bf8a8a 100644 (file)
--- a/src/admin/logic/Logic.cpp
+++ b/src/admin/logic/Logic.cpp
@@ -154,4 +154,10 @@ int Logic::adminCheck(const PolicyBucketId &startBucket, bool recursive, const P
     return CYNARA_API_SUCCESS;
 }
 
+int Logic::listPolicies(const PolicyBucketId &bucket UNUSED, const PolicyKey &filter UNUSED,
+                        std::vector<Policy> &policies UNUSED) {
+    //stub
+    return CYNARA_API_SUCCESS;
+}
+
 } // namespace Cynara

diff --git a/src/admin/logic/Logic.h b/src/admin/logic/Logic.h
index c0b3999..3469593 100644 (file)
--- a/src/admin/logic/Logic.h
+++ b/src/admin/logic/Logic.h
@@ -48,9 +48,10 @@ public:
     virtual int insertOrUpdateBucket(const PolicyBucketId &bucket,
                                      const PolicyResult &policyResult);
     virtual int removeBucket(const PolicyBucketId &bucket);
-
     virtual int adminCheck(const PolicyBucketId &startBucket, bool recursive,
                            const PolicyKey &key, PolicyResult &result);
+    virtual int listPolicies(const PolicyBucketId &bucket, const PolicyKey &filter,
+                             std::vector<Policy> &policies);
 };
 
 } // namespace Cynara