diff options
Diffstat (limited to 'src/Daemon/CommLayerServerSocket.cpp')
| -rw-r--r-- | src/Daemon/CommLayerServerSocket.cpp | 248 |
1 files changed, 248 insertions, 0 deletions
diff --git a/src/Daemon/CommLayerServerSocket.cpp b/src/Daemon/CommLayerServerSocket.cpp new file mode 100644 index 0000000..f5466d4 --- /dev/null +++ b/src/Daemon/CommLayerServerSocket.cpp @@ -0,0 +1,248 @@ +#include "CommLayerServerSocket.h" +#include "CommLayerInner.h" +#include "ABRTException.h" +#include "CrashTypesSocket.h" +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/un.h> +#include <iostream> +#include <sstream> +#include <sys/stat.h> +#include <unistd.h> +#include <fcntl.h> + +void CCommLayerServerSocket::Send(const std::string& pData, GIOChannel *pDestination) +{ + ssize_t ret = -1; + gsize len = pData.length(); + int offset = 0; + GError *err = NULL; + gchar* message = new gchar[len + 3]; + memcpy(message, pData.c_str(), len); + message[len] = MESSAGE_END_MARKER; + message[len + 1] = '\n'; + message[len + 2] = '\0'; + + len = 0; + while (len != strlen(message + offset)) + { + offset += len; + ret = g_io_channel_write_chars(pDestination, message + offset, strlen(message + offset), &len, &err); + if (ret == G_IO_STATUS_ERROR) + { + comm_layer_inner_warning("Error during sending data."); + } + } + + g_io_channel_flush(pDestination, &err); + delete[] message; +} + +std::string CCommLayerServerSocket::GetSenderUID(int pSenderSocket) +{ + struct ucred creds; + socklen_t len = sizeof(creds); + if (getsockopt(pSenderSocket, SOL_SOCKET, SO_PEERCRED, &creds, &len) == -1) + { + throw CABRTException(EXCEP_ERROR, "CCommLayerServerSocket::GetSenderUID(): Error can get sender uid."); + } + std::stringstream ss; + ss << creds.uid; + return ss.str(); +} + +gboolean CCommLayerServerSocket::client_socket_cb(GIOChannel *source, GIOCondition condition, gpointer data) +{ + CCommLayerServerSocket* serverSocket = static_cast<CCommLayerServerSocket*>(data); + std::string senderUID = serverSocket->GetSenderUID(g_io_channel_unix_get_fd(source)); + gchar buff[1]; + gsize len; + GIOStatus ret; + GError *err = NULL; + bool receivingMessage = true; + std::string message = ""; + + if (condition & G_IO_HUP || + condition & G_IO_ERR || + condition & G_IO_NVAL) + { + comm_layer_inner_debug("Socket client disconnected."); + g_io_channel_unref(serverSocket->m_mapClientChannels[g_io_channel_unix_get_fd(source)]); + serverSocket->m_mapClientChannels.erase(g_io_channel_unix_get_fd(source)); + return FALSE; + } + + // TODO: rewrite this + while (receivingMessage) + { + ret = g_io_channel_read_chars(source, buff, 1, &len, &err); + if (ret == G_IO_STATUS_ERROR) + { + comm_layer_inner_warning(std::string("Error while reading data from client socket: ") + err->message); + return FALSE; + } + message += buff[0]; + + if (message.length() > 2 && + message[message.length() - 2] == MESSAGE_END_MARKER && + message[message.length() - 1] == '\n') + { + receivingMessage = false; + message = message.substr(0, message.length() - 2); + } + } + + serverSocket->ProcessMessage(message, source); + return TRUE; +} + +gboolean CCommLayerServerSocket::server_socket_cb(GIOChannel *source, GIOCondition condition, gpointer data) +{ + CCommLayerServerSocket* serverSocket = static_cast<CCommLayerServerSocket*>(data); + int socket; + struct sockaddr_un remote; + socklen_t len = sizeof(remote); + + if (condition & G_IO_HUP || + condition & G_IO_ERR || + condition & G_IO_NVAL) + { + comm_layer_inner_warning("Server socket error."); + return FALSE; + } + + if ((socket = accept(serverSocket->m_nSocket, (struct sockaddr *)&remote, &len)) == -1) + { + comm_layer_inner_warning("Server can not accept client."); + return TRUE; + } + comm_layer_inner_debug("New socket client connected."); + GIOChannel* gSocket = g_io_channel_unix_new(socket); + if (!g_io_add_watch(gSocket, + static_cast<GIOCondition>(G_IO_IN |G_IO_PRI| G_IO_ERR | G_IO_HUP | G_IO_NVAL), + static_cast<GIOFunc>(client_socket_cb), + data)) + { + comm_layer_inner_warning("Can not init g_io_channel."); + return TRUE; + } + serverSocket->m_mapClientChannels[socket] = gSocket; + return TRUE; +} + +void CCommLayerServerSocket::ProcessMessage(const std::string& pMessage, GIOChannel *pSource) +{ + std::string UID = GetSenderUID(g_io_channel_unix_get_fd(pSource)); + + if (!strncmp(pMessage.c_str(), MESSAGE_GET_CRASH_INFOS, sizeof(MESSAGE_GET_CRASH_INFOS) - 1)) + { + vector_crash_infos_t crashInfos = GetCrashInfos(UID); + std::string message = MESSAGE_GET_CRASH_INFOS + crash_infos_to_string(crashInfos); + Send(message, pSource); + } + else if (!strncmp(pMessage.c_str(), MESSAGE_REPORT, sizeof(MESSAGE_REPORT) - 1)) + { + std::string message = pMessage.substr(sizeof(MESSAGE_REPORT) - 1); + map_crash_report_t report = string_to_crash_report(message); + Report(report, UID); + } + else if (!strncmp(pMessage.c_str(), MESSAGE_CREATE_REPORT, sizeof(MESSAGE_CREATE_REPORT) - 1)) + { + std::string UUID = pMessage.substr(sizeof(MESSAGE_CREATE_REPORT) - 1); + map_crash_report_t crashReport = CreateReport(UUID, UID); + std::string message = MESSAGE_CREATE_REPORT + crash_report_to_string(crashReport); + Send(message, pSource); + } + else if (!strncmp(pMessage.c_str(), MESSAGE_DELETE_DEBUG_DUMP, sizeof(MESSAGE_DELETE_DEBUG_DUMP) - 1)) + { + std::string UUID = pMessage.substr(sizeof(MESSAGE_DELETE_DEBUG_DUMP) - 1); + DeleteDebugDump(UUID, UID); + } + else + { + comm_layer_inner_warning("Received unknown message type."); + } +} + +CCommLayerServerSocket::CCommLayerServerSocket() +: CCommLayerServer() +{ + int len; + struct sockaddr_un local; + + unlink(SOCKET_FILE); + if ((m_nSocket = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) + { + throw CABRTException(EXCEP_FATAL, "CCommLayerServerSocket::CCommLayerServerSocket(): Can not create socket."); + } + fcntl(m_nSocket, F_SETFD, FD_CLOEXEC); + local.sun_family = AF_UNIX; + strcpy(local.sun_path, SOCKET_FILE); + len = strlen(local.sun_path) + sizeof(local.sun_family); + if (bind(m_nSocket, (struct sockaddr *)&local, len) == -1) + { + throw CABRTException(EXCEP_FATAL, "CCommLayerServerSocket::CCommLayerServerSocket(): Can not bind to the socket."); + } + if (listen(m_nSocket, 5) == -1) + { + throw CABRTException(EXCEP_FATAL, "CCommLayerServerSocket::CCommLayerServerSocket(): Can not listen on the socket."); + } + chmod(SOCKET_FILE, SOCKET_PERMISSION); + + m_pGSocket = g_io_channel_unix_new(m_nSocket); + if (!g_io_add_watch(m_pGSocket, + static_cast<GIOCondition>(G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP | G_IO_NVAL), + static_cast<GIOFunc>(server_socket_cb), + this)) + { + throw CABRTException(EXCEP_FATAL, "CCommLayerServerSocket::CCommLayerServerSocket(): Can not init g_io_channel."); + } +} + +CCommLayerServerSocket::~CCommLayerServerSocket() +{ + g_io_channel_unref(m_pGSocket); + close(m_nSocket); +} + +vector_crash_infos_t CCommLayerServerSocket::GetCrashInfos(const std::string &pSender) +{ + vector_crash_infos_t crashInfos; + crashInfos = m_pObserver->GetCrashInfos(pSender); + return crashInfos; +} + +map_crash_report_t CCommLayerServerSocket::CreateReport(const std::string &pUUID,const std::string &pSender) +{ + map_crash_report_t crashReport; + crashReport = m_pObserver->CreateReport(pUUID, pSender); + return crashReport; +} + +report_status_t CCommLayerServerSocket::Report(map_crash_report_t pReport, const std::string& pSender) +{ + report_status_t rs; + rs = m_pObserver->Report(pReport, pSender); + return rs; +} + +bool CCommLayerServerSocket::DeleteDebugDump(const std::string& pUUID, const std::string& pSender) +{ + m_pObserver->DeleteDebugDump(pUUID, pSender); + return true; +} + +void CCommLayerServerSocket::Crash(const std::string& arg1) +{ + //Send("(CRASH)New Crash Detected: " + arg1); +} + +void CCommLayerServerSocket::AnalyzeComplete(map_crash_report_t arg1) +{ + //Send("(ANALYZE_COMPLETE)Analyze Complete."); +} + +void CCommLayerServerSocket::Error(const std::string& arg1) +{ + //Send("(ERROR)Error: " + arg1); +} |