server/src/muse_server.c

   1 /*
   2  * muse-server
   3  *
   4  * Copyright (c) 2017 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: YoungHun Kim <yh8004.kim@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 #include "muse_server_private.h"
  23
  24 void muse_server_set_dispatch_timeout(muse_module_h m, int api, int timeout)
  25 {
  26         muse_return_if_fail(m);
  27         muse_return_if_fail(m->idx >= 0 && m->idx < ms_config_get_host_cnt());
  28         muse_return_if_fail(api >= 0 && api < MUSE_DISPATCHER_MAX);
  29
  30         ms_module_set_timeout(m->idx, api, timeout);
  31 }
  32
  33 int muse_server_get_dispatch_timeout(muse_module_h m, int api)
  34 {
  35         muse_return_val_if_fail(m, MM_ERROR_INVALID_ARGUMENT);
  36         muse_return_val_if_fail(m->pid > 0, MM_ERROR_INVALID_ARGUMENT);
  37         muse_return_val_if_fail(m->idx >= 0 && m->idx < ms_config_get_host_cnt(), MM_ERROR_INVALID_ARGUMENT);
  38         muse_return_val_if_fail(api >= 0 && api < MUSE_DISPATCHER_MAX, MM_ERROR_INVALID_ARGUMENT);
  39
  40         return ms_module_get_timeout(m->idx, api);
  41 }
  42
  43 /* module */
  44 int muse_server_module_set_value(muse_module_h m, const char *name, int value)
  45 {
  46         muse_return_val_if_fail(m, MM_ERROR_INVALID_ARGUMENT);
  47         muse_return_val_if_fail(m->pid > 0, MM_ERROR_INVALID_ARGUMENT);
  48         muse_return_val_if_fail(name, MM_ERROR_INVALID_ARGUMENT);
  49         muse_return_val_if_fail(m->idx >= 0 && m->idx < ms_config_get_host_cnt(), MM_ERROR_INVALID_ARGUMENT);
  50
  51         ms_module_set_dllsym_value(m->idx, name, GINT_TO_POINTER(value));
  52         return MM_ERROR_NONE;
  53 }
  54
  55 int muse_server_module_get_value(muse_module_h m, const char *name, int *value)
  56 {
  57         int ret = MM_ERROR_NONE;
  58         gpointer ptr;
  59
  60         muse_return_val_if_fail(m, MM_ERROR_INVALID_ARGUMENT);
  61         muse_return_val_if_fail(m->pid > 0, MM_ERROR_INVALID_ARGUMENT);
  62         muse_return_val_if_fail(name, MM_ERROR_INVALID_ARGUMENT);
  63         muse_return_val_if_fail(value, MM_ERROR_INVALID_ARGUMENT);
  64         muse_return_val_if_fail(m->idx >= 0 && m->idx < ms_config_get_host_cnt(), MM_ERROR_INVALID_ARGUMENT);
  65
  66         ret = ms_module_get_dllsym_value(m->idx, name, &ptr);
  67         if (ret == MM_ERROR_NONE)
  68                 *value = GPOINTER_TO_INT(ptr);
  69         return ret;
  70 }
  71
  72 int muse_server_module_get_msg_fd(muse_module_h m)
  73 {
  74         muse_return_val_if_fail(m, MM_ERROR_INVALID_ARGUMENT);
  75         muse_return_val_if_fail(m->pid > 0, MM_ERROR_INVALID_ARGUMENT);
  76         return m->ch[MUSE_CHANNEL_MSG].sock_fd;
  77 }
  78
  79 int muse_server_module_get_data_fd(muse_module_h m)
  80 {
  81         muse_return_val_if_fail(m, MM_ERROR_INVALID_ARGUMENT);
  82         muse_return_val_if_fail(m->pid > 0, MM_ERROR_INVALID_ARGUMENT);
  83         return m->ch[MUSE_CHANNEL_DATA].sock_fd;
  84 }
  85
  86 char *muse_server_module_get_msg(muse_module_h m)
  87 {
  88         muse_return_val_if_fail(m, NULL);
  89         return (m->recv_msg + m->msg_offset);
  90 }
  91
  92 void muse_server_set_user_data(muse_module_h m, void *data)
  93 {
  94         muse_return_if_fail(m);
  95         m->user_data = data;
  96 }
  97
  98 void *muse_server_get_user_data(muse_module_h m)
  99 {
 100         muse_return_val_if_fail(m, NULL);
 101         return m->user_data;
 102 }
 103
 104 bool muse_server_module_is_valid(muse_module_h m)
 105 {
 106         muse_return_val_if_fail(m, false);
 107         muse_return_val_if_fail(m->pid > 0, false);
 108         muse_return_val_if_fail(muse_core_fd_is_valid(m->ch[MUSE_CHANNEL_MSG].sock_fd), false);
 109
 110         return true;
 111 }
 112
 113 /* ipc */
 114 int muse_server_ipc_get_bufmgr(tbm_bufmgr *bufmgr)
 115 {
 116         LOGD("Enter");
 117
 118         muse_return_val_if_fail(ms_get_instance(), MM_ERROR_UNKNOWN);
 119         muse_return_val_if_fail(bufmgr, MM_ERROR_INVALID_ARGUMENT);
 120
 121         if (!ms_get_instance()->bufmgr)
 122                 muse_return_val_if_fail(ms_init_bufmgr(), MM_ERROR_INVALID_ARGUMENT);
 123
 124         LOGD("bufmgr: %p", ms_get_instance()->bufmgr);
 125         *bufmgr = ms_get_instance()->bufmgr;
 126
 127         LOGD("Leave");
 128         return MM_ERROR_NONE;
 129 }
 130
 131 int muse_server_ipc_get_gdbus_connection(GDBusConnection **gdbus)
 132 {
 133         LOGD("Enter");
 134
 135         muse_return_val_if_fail(gdbus, MM_ERROR_INVALID_ARGUMENT);
 136         if (!ms_system_get_gdbus(gdbus))
 137                 return MM_ERROR_UNKNOWN;
 138
 139         LOGD("gdbus : %p", *gdbus);
 140         return MM_ERROR_NONE;
 141 }
 142
 143 char *muse_server_ipc_get_data(muse_module_h m)
 144 {
 145         muse_channel_info_t *ch = NULL;
 146         char *raw_data = NULL;
 147
 148         gint64 end_time = g_get_monotonic_time() + 100 * G_TIME_SPAN_MILLISECOND;
 149         muse_return_val_if_fail(m, NULL);
 150
 151         ch = &m->ch[MUSE_CHANNEL_DATA];
 152         muse_return_val_if_fail(ch->data_queue, NULL);
 153
 154         g_mutex_lock(&ch->data_mutex);
 155         while (!(raw_data = (char *)g_queue_pop_head(ch->data_queue))) {
 156                 if (!g_cond_wait_until(&ch->data_cond, &ch->data_mutex, end_time)) {
 157                         LOGE("[%d] timeout has passed", ch->sock_fd);
 158                         break;
 159                 }
 160         }
 161         g_mutex_unlock(&ch->data_mutex);
 162
 163         if (!raw_data) {
 164                 LOGE("NULL raw_data");
 165                 return NULL;
 166         }
 167
 168         return (raw_data + sizeof(muse_recv_data_head_t));
 169 }
 170
 171 void muse_server_ipc_delete_data(char *data)
 172 {
 173         char *raw_data = NULL;
 174
 175         muse_return_if_fail(data);
 176
 177         raw_data = data - sizeof(muse_recv_data_head_t);
 178
 179         g_free(raw_data);
 180 }
 181
 182 bool muse_server_ipc_get_data_info(char *data, uint64_t *data_id, int *size)
 183 {
 184         muse_recv_data_t *qdata = NULL;
 185
 186         muse_return_val_if_fail(data, false);
 187
 188         qdata = (muse_recv_data_t *)(data - sizeof(muse_recv_data_head_t));
 189         if (qdata && qdata->header.marker == MUSE_DATA_HEAD) {
 190                 if (data_id)
 191                         *data_id = qdata->header.id;
 192                 if (size)
 193                         *size = qdata->header.size;
 194
 195                 return true;
 196         }
 197
 198         return false;
 199 }
 200
 201 intptr_t muse_server_ipc_get_handle(muse_module_h m)
 202 {
 203         muse_return_val_if_fail(m, 0);
 204         muse_return_val_if_fail(m->handle, 0);
 205
 206         return m->handle;
 207 }
 208
 209 int muse_server_ipc_set_handle(muse_module_h m, intptr_t handle)
 210 {
 211         muse_return_val_if_fail(m, MM_ERROR_INVALID_ARGUMENT);
 212
 213         m->handle = handle;
 214         return MM_ERROR_NONE;
 215 }
 216
 217 int muse_server_ipc_get_fd(muse_module_h m, int *fd)
 218 {
 219         muse_return_val_if_fail(m, MM_ERROR_INVALID_ARGUMENT);
 220         muse_return_val_if_fail(m->pid > 0, MM_ERROR_INVALID_ARGUMENT);
 221         muse_return_val_if_fail(fd, MM_ERROR_INVALID_ARGUMENT);
 222
 223         *fd = m->ch[MUSE_CHANNEL_MSG].tbm_fd[0];
 224         return MM_ERROR_NONE;
 225 }
 226
 227 int muse_server_ipc_get_fds(muse_module_h m, int *fds, int *number)
 228 {
 229         int i = 0;
 230
 231         muse_return_val_if_fail(m, MM_ERROR_INVALID_ARGUMENT);
 232         muse_return_val_if_fail(m->pid > 0, MM_ERROR_INVALID_ARGUMENT);
 233         muse_return_val_if_fail(fds, MM_ERROR_INVALID_ARGUMENT);
 234         muse_return_val_if_fail(number, MM_ERROR_INVALID_ARGUMENT);
 235
 236         for (i = 0 ; i < MUSE_NUM_FD ; i++) {
 237                 if (m->ch[MUSE_CHANNEL_MSG].tbm_fd[i] < 0)
 238                         break;
 239
 240                 fds[i] = m->ch[MUSE_CHANNEL_MSG].tbm_fd[i];
 241         }
 242
 243         *number = i;
 244
 245         return MM_ERROR_NONE;
 246 }
 247
 248 int muse_server_ipc_set_fd(muse_module_h m, int fd)
 249 {
 250         muse_return_val_if_fail(m, MM_ERROR_INVALID_ARGUMENT);
 251         muse_return_val_if_fail(m->pid > 0, MM_ERROR_INVALID_ARGUMENT);
 252
 253         if (!muse_core_fd_is_valid(fd)) {
 254                 LOGE("invalid fd: %d", fd);
 255                 return MM_ERROR_INVALID_ARGUMENT;
 256         }
 257
 258         m->ch[MUSE_CHANNEL_MSG].tbm_fd[0] = fd;
 259         return MM_ERROR_NONE;
 260 }
 261
 262 int muse_server_ipc_get_client_pid(muse_module_h m)
 263 {
 264         muse_return_val_if_fail(m, MUSE_ERR);
 265         return m->pid;
 266 }
 267
 268 /* security */
 269 bool muse_server_security_check_cynara(int fd, const char *privilege)
 270 {
 271         muse_return_val_if_fail(ms_get_instance(), false);
 272         muse_return_val_if_fail(ms_get_instance()->security, false);
 273
 274         return ms_security_is_privilege_granted(ms_get_instance()->security, fd, privilege);
 275 }
 276
 277 unsigned int muse_server_get_atomic_uint(void)
 278 {
 279         static guint atom = 0;
 280
 281         g_atomic_int_inc(&atom);
 282
 283         return atom;
 284 }
 285
 286 int muse_server_get_platform_info(const char *key, bool *value)
 287 {
 288         return ms_system_get_platform_info(key, value);
 289 }
 290
 291 int muse_server_get_module_instance_count(int idx)
 292 {
 293         ms_connection_t *connection = NULL;
 294
 295         muse_return_val_if_fail(ms_get_instance(), MUSE_ERR);
 296
 297         connection = ms_get_instance()->connection;
 298         muse_return_val_if_fail(connection, MUSE_ERR);
 299
 300         return connection->instance_count[idx];
 301 }
 302
 303 bool muse_server_is_on_demand(void)
 304 {
 305         ms_config_t *conf = NULL;
 306
 307         muse_return_val_if_fail(ms_get_instance(), FALSE);
 308
 309         conf = ms_get_instance()->conf;
 310         muse_return_val_if_fail(conf, FALSE);
 311
 312         return conf->is_on_demand;
 313 }
 314
 315 int main(int argc, char **argv)
 316 {
 317
 318 #ifdef MUSE_TTRACE_LOG
 319         trace_begin("MUSE:START");
 320 #endif
 321
 322         ms_init(argv);
 323
 324         ms_run();
 325
 326         return ms_deinit();
 327 }