SET(COMMON_SOURCES
${COMMON_PATH}/common/protocols.cpp
- ${COMMON_PATH}/common/socket-buffer.cpp
+ ${COMMON_PATH}/common/message-buffer.cpp
${COMMON_PATH}/dpl/log/src/abstract_log_provider.cpp
${COMMON_PATH}/dpl/log/src/dlog_log_provider.cpp
${COMMON_PATH}/dpl/log/src/log.cpp
#include <dpl/log/log.h>
#include <dpl/exception.h>
-#include <socket-buffer.h>
+#include <message-buffer.h>
#include <client-common.h>
#include <protocols.h>
int security_server_app_enable_permissions(const char *app_id, app_type_t app_type, const char **perm_list, int persistent)
{
using namespace SecurityServer;
- SocketBuffer send, recv;
+ MessageBuffer send, recv;
std::vector<std::string> permissions_list;
LogDebug("security_server_app_enable_permissions() called");
Deserialization::Deserialize(recv, result);
return result;
- } catch (SocketBuffer::Exception::Base &e) {
- LogDebug("SecurityServer::SocketBuffer::Exception " << e.DumpToString());
+ } catch (MessageBuffer::Exception::Base &e) {
+ LogDebug("SecurityServer::MessageBuffer::Exception " << e.DumpToString());
} catch (std::exception &e) {
LogDebug("STD exception " << e.what());
} catch (...) {
int security_server_app_disable_permissions(const char *app_id, app_type_t app_type, const char **perm_list)
{
using namespace SecurityServer;
- SocketBuffer send, recv;
+ MessageBuffer send, recv;
std::vector<std::string> permissions_list;
LogDebug("security_server_app_disable_permissions() called");
Deserialization::Deserialize(recv, result);
return result;
- } catch (SocketBuffer::Exception::Base &e) {
- LogDebug("SecurityServer::SocketBuffer::Exception " << e.DumpToString());
+ } catch (MessageBuffer::Exception::Base &e) {
+ LogDebug("SecurityServer::MessageBuffer::Exception " << e.DumpToString());
} catch (std::exception &e) {
LogDebug("STD exception " << e.what());
} catch (...) {
#include <dpl/singleton.h>
#include <dpl/singleton_safe_impl.h>
-#include <socket-buffer.h>
+#include <message-buffer.h>
#include <security-server.h>
namespace SecurityServer {
-int sendToServer(char const * const interface, const RawBuffer &send, SocketBuffer &recv) {
+int sendToServer(char const * const interface, const RawBuffer &send, MessageBuffer &recv) {
int ret;
SockRAII sock;
ssize_t done = 0;
#include <vector>
-#include <socket-buffer.h>
+#include <message-buffer.h>
namespace SecurityServer {
typedef std::vector<unsigned char> RawBuffer;
-int sendToServer(char const * const interface, const RawBuffer &send, SocketBuffer &recv);
+int sendToServer(char const * const interface, const RawBuffer &send, MessageBuffer &recv);
} // namespace SecuritySever
#include <dpl/log/log.h>
#include <dpl/exception.h>
-#include <socket-buffer.h>
+#include <message-buffer.h>
#include <client-common.h>
#include <protocols.h>
int security_server_request_cookie(char *cookie, size_t bufferSize)
{
using namespace SecurityServer;
- SocketBuffer send, recv;
+ MessageBuffer send, recv;
std::vector<char> receivedCookie;
LogDebug("security_server_request_cookie() called");
memcpy(cookie, &receivedCookie[0], receivedCookie.size());
return retval;
- } catch (SocketBuffer::Exception::Base &e) {
- LogDebug("SecurityServer::SocketBuffer::Exception " << e.DumpToString());
+ } catch (MessageBuffer::Exception::Base &e) {
+ LogDebug("SecurityServer::MessageBuffer::Exception " << e.DumpToString());
} catch (std::exception &e) {
LogDebug("STD exception " << e.what());
} catch (...) {
int security_server_get_cookie_pid(const char *cookie)
{
using namespace SecurityServer;
- SocketBuffer send, recv;
+ MessageBuffer send, recv;
int pid;
int retval = SECURITY_SERVER_API_ERROR_UNKNOWN;
Deserialization::Deserialize(recv, pid);
return pid;
- } catch (SocketBuffer::Exception::Base &e) {
- LogDebug("SecurityServer::SocketBuffer::Exception " << e.DumpToString());
+ } catch (MessageBuffer::Exception::Base &e) {
+ LogDebug("SecurityServer::MessageBuffer::Exception " << e.DumpToString());
} catch (std::exception &e) {
LogDebug("STD exception " << e.what());
} catch (...) {
char * security_server_get_smacklabel_cookie(const char *cookie)
{
using namespace SecurityServer;
- SocketBuffer send, recv;
+ MessageBuffer send, recv;
int retval = SECURITY_SERVER_API_ERROR_UNKNOWN;
std::string label;
return strdup(label.c_str());
- } catch (SocketBuffer::Exception::Base &e) {
- LogDebug("SecurityServer::SocketBuffer::Exception " << e.DumpToString());
+ } catch (MessageBuffer::Exception::Base &e) {
+ LogDebug("SecurityServer::MessageBuffer::Exception " << e.DumpToString());
} catch (std::exception &e) {
LogDebug("STD exception " << e.what());
} catch (...) {
int security_server_check_privilege(const char *cookie, gid_t privilege)
{
using namespace SecurityServer;
- SocketBuffer send, recv;
+ MessageBuffer send, recv;
int retval = SECURITY_SERVER_API_ERROR_UNKNOWN;
LogDebug("security_server_check_privilege() called");
Deserialization::Deserialize(recv, retval);
return retval;
- } catch (SocketBuffer::Exception::Base &e) {
- LogDebug("SecurityServer::SocketBuffer::Exception " << e.DumpToString());
+ } catch (MessageBuffer::Exception::Base &e) {
+ LogDebug("SecurityServer::MessageBuffer::Exception " << e.DumpToString());
} catch (std::exception &e) {
LogDebug("STD exception " << e.what());
} catch (...) {
int security_server_check_privilege_by_cookie(const char *cookie, const char *object, const char *access_rights)
{
using namespace SecurityServer;
- SocketBuffer send, recv;
+ MessageBuffer send, recv;
int retval = SECURITY_SERVER_API_ERROR_UNKNOWN;
LogDebug("security_server_check_privilege_by_cookie() called");
Deserialization::Deserialize(recv, retval);
return retval;
- } catch (SocketBuffer::Exception::Base &e) {
- LogDebug("SecurityServer::SocketBuffer::Exception " << e.DumpToString());
+ } catch (MessageBuffer::Exception::Base &e) {
+ LogDebug("SecurityServer::MessageBuffer::Exception " << e.DumpToString());
} catch (std::exception &e) {
LogDebug("STD exception " << e.what());
} catch (...) {
int security_server_get_uid_by_cookie(const char *cookie, uid_t *uid)
{
using namespace SecurityServer;
- SocketBuffer send, recv;
+ MessageBuffer send, recv;
int retval = SECURITY_SERVER_API_ERROR_UNKNOWN;
LogDebug("security_server_get_uid_by_cookie() called");
return retval;
- } catch (SocketBuffer::Exception::Base &e) {
- LogDebug("SecurityServer::SocketBuffer::Exception " << e.DumpToString());
+ } catch (MessageBuffer::Exception::Base &e) {
+ LogDebug("SecurityServer::MessageBuffer::Exception " << e.DumpToString());
} catch (std::exception &e) {
LogDebug("STD exception " << e.what());
} catch (...) {
int security_server_get_gid_by_cookie(const char *cookie, gid_t *gid)
{
using namespace SecurityServer;
- SocketBuffer send, recv;
+ MessageBuffer send, recv;
int retval = SECURITY_SERVER_API_ERROR_UNKNOWN;
LogDebug("security_server_get_uid_by_cookie() called");
return retval;
- } catch (SocketBuffer::Exception::Base &e) {
- LogDebug("SecurityServer::SocketBuffer::Exception " << e.DumpToString());
+ } catch (MessageBuffer::Exception::Base &e) {
+ LogDebug("SecurityServer::MessageBuffer::Exception " << e.DumpToString());
} catch (std::exception &e) {
LogDebug("STD exception " << e.what());
} catch (...) {
#include <dpl/log/log.h>
#include <dpl/exception.h>
-#include <socket-buffer.h>
+#include <message-buffer.h>
#include <client-common.h>
#include <protocols.h>
return SECURITY_SERVER_API_ERROR_INPUT_PARAM;
}
- SocketBuffer send, recv;
+ MessageBuffer send, recv;
Serialization::Serialize(send, std::string(objectName));
int retCode = sendToServer(
gid_t gid;
Deserialization::Deserialize(recv, gid);
return gid;
- } catch (SocketBuffer::Exception::Base &e) {
- LogDebug("SecurityServer::SocketBuffer::Exception " << e.DumpToString());
+ } catch (MessageBuffer::Exception::Base &e) {
+ LogDebug("SecurityServer::MessageBuffer::Exception " << e.DumpToString());
} catch (std::exception &e) {
LogDebug("STD exception " << e.what());
} catch (...) {
#include <dpl/log/log.h>
#include <dpl/exception.h>
-#include <socket-buffer.h>
+#include <message-buffer.h>
#include <client-common.h>
#include <protocols.h>
return SECURITY_SERVER_API_ERROR_INPUT_PARAM;
}
- SocketBuffer send, recv;
+ MessageBuffer send, recv;
Serialization::Serialize(send, gid);
int result = sendToServer(
return result;
- } catch (SocketBuffer::Exception::Base &e) {
- LogDebug("SecurityServer::SocketBuffer::Exception " << e.DumpToString());
+ } catch (MessageBuffer::Exception::Base &e) {
+ LogDebug("SecurityServer::MessageBuffer::Exception " << e.DumpToString());
} catch (std::exception &e) {
LogDebug("STD exception " << e.what());
} catch (...) {
#include <dpl/log/log.h>
#include <dpl/exception.h>
-#include <socket-buffer.h>
+#include <message-buffer.h>
#include <client-common.h>
#include <protocols.h>
#include <smack-check.h>
return SECURITY_SERVER_API_ERROR_INPUT_PARAM;
}
- SocketBuffer send, recv;
+ MessageBuffer send, recv;
Serialization::Serialize(send, pid);
Serialization::Serialize(send, std::string(object));
Serialization::Serialize(send, std::string(access_rights));
Deserialization::Deserialize(recv, result);
return result;
- } catch (SocketBuffer::Exception::Base &e) {
- LogDebug("SecurityServer::SocketBuffer::Exception " << e.DumpToString());
+ } catch (MessageBuffer::Exception::Base &e) {
+ LogDebug("SecurityServer::MessageBuffer::Exception " << e.DumpToString());
} catch (std::exception &e) {
LogDebug("STD exception " << e.what());
} catch (...) {
#include <dpl/log/log.h>
#include <dpl/exception.h>
-#include <socket-buffer.h>
+#include <message-buffer.h>
#include <client-common.h>
#include <protocols.h>
#include <smack-check.h>
return SECURITY_SERVER_API_ERROR_INPUT_PARAM;
}
- SocketBuffer send, recv;
+ MessageBuffer send, recv;
Serialization::Serialize(send, std::string(customer_label));
Serialization::Serialize(send, customer_pid);
Deserialization::Deserialize(recv, result);
return result;
- } catch (SocketBuffer::Exception::Base &e) {
- LogDebug("SecurityServer::SocketBuffer::Exception " << e.DumpToString());
+ } catch (MessageBuffer::Exception::Base &e) {
+ LogDebug("SecurityServer::MessageBuffer::Exception " << e.DumpToString());
} catch (std::exception &e) {
LogDebug("STD exception " << e.what());
} catch (...) {
#include <dpl/log/log.h>
#include <dpl/exception.h>
-#include <socket-buffer.h>
+#include <message-buffer.h>
#include <client-common.h>
#include <protocols.h>
#include <smack-check.h>
using namespace SecurityServer;
try{
- SocketBuffer send, recv;
+ MessageBuffer send, recv;
Serialization::Serialize(send, pid);
int result = sendToServer(
Deserialization::Deserialize(recv, exe);
return result;
- } catch (SocketBuffer::Exception::Base &e) {
- LogDebug("SecurityServer::SocketBuffer::Exception " << e.DumpToString());
+ } catch (MessageBuffer::Exception::Base &e) {
+ LogDebug("SecurityServer::MessageBuffer::Exception " << e.DumpToString());
} catch (std::exception &e) {
LogDebug("STD exception " << e.what());
} catch (...) {
* limitations under the License
*/
/*
- * @file socket-buffer.cpp
+ * @file message-buffer.cpp
* @author Bartlomiej Grzelewski (b.grzelewski@samsung.com)
* @version 1.0
- * @brief Implementation of SocketBuffer.
+ * @brief Implementation of MessageBuffer.
*/
-#include <socket-buffer.h>
+#include <message-buffer.h>
#include <dpl/log/log.h>
namespace SecurityServer {
-void SocketBuffer::Push(const RawBuffer &data) {
+void MessageBuffer::Push(const RawBuffer &data) {
m_buffer.AppendCopy(&data[0], data.size());
}
-RawBuffer SocketBuffer::Pop() {
+RawBuffer MessageBuffer::Pop() {
size_t size = m_buffer.Size();
RawBuffer buffer;
buffer.resize(size + sizeof(size_t));
return buffer;
}
-bool SocketBuffer::Ready() {
+bool MessageBuffer::Ready() {
CountBytesLeft();
if (m_bytesLeft == 0)
return false;
return true;
}
-void SocketBuffer::Read(size_t num, void *bytes) {
+void MessageBuffer::Read(size_t num, void *bytes) {
CountBytesLeft();
if (num > m_bytesLeft) {
LogDebug("Protocol broken. OutOfData. Asked for: " << num << " Ready: " << m_bytesLeft << " Buffer.size(): " << m_buffer.Size());
m_bytesLeft -= num;
}
-void SocketBuffer::Write(size_t num, const void *bytes) {
+void MessageBuffer::Write(size_t num, const void *bytes) {
m_buffer.AppendCopy(bytes, num);
}
* @file secket-buffer.h
* @author Bartlomiej Grzelewski (b.grzelewski@samsung.com)
* @version 1.0
- * @brief Implementatin of SocketBuffer.
+ * @brief Implementatin of MessageBuffer.
*/
#ifndef _SECURITY_SERVER_SOCKET_BUFFER_
typedef std::vector<unsigned char> RawBuffer;
-class SocketBuffer : public SecurityServer::IStream {
+class MessageBuffer : public SecurityServer::IStream {
public:
class Exception
{
DECLARE_EXCEPTION_TYPE(Base, OutOfData)
};
- SocketBuffer()
+ MessageBuffer()
: m_bytesLeft(0)
{}
void AppPermissionsService::read(const ReadEvent &event) {
LogDebug("Read event for counter: " << event.connectionID.counter);
- auto &buffer = m_socketBufferMap[event.connectionID.counter];
+ auto &buffer = m_messageBufferMap[event.connectionID.counter];
buffer.Push(event.rawBuffer);
// We can get several requests in one package.
void AppPermissionsService::close(const CloseEvent &event) {
LogDebug("CloseEvent. ConnectionID: " << event.connectionID.sock);
- m_socketBufferMap.erase(event.connectionID.counter);
+ m_messageBufferMap.erase(event.connectionID.counter);
}
void AppPermissionsService::error(const ErrorEvent &event) {
m_serviceManager->Close(event.connectionID);
}
-bool AppPermissionsService::readOne(const ConnectionID &conn, SocketBuffer &buffer)
+bool AppPermissionsService::readOne(const ConnectionID &conn, MessageBuffer &buffer)
{
LogDebug("Iteration begin");
- SocketBuffer send, recv;
+ MessageBuffer send, recv;
std::vector<std::string> permissions_list;
std::string app_id;
int persistent;
app_type = (app_type_t)temp;
Deserialization::Deserialize(buffer, app_id);
Deserialization::Deserialize(buffer, permissions_list);
- } Catch (SocketBuffer::Exception::Base) {
+ } Catch (MessageBuffer::Exception::Base) {
LogDebug("Broken protocol. Closing socket.");
m_serviceManager->Close(conn);
return false;
#include <service-thread.h>
#include <generic-socket-manager.h>
#include <dpl/serialization.h>
-#include <socket-buffer.h>
+#include <message-buffer.h>
#include <security-server-common.h>
namespace SecurityServer {
, public SecurityServer::ServiceThread<AppPermissionsService>
{
public:
- typedef std::map<int, SocketBuffer> SocketBufferMap;
+ typedef std::map<int, MessageBuffer> MessageBufferMap;
ServiceDescriptionVector GetServiceDescription();
void error(const ErrorEvent &event);
private:
- bool readOne(const ConnectionID &conn, SocketBuffer &buffer);
+ bool readOne(const ConnectionID &conn, MessageBuffer &buffer);
- SocketBufferMap m_socketBufferMap;
+ MessageBufferMap m_messageBufferMap;
};
} // namespace SecurityServer
m_serviceManager->Close(event.connectionID);
}
-bool CookieService::readOne(const ConnectionID &conn, SocketBuffer &buffer, int interfaceID)
+bool CookieService::readOne(const ConnectionID &conn, MessageBuffer &buffer, int interfaceID)
{
LogDebug("Iteration begin");
- SocketBuffer send, recv;
+ MessageBuffer send, recv;
int msgType;
bool removeGarbage = false;
//receive data from buffer and check MSG_ID
Try {
Deserialization::Deserialize(buffer, msgType); //receive MSG_ID
- } Catch (SocketBuffer::Exception::Base) {
+ } Catch (MessageBuffer::Exception::Base) {
LogDebug("Broken protocol. Closing socket.");
m_serviceManager->Close(conn);
return false;
return retval;
}
-bool CookieService::cookieRequest(SocketBuffer &send, int socket)
+bool CookieService::cookieRequest(MessageBuffer &send, int socket)
{
struct ucred cr;
unsigned len = sizeof(cr);
return true;
}
-bool CookieService::pidByCookieRequest(SocketBuffer &buffer, SocketBuffer &send)
+bool CookieService::pidByCookieRequest(MessageBuffer &buffer, MessageBuffer &send)
{
std::vector<char> cookieKey;
Try {
Deserialization::Deserialize(buffer, cookieKey);
- } Catch (SocketBuffer::Exception::Base) {
+ } Catch (MessageBuffer::Exception::Base) {
LogDebug("Broken protocol. Closing socket.");
return false;
}
return true;
}
-bool CookieService::smackLabelByCookieRequest(SocketBuffer &buffer, SocketBuffer &send)
+bool CookieService::smackLabelByCookieRequest(MessageBuffer &buffer, MessageBuffer &send)
{
std::vector<char> cookieKey;
Try {
Deserialization::Deserialize(buffer, cookieKey);
- } Catch (SocketBuffer::Exception::Base) {
+ } Catch (MessageBuffer::Exception::Base) {
LogDebug("Broken protocol. Closing socket.");
return false;
}
return true;
}
-bool CookieService::privilegeByCookieGidRequest(SocketBuffer &buffer, SocketBuffer &send)
+bool CookieService::privilegeByCookieGidRequest(MessageBuffer &buffer, MessageBuffer &send)
{
std::vector<char> cookieKey;
int gid;
Try {
Deserialization::Deserialize(buffer, cookieKey);
Deserialization::Deserialize(buffer, gid);
- } Catch (SocketBuffer::Exception::Base) {
+ } Catch (MessageBuffer::Exception::Base) {
LogDebug("Broken protocol. Closing socket.");
return false;
}
return true;
}
-bool CookieService::privilegeByCookieRequest(SocketBuffer &buffer, SocketBuffer &send)
+bool CookieService::privilegeByCookieRequest(MessageBuffer &buffer, MessageBuffer &send)
{
std::vector<char> cookieKey;
std::string subject;
Deserialization::Deserialize(buffer, cookieKey);
Deserialization::Deserialize(buffer, object);
Deserialization::Deserialize(buffer, access);
- } Catch (SocketBuffer::Exception::Base) {
+ } Catch (MessageBuffer::Exception::Base) {
LogDebug("Broken protocol. Closing socket.");
return false;
}
return true;
}
-bool CookieService::uidByCookieRequest(SocketBuffer &buffer, SocketBuffer &send)
+bool CookieService::uidByCookieRequest(MessageBuffer &buffer, MessageBuffer &send)
{
std::vector<char> cookieKey;
Try {
Deserialization::Deserialize(buffer, cookieKey);
- } Catch (SocketBuffer::Exception::Base) {
+ } Catch (MessageBuffer::Exception::Base) {
LogDebug("Broken protocol. Closing socket.");
return false;
}
return true;
}
-bool CookieService::gidByCookieRequest(SocketBuffer &buffer, SocketBuffer &send)
+bool CookieService::gidByCookieRequest(MessageBuffer &buffer, MessageBuffer &send)
{
std::vector<char> cookieKey;
Try {
Deserialization::Deserialize(buffer, cookieKey);
- } Catch (SocketBuffer::Exception::Base) {
+ } Catch (MessageBuffer::Exception::Base) {
LogDebug("Broken protocol. Closing socket.");
return false;
}
#include <service-thread.h>
#include <generic-socket-manager.h>
#include <dpl/serialization.h>
-#include <socket-buffer.h>
+#include <message-buffer.h>
#include <security-server-common.h>
#include <cookie-jar.h>
struct SocketInfo
{
int interfaceID;
- SocketBuffer buffer;
+ MessageBuffer buffer;
};
typedef std::map<int, SocketInfo> SocketInfoMap;
void error(const ErrorEvent &event);
private:
- bool readOne(const ConnectionID &conn, SocketBuffer &buffer, int interfaceID);
+ bool readOne(const ConnectionID &conn, MessageBuffer &buffer, int interfaceID);
- bool cookieRequest(SocketBuffer &send, int socket);
+ bool cookieRequest(MessageBuffer &send, int socket);
- bool pidByCookieRequest(SocketBuffer &buffer, SocketBuffer &send);
- bool smackLabelByCookieRequest(SocketBuffer &buffer, SocketBuffer &send);
- bool privilegeByCookieGidRequest(SocketBuffer &buffer, SocketBuffer &send);
- bool privilegeByCookieRequest(SocketBuffer &buffer, SocketBuffer &send);
+ bool pidByCookieRequest(MessageBuffer &buffer, MessageBuffer &send);
+ bool smackLabelByCookieRequest(MessageBuffer &buffer, MessageBuffer &send);
+ bool privilegeByCookieGidRequest(MessageBuffer &buffer, MessageBuffer &send);
+ bool privilegeByCookieRequest(MessageBuffer &buffer, MessageBuffer &send);
- bool uidByCookieRequest(SocketBuffer &buffer, SocketBuffer &send);
- bool gidByCookieRequest(SocketBuffer &buffer, SocketBuffer &send);
+ bool uidByCookieRequest(MessageBuffer &buffer, MessageBuffer &send);
+ bool gidByCookieRequest(MessageBuffer &buffer, MessageBuffer &send);
CookieJar m_cookieJar;
m_serviceManager->Close(event.connectionID);
}
-bool SharedMemoryService::readOne(const ConnectionID &conn, SocketBuffer &buffer) {
+bool SharedMemoryService::readOne(const ConnectionID &conn, MessageBuffer &buffer) {
LogDebug("Iteration begin");
static const char * const revoke = "-----";
static const char * const permissions = "rwxat";
Try {
Deserialization::Deserialize(buffer, clientLabel);
Deserialization::Deserialize(buffer, clientPid);
- } Catch (SocketBuffer::Exception::Base) {
+ } Catch (MessageBuffer::Exception::Base) {
LogDebug("Broken protocol. Closing socket.");
m_serviceManager->Close(conn);
return false;
free(providerLabel);
smack_accesses_free(smack);
- SocketBuffer sendBuffer;
+ MessageBuffer sendBuffer;
Serialization::Serialize(sendBuffer, retCode);
m_serviceManager->Write(conn, sendBuffer.Pop());
return true;
void SharedMemoryService::read(const ReadEvent &event) {
LogDebug("Read event for counter: " << event.connectionID.counter);
- auto &buffer = m_socketBufferMap[event.connectionID.counter];
+ auto &buffer = m_messageBufferMap[event.connectionID.counter];
buffer.Push(event.rawBuffer);
// We can get several requests in one package.
void SharedMemoryService::close(const CloseEvent &event) {
LogDebug("CloseEvent. ConnectionID: " << event.connectionID.sock);
- m_socketBufferMap.erase(event.connectionID.counter);
+ m_messageBufferMap.erase(event.connectionID.counter);
}
void SharedMemoryService::error(const ErrorEvent &event) {
#include <service-thread.h>
#include <generic-socket-manager.h>
-#include <socket-buffer.h>
+#include <message-buffer.h>
namespace SecurityServer {
, public SecurityServer::ServiceThread<SharedMemoryService>
{
public:
- typedef std::map<int, SocketBuffer> SocketBufferMap;
+ typedef std::map<int, MessageBuffer> MessageBufferMap;
ServiceDescriptionVector GetServiceDescription();
void close(const CloseEvent &event);
void error(const ErrorEvent &event);
private:
- bool readOne(const ConnectionID &conn, SocketBuffer &buffer);
+ bool readOne(const ConnectionID &conn, MessageBuffer &buffer);
- SocketBufferMap m_socketBufferMap;
+ MessageBufferMap m_messageBufferMap;
};
} // namespace SecurityServer
#include <dpl/serialization.h>
-#include <socket-buffer.h>
+#include <message-buffer.h>
namespace SecurityServer {
m_serviceManager->Close(event.connectionID);
}
-bool ExecPathService::processOne(const ConnectionID &conn, SocketBuffer &buffer) {
+bool ExecPathService::processOne(const ConnectionID &conn, MessageBuffer &buffer) {
LogDebug("Processing message");
int pid = 0;
Try {
Deserialization::Deserialize(buffer, pid);
- } Catch (SocketBuffer::Exception::Base) {
+ } Catch (MessageBuffer::Exception::Base) {
LogDebug("Broken protocol. Closing socket.");
m_serviceManager->Close(conn);
return false;
}
- SocketBuffer sendBuffer;
+ MessageBuffer sendBuffer;
int retVal;
// get executable path
void ExecPathService::read(const ReadEvent &event) {
LogDebug("Read event for counter: " << event.connectionID.counter);
- auto &buffer = m_socketBufferMap[event.connectionID.counter];
+ auto &buffer = m_messageBufferMap[event.connectionID.counter];
buffer.Push(event.rawBuffer);
// We can get several requests in one package.
void ExecPathService::close(const CloseEvent &event) {
LogDebug("CloseEvent. ConnectionID: " << event.connectionID.sock);
- m_socketBufferMap.erase(event.connectionID.counter);
+ m_messageBufferMap.erase(event.connectionID.counter);
}
void ExecPathService::error(const ErrorEvent &event) {
#include <service-thread.h>
#include <generic-socket-manager.h>
-#include <socket-buffer.h>
+#include <message-buffer.h>
namespace SecurityServer {
, public SecurityServer::ServiceThread<ExecPathService>
{
public:
- typedef std::map<int, SocketBuffer> SocketBufferMap;
+ typedef std::map<int, MessageBuffer> MessageBufferMap;
ServiceDescriptionVector GetServiceDescription();
void close(const CloseEvent &event);
void error(const ErrorEvent &event);
private:
- bool processOne(const ConnectionID &conn, SocketBuffer &buffer);
- SocketBufferMap m_socketBufferMap;
+ bool processOne(const ConnectionID &conn, MessageBuffer &buffer);
+ MessageBufferMap m_messageBufferMap;
};
} // namespace SecurityServer
}
-bool GetGidService::readOne(const ConnectionID &conn, SocketBuffer &buffer) {
+bool GetGidService::readOne(const ConnectionID &conn, MessageBuffer &buffer) {
LogDebug("Iteration begin");
std::string objectName;
int retCode = SECURITY_SERVER_API_ERROR_SERVER_ERROR;
// Get objects name:
Try {
Deserialization::Deserialize(buffer, objectName);
- } Catch (SocketBuffer::Exception::Base) {
+ } Catch (MessageBuffer::Exception::Base) {
LogDebug("Broken protocol. Closing socket.");
m_serviceManager->Close(conn);
return false;
retCode = setGid(objectName);
// Send the result
- SocketBuffer sendBuffer;
+ MessageBuffer sendBuffer;
Serialization::Serialize(sendBuffer, retCode);
Serialization::Serialize(sendBuffer, m_gid);
m_serviceManager->Write(conn, sendBuffer.Pop());
void GetGidService::read(const ReadEvent &event) {
LogDebug("Read event for counter: " << event.connectionID.counter);
- auto &buffer = m_socketBufferMap[event.connectionID.counter];
+ auto &buffer = m_messageBufferMap[event.connectionID.counter];
buffer.Push(event.rawBuffer);
// We can get several requests in one package.
void GetGidService::close(const CloseEvent &event) {
LogDebug("CloseEvent. ConnectionID: " << event.connectionID.sock);
- m_socketBufferMap.erase(event.connectionID.counter);
+ m_messageBufferMap.erase(event.connectionID.counter);
}
void GetGidService::error(const ErrorEvent &event) {
#include <generic-socket-manager.h>
#include <dpl/serialization.h>
-#include <socket-buffer.h>
+#include <message-buffer.h>
#include <security-server-common.h>
, public SecurityServer::ServiceThread<GetGidService>
{
public:
- typedef std::map<int, SocketBuffer> SocketBufferMap;
+ typedef std::map<int, MessageBuffer> MessageBufferMap;
ServiceDescriptionVector GetServiceDescription();
void error(const ErrorEvent &event);
private:
gid_t m_gid;
- bool readOne(const ConnectionID &conn, SocketBuffer &buffer);
+ bool readOne(const ConnectionID &conn, MessageBuffer &buffer);
int setGid(std::string& objectName);
- SocketBufferMap m_socketBufferMap;
+ MessageBufferMap m_messageBufferMap;
};
} // namespace SecurityServer
}
-bool GetObjectNameService::readOne(const ConnectionID &conn, SocketBuffer &buffer) {
+bool GetObjectNameService::readOne(const ConnectionID &conn, MessageBuffer &buffer) {
LogDebug("Iteration begin");
gid_t gid;
int retCode = SECURITY_SERVER_API_ERROR_SERVER_ERROR;
// Get objects GID:
Try {
Deserialization::Deserialize(buffer, gid);
- } Catch (SocketBuffer::Exception::Base) {
+ } Catch (MessageBuffer::Exception::Base) {
LogDebug("Broken protocol. Closing socket.");
m_serviceManager->Close(conn);
return false;
retCode = setName(gid);
// Send the result
- SocketBuffer sendBuffer;
+ MessageBuffer sendBuffer;
Serialization::Serialize(sendBuffer, retCode);
Serialization::Serialize(sendBuffer, m_name);
m_serviceManager->Write(conn, sendBuffer.Pop());
void GetObjectNameService::read(const ReadEvent &event) {
LogDebug("Read event for counter: " << event.connectionID.counter);
- auto &buffer = m_socketBufferMap[event.connectionID.counter];
+ auto &buffer = m_messageBufferMap[event.connectionID.counter];
buffer.Push(event.rawBuffer);
// We can get several requests in one package.
void GetObjectNameService::close(const CloseEvent &event) {
LogDebug("CloseEvent. ConnectionID: " << event.connectionID.sock);
- m_socketBufferMap.erase(event.connectionID.counter);
+ m_messageBufferMap.erase(event.connectionID.counter);
}
void GetObjectNameService::error(const ErrorEvent &event) {
#include <generic-socket-manager.h>
#include <dpl/serialization.h>
-#include <socket-buffer.h>
+#include <message-buffer.h>
#include <security-server-common.h>
, public SecurityServer::ServiceThread<GetObjectNameService>
{
public:
- typedef std::map<int, SocketBuffer> SocketBufferMap;
+ typedef std::map<int, MessageBuffer> MessageBufferMap;
ServiceDescriptionVector GetServiceDescription();
private:
std::string m_name;
- bool readOne(const ConnectionID &conn, SocketBuffer &buffer);
+ bool readOne(const ConnectionID &conn, MessageBuffer &buffer);
int setName(gid_t gid);
- SocketBufferMap m_socketBufferMap;
+ MessageBufferMap m_messageBufferMap;
};
} // namespace SecurityServer
-#endif // _SECURITY_SERVER_SERV_GET_OBJECT_NAME_
\ No newline at end of file
+#endif // _SECURITY_SERVER_SERV_GET_OBJECT_NAME_
m_serviceManager->Close(event.connectionID);
}
-bool PrivilegeByPidService::readOne(const ConnectionID &conn, SocketBuffer &buffer) {
+bool PrivilegeByPidService::readOne(const ConnectionID &conn, MessageBuffer &buffer) {
LogDebug("Iteration begin");
int retval;
Deserialization::Deserialize(buffer, pid);
Deserialization::Deserialize(buffer, object);
Deserialization::Deserialize(buffer, access_rights);
- } Catch (SocketBuffer::Exception::Base) {
+ } Catch (MessageBuffer::Exception::Base) {
LogDebug("Broken protocol. Closing socket.");
m_serviceManager->Close(conn);
return false;
else //there is no permission
retCode = SECURITY_SERVER_API_ERROR_ACCESS_DENIED;
- SocketBuffer sendBuffer;
+ MessageBuffer sendBuffer;
Serialization::Serialize(sendBuffer, retCode);
m_serviceManager->Write(conn, sendBuffer.Pop());
return true;
void PrivilegeByPidService::read(const ReadEvent &event) {
LogDebug("Read event for counter: " << event.connectionID.counter);
- auto &buffer = m_socketBufferMap[event.connectionID.counter];
+ auto &buffer = m_messageBufferMap[event.connectionID.counter];
buffer.Push(event.rawBuffer);
// We can get several requests in one package.
void PrivilegeByPidService::close(const CloseEvent &event) {
LogDebug("CloseEvent. ConnectionID: " << event.connectionID.sock);
- m_socketBufferMap.erase(event.connectionID.counter);
+ m_messageBufferMap.erase(event.connectionID.counter);
}
void PrivilegeByPidService::error(const ErrorEvent &event) {
#include <service-thread.h>
#include <generic-socket-manager.h>
-#include <socket-buffer.h>
+#include <message-buffer.h>
namespace SecurityServer {
, public SecurityServer::ServiceThread<PrivilegeByPidService>
{
public:
- typedef std::map<int, SocketBuffer> SocketBufferMap;
+ typedef std::map<int, MessageBuffer> MessageBufferMap;
ServiceDescriptionVector GetServiceDescription();
void close(const CloseEvent &event);
void error(const ErrorEvent &event);
private:
- bool readOne(const ConnectionID &conn, SocketBuffer &buffer);
+ bool readOne(const ConnectionID &conn, MessageBuffer &buffer);
- SocketBufferMap m_socketBufferMap;
+ MessageBufferMap m_messageBufferMap;
};
} // namespace SecurityServer