src/shared/message.cpp

   1 /*
   2  * sensord
   3  *
   4  * Copyright (c) 2017 Samsung Electronics Co., Ltd.
   5  *
   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
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  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.
  17  *
  18  */
  19
  20 #include "message.h"
  21
  22 #include <sensor_log.h>
  23 #include <atomic>
  24
  25 using namespace ipc;
  26
  27 #define UNDEFINED_TYPE -2
  28
  29 static std::atomic<uint64_t> sequence(0);
  30
  31 message::message(size_t capacity)
  32 : m_size(0)
  33 , m_capacity(capacity)
  34 , m_msg((char *)malloc(sizeof(char) * capacity))
  35 , ref_cnt(0)
  36 {
  37         m_header.id = sequence++;
  38         m_header.type = UNDEFINED_TYPE;
  39         m_header.length = m_size;
  40         m_header.err = 0;
  41 }
  42
  43 message::message(const void *msg, size_t sz)
  44 : m_size(sz)
  45 , m_capacity(sz)
  46 , m_msg((char *)msg)
  47 , ref_cnt(0)
  48 {
  49         m_header.id = sequence++;
  50         m_header.type = UNDEFINED_TYPE;
  51         m_header.length = m_size;
  52         m_header.err = 0;
  53 }
  54
  55 message::message(const message &msg)
  56 : m_size(msg.m_size)
  57 , m_capacity(msg.m_capacity)
  58 , m_msg((char *)malloc(sizeof(char) * msg.m_capacity))
  59 , ref_cnt(0)
  60 {
  61         ::memcpy(&m_header, &msg.m_header, sizeof(message_header));
  62         ::memcpy(m_msg, msg.m_msg, msg.m_size);
  63 }
  64
  65 message::message(int error)
  66 : m_size(0)
  67 , m_capacity(0)
  68 , m_msg(NULL)
  69 , ref_cnt(0)
  70 {
  71         m_header.id = sequence++;
  72         m_header.type = UNDEFINED_TYPE;
  73         m_header.length = 0;
  74         m_header.err = error;
  75 }
  76
  77 message::~message()
  78 {
  79         if (m_msg && ref_cnt == 0) {
  80                 free(m_msg);
  81                 m_msg = NULL;
  82         }
  83 }
  84
  85 void message::enclose(const void *msg, const size_t sz)
  86 {
  87         if (!msg || sz == 0)
  88                 return;
  89
  90         if (m_capacity < sz)
  91                 return;
  92
  93         ::memcpy(reinterpret_cast<char *>(m_msg), msg, sz);
  94         m_size = sz;
  95         m_header.length = sz;
  96 }
  97
  98 void message::enclose(int error)
  99 {
 100         m_header.err = error;
 101         m_header.length = 0;
 102         m_size = 0;
 103 }
 104
 105 void message::disclose(void *msg)
 106 {
 107         if (!msg || !m_msg)
 108                 return;
 109
 110         ::memcpy(msg, m_msg, m_size);
 111 }
 112
 113 uint32_t message::type(void)
 114 {
 115         return m_header.type;
 116 }
 117
 118 void message::set_type(uint32_t msg_type)
 119 {
 120         m_header.type = msg_type;
 121 }
 122
 123 size_t message::size(void)
 124 {
 125         return m_size;
 126 }
 127
 128 /* TODO: remove ref/unref and use reference counting automatically */
 129 void message::ref(void)
 130 {
 131         ref_cnt++;
 132 }
 133
 134 void message::unref(void)
 135 {
 136         ref_cnt--;
 137
 138         if (ref_cnt > 0 || !m_msg)
 139                 return;
 140
 141         free(m_msg);
 142         m_msg = NULL;
 143         delete this;
 144 }
 145
 146 int message::ref_count(void)
 147 {
 148         return ref_cnt;
 149 }
 150
 151 message_header *message::header(void)
 152 {
 153         return &m_header;
 154 }
 155
 156 char *message::body(void)
 157 {
 158         return m_msg;
 159 }