4 * Copyright (c) 2017 Samsung Electronics Co., Ltd.
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
26 #include "sensor_log.h"
28 #define SYSTEMD_SOCK_BUF_SIZE 40000
32 class send_event_handler : public event_handler
35 send_event_handler(channel *ch, message *msg)
40 bool handle(int fd, event_condition condition)
42 if (!m_ch || !m_ch->is_connected())
45 if (condition & (EVENT_IN | EVENT_HUP))
48 if (!m_ch->send_sync(m_msg))
62 class read_event_handler : public event_handler
65 read_event_handler(channel *ch)
69 bool handle(int fd, event_condition condition)
73 if (!m_ch || !m_ch->is_connected())
76 if (condition & (EVENT_OUT | EVENT_HUP))
79 if (!m_ch->read_sync(msg))
89 channel::channel(socket *sock)
90 : m_fd(sock->get_fd())
101 /* disconnect() should not be called here */
104 void channel::bind(channel_handler *handler, event_loop *loop)
108 m_connected.store(true);
111 m_handler->connected(this);
114 bool channel::connect(channel_handler *handler, event_loop *loop)
116 if (!m_socket->connect())
123 void channel::disconnect(void)
125 ret_if(!is_connected());
126 m_connected.store(false);
129 m_handler->disconnected(this);
134 m_loop->remove_event(m_event_id, true);
145 bool channel::send(message *msg)
147 retv_if(!m_loop, false);
149 /* TODO: check buffer size(is there any linux api for this?) */
150 int cur_buffer_size = m_socket->get_current_buffer_size();
151 retvm_if(cur_buffer_size > SYSTEMD_SOCK_BUF_SIZE, false, "Failed to send data");
153 send_event_handler *handler = new(std::nothrow) send_event_handler(this, msg);
154 retvm_if(!handler, false, "Failed to allocate memory");
158 m_loop->add_event(m_socket->get_fd(),
159 (EVENT_OUT | EVENT_HUP | EVENT_NVAL) , handler);
164 bool channel::send_sync(message *msg)
166 retv_if(!msg, false);
169 char *buf = msg->body();
172 size = m_socket->send(reinterpret_cast<void *>(msg->header()),
173 sizeof(message_header), true);
174 retv_if(size <= 0, false);
175 retv_if(msg->size() <= 0, true);
178 size = m_socket->send(buf, msg->size(), true);
179 retv_if(size <= 0, false);
184 bool channel::read(void)
186 retv_if(!m_loop, false);
188 read_event_handler *handler = new(std::nothrow) read_event_handler(this);
189 retvm_if(!handler, false, "Failed to allocate memory");
191 m_loop->add_event(m_socket->get_fd(), (EVENT_IN | EVENT_HUP | EVENT_NVAL), handler);
196 bool channel::read_sync(message &msg)
198 message_header header;
200 char buf[MAX_MSG_CAPACITY];
203 size = m_socket->recv(&header, sizeof(message_header), true);
204 retv_if(size <= 0, false);
206 /* check error from header */
207 if (m_handler && header.err != 0) {
208 m_handler->error_caught(this, header.err);
209 msg.header()->err = header.err;
214 if (header.length > 0) {
215 size = m_socket->recv(&buf, header.length, true);
216 retv_if(size <= 0, false);
219 buf[header.length] = '\0';
220 msg.enclose(reinterpret_cast<const void *>(buf), header.length);
221 msg.set_type(header.type);
222 msg.header()->err = header.err;
225 m_handler->read(this, msg);
230 bool channel::is_connected(void)
232 return m_connected.load();
235 bool channel::set_option(int type, int value)
239 m_socket->set_buffer_size(type, value);
242 m_socket->set_buffer_size(type, value);
251 bool channel::get_option(int type, int &value) const
255 value = m_socket->get_current_buffer_size();
258 value = m_socket->get_buffer_size(type);
261 value = m_socket->get_buffer_size(type);
270 int channel::get_fd(void) const
275 void channel::set_event_id(uint64_t id)