Implement and use template methods for serialization of multiple variables

Change-Id: I84f0deaa1a8623d1f3cc1039f6b8689a4d9b4ae1

diff --git a/src/client/client-security-manager.cpp b/src/client/client-security-manager.cpp
index 62e5663..a995aa0 100644 (file)
--- a/src/client/client-security-manager.cpp
+++ b/src/client/client-security-manager.cpp
@@ -176,12 +176,8 @@ int security_manager_app_install(const app_inst_req *p_req)
             MessageBuffer send, recv;
 
             //put data into buffer
-            Serialization::Serialize(send, (int)SecurityModuleCall::APP_INSTALL);
-            Serialization::Serialize(send, p_req->appId);
-            Serialization::Serialize(send, p_req->pkgId);
-            Serialization::Serialize(send, p_req->privileges);
-            Serialization::Serialize(send, p_req->appPaths);
-            Serialization::Serialize(send, p_req->uid);
+            Serialization::Serialize(send, (int)SecurityModuleCall::APP_INSTALL,
+                p_req->appId, p_req->pkgId, p_req->privileges, p_req->appPaths, p_req->uid);
 
             //send buffer to server
             retval = sendToServer(SERVICE_SOCKET, send.Pop(), recv);
@@ -223,8 +219,8 @@ int security_manager_app_uninstall(const app_inst_req *p_req)
             return SECURITY_MANAGER_ERROR_REQ_NOT_COMPLETE;
 
         //put data into buffer
-        Serialization::Serialize(send, (int)SecurityModuleCall::APP_UNINSTALL);
-        Serialization::Serialize(send, p_req->appId);
+        Serialization::Serialize(send, (int)SecurityModuleCall::APP_UNINSTALL,
+            p_req->appId);
 
         //send buffer to server
         int retval = sendToServer(SERVICE_SOCKET, send.Pop(), recv);
@@ -264,8 +260,8 @@ int security_manager_get_app_pkgid(char **pkg_id, const char *app_id)
         }
 
         //put data into buffer
-        Serialization::Serialize(send, static_cast<int>(SecurityModuleCall::APP_GET_PKGID));
-        Serialization::Serialize(send, std::string(app_id));
+        Serialization::Serialize(send, static_cast<int>(SecurityModuleCall::APP_GET_PKGID),
+            std::string(app_id));
 
         //send buffer to server
         int retval = sendToServer(SERVICE_SOCKET, send.Pop(), recv);
@@ -411,8 +407,8 @@ int security_manager_set_process_groups_from_appid(const char *app_id)
         }
 
         //put data into buffer
-        Serialization::Serialize(send, static_cast<int>(SecurityModuleCall::APP_GET_GROUPS));
-        Serialization::Serialize(send, std::string(app_id));
+        Serialization::Serialize(send, static_cast<int>(SecurityModuleCall::APP_GET_GROUPS),
+            std::string(app_id));
 
         //send buffer to server
         int retval = sendToServer(SERVICE_SOCKET, send.Pop(), recv);
@@ -586,10 +582,8 @@ int security_manager_user_add(const user_req *p_req)
             //server is working
 
             //put data into buffer
-            Serialization::Serialize(send, static_cast<int>(SecurityModuleCall::USER_ADD));
-
-            Serialization::Serialize(send, p_req->uid);
-            Serialization::Serialize(send, p_req->utype);
+            Serialization::Serialize(send, static_cast<int>(SecurityModuleCall::USER_ADD),
+                p_req->uid, p_req->utype);
 
             //send buffer to server
             retval = sendToServer(SERVICE_SOCKET, send.Pop(), recv);
@@ -622,10 +616,8 @@ int security_manager_user_delete(const user_req *p_req)
     return try_catch([&] {
 
         //put data into buffer
-        Serialization::Serialize(send, static_cast<int>(SecurityModuleCall::USER_DELETE));
-
-        Serialization::Serialize(send, p_req->uid);
-
+        Serialization::Serialize(send, static_cast<int>(SecurityModuleCall::USER_DELETE),
+            p_req->uid);
 
         //send buffer to server
         int retval = sendToServer(SERVICE_SOCKET, send.Pop(), recv);
@@ -683,8 +675,8 @@ int security_manager_policy_update_send(policy_update_req *p_req)
     return try_catch([&] {
 
         //put request into buffer
-        Serialization::Serialize(send, static_cast<int>(SecurityModuleCall::POLICY_UPDATE));
-        Serialization::Serialize(send, p_req->units);
+        Serialization::Serialize(send, static_cast<int>(SecurityModuleCall::POLICY_UPDATE),
+            p_req->units);
 
         //send it to server
         int retval = sendToServer(SERVICE_SOCKET, send.Pop(), recv);
@@ -724,8 +716,9 @@ static inline int security_manager_get_policy_internal(
 
     return try_catch([&] {
         //put request into buffer
-        Serialization::Serialize(send, static_cast<int>(call_type));
-        Serialization::Serialize(send, *p_filter);
+        Serialization::Serialize(send, static_cast<int>(call_type),
+            *p_filter);
+
         //send it to server
         int retval = sendToServer(SERVICE_SOCKET, send.Pop(), recv);
         if (retval != SECURITY_MANAGER_API_SUCCESS) {

diff --git a/src/common/include/protocols.h b/src/common/include/protocols.h
index 4031510..24859d1 100644 (file)
--- a/src/common/include/protocols.h
+++ b/src/common/include/protocols.h
@@ -181,11 +181,8 @@ struct policy_entry : ISerializable {
     }
 
     virtual void Serialize(IStream &stream) const {
-        Serialization::Serialize(stream, user);
-        Serialization::Serialize(stream, appId);
-        Serialization::Serialize(stream, privilege);
-        Serialization::Serialize(stream, currentLevel);
-        Serialization::Serialize(stream, maxLevel);
+        Serialization::Serialize(stream,
+            user, appId, privilege, currentLevel, maxLevel);
     }
 
 };

diff --git a/src/common/master-req.cpp b/src/common/master-req.cpp
index 96555e3..f6526b3 100644 (file)
--- a/src/common/master-req.cpp
+++ b/src/common/master-req.cpp
@@ -38,12 +38,11 @@ int CynaraPolicyUpdate(const std::string &appId,  const std::string &uidstr,
 {
     int ret;
     MessageBuffer sendBuf, retBuf;
+
     Serialization::Serialize(sendBuf,
-                             static_cast<int>(MasterSecurityModuleCall::CYNARA_UPDATE_POLICY));
-    Serialization::Serialize(sendBuf, appId);
-    Serialization::Serialize(sendBuf, uidstr);
-    Serialization::Serialize(sendBuf, oldPkgPrivileges);
-    Serialization::Serialize(sendBuf, newPkgPrivileges);
+        static_cast<int>(MasterSecurityModuleCall::CYNARA_UPDATE_POLICY),
+        appId, uidstr, oldPkgPrivileges, newPkgPrivileges);
+
     ret = sendToServer(MASTER_SERVICE_SOCKET, sendBuf.Pop(), retBuf);
     if (ret == SECURITY_MANAGER_API_SUCCESS)
         Deserialization::Deserialize(retBuf, ret);
@@ -55,10 +54,11 @@ int CynaraUserInit(const uid_t uidAdded, int userType)
 {
     int ret;
     MessageBuffer sendBuf, retBuf;
+
     Serialization::Serialize(sendBuf,
-                             static_cast<int>(MasterSecurityModuleCall::CYNARA_USER_INIT));
-    Serialization::Serialize(sendBuf, uidAdded);
-    Serialization::Serialize(sendBuf, userType);
+        static_cast<int>(MasterSecurityModuleCall::CYNARA_USER_INIT),
+        uidAdded, userType);
+
     ret = sendToServer(MASTER_SERVICE_SOCKET, sendBuf.Pop(), retBuf);
     if (ret == SECURITY_MANAGER_API_SUCCESS)
         Deserialization::Deserialize(retBuf, ret);
@@ -70,9 +70,11 @@ int CynaraUserRemove(const uid_t uidDeleted)
 {
     int ret;
     MessageBuffer sendBuf, retBuf;
+
     Serialization::Serialize(sendBuf,
-                             static_cast<int>(MasterSecurityModuleCall::CYNARA_USER_REMOVE));
-    Serialization::Serialize(sendBuf, uidDeleted);
+        static_cast<int>(MasterSecurityModuleCall::CYNARA_USER_REMOVE),
+        uidDeleted);
+
     ret = sendToServer(MASTER_SERVICE_SOCKET, sendBuf.Pop(), retBuf);
     if (ret == SECURITY_MANAGER_API_SUCCESS)
         Deserialization::Deserialize(retBuf, ret);
@@ -86,10 +88,9 @@ int SmackInstallRules(const std::string &appId, const std::string &pkgId,
     int ret;
     MessageBuffer sendBuf, retBuf;
     Serialization::Serialize(sendBuf,
-                             static_cast<int>(MasterSecurityModuleCall::SMACK_INSTALL_RULES));
-    Serialization::Serialize(sendBuf, appId);
-    Serialization::Serialize(sendBuf, pkgId);
-    Serialization::Serialize(sendBuf, pkgContents);
+        static_cast<int>(MasterSecurityModuleCall::SMACK_INSTALL_RULES),
+        appId, pkgId, pkgContents);
+
     ret = sendToServer(MASTER_SERVICE_SOCKET, sendBuf.Pop(), retBuf);
     if (ret == SECURITY_MANAGER_API_SUCCESS)
         Deserialization::Deserialize(retBuf, ret);
@@ -102,12 +103,11 @@ int SmackUninstallRules(const std::string &appId, const std::string &pkgId,
 {
     int ret;
     MessageBuffer sendBuf, retBuf;
+
     Serialization::Serialize(sendBuf,
-                             static_cast<int>(MasterSecurityModuleCall::SMACK_UNINSTALL_RULES));
-    Serialization::Serialize(sendBuf, appId);
-    Serialization::Serialize(sendBuf, pkgId);
-    Serialization::Serialize(sendBuf, pkgContents);
-    Serialization::Serialize(sendBuf, removePkg);
+        static_cast<int>(MasterSecurityModuleCall::SMACK_UNINSTALL_RULES),
+        appId, pkgId, pkgContents, removePkg);
+
     ret = sendToServer(MASTER_SERVICE_SOCKET, sendBuf.Pop(), retBuf);
     if (ret == SECURITY_MANAGER_API_SUCCESS)
         Deserialization::Deserialize(retBuf, ret);
@@ -122,12 +122,10 @@ int PolicyUpdate(const std::vector<policy_entry> &policyEntries, uid_t uid, pid_
 {
     int ret;
     MessageBuffer sendBuf, retBuf;
+
     Serialization::Serialize(sendBuf,
-                             static_cast<int>(MasterSecurityModuleCall::POLICY_UPDATE));
-    Serialization::Serialize(sendBuf, policyEntries);
-    Serialization::Serialize(sendBuf, uid);
-    Serialization::Serialize(sendBuf, pid);
-    Serialization::Serialize(sendBuf, smackLabel);
+        static_cast<int>(MasterSecurityModuleCall::POLICY_UPDATE),
+        policyEntries, uid, pid, smackLabel);
 
     ret = sendToServer(MASTER_SERVICE_SOCKET, sendBuf.Pop(), retBuf);
     if (ret == SECURITY_MANAGER_API_SUCCESS)
@@ -141,13 +139,10 @@ int GetConfiguredPolicy(bool forAdmin, const policy_entry &filter, uid_t uid, pi
 {
     int ret;
     MessageBuffer sendBuf, retBuf;
+
     Serialization::Serialize(sendBuf,
-                             static_cast<int>(MasterSecurityModuleCall::GET_CONFIGURED_POLICY));
-    Serialization::Serialize(sendBuf, forAdmin);
-    Serialization::Serialize(sendBuf, filter);
-    Serialization::Serialize(sendBuf, uid);
-    Serialization::Serialize(sendBuf, pid);
-    Serialization::Serialize(sendBuf, smackLabel);
+        static_cast<int>(MasterSecurityModuleCall::GET_CONFIGURED_POLICY),
+        forAdmin, filter, uid, pid, smackLabel);
 
     ret = sendToServer(MASTER_SERVICE_SOCKET, sendBuf.Pop(), retBuf);
     if (ret == SECURITY_MANAGER_API_SUCCESS) {
@@ -164,12 +159,10 @@ int GetPolicy(const policy_entry &filter, uid_t uid, pid_t pid, const std::strin
 {
     int ret;
     MessageBuffer sendBuf, retBuf;
+
     Serialization::Serialize(sendBuf,
-                             static_cast<int>(MasterSecurityModuleCall::GET_POLICY));
-    Serialization::Serialize(sendBuf, filter);
-    Serialization::Serialize(sendBuf, uid);
-    Serialization::Serialize(sendBuf, pid);
-    Serialization::Serialize(sendBuf, smackLabel);
+        static_cast<int>(MasterSecurityModuleCall::GET_POLICY),
+        filter, uid, pid, smackLabel);
 
     ret = sendToServer(MASTER_SERVICE_SOCKET, sendBuf.Pop(), retBuf);
     if (ret == SECURITY_MANAGER_API_SUCCESS) {
@@ -185,8 +178,9 @@ int PolicyGetDesc(std::vector<std::string> &descriptions)
 {
     int ret;
     MessageBuffer sendBuf, retBuf;
+
     Serialization::Serialize(sendBuf,
-                             static_cast<int>(MasterSecurityModuleCall::POLICY_GET_DESC));
+        static_cast<int>(MasterSecurityModuleCall::POLICY_GET_DESC));
 
     ret = sendToServer(MASTER_SERVICE_SOCKET, sendBuf.Pop(), retBuf);
     if (ret == SECURITY_MANAGER_API_SUCCESS) {

diff --git a/src/dpl/core/include/dpl/serialization.h b/src/dpl/core/include/dpl/serialization.h
index bb6602c..4782e1c 100644 (file)
--- a/src/dpl/core/include/dpl/serialization.h
+++ b/src/dpl/core/include/dpl/serialization.h
@@ -211,6 +211,14 @@ struct Serialization {
     {
         Serialize(stream, *p);
     }
+
+    // serialize 'em all
+    template<typename T1, typename T2, typename... Tail>
+    static void Serialize(IStream& stream, const T1& first, const T2& second, const Tail&... tail)
+    {
+        Serialize(stream, first);
+        Serialize(stream, second, tail...);
+    }
 }; // struct Serialization
 
 struct Deserialization {