Add query functionality to daemonctl

Change-Id: I61455821bfdd5b83ecd1c61895320d36d3fa0f57
Signed-off-by: Igor Kotrasinski <i.kotrasinsk@partner.samsung.com>

diff --git a/simulatordaemon/daemonctl/inc/ControlCommand.h b/simulatordaemon/daemonctl/inc/ControlCommand.h
index a77cd477ef54930d620de8d846e2b8fef81253da..bef3dc30f965de502523064155c0b1a676550482 100644 (file)
--- a/simulatordaemon/daemonctl/inc/ControlCommand.h
+++ b/simulatordaemon/daemonctl/inc/ControlCommand.h
@@ -29,6 +29,8 @@
 enum ControlCommand : uint32_t {
        CTL_SET_PORT,
        CTL_SET_PORT_REPLY,
+       CTL_QUERY_PORT,
+       CTL_QUERY_PORT_REPLY,
        CTL_INVALID_CMD_REPLY,
 };
 
@@ -38,7 +40,6 @@ enum ControlReplyStatus : uint32_t {
        CTL_REPLY_INTERNAL_ERROR,
 };
 
-
 struct __attribute__((packed)) SetPortControlCommand {
        TEEC_UUID uuid;
        bool clear;
@@ -49,4 +50,15 @@ struct __attribute__((packed)) SetPortControlCommandReply {
        enum ControlReplyStatus status;
 };
 
+struct __attribute__((packed)) QueryPortControlCommand {
+       TEEC_UUID uuid;
+};
+
+
+struct __attribute__((packed)) QueryPortControlCommandReply {
+       enum ControlReplyStatus status;
+       bool clear;
+       uint32_t port;
+};
+
 #endif /* _CONTROLCOMMAND_H */

diff --git a/simulatordaemon/daemonctl/inc/handlers/DebugPortHandler.h b/simulatordaemon/daemonctl/inc/handlers/DebugPortHandler.h
index 863ab5bf3aacc1a40265d98147ea26935b70aa4a..174e8b5f78427552bfa939f4a1436b4f971e33a5 100644 (file)
--- a/simulatordaemon/daemonctl/inc/handlers/DebugPortHandler.h
+++ b/simulatordaemon/daemonctl/inc/handlers/DebugPortHandler.h
@@ -20,6 +20,7 @@
  * @brief  Common daemonctl code and main method
  */
 
+#include <stdint.h>
 #include <string>
 #include <boost/program_options/options_description.hpp>
 #include <boost/program_options/variables_map.hpp>
@@ -41,8 +42,11 @@ private:
        void readOptionsPermissively(int argc, char *argv[]);
        void parseCommandlineArgs(int argc, char *argv[]);
        void checkExactlyOneMainFlag();
-       bool handleCommandlineArgs(
-               int argc, char *argv[], SetPortControlCommand &cmd);
+       TEEC_UUID getUuidArgument();
+       int32_t getPortArgument();
+       int doHandle(int argc, char *argv[]);
+       int handleSetPortCommand();
+       int handleQueryPortCommand();
 };
 
 #endif /* _DEBUG_PORT_HANDLER_H */

diff --git a/simulatordaemon/daemonctl/src/handlers/DebugPortHandler.cpp b/simulatordaemon/daemonctl/src/handlers/DebugPortHandler.cpp
index 8260cded6e57cd227bc9350ac9c0b2e91d67e509..05d9a6deb85fcc323bcdf66f8a3735a155e65a57 100644 (file)
--- a/simulatordaemon/daemonctl/src/handlers/DebugPortHandler.cpp
+++ b/simulatordaemon/daemonctl/src/handlers/DebugPortHandler.cpp
@@ -46,10 +46,11 @@ DebugPortHandler::DebugPortHandler()
        m_desc.add_options()
                ("help,h", "Display this help message")
                ("uuid,u", boost::program_options::value<std::string>(),
-                "TA UUID to set / clear port for")
+                "TA UUID to set / clear / query port for")
                ("port,p", boost::program_options::value<int32_t>(),
                 "Set debug port number")
-               ("clear,c", "Clear debug port number");
+               ("clear,c", "Clear debug port number")
+               ("query,q", "Query debug port number");
 }
 
 void DebugPortHandler::readOptions(int argc, char *argv[]) {
@@ -71,7 +72,7 @@ void DebugPortHandler::readOptionsPermissively(int argc, char *argv[])
 
 void DebugPortHandler::checkExactlyOneMainFlag()
 {
-       std::vector<std::string> mainOptions = { "port", "clear" };
+       std::vector<std::string> mainOptions = { "port", "clear", "query" };
        auto optionCount = [this](std::string &s) { return m_opts.count(s) > 0; };
        bool mainOptionCount = std::count_if(mainOptions.begin(),
                                             mainOptions.end(),
@@ -92,68 +93,104 @@ void DebugPortHandler::parseCommandlineArgs(
        readOptionsPermissively(argc, argv);
        if (m_opts.count("help"))
                return;
+
+       readOptions(argc, argv);
        checkExactlyOneMainFlag();
+}
+
+TEEC_UUID DebugPortHandler::getUuidArgument()
+{
+       int ret;
+       TEEC_UUID uuid;
        if (!m_opts.count("uuid"))
                throw boost::program_options::required_option("uuid");
+       ret = uuidStringToUuid(m_opts["uuid"].as<std::string>(), uuid);
+       if (ret)
+               throw boost::program_options::error(
+                       "Invalid UUID format, expected x{8}-x{4}-x{4}-x{4}-x{12}");
+       return uuid;
 }
 
-bool DebugPortHandler::handleCommandlineArgs(
-               int argc, char *argv[], SetPortControlCommand &cmd)
+int32_t DebugPortHandler::getPortArgument()
 {
-       int ret;
+       if (!m_opts.count("port"))
+               throw boost::program_options::required_option("port");
+       int32_t port = m_opts["port"].as<int32_t>();
+       if (port < 0)
+               throw boost::program_options::error(
+                               "Port number cannot be negative!");
+       return port;
+}
 
+int DebugPortHandler::doHandle(int argc, char *argv[])
+{
        parseCommandlineArgs(argc, argv);
        if (m_opts.count("help")) {
                std::cout << m_desc;
-               return false;
+               return 0;
        }
 
+       if (m_opts.count("query"))
+               return handleQueryPortCommand();
+       else
+               return handleSetPortCommand();
+}
+
+int DebugPortHandler::handleSetPortCommand()
+{
+       SetPortControlCommand cmd;
+       SetPortControlCommandReply reply;
+       int ret;
+
        if (m_opts.count("clear")) {
                cmd.clear = true;
                cmd.port = 0;
        } else if (m_opts.count("port")) {
                cmd.clear = false;
-               cmd.port = m_opts["port"].as<int32_t>();
-               if (cmd.port < 0)
-                       throw boost::program_options::error(
-                                       "Port number cannot be negative!");
+               cmd.port = getPortArgument();
        }
-
-       TEEC_UUID taUuid;
-       ret = uuidStringToUuid(m_opts["uuid"].as<std::string>(), taUuid);
+       cmd.uuid = getUuidArgument();
+       ret = communicateWithDaemon(CTL_SET_PORT, &cmd, sizeof(cmd),
+                                   CTL_SET_PORT_REPLY, &reply, sizeof(reply));
        if (ret)
-               throw boost::program_options::error(
-                       "Invalid UUID format, expected x{8}-x{4}-x{4}-x{4}-x{12}");
-       cmd.uuid = taUuid;
-       return true;
+               return ret;
+       if (reply.status != CTL_REPLY_SUCCESS) {
+               std::cerr << "Command failed: " << controlErrors[reply.status] << std::endl;
+               return 1;
+       }
+       return 0;
 }
 
-int DebugPortHandler::handle(int argc, char *argv[])
+int DebugPortHandler::handleQueryPortCommand()
 {
+       QueryPortControlCommand cmd;
+       QueryPortControlCommandReply reply;
        int ret;
-       bool shouldCommunicate;
-       SetPortControlCommand cmd;
-       SetPortControlCommandReply reply;
-
-       try {
-               shouldCommunicate = handleCommandlineArgs(argc, argv, cmd);
-       } catch (boost::program_options::error &e) {
-               std::cerr << "Commandline parsing error: " << e.what() << std::endl;
-               std::cerr << m_desc;
-               return 1;
-       }
-       if (!shouldCommunicate)
-               return 0;
 
-       ret = communicateWithDaemon(CTL_SET_PORT, &cmd, sizeof(cmd),
-                                   CTL_SET_PORT_REPLY, &reply, sizeof(reply));
+       cmd.uuid = getUuidArgument();
+       ret = communicateWithDaemon(CTL_QUERY_PORT, &cmd, sizeof(cmd),
+                                   CTL_QUERY_PORT_REPLY, &reply, sizeof(reply));
        if (ret)
                return ret;
-
        if (reply.status != CTL_REPLY_SUCCESS) {
                std::cerr << "Command failed: " << controlErrors[reply.status] << std::endl;
                return 1;
+       } else {
+               if (reply.clear)
+                       std::cout << std::endl;
+               else
+                       std::cout << reply.port << std::endl;
        }
-
        return 0;
 }
+
+int DebugPortHandler::handle(int argc, char *argv[])
+{
+       try {
+               return doHandle(argc, argv);
+       } catch (boost::program_options::error &e) {
+               std::cerr << "Commandline parsing error: " << e.what() << std::endl;
+               std::cerr << m_desc;
+               return 1;
+       }
+}

diff --git a/simulatordaemon/inc/ControlConnectionHandler.h b/simulatordaemon/inc/ControlConnectionHandler.h
index ad3d31d553e5e4eaade32da784736d30492d5350..165056869c6d0cf0d542e7f96e59e22cf4116b73 100644 (file)
--- a/simulatordaemon/inc/ControlConnectionHandler.h
+++ b/simulatordaemon/inc/ControlConnectionHandler.h
@@ -42,6 +42,7 @@ public:
 private:
        std::shared_ptr<UUIDConfigManager> getUUIDConfig();
        void handleSetPortCommand(std::vector<char> &data);
+       void handleQueryPortCommand(std::vector<char> &data);
        void handleInvalidCommand();
        void handleConnectionClosed();
        IConnectionWriter<enum ControlCommand> *m_writer= nullptr;

diff --git a/simulatordaemon/src/ControlConnectionHandler.cpp b/simulatordaemon/src/ControlConnectionHandler.cpp
index f768e7f6108e8ea3e8ef42c17015b19e1da55aba..fd698b6ab21070885bc15f0fc77a7c1dd349423f 100644 (file)
--- a/simulatordaemon/src/ControlConnectionHandler.cpp
+++ b/simulatordaemon/src/ControlConnectionHandler.cpp
@@ -23,6 +23,8 @@
 #include <cstring>
 #include <memory>
 #include <boost/asio.hpp>
+#include <boost/optional.hpp>
+#include <boost/none.hpp>
 #include "log.h"
 #include "ControlConnectionHandler.h"
 #include "IConnectionWriter.h"
@@ -44,6 +46,8 @@ int32_t ControlConnectionHandler::getDataSize(enum ControlCommand cmd)
        switch(cmd) {
        case CTL_SET_PORT:
                return sizeof(SetPortControlCommand);
+       case CTL_QUERY_PORT:
+               return sizeof(QueryPortControlCommand);
        default:
                LOGE(SIM_DAEMON, "Invalid command received!");
                return -1;
@@ -57,6 +61,8 @@ void ControlConnectionHandler::handleRead(enum ControlCommand header,
        case CTL_SET_PORT:
                handleSetPortCommand(data);
                break;
+       case CTL_QUERY_PORT:
+               handleQueryPortCommand(data);
        default:
                handleInvalidCommand();
                break;
@@ -101,6 +107,38 @@ void ControlConnectionHandler::handleSetPortCommand(std::vector<char> &data)
        m_writer->write(CTL_SET_PORT_REPLY, (char *) &reply, sizeof(reply));
 }
 
+void ControlConnectionHandler::handleQueryPortCommand(std::vector<char> &data)
+{
+       struct QueryPortControlCommand cmd;
+       struct QueryPortControlCommandReply reply;
+
+       auto UUIDConfig = getUUIDConfig();
+       if (!UUIDConfig) {
+               reply.status = CTL_REPLY_INTERNAL_ERROR;
+               LOGE(SIM_DAEMON, "Setting UUID debug port failed - config manager not found");
+               m_writer->write(CTL_QUERY_PORT_REPLY, (char *) &reply, sizeof(reply));
+               return;
+       }
+
+       std::memcpy(&cmd, data.data(), sizeof(cmd));
+       boost::optional<uint32_t> port;
+       try {
+               port = UUIDConfig->at(cmd.uuid)->getDebugPort();
+       } catch (std::out_of_range) {
+               port = boost::none;
+       }
+
+       if (port == boost::none) {
+               reply.clear = true;
+               reply.port = 0;
+       } else {
+               reply.clear = false;
+               reply.port = *port;
+       }
+       reply.status = CTL_REPLY_SUCCESS;
+       m_writer->write(CTL_QUERY_PORT_REPLY, (char *) &reply, sizeof(reply));
+}
+
 void ControlConnectionHandler::handleInvalidCommand()
 {
        m_writer->write(CTL_INVALID_CMD_REPLY, nullptr, 0);