From: Piotr Sawicki <p.sawicki2@partner.samsung.com>
Date: Mon, 24 Jul 2017 11:30:06 +0000 (+0200)
Subject: Add auto mode to the CAPI test app
X-Git-Tag: submit/tizen/20170727.154157~1^2~1
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=a19387defa7e9c700fbcce01fb21d6b806cb29a4;p=platform%2Fcore%2Fsecurity%2Faskuser.git

Add auto mode to the CAPI test app

The client sends randomly generated privilege at random intervals
of time. The server responds with 'deny once' to all pending requests
also at random intervals. This mode allows to perform stress tests of
the IPC module.

Change-Id: I52aa284fef5d50daec6831b02f3bc34a6679d12a
---

diff --git a/src/capi/test/privacy_privilege_manager_test.cpp b/src/capi/test/privacy_privilege_manager_test.cpp
index 5496cf9..a2c33f6 100644
--- a/src/capi/test/privacy_privilege_manager_test.cpp
+++ b/src/capi/test/privacy_privilege_manager_test.cpp
@@ -20,11 +20,13 @@
  * @brief       This file contains test of CAPI for Privacy Privilege Manager
  */
 
+#include <functional>
 #include <map>
 #include <set>
 #include <stdio.h>
 #include <string.h>
 #include <sys/types.h>
+#include <random>
 #include <glib.h>
 #include <unistd.h>
 
@@ -196,6 +198,9 @@ void printAppHelp(const char *programName)
     printf("Options:\n");
     printf("-s  run as a server\n");
     printf("-c  run as a client (uses CAPI)\n");
+    printf("-a  run client or server in auto mode (stress testing)");
+    printf("    The client will send randomly generated requests at random intervals of time.");
+    printf("    The server will respond with 'deny once' to all pending requests at random intervals of time.");
     printf("-h  display this help end exit\n");
 }
 
@@ -212,6 +217,12 @@ void printServerHelp()
     printPrompt(Mode::SERVER);
 }
 
+std::function<int(void)> createRandomGenerator() {
+    std::uniform_int_distribution<int> distribution(0, 1000);
+    std::mt19937 engine(time(0));
+    return std::bind(distribution, engine);
+}
+
 struct ServerSimulator : public IServerCallbacks {
 
     ServerSimulator()
@@ -334,6 +345,16 @@ struct ServerSimulator : public IServerCallbacks {
         }
     }
 
+    void respondToAllRequests() {
+        for (const auto &reqSet : m_requests) {
+            for (const auto &req : reqSet.second) {
+                m_channel->popupResponse(reqSet.first, req.m_id, PRIVACY_PRIVILEGE_MANAGER_REQUEST_RESULT_DENY_ONCE);
+            }
+        }
+
+        m_requests.clear();
+    }
+
     void showPrivilegeRequests() {
         printf("fd          requestId   privilege\n");
         for (const auto &con : m_requests) {
@@ -394,9 +415,10 @@ public:
             throw std::logic_error("AppContext::initialize called with argc < 1");
         }
 
+        bool autoMode = false;
         int c;
         opterr = 0;
-        while ((c = getopt (argc, argv, "sch")) != -1) {
+        while ((c = getopt (argc, argv, "cash")) != -1) {
             switch (c) {
                 case 's':
                     m_mode = Mode::SERVER;
@@ -404,6 +426,9 @@ public:
                 case 'c':
                     m_mode = Mode::CLIENT;
                     break;
+                case 'a':
+                    autoMode = true;
+                    break;
                 case 'h':
                 default:
                     break;
@@ -429,6 +454,11 @@ public:
         GIOChannel *gio_channel = g_io_channel_unix_new(0);
         g_io_add_watch(gio_channel, static_cast<GIOCondition>(G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL),
                        &AppContext::mainLoopCallback, this);
+
+        if (autoMode) {
+            m_randomGenerator = createRandomGenerator();
+            g_timeout_add(0, &AppContext::timerCallback, this);
+        }
     }
 
     void run() {
@@ -601,10 +631,68 @@ private:
         return TRUE;
     }
 
+    static gboolean timerCallback(gpointer user_data) {
+        AppContext *ctx = static_cast<AppContext *>(user_data);
+
+        switch (ctx->m_mode) {
+            case Mode::CLIENT:
+                ctx->handleAutoClient();
+                break;
+            case Mode::SERVER:
+                ctx->handleAutoServer();
+                break;
+            case Mode::UNKNOWN:
+            default:
+                printf("Mode not set, exiting.\n");
+                exit(EXIT_FAILURE);
+        }
+
+        g_timeout_add(ctx->m_randomGenerator(), timerCallback, ctx);
+
+        return FALSE;
+    }
+
+    void handleAutoClient() {
+        int requests = m_randomGenerator() % 10;
+        static RequestId clientRequestId;
+
+        for (int ri = 0; ri < requests; ri++) {
+            std::string privilege = generateRandomString(1 + m_randomGenerator() % 128);
+
+            printf("sending localId: %d privilege: \"%s\"\n", clientRequestId, privilege.c_str());
+
+            ClientRequest *request = new ClientRequest{ clientRequestId++, m_mainloop, false };
+            ppm_error_e err = static_cast<ppm_error_e>(ppm_request_permission(privilege.c_str(),
+                                                       &AppContext::requestResponseCallback, request));
+            if (err != PRIVACY_PRIVILEGE_MANAGER_ERROR_NONE) {
+                delete request;
+            }
+        }
+    }
+
+    void handleAutoServer() {
+        m_serverSimulator->respondToAllRequests();
+    }
+
+    std::string generateRandomString(int len) {
+        if (len > 1024)
+            throw std::logic_error("String too long " + std::to_string(len));
+
+        char tab[len + 1];
+
+        for (int i = 0; i < len; i++) {
+            tab[i] = 'a' + m_randomGenerator() % ('z' - 'a' + 1);
+        }
+        tab[len] = '\0';
+
+        return std::string(tab);
+    }
+
     GMainLoop *m_mainloop;
     ServerSimulator *m_serverSimulator;
     ServerChannel *m_channel;
     Mode m_mode;
+    std::function<int(void)> m_randomGenerator;
 };
 
 int main(int argc, char **argv)