Integrate internal fixes

[platform/core/system/sensord.git] / src / shared / channel.cpp

diff --git a/src/shared/channel.cpp b/src/shared/channel.cpp
index 8dc25ac..f27e1d4 100644 (file)
--- a/src/shared/channel.cpp
+++ b/src/shared/channel.cpp
@@ -24,8 +24,9 @@
 #include <memory>
 
 #include "sensor_log.h"
+#include "channel_event_handler.h"
 
-#define SYSTEMD_SOCK_BUF_SIZE 40000
+#define SYSTEMD_SOCK_BUF_SIZE (128*1024)
 
 using namespace ipc;
 
@@ -76,7 +77,7 @@ public:
                if (condition & (EVENT_OUT | EVENT_HUP))
                        return false;
 
-               if (!m_ch->read_sync(msg))
+               if (!m_ch->read_sync(msg, false))
                        return false;
 
                return false;
@@ -94,14 +95,27 @@ channel::channel(socket *sock)
 , m_loop(NULL)
 , m_connected(false)
 {
+       _D("Created");
 }
 
 channel::~channel()
 {
-       /* disconnect() should not be called here */
+       _D("Destroyed[%llu]", m_event_id);
+       disconnect();
 }
 
-void channel::bind(channel_handler *handler, event_loop *loop)
+uint64_t channel::bind(void)
+{
+       retv_if(!m_loop, 0);
+       m_event_id = m_loop->add_event(m_socket->get_fd(),
+                       (EVENT_IN | EVENT_HUP | EVENT_NVAL),
+                       dynamic_cast<channel_event_handler *>(m_handler));
+
+       _D("Bound[%llu]", m_event_id);
+       return m_event_id;
+}
+
+uint64_t channel::bind(channel_handler *handler, event_loop *loop, bool loop_bind)
 {
        m_handler = handler;
        m_loop = loop;
@@ -109,46 +123,71 @@ void channel::bind(channel_handler *handler, event_loop *loop)
 
        if (m_handler)
                m_handler->connected(this);
+
+       if (loop_bind)
+               bind();
+
+       return m_event_id;
 }
 
-bool channel::connect(channel_handler *handler, event_loop *loop)
+uint64_t channel::connect(channel_handler *handler, event_loop *loop, bool loop_bind)
 {
        if (!m_socket->connect())
                return false;
 
-       bind(handler, loop);
-       return true;
+       bind(handler, loop, loop_bind);
+
+       _D("Connected[%llu]", m_event_id);
+       return m_event_id;
 }
 
 void channel::disconnect(void)
 {
-       ret_if(!is_connected());
+       if (!is_connected()) {
+               _D("Channel is not connected");
+               return;
+       }
+
        m_connected.store(false);
 
+       _D("Disconnecting..[%llu]", m_event_id);
+
        if (m_handler) {
                m_handler->disconnected(this);
                m_handler = NULL;
        }
 
        if (m_loop) {
+               _D("Remove event[%llu]", m_event_id);
                m_loop->remove_event(m_event_id, true);
                m_loop = NULL;
                m_event_id = 0;
        }
 
        if (m_socket) {
+               _D("Release socket[%d]", m_socket->get_fd());
                delete m_socket;
                m_socket = NULL;
        }
+
+       _D("Disconnected");
 }
 
 bool channel::send(message *msg)
 {
+       int retry_cnt = 0;
+       int cur_buffer_size = 0;
+
        retv_if(!m_loop, false);
 
-       /* TODO: check buffer size(is there any linux api for this?) */
-       int cur_buffer_size = m_socket->get_current_buffer_size();
-       retvm_if(cur_buffer_size > SYSTEMD_SOCK_BUF_SIZE, false, "Failed to send data");
+       while (retry_cnt < 3) {
+               cur_buffer_size = m_socket->get_current_buffer_size();
+               if (cur_buffer_size <= SYSTEMD_SOCK_BUF_SIZE)
+                       break;
+               usleep(3000);
+               retry_cnt++;
+       }
+       retvm_if(retry_cnt >= 3, false, "Socket buffer[%d] is exceeded", cur_buffer_size);
 
        send_event_handler *handler = new(std::nothrow) send_event_handler(this, msg);
        retvm_if(!handler, false, "Failed to allocate memory");
@@ -163,20 +202,23 @@ bool channel::send(message *msg)
 
 bool channel::send_sync(message *msg)
 {
-       retv_if(!msg, false);
+       retvm_if(!msg, false, "Invalid message");
+       retvm_if(msg->size() >= MAX_MSG_CAPACITY, true, "Invaild message size[%u]", msg->size());
 
        ssize_t size = 0;
        char *buf = msg->body();
 
        /* header */
        size = m_socket->send(reinterpret_cast<void *>(msg->header()),
-                                  sizeof(message_header), true);
-       retv_if(size <= 0, false);
-       retv_if(msg->size() <= 0, true);
+           sizeof(message_header), true);
+       retvm_if(size <= 0, false, "Failed to send header");
+
+       /* if body size is zero, skip to send body message */
+       retv_if(msg->size() == 0, true);
 
        /* body */
        size = m_socket->send(buf, msg->size(), true);
-       retv_if(size <= 0, false);
+       retvm_if(size <= 0, false, "Failed to send body");
 
        return true;
 }
@@ -193,14 +235,14 @@ bool channel::read(void)
        return true;
 }
 
-bool channel::read_sync(message &msg)
+bool channel::read_sync(message &msg, bool select)
 {
        message_header header;
        ssize_t size = 0;
        char buf[MAX_MSG_CAPACITY];
 
        /* header */
-       size = m_socket->recv(&header, sizeof(message_header), true);
+       size = m_socket->recv(&header, sizeof(message_header), select);
        retv_if(size <= 0, false);
 
        /* check error from header */
@@ -211,8 +253,13 @@ bool channel::read_sync(message &msg)
        }
 
        /* body */
+       if (header.length >= MAX_MSG_CAPACITY) {
+               _E("header.length error %u", header.length);
+               return false;
+       }
+
        if (header.length > 0) {
-               size = m_socket->recv(&buf, header.length, true);
+               size = m_socket->recv(&buf, header.length, select);
                retv_if(size <= 0, false);
        }
 
@@ -271,8 +318,3 @@ int channel::get_fd(void) const
 {
        return m_fd;
 }
-
-void channel::set_event_id(uint64_t id)
-{
-       m_event_id = id;
-}