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 (...) {
--- /dev/null
+/*
+ * Copyright (c) 2000 - 2013 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Contact: Bumjin Im <bj.im@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+/*
+ * @file message-buffer.cpp
+ * @author Bartlomiej Grzelewski (b.grzelewski@samsung.com)
+ * @version 1.0
+ * @brief Implementation of MessageBuffer.
+ */
+
+#include <message-buffer.h>
+
+#include <dpl/log/log.h>
+
+namespace SecurityServer {
+
+void MessageBuffer::Push(const RawBuffer &data) {
+ m_buffer.AppendCopy(&data[0], data.size());
+}
+
+RawBuffer MessageBuffer::Pop() {
+ size_t size = m_buffer.Size();
+ RawBuffer buffer;
+ buffer.resize(size + sizeof(size_t));
+ memcpy(&buffer[0], &size, sizeof(size_t));
+ m_buffer.FlattenConsume(&buffer[sizeof(size_t)], size);
+ return buffer;
+}
+
+bool MessageBuffer::Ready() {
+ CountBytesLeft();
+ if (m_bytesLeft == 0)
+ return false;
+ if (m_bytesLeft > m_buffer.Size())
+ return false;
+ return true;
+}
+
+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());
+ Throw(Exception::OutOfData);
+ }
+
+ m_buffer.FlattenConsume(bytes, num);
+ m_bytesLeft -= num;
+}
+
+void MessageBuffer::Write(size_t num, const void *bytes) {
+ m_buffer.AppendCopy(bytes, num);
+}
+
+} // namespace SecurityServer
+
--- /dev/null
+/*
+ * Copyright (c) 2000 - 2013 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Contact: Bumjin Im <bj.im@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+/*
+ * @file secket-buffer.h
+ * @author Bartlomiej Grzelewski (b.grzelewski@samsung.com)
+ * @version 1.0
+ * @brief Implementatin of MessageBuffer.
+ */
+
+#ifndef _SECURITY_SERVER_SOCKET_BUFFER_
+#define _SECURITY_SERVER_SOCKET_BUFFER_
+
+#include <vector>
+
+#include <dpl/binary_queue.h>
+#include <dpl/exception.h>
+#include <dpl/serialization.h>
+
+namespace SecurityServer {
+
+typedef std::vector<unsigned char> RawBuffer;
+
+class MessageBuffer : public SecurityServer::IStream {
+public:
+ class Exception
+ {
+ public:
+ DECLARE_EXCEPTION_TYPE(SecurityServer::Exception, Base)
+ DECLARE_EXCEPTION_TYPE(Base, OutOfData)
+ };
+
+ MessageBuffer()
+ : m_bytesLeft(0)
+ {}
+
+ void Push(const RawBuffer &data);
+
+ RawBuffer Pop();
+
+ bool Ready();
+
+ virtual void Read(size_t num, void *bytes);
+
+ virtual void Write(size_t num, const void *bytes);
+
+protected:
+
+ inline void CountBytesLeft() {
+ if (m_bytesLeft > 0)
+ return; // we already counted m_bytesLeft nothing to do
+
+ if (m_buffer.Size() < sizeof(size_t))
+ return; // we cannot count m_bytesLeft because buffer is too small
+
+ m_buffer.FlattenConsume(&m_bytesLeft, sizeof(size_t));
+ }
+
+ size_t m_bytesLeft;
+ SecurityServer::BinaryQueue m_buffer;
+};
+
+} // namespace SecurityServer
+
+#endif // _SECURITY_SERVER_SOCKET_BUFFER_
+++ /dev/null
-/*
- * Copyright (c) 2000 - 2013 Samsung Electronics Co., Ltd All Rights Reserved
- *
- * Contact: Bumjin Im <bj.im@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License
- */
-/*
- * @file socket-buffer.cpp
- * @author Bartlomiej Grzelewski (b.grzelewski@samsung.com)
- * @version 1.0
- * @brief Implementation of SocketBuffer.
- */
-
-#include <socket-buffer.h>
-
-#include <dpl/log/log.h>
-
-namespace SecurityServer {
-
-void SocketBuffer::Push(const RawBuffer &data) {
- m_buffer.AppendCopy(&data[0], data.size());
-}
-
-RawBuffer SocketBuffer::Pop() {
- size_t size = m_buffer.Size();
- RawBuffer buffer;
- buffer.resize(size + sizeof(size_t));
- memcpy(&buffer[0], &size, sizeof(size_t));
- m_buffer.FlattenConsume(&buffer[sizeof(size_t)], size);
- return buffer;
-}
-
-bool SocketBuffer::Ready() {
- CountBytesLeft();
- if (m_bytesLeft == 0)
- return false;
- if (m_bytesLeft > m_buffer.Size())
- return false;
- return true;
-}
-
-void SocketBuffer::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());
- Throw(Exception::OutOfData);
- }
-
- m_buffer.FlattenConsume(bytes, num);
- m_bytesLeft -= num;
-}
-
-void SocketBuffer::Write(size_t num, const void *bytes) {
- m_buffer.AppendCopy(bytes, num);
-}
-
-} // namespace SecurityServer
-
+++ /dev/null
-/*
- * Copyright (c) 2000 - 2013 Samsung Electronics Co., Ltd All Rights Reserved
- *
- * Contact: Bumjin Im <bj.im@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License
- */
-/*
- * @file secket-buffer.h
- * @author Bartlomiej Grzelewski (b.grzelewski@samsung.com)
- * @version 1.0
- * @brief Implementatin of SocketBuffer.
- */
-
-#ifndef _SECURITY_SERVER_SOCKET_BUFFER_
-#define _SECURITY_SERVER_SOCKET_BUFFER_
-
-#include <vector>
-
-#include <dpl/binary_queue.h>
-#include <dpl/exception.h>
-#include <dpl/serialization.h>
-
-namespace SecurityServer {
-
-typedef std::vector<unsigned char> RawBuffer;
-
-class SocketBuffer : public SecurityServer::IStream {
-public:
- class Exception
- {
- public:
- DECLARE_EXCEPTION_TYPE(SecurityServer::Exception, Base)
- DECLARE_EXCEPTION_TYPE(Base, OutOfData)
- };
-
- SocketBuffer()
- : m_bytesLeft(0)
- {}
-
- void Push(const RawBuffer &data);
-
- RawBuffer Pop();
-
- bool Ready();
-
- virtual void Read(size_t num, void *bytes);
-
- virtual void Write(size_t num, const void *bytes);
-
-protected:
-
- inline void CountBytesLeft() {
- if (m_bytesLeft > 0)
- return; // we already counted m_bytesLeft nothing to do
-
- if (m_buffer.Size() < sizeof(size_t))
- return; // we cannot count m_bytesLeft because buffer is too small
-
- m_buffer.FlattenConsume(&m_bytesLeft, sizeof(size_t));
- }
-
- size_t m_bytesLeft;
- SecurityServer::BinaryQueue m_buffer;
-};
-
-} // namespace SecurityServer
-
-#endif // _SECURITY_SERVER_SOCKET_BUFFER_
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
projects / platform / core / security / security-server.git / commitdiff