int retval;
ClientOffline offlineMode;
if (offlineMode.isOffline()) {
- retval = SecurityManager::ServiceImpl::appInstall(*p_req, geteuid(), false);
+ retval = SecurityManager::ServiceImpl().appInstall(*p_req, geteuid(), false);
} else {
MessageBuffer send, recv;
int retval;
ClientOffline offlineMode;
if (offlineMode.isOffline()) {
- retval = SecurityManager::ServiceImpl::userAdd(p_req->uid, p_req->utype, geteuid(),
+ retval = SecurityManager::ServiceImpl().userAdd(p_req->uid, p_req->utype, geteuid(),
false);
} else {
MessageBuffer send, recv;
#include "security-manager.h"
namespace SecurityManager {
-namespace ServiceImpl {
-/**
- * Retrieves ID (UID and PID) of peer connected to socket
- *
- * @param[in] Socket file descriptor
- * @param[out] UID of connected peer. Function does not modify the variable if ID retrieval fails.
- * @param[out] PID of connected peer. Function does not modify the variable if ID retrieval fails.
- *
- * @return True if peer ID was successfully retrieved, false otherwise.
- */
-bool getPeerID(int sock, uid_t &uid, pid_t &pid);
-
-/**
- * Process application installation request.
- *
- * @param[in] req installation request
- * @param[in] uid id of the requesting user
- * @param[in] isSlave Indicates if function should be called under slave mode
- *
- * @return API return code, as defined in protocols.h
- */
-int appInstall(const app_inst_req &req, uid_t uid, bool isSlave);
-
-/**
- * Process application uninstallation request.
- *
- * @param[in] req uninstallation request
- * @param[in] uid id of the requesting user
- * @param[in] isSlave Indicates if function should be called under slave mode
- *
- * @return API return code, as defined in protocols.h
- */
-int appUninstall(const std::string &appId, uid_t uid, bool isSlave);
-
-/**
- * Process package id query.
- * Retrieves the package id associated with given application id.
- *
- * @param[in] appId application identifier
- * @param[out] pkgId returned package identifier
- *
- * @return API return code, as defined in protocols.h
- */
-int getPkgId(const std::string &appId, std::string &pkgId);
-
-/**
- * Process query for supplementary groups allowed for the application.
- * For given appId and uid, calculate allowed privileges that give
- * direct access to file system resources. For each permission Cynara will be
- * queried.
- * Returns set of group ids that are permitted.
- *
- * @param[in] appId application identifier
- * @param[in] uid id of the requesting user
- * @param[in] pid id of the requesting process (to construct Cynara session id)
- * @param[in] isSlave Indicates if function should be called under slave mode
- * @param[out] gids returned set of allowed group ids
- *
- * @return API return code, as defined in protocols.h
- */
-int getAppGroups(const std::string &appId, uid_t uid, pid_t pid, bool isSlave,
- std::unordered_set<gid_t> &gids);
-
-/**
- * Process user adding request.
- *
- * @param[in] uidAdded uid of newly created user
- * @param[in] userType type of newly created user
- * @param[in] uid uid of requesting user
- * @param[in] isSlave Indicates if function should be called under slave mode
- *
- * @return API return code, as defined in protocols.h
- */
-int userAdd(uid_t uidAdded, int userType, uid_t uid, bool isSlave);
-
-/**
- * Process user deletion request.
- *
- * @param[in] uidDeleted uid of removed user
- * @param[in] uid uid of requesting user
- * @param[in] isSlave Indicates if function should be called under slave mode
- *
- * @return API return code, as defined in protocols.h
- */
-int userDelete(uid_t uidDeleted, uid_t uid, bool isSlave);
-
-/**
- * Update policy in Cynara - proper privilege: http://tizen.org/privilege/systemsettings.admin
- * is needed for this to succeed
- *
- * @param[in] policyEntries vector of policy chunks with instructions
- * @param[in] uid identifier of requesting user
- * @param[in] pid PID of requesting process
- * @param[in] smackLabel smack label of requesting app
- *
- * @return API return code, as defined in protocols.h
- */
-
-int policyUpdate(const std::vector<policy_entry> &policyEntries, uid_t uid, pid_t pid, const std::string &smackLabel);
-/**
- * Fetch all configured privileges from user configurable bucket.
- * Depending on forAdmin value: personal user policies or admin enforced
- * policies are returned.
- *
- * @param[in] forAdmin determines if user is asking as ADMIN or not
- * @param[in] filter filter for limiting the query
- * @param[in] uid identifier of queried user
- * @param[in] pid PID of requesting process
- * @param[out] policyEntries vector of policy entries with result
- *
- * @return API return code, as defined in protocols.h
- */
-int getConfiguredPolicy(bool forAdmin, const policy_entry &filter, uid_t uid, pid_t pid, const std::string &smackLabel, std::vector<policy_entry> &policyEntries);
-
-/**
- * Fetch all privileges for all apps installed for specific user.
- *
- * @param[in] forAdmin determines if user is asking as ADMIN or not
- * @param[in] filter filter for limiting the query
- * @param[in] uid identifier of queried user
- * @param[in] pid PID of requesting process
- * @param[out] policyEntries vector of policy entries with result
- *
- * @return API return code, as defined in protocols.h
- */
-int getPolicy(const policy_entry &filter, uid_t uid, pid_t pid, const std::string &smackLabel, std::vector<policy_entry> &policyEntries);
-
-/**
- * Process getting policy descriptions list.
- *
- * @param[in] descriptions empty vector for descriptions strings
- *
- * @return API return code, as defined in protocols.h
- */
-int policyGetDesc(std::vector<std::string> &descriptions);
-
-/**
- * Process getting privileges mappings from one version to another.
- *
- * @param[in] version_from version to be mapped from
- * @param[in] version_to version to be mapped to
- * @param[in] privileges vector of privileges to be mapped
- * @param[out] mappings mappings of given privileges
- */
-int getPrivilegesMappings(const std::string &version_from,
- const std::string &version_to,
- const std::vector<std::string> &privileges,
- std::vector<std::string> &mappings);
-
-/**
- * Process getting resources group list.
- *
- * @param[out] groups empty vector for group strings
- *
- * @return API return code, as defined in protocols.h
- */
-int policyGetGroups(std::vector<std::string> &groups);
-
-} /* namespace ServiceImpl */
+class ServiceImpl {
+private:
+ static uid_t getGlobalUserId(void);
+
+ static void checkGlobalUser(uid_t &uid, std::string &cynaraUserStr);
+
+ static bool isSubDir(const char *parent, const char *subdir);
+
+ static bool getUserAppDir(const uid_t &uid, std::string &userAppDir);
+
+ static bool installRequestAuthCheck(const app_inst_req &req, uid_t uid, bool &isCorrectPath, std::string &appPath);
+
+ static bool getZoneId(std::string &zoneId);
+
+public:
+ ServiceImpl();
+ virtual ~ServiceImpl();
+
+ /**
+ * Process application installation request.
+ *
+ * @param[in] req installation request
+ * @param[in] uid id of the requesting user
+ * @param[in] isSlave Indicates if function should be called under slave mode
+ *
+ * @return API return code, as defined in protocols.h
+ */
+ int appInstall(const app_inst_req &req, uid_t uid, bool isSlave);
+
+ /**
+ * Process application uninstallation request.
+ *
+ * @param[in] req uninstallation request
+ * @param[in] uid id of the requesting user
+ * @param[in] isSlave Indicates if function should be called under slave mode
+ *
+ * @return API return code, as defined in protocols.h
+ */
+ int appUninstall(const std::string &appId, uid_t uid, bool isSlave);
+
+ /**
+ * Process package id query.
+ * Retrieves the package id associated with given application id.
+ *
+ * @param[in] appId application identifier
+ * @param[out] pkgId returned package identifier
+ *
+ * @return API return code, as defined in protocols.h
+ */
+ int getPkgId(const std::string &appId, std::string &pkgId);
+
+ /**
+ * Process query for supplementary groups allowed for the application.
+ * For given appId and uid, calculate allowed privileges that give
+ * direct access to file system resources. For each permission Cynara will be
+ * queried.
+ * Returns set of group ids that are permitted.
+ *
+ * @param[in] appId application identifier
+ * @param[in] uid id of the requesting user
+ * @param[in] pid id of the requesting process (to construct Cynara session id)
+ * @param[in] isSlave Indicates if function should be called under slave mode
+ * @param[out] gids returned set of allowed group ids
+ *
+ * @return API return code, as defined in protocols.h
+ */
+ int getAppGroups(const std::string &appId, uid_t uid, pid_t pid, bool isSlave,
+ std::unordered_set<gid_t> &gids);
+
+ /**
+ * Process user adding request.
+ *
+ * @param[in] uidAdded uid of newly created user
+ * @param[in] userType type of newly created user
+ * @param[in] uid uid of requesting user
+ * @param[in] isSlave Indicates if function should be called under slave mode
+ *
+ * @return API return code, as defined in protocols.h
+ */
+ int userAdd(uid_t uidAdded, int userType, uid_t uid, bool isSlave);
+
+ /**
+ * Process user deletion request.
+ *
+ * @param[in] uidDeleted uid of removed user
+ * @param[in] uid uid of requesting user
+ * @param[in] isSlave Indicates if function should be called under slave mode
+ *
+ * @return API return code, as defined in protocols.h
+ */
+ int userDelete(uid_t uidDeleted, uid_t uid, bool isSlave);
+
+ /**
+ * Update policy in Cynara - proper privilege: http://tizen.org/privilege/systemsettings.admin
+ * is needed for this to succeed
+ *
+ * @param[in] policyEntries vector of policy chunks with instructions
+ * @param[in] uid identifier of requesting user
+ * @param[in] pid PID of requesting process
+ * @param[in] smackLabel smack label of requesting app
+ *
+ * @return API return code, as defined in protocols.h
+ */
+
+ int policyUpdate(const std::vector<policy_entry> &policyEntries, uid_t uid, pid_t pid, const std::string &smackLabel);
+ /**
+ * Fetch all configured privileges from user configurable bucket.
+ * Depending on forAdmin value: personal user policies or admin enforced
+ * policies are returned.
+ *
+ * @param[in] forAdmin determines if user is asking as ADMIN or not
+ * @param[in] filter filter for limiting the query
+ * @param[in] uid identifier of queried user
+ * @param[in] pid PID of requesting process
+ * @param[out] policyEntries vector of policy entries with result
+ *
+ * @return API return code, as defined in protocols.h
+ */
+ int getConfiguredPolicy(bool forAdmin, const policy_entry &filter, uid_t uid, pid_t pid, const std::string &smackLabel, std::vector<policy_entry> &policyEntries);
+
+ /**
+ * Fetch all privileges for all apps installed for specific user.
+ *
+ * @param[in] forAdmin determines if user is asking as ADMIN or not
+ * @param[in] filter filter for limiting the query
+ * @param[in] uid identifier of queried user
+ * @param[in] pid PID of requesting process
+ * @param[out] policyEntries vector of policy entries with result
+ *
+ * @return API return code, as defined in protocols.h
+ */
+ int getPolicy(const policy_entry &filter, uid_t uid, pid_t pid, const std::string &smackLabel, std::vector<policy_entry> &policyEntries);
+
+ /**
+ * Process getting policy descriptions list.
+ *
+ * @param[in] descriptions empty vector for descriptions strings
+ *
+ * @return API return code, as defined in protocols.h
+ */
+ int policyGetDesc(std::vector<std::string> &descriptions);
+
+ /**
+ * Process getting privileges mappings from one version to another.
+ *
+ * @param[in] version_from version to be mapped from
+ * @param[in] version_to version to be mapped to
+ * @param[in] privileges vector of privileges to be mapped
+ * @param[out] mappings mappings of given privileges
+ */
+ int getPrivilegesMappings(const std::string &version_from,
+ const std::string &version_to,
+ const std::vector<std::string> &privileges,
+ std::vector<std::string> &mappings);
+
+ /**
+ * Process getting resources group list.
+ *
+ * @param[out] groups empty vector for group strings
+ *
+ * @return API return code, as defined in protocols.h
+ */
+ int policyGetGroups(std::vector<std::string> &groups);
+};
} /* namespace SecurityManager */
#endif /* _SECURITY_MANAGER_SERVICE_IMPL_ */
#include "master-req.h"
namespace SecurityManager {
-namespace ServiceImpl {
static const std::string ADMIN_PRIVILEGE = "http://tizen.org/privilege/systemsettings.admin";
static const std::string SELF_PRIVILEGE = "http://tizen.org/privilege/systemsettings";
}
} // end of anonymous namespace
-static uid_t getGlobalUserId(void)
+ServiceImpl::ServiceImpl()
+{
+}
+
+ServiceImpl::~ServiceImpl()
+{
+}
+
+uid_t ServiceImpl::getGlobalUserId(void)
{
static uid_t globaluid = tzplatform_getuid(TZ_SYS_GLOBALAPP_USER);
return globaluid;
* @param uid peer's uid - may be changed during process
* @param cynaraUserStr string to which cynara user parameter will be put
*/
-static void checkGlobalUser(uid_t &uid, std::string &cynaraUserStr)
+void ServiceImpl::checkGlobalUser(uid_t &uid, std::string &cynaraUserStr)
{
static uid_t globaluid = getGlobalUserId();
if (uid == 0 || uid == globaluid) {
cynaraUserStr = std::to_string(static_cast<unsigned int>(uid));
}
}
-static inline bool isSubDir(const char *parent, const char *subdir)
+
+bool ServiceImpl::isSubDir(const char *parent, const char *subdir)
{
while (*parent && *subdir)
if (*parent++ != *subdir++)
return (*subdir == '/');
}
-bool getPeerID(int sock, uid_t &uid, pid_t &pid)
-{
- struct ucred cr;
- socklen_t len = sizeof(cr);
-
- if (!getsockopt(sock, SOL_SOCKET, SO_PEERCRED, &cr, &len)) {
- uid = cr.uid;
- pid = cr.pid;
- return true;
- }
-
- return false;
-}
-
-static bool getUserAppDir(const uid_t &uid, std::string &userAppDir)
+bool ServiceImpl::getUserAppDir(const uid_t &uid, std::string &userAppDir)
{
struct tzplatform_context *tz_ctx = nullptr;
return true;
}
-static inline bool installRequestAuthCheck(const app_inst_req &req, uid_t uid, bool &isCorrectPath, std::string &appPath)
+bool ServiceImpl::installRequestAuthCheck(const app_inst_req &req, uid_t uid, bool &isCorrectPath, std::string &appPath)
{
std::string userHome;
std::string userAppDir;
return true;
}
-static inline bool getZoneId(std::string &zoneId)
+bool ServiceImpl::getZoneId(std::string &zoneId)
{
if (!getZoneIdFromPid(getpid(), zoneId)) {
LogError("Failed to get zone ID from current PID");
return true;
}
-int appInstall(const app_inst_req &req, uid_t uid, bool isSlave)
+int ServiceImpl::appInstall(const app_inst_req &req, uid_t uid, bool isSlave)
{
std::vector<std::string> addedPermissions;
std::vector<std::string> removedPermissions;
return SECURITY_MANAGER_API_SUCCESS;
}
-int appUninstall(const std::string &appId, uid_t uid, bool isSlave)
+int ServiceImpl::appUninstall(const std::string &appId, uid_t uid, bool isSlave)
{
std::string pkgId;
std::string smackLabel;
return SECURITY_MANAGER_API_SUCCESS;
}
-int getPkgId(const std::string &appId, std::string &pkgId)
+int ServiceImpl::getPkgId(const std::string &appId, std::string &pkgId)
{
LogDebug("appId: " << appId);
return SECURITY_MANAGER_API_SUCCESS;
}
-int getAppGroups(const std::string &appId, uid_t uid, pid_t pid, bool isSlave,
+int ServiceImpl::getAppGroups(const std::string &appId, uid_t uid, pid_t pid, bool isSlave,
std::unordered_set<gid_t> &gids)
{
// FIXME Temporary solution, see below
return SECURITY_MANAGER_API_SUCCESS;
}
-int userAdd(uid_t uidAdded, int userType, uid_t uid, bool isSlave)
+int ServiceImpl::userAdd(uid_t uidAdded, int userType, uid_t uid, bool isSlave)
{
if (uid != 0)
return SECURITY_MANAGER_API_ERROR_AUTHENTICATION_FAILED;
return SECURITY_MANAGER_API_SUCCESS;
}
-int userDelete(uid_t uidDeleted, uid_t uid, bool isSlave)
+int ServiceImpl::userDelete(uid_t uidDeleted, uid_t uid, bool isSlave)
{
int ret = SECURITY_MANAGER_API_SUCCESS;
if (uid != 0)
return ret;
}
-int policyUpdate(const std::vector<policy_entry> &policyEntries, uid_t uid, pid_t pid, const std::string &smackLabel)
+int
ServiceImpl::policyUpdate(const std::vector<policy_entry> &policyEntries, uid_t uid, pid_t pid, const std::string &smackLabel)
{
enum {
NOT_CHECKED,
return SECURITY_MANAGER_API_SUCCESS;
}
-int getConfiguredPolicy(bool forAdmin, const policy_entry &filter, uid_t uid, pid_t pid,
+int ServiceImpl::getConfiguredPolicy(bool forAdmin, const policy_entry &filter, uid_t uid, pid_t pid,
const std::string &smackLabel, std::vector<policy_entry> &policyEntries)
{
try {
return SECURITY_MANAGER_API_SUCCESS;
}
-int getPolicy(const policy_entry &filter, uid_t uid, pid_t pid, const std::string &smackLabel, std::vector<policy_entry> &policyEntries)
+int
ServiceImpl::getPolicy(const policy_entry &filter, uid_t uid, pid_t pid, const std::string &smackLabel, std::vector<policy_entry> &policyEntries)
{
try {
std::string uidStr = std::to_string(uid);
return SECURITY_MANAGER_API_SUCCESS;
}
-int policyGetDesc(std::vector<std::string> &levels)
+int ServiceImpl::policyGetDesc(std::vector<std::string> &levels)
{
int ret = SECURITY_MANAGER_API_SUCCESS;
return ret;
}
-int getPrivilegesMappings(const std::string &version_from,
+int ServiceImpl::getPrivilegesMappings(const std::string &version_from,
const std::string &version_to,
const std::vector<std::string> &privileges,
std::vector<std::string> &mappings)
return errorRet;
}
-int policyGetGroups(std::vector<std::string> &groups) {
+int ServiceImpl::policyGetGroups(std::vector<std::string> &groups)
+{
int ret = SECURITY_MANAGER_API_SUCCESS;
try {
return ret;
}
-} /* namespace ServiceImpl */
} /* namespace SecurityManager */
* @brief Implementation of security-manager base service.
*/
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/smack.h>
+
#include <cstring>
#include <unordered_set>
{
}
+bool BaseService::getPeerID(int sock, uid_t &uid, pid_t &pid, std::string &smackLabel)
+{
+ struct ucred cr;
+ socklen_t len = sizeof(cr);
+
+ if (!getsockopt(sock, SOL_SOCKET, SO_PEERCRED, &cr, &len)) {
+ char *smk;
+ ssize_t ret = smack_new_label_from_socket(sock, &smk);
+ if (ret < 0)
+ return false;
+ smackLabel = smk;
+ uid = cr.uid;
+ pid = cr.pid;
+ free(smk);
+ return true;
+ }
+
+ return false;
+}
+
void BaseService::accept(const AcceptEvent &event)
{
LogDebug("Accept event. ConnectionID.sock: " << event.connectionID.sock <<
#include <generic-socket-manager.h>
#include <message-buffer.h>
#include <connection-info.h>
+#include <service_impl.h>
namespace SecurityManager {
void close(const CloseEvent &event);
protected:
+ ServiceImpl serviceImpl;
+
ConnectionInfoMap m_connectionInfoMap;
/**
+ * Retrieves ID (UID and PID) of peer connected to socket
+ *
+ * @param[in] sock Socket file descriptor
+ * @param[out] uid PID of connected peer.
+ * @param[out] pid PID of connected peer.
+ * @param[out] smackLabel Smack label of connected peer.
+ *
+ * @return True if peer ID was successfully retrieved, false otherwise.
+ */
+ bool getPeerID(int sock, uid_t &uid, pid_t &pid, std::string &smackLabel);
+
+ /**
* Handle request from a client
*
* @param conn Socket connection information
#define _SECURITY_MANAGER_MASTER_SERVICE_
#include "base-service.h"
+#include "service_impl.h"
namespace SecurityManager {
ServiceDescriptionVector GetServiceDescription();
private:
+ ServiceImpl serviceImpl;
/**
* Handle request from a client
#define _SECURITY_MANAGER_SERVICE_
#include "base-service.h"
+#include "service_impl.h"
namespace SecurityManager {
private:
const bool m_isSlave;
+ ServiceImpl serviceImpl;
/**
* Handle request from a client
uid_t uid;
pid_t pid;
+ std::string smackLabel;
- if (!ServiceImpl::getPeerID(conn.sock, uid, pid)) {
+ if (!getPeerID(conn.sock, uid, pid, smackLabel)) {
LogError("Closing socket because of error: unable to get peer's uid and pid");
m_serviceManager->Close(conn);
return false;
Deserialization::Deserialize(buffer, pid);
Deserialization::Deserialize(buffer, smackLabel);
- ret = ServiceImpl::policyUpdate(policyEntries, uid, pid, smackLabel);
+ ret = serviceImpl.policyUpdate(policyEntries, uid, pid, smackLabel);
Serialization::Serialize(send, ret);
}
Deserialization::Deserialize(buffer, pid);
Deserialization::Deserialize(buffer, smackLabel);
- ret = ServiceImpl::getConfiguredPolicy(forAdmin, filter, uid, pid, smackLabel, policyEntries);
+ ret = serviceImpl.getConfiguredPolicy(forAdmin, filter, uid, pid, smackLabel, policyEntries);
Serialization::Serialize(send, ret);
if (ret == SECURITY_MANAGER_API_SUCCESS)
Serialization::Serialize(send, policyEntries);
Deserialization::Deserialize(buffer, pid);
Deserialization::Deserialize(buffer, smackLabel);
- ret = ServiceImpl::getPolicy(filter, uid, pid, smackLabel, policyEntries);*/
+ ret = serviceImpl.getPolicy(filter, uid, pid, smackLabel, policyEntries);*/
Serialization::Serialize(send, ret);
/*if (ret == SECURITY_MANAGER_API_SUCCESS)
Serialization::Serialize(send, policyEntries);*/
int ret = SECURITY_MANAGER_API_ERROR_SERVER_ERROR;
std::vector<std::string> descriptions;
- ret = ServiceImpl::policyGetDesc(descriptions);
+ ret = serviceImpl.policyGetDesc(descriptions);
Serialization::Serialize(send, ret);
if (ret == SECURITY_MANAGER_API_SUCCESS)
Serialization::Serialize(send, descriptions);
};
}
-static bool getPeerID(int sock, uid_t &uid, pid_t &pid, std::string &smackLabel)
-{
- struct ucred cr;
- socklen_t len = sizeof(cr);
-
- if (!getsockopt(sock, SOL_SOCKET, SO_PEERCRED, &cr, &len)) {
- char *smk;
- ssize_t ret = smack_new_label_from_socket(sock, &smk);
- if (ret < 0)
- return false;
- smackLabel = smk;
- uid = cr.uid;
- pid = cr.pid;
- free(smk);
- return true;
- }
-
- return false;
-}
-
bool Service::processOne(const ConnectionID &conn, MessageBuffer &buffer,
InterfaceID interfaceID)
{
Deserialization::Deserialize(buffer, req.privileges);
Deserialization::Deserialize(buffer, req.appPaths);
Deserialization::Deserialize(buffer, req.uid);
- Serialization::Serialize(send, ServiceImpl::appInstall(req, uid, m_isSlave));
+ Serialization::Serialize(send, serviceImpl.appInstall(req, uid, m_isSlave));
}
void Service::processAppUninstall(MessageBuffer &buffer, MessageBuffer &send, uid_t uid)
std::string appId;
Deserialization::Deserialize(buffer, appId);
- Serialization::Serialize(send, ServiceImpl::appUninstall(appId, uid, m_isSlave));
+ Serialization::Serialize(send, serviceImpl.appUninstall(appId, uid, m_isSlave));
}
void Service::processGetPkgId(MessageBuffer &buffer, MessageBuffer &send)
int ret;
Deserialization::Deserialize(buffer, appId);
- ret = ServiceImpl::getPkgId(appId, pkgId);
+ ret = serviceImpl.getPkgId(appId, pkgId);
Serialization::Serialize(send, ret);
if (ret == SECURITY_MANAGER_API_SUCCESS)
Serialization::Serialize(send, pkgId);
int ret;
Deserialization::Deserialize(buffer, appId);
- ret = ServiceImpl::getAppGroups(appId, uid, pid, m_isSlave, gids);
+ ret = serviceImpl.getAppGroups(appId, uid, pid, m_isSlave, gids);
Serialization::Serialize(send, ret);
if (ret == SECURITY_MANAGER_API_SUCCESS) {
Serialization::Serialize(send, static_cast<int>(gids.size()));
Deserialization::Deserialize(buffer, uidAdded);
Deserialization::Deserialize(buffer, userType);
- ret = ServiceImpl::userAdd(uidAdded, userType, uid, m_isSlave);
+ ret = serviceImpl.userAdd(uidAdded, userType, uid, m_isSlave);
Serialization::Serialize(send, ret);
}
Deserialization::Deserialize(buffer, uidRemoved);
- ret = ServiceImpl::userDelete(uidRemoved, uid, m_isSlave);
+ ret = serviceImpl.userDelete(uidRemoved, uid, m_isSlave);
Serialization::Serialize(send, ret);
}
if (m_isSlave) {
ret = MasterReq::PolicyUpdate(policyEntries, uid, pid, smackLabel);
} else {
- ret = ServiceImpl::policyUpdate(policyEntries, uid, pid, smackLabel);
+ ret = serviceImpl.policyUpdate(policyEntries, uid, pid, smackLabel);
}
Serialization::Serialize(send, ret);
}
if (m_isSlave) {
ret = MasterReq::GetConfiguredPolicy(forAdmin, filter, uid, pid, smackLabel, policyEntries);
} else {
- ret = ServiceImpl::getConfiguredPolicy(forAdmin, filter, uid, pid, smackLabel,
+ ret = serviceImpl.getConfiguredPolicy(forAdmin, filter, uid, pid, smackLabel,
policyEntries);
}
if (m_isSlave) {
ret = MasterReq::GetPolicy(filter, uid, pid, smackLabel, policyEntries);
} else {
- ret = ServiceImpl::getPolicy(filter, uid, pid, smackLabel, policyEntries);
+ ret = serviceImpl.getPolicy(filter, uid, pid, smackLabel, policyEntries);
}
Serialization::Serialize(send, ret);
if (m_isSlave) {
ret = MasterReq::PolicyGetDesc(descriptions);
} else {
- ret = ServiceImpl::policyGetDesc(descriptions);
+ ret = serviceImpl.policyGetDesc(descriptions);
}
Serialization::Serialize(send, ret);
if (ret == SECURITY_MANAGER_API_SUCCESS) {
Deserialization::Deserialize(recv, privileges);
std::vector<std::string> mappings;
- int ret = ServiceImpl::getPrivilegesMappings(version_from, version_to, privileges, mappings);
+ int ret = serviceImpl.getPrivilegesMappings(version_from, version_to, privileges, mappings);
Serialization::Serialize(send, ret);
Serialization::Serialize(send, mappings);
void Service::processGroupsGet(MessageBuffer &send)
{
std::vector<std::string> groups;
- int ret = ServiceImpl::policyGetGroups(groups);
+ int ret = serviceImpl.policyGetGroups(groups);
Serialization::Serialize(send, ret);
if (ret == SECURITY_MANAGER_API_SUCCESS) {
projects / platform / core / security / security-manager.git / commitdiff