Set simple type at tv service
[platform/core/multimedia/mmsvc-core.git] / server / src / muse_server_private.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 #include <sys/file.h>
24 #include <gst/gst.h>
25 #include <syslog.h>
26 #include <malloc.h>
27 #include <tzplatform_config.h>
28
29 #if !GLIB_CHECK_VERSION(2, 58, 0)
30 #define G_SOURCE_FUNC(f) ((GSourceFunc) (void (*)(void)) (f))
31 #endif
32
33 #if defined (__aarch64__) || defined (__x86_64__)
34 #define MUSE_DEFAULT_MMAP_THRESHOLD_MAX (512 * 1024)
35 #endif
36
37
38 #ifdef MUSE_REGISTER_VIP
39 #include <proc_stat.h>
40 #endif
41
42 #ifdef MUSE_USE_LWIPC
43 #include <lwipc.h>
44 #define MUSE_LWIPC_WAIT_TIME                    1000
45 #endif
46
47
48 static const char *channel_name[MUSE_CHANNEL_MAX] = {
49         "msg",
50         "data"
51 };
52
53 static const char *UDS_files[MUSE_CHANNEL_MAX] = {MUSE_MSG_SOCK, MUSE_DATA_SOCK};
54
55 static muse_server_h muse_server;
56
57 static const char *module_cmd[MUSE_MODULE_COMMAND_MAX] = {
58         "initialize",
59         "shutdown",
60         "debug_info_dump",
61         "create_server_ack",
62         "resource_not_available",
63         "external_storage_state_changed",
64         "create_caution",
65         "resource_manager_shutdown"
66 };
67
68 static bool _ms_attach(int fd, muse_module_callback connection_handler, gpointer module_idx);
69 static void _ms_create_new_server_from_fd(int fd[], int type);
70 static int _ms_new(muse_channel_e channel);
71 static int _ms_get_pid(int fd);
72 static void _ms_get_module_addr(int fd, intptr_t *module_addr);
73 static void _ms_check_idle_state(void);
74 static gpointer _ms_diag_check_idle_state_thread(gpointer data);
75 static gpointer _ms_diag_check_connection_event_thread(gpointer data);
76 static void _ms_lock_state(void);
77 static void _ms_unlock_state(void);
78 static gboolean _ms_connection_handler(GIOChannel *source, GIOCondition condition, gpointer data);
79 static void _ms_diag_init(void);
80 static void _ms_diag_deinit(void);
81 static gboolean _ms_idle_cb(gpointer data);
82 static int _ms_open_lockfile(void);
83 static void _ms_process_init(void);
84 static void _ms_launch_foreground(void);
85 static void _ms_daemonize(void);
86
87 #ifdef MUSE_USE_LWIPC
88 static void _ms_wait_event(void);
89
90 static void _ms_wait_event(void)
91 {
92         const char *lw_event_list[] = { "/run/.wm_ready", "/tmp/avoc_ready" };
93         unsigned int count = sizeof(lw_event_list) / sizeof(char *);
94
95         if (LwipcWaitMultiEvents(lw_event_list, count, true, MUSE_LWIPC_WAIT_TIME, NULL, 0) != 0)
96                 LOGE("Fail to receive Multiple Events");
97 }
98 #endif
99
100 static bool _ms_attach(int fd, muse_module_callback connection_handler, gpointer module_idx)
101 {
102         GIOChannel *channel = NULL;
103         GSource *src = NULL;
104
105         LOGI("Enter");
106
107         muse_return_val_if_fail(muse_server, false);
108         muse_return_val_if_fail(muse_core_fd_is_valid(fd), false);
109
110         channel = g_io_channel_unix_new(fd);
111         muse_return_val_if_fail(channel, false);
112
113         src = g_io_create_watch(channel, G_IO_IN);
114         if (!src) {
115                 LOGE("g_io_create_watch() is failed");
116                 g_io_channel_unref(channel);
117                 return false;
118         }
119
120         g_source_set_callback(src, G_SOURCE_FUNC(connection_handler), module_idx, NULL);
121
122         if (g_source_attach(src, g_main_loop_get_context(muse_server->main_loop)) == 0) {
123                 LOGE("g_source_attach() is failed");
124                 g_io_channel_unref(channel);
125                 return false;
126         }
127
128         g_source_unref(src);
129
130         g_io_channel_unref(channel);
131
132         LOGI("Leave");
133
134         return true;
135 }
136
137 static void _ms_create_new_server_from_fd(int fd[], int type)
138 {
139         int i;
140         char err_msg[MUSE_MSG_LEN_MAX] = {'\0',};
141
142         LOGD("Enter");
143
144         muse_return_if_fail(muse_server);
145
146         muse_server->msg_fd = fd[MUSE_CHANNEL_MSG];
147         muse_server->data_fd = fd[MUSE_CHANNEL_DATA];
148         muse_server->type = type;
149
150         for (i = 0; i < MUSE_CHANNEL_MAX; i++) {
151                 if (!_ms_attach(fd[i], _ms_connection_handler, GINT_TO_POINTER(i))) {
152                         snprintf(err_msg, sizeof(err_msg), "Fail to attach server fd %d", fd[i]);
153
154                         LOGE("%s", err_msg);
155                         ms_terminate(SIGABRT);
156                 }
157         }
158
159         LOGD("Leave");
160 }
161
162 static int _ms_new(muse_channel_e channel)
163 {
164         int fd, errsv;
165         mode_t m = 0;
166         struct sockaddr_un addr_un;
167         socklen_t address_len;
168         char err_msg[MUSE_MSG_LEN_MAX] = {'\0',};
169
170         muse_return_val_if_fail(channel < MUSE_CHANNEL_MAX, MM_ERROR_INVALID_ARGUMENT);
171
172         unlink(UDS_files[channel]);
173
174         /* Create Socket */
175         fd = socket(AF_UNIX, SOCK_STREAM, 0); /* Unix Domain Socket */
176         if (!muse_core_fd_is_valid(fd)) {
177                 strerror_r(errno, err_msg, MUSE_MSG_LEN_MAX);
178                 LOGE("socket failed sock (%d) : %s", errno, err_msg);
179                 return MUSE_ERR;
180         }
181
182         LOGD("muse server fd : %d", fd);
183
184         memset(&addr_un, 0, sizeof(addr_un));
185         addr_un.sun_family = AF_UNIX;
186         strncpy(addr_un.sun_path, UDS_files[channel], sizeof(addr_un.sun_path) - 1);
187         address_len = (socklen_t)sizeof(addr_un);
188
189         if (!muse_server->daemonize)
190                 m = umask(0);
191
192         /* Bind to filename */
193         if (bind(fd, (struct sockaddr *)&addr_un, address_len) < 0) {
194                 errsv = errno;
195                 strerror_r(errsv, err_msg, MUSE_MSG_LEN_MAX);
196                 LOGE("[%d] socket bind failed (%d) %s", fd, errsv, err_msg);
197                 muse_core_log_file_list(UDS_files[channel]);
198                 ms_log_user_group_info();
199                 if (errsv == EADDRINUSE)
200                         unlink(addr_un.sun_path);
201                 close(fd);
202                 return MUSE_ERR;
203         }
204
205         /* Setup listen queue */
206         if (listen(fd, 5) == MUSE_ERR) {
207                 strerror_r(errno, err_msg, MUSE_MSG_LEN_MAX);
208                 LOGE("[%d] listen() failed (%d) %s", fd, errno, err_msg);
209                 muse_core_log_file_list(UDS_files[channel]);
210                 ms_log_user_group_info();
211                 close(fd);
212                 return MUSE_ERR;
213         }
214
215         if (muse_core_set_nonblocking(fd, false) < 0) /* blocking */
216                 LOGE("failed to set server socket to blocking");
217
218         if (!muse_server->daemonize)
219                 umask(m);
220
221         return fd;
222 }
223
224 static int _ms_get_pid(int fd)
225 {
226         char err_msg[MUSE_MSG_LEN_MAX] = {'\0',};
227         struct ucred credentials;
228         socklen_t length;
229
230         length = (socklen_t)sizeof(struct ucred);
231         if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &credentials, &length) < 0) {
232                 strerror_r(errno, err_msg, MUSE_MSG_LEN_MAX);
233                 LOGE("failed to get the value of credential type %s", err_msg);
234                 return MUSE_ERR;
235         }
236
237         muse_core_update_fd_state(fd);
238
239         return credentials.pid;
240 }
241
242 static void _ms_get_module_addr(int fd, intptr_t *module_addr)
243 {
244         void *jobj;
245         int try_count = 0;
246         bool ret = true;
247         char err_msg[MUSE_MSG_LEN_MAX] = {'\0',};
248         char recv_buf[MUSE_MSG_LEN_MAX] = {'\0',};
249
250         do {
251                 if (muse_core_msg_recv_fd(fd, recv_buf, MUSE_MSG_LEN_MAX, NULL) <= 0) {
252                         strerror_r(errno, err_msg, MUSE_MSG_LEN_MAX);
253                         LOGE("failed to receive message for module %s", err_msg);
254                         return;
255                 }
256
257                 jobj = muse_core_msg_object_new(recv_buf, NULL, NULL);
258                 if (jobj) {
259                         ret = muse_core_msg_object_get_value(MSG_KEY_MODULE_ADDR, jobj, MUSE_TYPE_POINTER, module_addr);
260                         muse_core_msg_object_free(jobj);
261                         if (!ret)
262                                 LOGE("[%d] Error - module_addr %s", try_count, recv_buf);
263                         else
264                                 break;
265                 }
266         } while (++try_count < MS_RECV_TRY_COUNT_MAX);
267 }
268
269 static gboolean _ms_connection_handler(GIOChannel *source, GIOCondition condition, gpointer data)
270 {
271         int server_sockfd, client_sockfd, pid, idx, len;
272         socklen_t client_len;
273         struct sockaddr_un client_address;
274         muse_channel_e channel = GPOINTER_TO_INT(data);
275         muse_module_h m = NULL;
276         muse_module_h peeked_m = NULL;
277         muse_module_h candidate_m = NULL;
278         intptr_t module_addr = 0;
279         GQueue *instance_queue = NULL;
280         ms_system_t *system = NULL;
281         ms_connection_t *connection = NULL;
282         char time_buf[MUSE_MSG_TIME_LEN];
283
284         muse_return_val_if_fail(channel == MUSE_CHANNEL_MSG || channel == MUSE_CHANNEL_DATA, FALSE);
285
286         LOGI("Enter [%s channel]", channel_name[channel]);
287
288         muse_return_val_if_fail(muse_server, FALSE);
289
290         system = muse_server->system;
291         muse_return_val_if_fail(system, FALSE);
292
293         ms_system_stat_detach(system);
294
295         connection = muse_server->connection;
296         muse_return_val_if_fail(connection, FALSE);
297
298         _ms_lock_state();
299
300         if (!ms_is_server_ready()) {
301                 LOGW("Now mused state is not ready...");
302                 _ms_unlock_state();
303                 ms_terminate(SIGABRT);
304         }
305
306         server_sockfd = g_io_channel_unix_get_fd(source);
307         if (!muse_core_fd_is_valid(server_sockfd)) {
308                 LOGE("Critical Error : server %d is invalid", server_sockfd);
309                 _ms_unlock_state();
310                 muse_core_dump_fd_state(server_sockfd);
311                 ms_terminate(SIGABRT);
312         }
313
314         client_len = (socklen_t)sizeof(client_address);
315
316         LOGI("[%d] Try to accept...", server_sockfd);
317         client_sockfd = accept(server_sockfd, (struct sockaddr *)&client_address, &client_len);
318         if (!muse_core_fd_is_valid(client_sockfd)) {
319                 LOGE("Critical Error : accept %d is invalid", client_sockfd);
320                 muse_core_dump_fd_state(client_sockfd);
321                 close(server_sockfd);
322                 _ms_unlock_state();
323                 ms_terminate(SIGABRT);
324         }
325
326         LOGI("server : %d client [%s channel] : %d", server_sockfd, channel_name[channel], client_sockfd);
327
328         pid = _ms_get_pid(client_sockfd);
329         if (pid == -1) {
330                 close(client_sockfd);
331                 _ms_unlock_state();
332                 return FALSE;
333         }
334
335
336         if (channel == MUSE_CHANNEL_MSG) {
337                 m = g_new0(muse_module_t, 1);
338                 SECURE_LOGI("module [%p]", m);
339                 m->ch[MUSE_CHANNEL_MSG].sock_fd = client_sockfd;
340                 m->pid = pid;
341                 g_mutex_init(&m->dispatch_lock);
342
343                 ms_ipc_create_msg_dispatch_worker(m);
344
345         } else {
346                 _ms_get_module_addr(client_sockfd, &module_addr);
347
348                 ms_connection_lock(connection);
349
350                 instance_queue = connection->instance_q;
351                 len = g_queue_get_length(instance_queue);
352
353                 m = (muse_module_h)module_addr;
354
355                 for (idx = 0; idx < len; idx++) {
356                         peeked_m = (muse_module_h)g_queue_peek_nth(instance_queue, idx);
357                         if (!peeked_m) {
358                                 LOGW("[%d] Make sure if the queue length is changed (%d = %d), which means that it was destroyed somewhere",
359                                         idx, len, g_queue_get_length(instance_queue));
360                                 continue;
361                         }
362
363                         if (peeked_m->pid != pid)
364                                 continue;
365
366                         if (!m) {
367                                 if (candidate_m) {
368                                         LOGE("muse-server can't support the error case which there are several modules now");
369                                         ms_connection_unlock(connection);
370                                         goto out;
371                                 }
372
373                                 if (!muse_core_fd_is_valid(peeked_m->ch[MUSE_CHANNEL_DATA].sock_fd))
374                                         candidate_m = peeked_m;
375                                 else
376                                         SECURE_LOGW("already paired module %p", peeked_m);
377
378                                 continue;
379                         }
380
381                         if (m != peeked_m)
382                                 continue;
383
384                         if (muse_core_fd_is_valid(m->ch[MUSE_CHANNEL_DATA].sock_fd)) {
385                                 SECURE_LOGE("[%d] %s pid %d %p you had better check if instance destroy completed properly",
386                                         client_sockfd, ms_config_get_host_name(m->idx), pid, m);
387                                 ms_connection_unlock(connection);
388                                 goto out;
389                         }
390
391                         m->ch[MUSE_CHANNEL_DATA].sock_fd = client_sockfd;
392                         SECURE_LOGI("%s (pid %d) module : %p module addr from client : %p",
393                                 ms_config_get_host_name(m->idx), pid, m, (void *)module_addr);
394                         break;
395                 }
396
397                 if (candidate_m) {
398                         m = candidate_m;
399                         m->ch[MUSE_CHANNEL_DATA].sock_fd = client_sockfd;
400                         SECURE_LOGW("[%d] %s pid %d %p restore module address at the only one null data channel",
401                                 client_sockfd, ms_config_get_host_name(m->idx), pid, m);
402                 }
403
404                 ms_connection_unlock(connection);
405
406                 ms_ipc_create_data_dispatch_worker(m);
407         }
408
409         muse_core_get_cur_time(&muse_server->tv, NULL);
410         muse_core_change_time_format((int)muse_server->tv.tv_sec, time_buf);
411         LOGW("connected time (%s)", time_buf);
412
413         _ms_unlock_state();
414
415         LOGI("Leave");
416
417         return TRUE;
418 out:
419         close(server_sockfd);
420         close(client_sockfd);
421
422         if (m)
423                 muse_core_connection_close(m->ch[MUSE_CHANNEL_MSG].sock_fd);
424
425         _ms_unlock_state();
426
427         LOGE("FALSE");
428
429         return FALSE;
430 }
431
432 static void _ms_check_idle_state(void)
433 {
434         ms_connection_t *connection = NULL;
435         ms_config_t *conf = NULL;
436         int instance_number, period;
437         uint32_t elapsed_time;
438         struct timespec tv;
439         static int period_idx = 1;
440         char time_buf[MUSE_MSG_TIME_LEN];
441
442         muse_return_if_fail(muse_server);
443         muse_return_if_fail(muse_server->state == MUSE_SERVER_STATE_READY);
444
445         connection = muse_server->connection;
446         muse_return_if_fail(connection);
447
448         conf = muse_server->conf;
449         muse_return_if_fail(conf);
450
451         period = ms_config_get_log_period();
452
453         if (muse_server->tv.tv_sec == 0)
454                 return;
455
456         muse_core_get_cur_time(&tv, NULL);
457
458         elapsed_time = (uint32_t)(tv.tv_sec - muse_server->tv.tv_sec);
459
460         ms_connection_lock(connection);
461
462         instance_number = g_queue_get_length(connection->instance_q);
463
464         if (elapsed_time >= (uint32_t)(period * period_idx)) {
465                 muse_core_change_time_format((int)muse_server->tv.tv_sec, time_buf);
466                 LOGW("[#%d] %us [period %ds] [%s] total number of modules = %d ( %s)", period_idx,
467                         elapsed_time, period, time_buf, instance_number, muse_server->instance_pid_info);
468                 period_idx++;
469         }
470
471         ms_connection_unlock(connection);
472
473         if (conf->is_on_demand) {
474                 if (instance_number == 0 && elapsed_time >= (uint32_t)ms_config_get_max_idle_time()) {
475                         LOGE("Timeout exit !!! [Idle time] %u sec", elapsed_time);
476                         ms_remove_ready_file();
477                         exit(EXIT_SUCCESS);
478                 }
479         }
480 }
481
482 static gpointer _ms_diag_check_idle_state_thread(gpointer data)
483 {
484         int idle_state_wait_time = ms_config_get_idle_state_wait_time();
485
486         muse_return_val_if_fail(muse_server, NULL);
487         muse_return_val_if_fail(idle_state_wait_time > 0, NULL);
488
489         while (ms_is_server_ready()) {
490                 _ms_check_idle_state();
491                 sleep(idle_state_wait_time);
492         }
493
494         return NULL;
495 }
496
497 static gpointer _ms_diag_check_connection_event_thread(gpointer data)
498 {
499         ms_diag_t *d;
500         ms_diag_msg_t *dm = NULL;
501         muse_return_val_if_fail(muse_server, NULL);
502
503         d = &muse_server->diag;
504
505         while (ms_is_server_ready()) {
506                 dm = (ms_diag_msg_t *)g_async_queue_pop(d->msg_aq);
507
508                 LOGD("[%p] POP message (thread stop ? %d [%s])", dm, dm->thread_stop, ms_get_command_string(dm->cmd));
509
510                 if (dm->thread_stop) {
511                         g_free(dm);
512                         break;
513                 }
514
515                 if (dm->cmd == API_CREATE) {
516                         /* can be updated if connection at the next patch */
517                 } else if (dm->cmd == API_DESTROY) {
518                         if (ms_config_is_check_cpu_memory())
519                                 ms_check_cpu_memory();
520                 }
521
522                 g_free(dm);
523         }
524
525         return NULL;
526 }
527
528 static void _ms_lock_state(void)
529 {
530         muse_return_if_fail(muse_server);
531         g_mutex_lock(&muse_server->state_lock);
532 }
533
534 static void _ms_unlock_state(void)
535 {
536         muse_return_if_fail(muse_server);
537         g_mutex_unlock(&muse_server->state_lock);
538 }
539
540 static void _ms_diag_init(void)
541 {
542         ms_diag_t *d;
543         char err_msg[MUSE_MSG_LEN_MAX] = {'\0',};
544         GError *error = NULL;
545
546         muse_return_if_fail(muse_server);
547
548         d = &muse_server->diag;
549
550         d->idle_state_thread = g_thread_try_new("diag_idle_state",
551                 _ms_diag_check_idle_state_thread, muse_server->main_loop, &error);
552         if (!d->idle_state_thread) {
553                 snprintf(err_msg, sizeof(err_msg), "diag_idle_state_thread creation failed : %s", error->message);
554                 LOGE("%s", err_msg);
555                 g_error_free(error);
556                 ms_log_process_info(muse_server->pid);
557         }
558
559         d->msg_aq = g_async_queue_new_full(g_free);
560
561         d->conn_event_thread = g_thread_try_new("diag_connection",
562                 _ms_diag_check_connection_event_thread, muse_server->main_loop, &error);
563         if (!d->conn_event_thread) {
564                 snprintf(err_msg, sizeof(err_msg), "diag_connection_event_thread creation failed : %s", error->message);
565                 LOGE("%s", err_msg);
566                 g_error_free(error);
567                 ms_log_process_info(muse_server->pid);
568         }
569 }
570
571 static void _ms_diag_deinit(void)
572 {
573         ms_diag_t *d;
574         ms_diag_msg_t *dm;
575
576         LOGD("Enter");
577
578         muse_return_if_fail(muse_server);
579
580         d = &muse_server->diag;
581
582         dm = g_new0(ms_diag_msg_t, 1);
583
584         dm->thread_stop = TRUE;
585         LOGI("[%p] g_async_queue_push", dm);
586         g_async_queue_push_front(d->msg_aq, (gpointer)dm);
587
588         if (d->idle_state_thread) {
589                 g_thread_join(d->idle_state_thread);
590                 d->idle_state_thread = NULL;
591         }
592
593         if (d->conn_event_thread) {
594                 g_thread_join(d->conn_event_thread);
595                 d->conn_event_thread = NULL;
596         }
597
598         g_async_queue_unref(d->msg_aq);
599         d->msg_aq = NULL;
600 }
601
602 static gboolean _ms_idle_cb(gpointer data)
603 {
604         struct timespec tv;
605         char time_buf[MUSE_MSG_TIME_LEN];
606
607         if (!ms_create_ready_file())
608                 LOGE("%s file creation is failed", MUSE_SERVER_READY);
609
610         _ms_diag_init();
611
612         muse_core_get_cur_time(&tv, NULL);
613
614         muse_core_change_time_format((int)tv.tv_sec, time_buf);
615
616         LOGW("muse server is completed to ready (%s)", time_buf);
617
618         return G_SOURCE_REMOVE;
619 }
620
621 static void _ms_init(void)
622 {
623         int idx;
624
625         LOGD("Enter");
626
627 #if defined (__aarch64__) || defined (__x86_64__)
628         mallopt(M_MMAP_THRESHOLD, MUSE_DEFAULT_MMAP_THRESHOLD_MAX);
629         mallopt(M_TRIM_THRESHOLD, 2 * MUSE_DEFAULT_MMAP_THRESHOLD_MAX);
630 #endif
631
632         muse_server->system = g_new0(ms_system_t, 1);
633         ms_system_init(muse_server->system);
634
635         muse_server->conf = g_new0(ms_config_t, 1);
636         ms_config_init(muse_server->conf);
637
638         muse_server->log = g_new0(ms_log_t, 1);
639         ms_log_init(muse_server->log);
640
641         muse_server->security = g_new0(ms_security_t, 1);
642         ms_security_init(muse_server->security);
643
644         for (idx = 0; idx < muse_server->conf->host_cnt; idx++) {
645                 muse_server->module[idx] = g_new0(ms_module_t, 1);
646                 muse_server->module[idx]->idx = idx;
647                 ms_module_init(muse_server->module[idx]);
648         }
649
650 #ifdef MUSE_USE_WATCHDOG
651         muse_server->watchdog = g_new0(ms_watchdog_t, 1);
652         if (ms_watchdog_init(muse_server->watchdog) != MM_ERROR_NONE)
653                 LOGE("Fail to initialize server watchdog");
654 #endif
655
656         muse_server->connection = g_new0(ms_connection_t, 1);
657         ms_connection_init(muse_server->connection);
658
659         ms_signal_init();
660
661         g_mutex_init(&muse_server->state_lock);
662
663         muse_core_create_fd_table();
664
665         muse_server->main_loop = g_main_loop_new(NULL, FALSE);
666         muse_return_if_fail(muse_server->main_loop);
667
668         LOGD("Leave");
669 }
670
671 static int _ms_open_lockfile(void)
672 {
673         int fd, already_running;
674         char err_msg[MUSE_MSG_LEN_MAX] = {'\0',};
675         char *lockfile = NULL;
676
677         muse_return_val_if_fail(muse_server, MUSE_ERR);
678
679         lockfile = ms_config_get_lockfile();
680         muse_return_val_if_fail(lockfile, MUSE_ERR);
681
682         muse_core_remove_symlink((const char *)lockfile);
683         fd = open(lockfile, O_RDONLY);
684         if (fd == -1 && errno != ENOENT) {
685                 /* Cannot open file even though file exists. */
686                 snprintf(err_msg, sizeof(err_msg), "Cannot open lock file %s", lockfile);
687                 LOGE("open failed : %s", err_msg);
688                 return MUSE_ERR;
689         } else if (fd != -1) {
690                 already_running = flock(fd, LOCK_EX | LOCK_NB) == -1;
691                 close(fd);
692                 if (already_running) {
693                         LOGE("File already locked. There's already a server running");
694                         return MUSE_ERR;
695                 }
696         }
697
698         /* Lock file does not exist, or is not locked. Create a new lockfile and lock it. */
699         fd = open(lockfile, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
700         if (fd == -1) {
701                 LOGE("dataserver: Cannot create lock file");
702                 return MUSE_ERR;
703         }
704
705         if (flock(fd, LOCK_EX | LOCK_NB) != 0) {
706                 LOGE("Can't lock the lock file \"%s\". " "Is another instance running?", lockfile);
707                 close(fd);
708                 return MUSE_ERR;
709         }
710
711         close(fd);
712
713         return MM_ERROR_NONE;
714 }
715
716 static void _ms_process_init(void)
717 {
718         if (g_mkdir_with_parents(tzplatform_mkpath(TZ_SYS_RUN, "mused"), S_IRWXU | S_IRWXG | S_IRWXO) != 0)
719                 exit(EXIT_FAILURE);
720
721         if (muse_server->daemonize) {
722                 if (ms_pidfile_create(MUSE_DEFAULT_PIDFILE, muse_server->pid) != MM_ERROR_NONE)
723                         exit(EXIT_FAILURE);
724                 else
725                         LOGW("MUSE_DEFAULT_PIDFILE(%s) file was created", MUSE_DEFAULT_PIDFILE);
726         }
727
728         _ms_init();
729
730         muse_return_if_fail(_ms_open_lockfile() == MM_ERROR_NONE);
731
732         ms_new();
733 }
734
735 static void _ms_launch_foreground(void)
736 {
737         muse_server->pid = (int)getpid();
738
739         _ms_process_init();
740 }
741
742 static void _ms_daemonize(void)
743 {
744         int notify_fd;
745
746         muse_server->pid = ms_daemonize(&notify_fd);
747
748         _ms_process_init();
749
750         ms_daemonize_complete(notify_fd);
751 }
752
753 void ms_setup_syslog(void)
754 {
755         int flags = LOG_CONS|LOG_NDELAY|LOG_PID;
756         if (isatty(STDOUT_FILENO))
757                 flags |= LOG_PERROR;
758
759         openlog("mused", flags, LOG_DAEMON);
760         LOGD("openlog - mused");
761 }
762
763 void ms_fork(int *notify_fd)
764 {
765         pid_t pid;
766         int fds[2];
767         char err_msg[MUSE_MSG_LEN_MAX] = {'\0',};
768         char msg[MUSE_MSG_LEN_MAX] = {'\0',};
769
770         if (pipe(fds) == MUSE_ERR) {
771                 strerror_r(errno, err_msg, MUSE_MSG_LEN_MAX);
772                 LOGE("Failed to create pipe to get child status: %s", err_msg);
773                 exit(EXIT_FAILURE);
774         }
775
776         if ((pid = fork()) < 0) {
777                 strerror_r(errno, err_msg, MUSE_MSG_LEN_MAX);
778                 LOGE("Error: fork() failed: %s", err_msg);
779                 exit(EXIT_FAILURE);
780         } else if (pid != 0) {
781                 close(fds[1]);
782                 /* Read in a string from the pipe */
783                 if (read(fds[0], msg, sizeof(msg)) <= 0) {
784                         LOGE("Failed to read from a file descriptor [%d]", fds[0]);
785                         close(fds[0]);
786                         return;
787                 }
788                 close(fds[0]);
789
790                 /* Parent process closes up output side of pipe */
791                 if (!strncmp(msg, MSG_DONE, strlen(MSG_DONE))) {
792                         LOGI("Successfully daemonized");
793                         exit(EXIT_SUCCESS);
794                 } else {
795                         LOGE("Daemonizing failed after fork");
796                         exit(EXIT_FAILURE);
797                 }
798         } else if (pid == 0) {
799                 /* Child process closes up input side of pipe */
800                 close(fds[0]);
801                 *notify_fd = fds[1];
802         }
803 }
804
805 pid_t ms_daemonize(int *notify_fd)
806 {
807         pid_t pid;
808         int fd, result;
809
810         muse_return_val_if_fail(notify_fd, MUSE_ERR);
811
812         ms_fork(notify_fd);
813
814         if ((pid = setsid()) < 0) {
815                 LOGE("create new session");
816                 exit(EXIT_FAILURE);
817         }
818
819         /* change the file mode mask */
820         umask(0);
821
822         result = chdir("/");
823         LOGD("result = %d sid: %d pgid: %d pid: %d ppid: %d", result, (int)getsid(0), (int)getpgid(0), (int)pid, (int)getppid());
824
825         /* redirect fds to /dev/null */
826         fd = open("/dev/null", O_RDWR);
827         if (!muse_core_fd_is_valid(fd)) {
828                 LOGE("Critical Error : %d is invalid", fd);
829                 exit(EXIT_SUCCESS);
830         }
831
832         close(STDIN_FILENO);
833         close(STDOUT_FILENO);
834         close(STDERR_FILENO);
835
836         dup2(fd, STDIN_FILENO);
837         dup2(fd, STDOUT_FILENO);
838         dup2(fd, STDERR_FILENO);
839
840         close(fd);
841
842         return pid;
843 }
844
845 void ms_daemonize_complete(int notify_fd)
846 {
847         LOGD("Enter");
848
849         muse_return_if_fail(muse_core_fd_is_valid(notify_fd));
850
851         write(notify_fd, MSG_DONE, strlen(MSG_DONE) + 1);
852         LOGW("[%d] Notify parent process that child initialization is done", notify_fd);
853         close(notify_fd);
854
855         LOGD("Leave");
856 }
857
858 void ms_gst_init(char **cmd)
859 {
860         gint argc = 0;
861         gchar **argv = NULL;
862         GError *err = NULL;
863         gboolean ret = FALSE;
864         int gst_param_cnt;
865
866 #ifdef MUSE_TTRACE_LOG
867         trace_begin("MUSE:gst_init");
868 #endif
869
870         gst_param_cnt = ms_config_get_gst_param_cnt();
871
872         /* add gst_param */
873         argv = g_malloc0(sizeof(gchar *) * (gst_param_cnt + 1));
874
875         argv[argc++] = (gchar *)cmd[0];
876         for (; argc <= gst_param_cnt; argc++) {
877                 argv[argc] = ms_config_get_gst_param_str(argc - 1);
878                 LOGI("%d %s", argc, argv[argc]);
879         }
880
881         /* initializing gstreamer */
882         ret = gst_init_check(&argc, &argv, &err);
883         if (!ret) {
884                 LOGE("Could not initialize GStreamer: %s ", err ? err->message : "unknown error occurred");
885                 if (err)
886                         g_error_free(err);
887         }
888
889         LOGI("gst_init_check is completed");
890
891         /* release */
892         g_free(argv);
893
894         LOGI("complete to initialize gstreamer");
895
896 #ifdef MUSE_TTRACE_LOG
897         trace_end();
898 #endif
899 }
900
901 void ms_gst_preload_plugin(void)
902 {
903         char *token = NULL;
904         char *saveptr = NULL;
905         char plugin_path[128];
906         const char *delimeters = " ,";
907         gchar *gst_preload_plugins = g_strdup(ms_config_get_gst_preload_plugins());
908         GstPlugin *plugin = NULL;
909
910         muse_return_if_fail(gst_preload_plugins);
911
912         LOGI("preload plugins [%s]", gst_preload_plugins);
913
914         token = strtok_r(gst_preload_plugins, delimeters, &saveptr);
915         while (token) {
916                 snprintf(plugin_path, sizeof(plugin_path), "%s/gstreamer-1.0/libgst%s.so", LIBDIR, token);
917
918                 LOGI("    plugin path : %s", plugin_path);
919
920                 plugin = gst_plugin_load_file(plugin_path, NULL);
921                 if (plugin)
922                         gst_object_unref(plugin);
923                 else
924                         LOGW("failed to load plugin [%s]", plugin_path);
925
926                 token = strtok_r(NULL, delimeters, &saveptr);
927         }
928
929         g_free(gst_preload_plugins);
930
931         LOGI("Leave");
932 }
933
934 int ms_pidfile_create(const char *path, pid_t pid)
935 {
936         int fd;
937         struct flock lock;
938         char pid_buf[MUSE_MSG_LEN] = {'\0',};
939         char err_msg[MUSE_MSG_LEN_MAX] = {'\0',};
940
941         muse_return_val_if_fail(path, MM_ERROR_INVALID_ARGUMENT);
942         muse_core_remove_symlink(path);
943         fd = open(path, O_WRONLY | O_CREAT, (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH));
944
945         if (!muse_core_fd_is_valid(fd)) {
946                 strerror_r(errno, err_msg, MUSE_MSG_LEN_MAX);
947                 LOGE("Fail to open pidfile [%s] : %s", path, err_msg);
948                 return MM_ERROR_FILE_NOT_FOUND;
949         }
950
951         lock.l_type = F_WRLCK;
952         lock.l_start = 0;
953         lock.l_whence = SEEK_SET;
954         lock.l_len = 0;
955
956         if (fcntl(fd, F_SETLK, &lock) < 0) {
957                 if (errno != EACCES && errno != EAGAIN) {
958                         strerror_r(errno, err_msg, MUSE_MSG_LEN_MAX);
959                         LOGE("Fail to lock pidfile [%s] : %s", path, err_msg);
960                 } else {
961                         LOGE("process is already running");
962                 }
963                 close(fd);
964                 return MM_ERROR_FILE_INTERNAL;
965         }
966
967         if (ftruncate(fd, 0) < 0) {
968                 strerror_r(errno, err_msg, MUSE_MSG_LEN_MAX);
969                 LOGE("Fail to truncate pidfile [%s] : %s", path, err_msg);
970                 close(fd);
971                 return MM_ERROR_FILE_INTERNAL;
972         }
973
974         memset(pid_buf, 0, sizeof(pid_buf));
975         snprintf(pid_buf, sizeof(pid_buf), "%u", pid);
976
977         if (write(fd, pid_buf, strlen(pid_buf)) != (int)strlen(pid_buf)) {
978                 strerror_r(errno, err_msg, MUSE_MSG_LEN_MAX);
979                 LOGE("Fail to write pid to pidfile [%s] : %s", path, err_msg);
980                 close(fd);
981                 return MM_ERROR_FILE_WRITE;
982         }
983
984         close(fd);
985         return MM_ERROR_NONE;
986 }
987
988 void ms_init(char **argv)
989 {
990         int idx;
991
992         muse_module_cmd_dispatchfunc *cmd_dispatcher = NULL;
993
994         LOGW("Enter");
995
996         muse_server = g_new0(muse_server_t, 1);
997
998         for (idx = 1; argv[idx] != NULL; idx++) {
999                 if (strcmp(argv[idx], "-D") == 0) {
1000                         LOGI("enable daemonize");
1001                         muse_server->daemonize = TRUE;
1002                 }
1003         }
1004
1005         ms_setup_syslog();
1006
1007         if (muse_server->daemonize)
1008                 _ms_daemonize();
1009         else
1010                 _ms_launch_foreground();
1011
1012 #ifdef MUSE_REGISTER_VIP
1013         proc_stat_set_vip_process();
1014 #endif
1015
1016 #ifdef MUSE_TTRACE_LOG
1017         trace_end();
1018 #endif
1019
1020         ms_system_subscribe_external_event(muse_server->system);
1021
1022 #ifdef MUSE_USE_WATCHDOG
1023         if (!ms_watchdog_attach(muse_server->watchdog)) {
1024                 LOGE("watchdog thread failed");
1025                 ms_log_process_info(muse_server->pid);
1026                 return;
1027         }
1028 #endif
1029
1030         ms_gst_init(argv);
1031
1032         ms_init_bufmgr();
1033
1034 #ifdef MUSE_TTRACE_LOG
1035         trace_begin("MUSE:preloading module");
1036 #endif
1037         for (idx = 0; idx < ms_config_get_host_cnt(); idx++) {
1038                 if (0 == strncmp(ms_config_get_preloaded_value(idx), "yes", strlen("yes"))) {
1039                         g_module_symbol(ms_module_open(idx), CMD_DISPATCHER, (gpointer *)&cmd_dispatcher);
1040                         if (cmd_dispatcher && cmd_dispatcher[MUSE_MODULE_COMMAND_INITIALIZE])
1041                                 cmd_dispatcher[MUSE_MODULE_COMMAND_INITIALIZE](NULL);
1042                 }
1043         }
1044 #ifdef MUSE_TTRACE_LOG
1045         trace_end();
1046 #endif
1047
1048 #ifdef MUSE_TTRACE_LOG
1049         trace_begin("MUSE:preloading GST module");
1050 #endif
1051         ms_gst_preload_plugin();
1052 #ifdef MUSE_TTRACE_LOG
1053         trace_end();
1054 #endif
1055
1056 #ifdef MUSE_GCOV_TEST
1057         muse_core_setenv("GCOV_PREFIX", "/tmp", 1);
1058 #endif
1059
1060         LOGW("Leave");
1061 }
1062
1063 muse_server_h ms_get_instance(void)
1064 {
1065         return muse_server;
1066 }
1067
1068 gboolean ms_check_module_idx(int idx)
1069 {
1070         int module_cnt = ms_config_get_host_cnt();
1071
1072         if (idx < 0 || idx >= module_cnt) {
1073                 LOGE("%d error - the number of modules is %d", idx, module_cnt);
1074                 return FALSE;
1075         }
1076
1077         return TRUE;
1078 }
1079
1080 ms_module_t *ms_get_module_instance(int idx)
1081 {
1082         muse_return_val_if_fail(ms_check_module_idx(idx), NULL);
1083
1084         return muse_server->module[idx];
1085 }
1086
1087 int ms_deinit(void)
1088 {
1089         int retval = MUSE_ERR;
1090         int idx;
1091
1092         LOGD("Enter");
1093
1094         muse_return_val_if_fail(muse_server, retval);
1095         muse_return_val_if_fail(muse_server->conf, retval);
1096         muse_return_val_if_fail(muse_server->connection, retval);
1097         muse_return_val_if_fail(muse_server->log, retval);
1098         muse_return_val_if_fail(muse_server->security, retval);
1099         muse_return_val_if_fail(muse_server->watchdog, retval);
1100
1101         ms_recursive_rmdir(MUSE_DATA_ROOT_PATH);
1102
1103         ms_set_state(MUSE_SERVER_STATE_IDLE);
1104
1105         _ms_diag_deinit();
1106
1107 #ifdef MUSE_USE_WATCHDOG
1108         ms_watchdog_detach(muse_server->watchdog);
1109
1110         if (ms_watchdog_deinit(muse_server->watchdog) == MM_ERROR_NONE)
1111                 free(muse_server->watchdog);
1112         else
1113                 LOGE("Fail to deinitialize server watchdog");
1114 #endif
1115
1116         ms_remove_ready_file();
1117
1118         retval = muse_server->retval;
1119         muse_core_fd_close(muse_server->msg_fd);
1120         muse_core_fd_close(muse_server->data_fd);
1121         for (idx = 0; idx < MUSE_CHANNEL_MAX; idx++) {
1122                 if (remove(UDS_files[idx]) == MUSE_ERR)
1123                         LOGE("remove %s failed", UDS_files[idx]);
1124         }
1125
1126         if (remove(MUSE_DEFAULT_PIDFILE) == -1)
1127                 LOGE("remove %s failed [errno : %d]", MUSE_DEFAULT_PIDFILE, errno);
1128
1129         for (idx = 0; idx < muse_server->conf->host_cnt; idx++)
1130                 ms_module_deinit(muse_server->module[idx]);
1131
1132         ms_security_deinit(muse_server->security);
1133         muse_server->security = NULL;
1134
1135         ms_system_deinit(muse_server->system);
1136         muse_server->system = NULL;
1137
1138         ms_log_deinit(muse_server->log);
1139         muse_server->log = NULL;
1140
1141         ms_config_deinit(muse_server->conf);
1142         muse_server->conf = NULL;
1143
1144         ms_connection_deinit(muse_server->connection);
1145         muse_server->connection = NULL;
1146
1147         muse_core_destroy_fd_table();
1148
1149         ms_deinit_bufmgr();
1150
1151         g_mutex_clear(&muse_server->state_lock);
1152
1153         g_free(muse_server);
1154         muse_server = NULL;
1155
1156         LOGD("Leave");
1157         return retval;
1158 }
1159
1160 void ms_check_cpu_memory(void)
1161 {
1162         int used_pss, memory_threshold, cpu_usage, cpu_threshold;
1163         char err_msg[MUSE_MSG_LEN_MAX] = {'\0',};
1164         ms_connection_t *connection = NULL;
1165         ms_system_t *system = NULL;
1166
1167         muse_return_if_fail(muse_server);
1168
1169         connection = muse_server->connection;
1170         muse_return_if_fail(connection);
1171
1172         system = muse_server->system;
1173         muse_return_if_fail(system);
1174
1175         ms_connection_lock(connection);
1176
1177         if (g_queue_is_empty(connection->instance_q) && ms_is_server_ready()) {
1178                 used_pss = ms_system_get_memory_usage(muse_server->pid);
1179                 cpu_usage = muse_core_get_process_cpu_usage(muse_server->pid);
1180
1181                 LOGW("[%d] Proportional set size %d (KByte) (CPU %d %%)", muse_server->pid, used_pss, cpu_usage);
1182
1183                 memory_threshold = ms_config_get_memory_threshold();
1184                 cpu_threshold = ms_config_get_cpu_threshold();
1185
1186                 if (used_pss >= memory_threshold) {
1187                         ms_log_process_info(muse_server->pid);
1188
1189                         snprintf(err_msg, sizeof(err_msg), "[Memory Leak] %d >= %d (KByte)", used_pss, memory_threshold);
1190
1191                         LOGE("%s", err_msg);
1192                         ms_connection_unlock(connection);
1193                         ms_terminate(SIGTERM);
1194                 }
1195
1196                 if (cpu_usage > cpu_threshold)
1197                         ms_system_stat_attach(system);
1198
1199                 muse_core_remove_all_fd_table();
1200         } else {
1201                 LOGI("skip cpu memory check due to instance queue length : %d", g_queue_get_length(connection->instance_q));
1202         }
1203
1204         ms_connection_unlock(connection);
1205 }
1206
1207 void ms_new(void)
1208 {
1209         int fd[MUSE_CHANNEL_MAX];
1210         int i, j;
1211
1212         for (i = 0; i < MUSE_CHANNEL_MAX; i++) {
1213                 if (ms_config_is_on_demand() && i == MUSE_CHANNEL_MSG)
1214                         fd[i] = SD_LISTEN_FDS_START;
1215                 else
1216                         fd[i] = _ms_new(i);
1217
1218                 if (!muse_core_fd_is_valid(fd[i])) {
1219                         LOGE("Failed to create socket server %d", i);
1220                         for (j = 0; j < i; j++)
1221                                 close(fd[j]);
1222                         return;
1223                 }
1224         }
1225
1226         _ms_create_new_server_from_fd(fd, READ | PERSIST);
1227 }
1228
1229 void ms_run(void)
1230 {
1231         LOGW("Enter");
1232
1233         muse_return_if_fail(muse_server->main_loop);
1234
1235         muse_return_if_fail(g_idle_add_full(G_PRIORITY_HIGH, _ms_idle_cb, NULL, NULL) > 0);
1236
1237         LOGI("g_main_loop_run");
1238         g_main_loop_run(muse_server->main_loop);
1239
1240         LOGW("Leave");
1241 }
1242
1243 void ms_cmd_dispatch(muse_module_h m, muse_module_command_e cmd)
1244 {
1245         muse_module_cmd_dispatchfunc *cmd_dispatcher = NULL;
1246
1247         if (m->ch[MUSE_CHANNEL_MSG].dll_handle &&
1248                 g_module_symbol(m->ch[MUSE_CHANNEL_MSG].dll_handle, CMD_DISPATCHER, (gpointer *)&cmd_dispatcher)) {
1249                 if (cmd_dispatcher && cmd_dispatcher[cmd])
1250                         cmd_dispatcher[cmd](m);
1251         }
1252 }
1253
1254 void ms_terminate(int signo)
1255 {
1256         muse_return_if_fail(muse_server);
1257
1258         ms_set_state(MUSE_SERVER_STATE_IDLE);
1259
1260         LOGE("send signal %d to process %d", signo, muse_server->pid);
1261         raise(signo);
1262 }
1263
1264 int ms_get_pid(muse_module_h m)
1265 {
1266         muse_return_val_if_fail(m, MUSE_ERR);
1267         return m->pid;
1268 }
1269
1270 void ms_log_process_info(int pid)
1271 {
1272         muse_core_log_process_thread_info(pid);
1273
1274         muse_core_log_process_opened_fds(pid);
1275
1276         muse_core_log_process_cpu_memory(pid);
1277 }
1278
1279 void ms_log_user_group_info(void)
1280 {
1281         uid_t uid;
1282         gid_t gid;
1283         char buffer[MUSE_MSG_MAX_LENGTH];
1284         struct passwd pwbuf;
1285         struct passwd *pwbufp;
1286         struct group gbuf;
1287         struct group *gbufp;
1288
1289         uid = getuid();
1290         gid = getgid();
1291
1292         getpwuid_r(uid, &pwbuf, buffer, sizeof(buffer), &pwbufp);
1293         muse_return_if_fail(pwbufp);
1294
1295         getgrgid_r(gid, &gbuf, buffer, sizeof(buffer), &gbufp);
1296         muse_return_if_fail(gbufp);
1297
1298         LOGE("user [%s : %lu] group [%s : %lu]", pwbufp->pw_name, (unsigned long)uid, gbufp->gr_name, (unsigned long)gid);
1299 }
1300
1301 gboolean ms_is_log_enabled(void)
1302 {
1303         return ms_config_is_log_enabled();
1304 }
1305
1306 gboolean ms_init_bufmgr(void)
1307 {
1308         LOGD("Enter");
1309
1310         muse_return_val_if_fail(muse_server, FALSE);
1311
1312         muse_server->bufmgr = tbm_bufmgr_init(-1);
1313         if (!muse_server->bufmgr) {
1314                 LOGE("Error - tbm_bufmgr_init");
1315                 ms_log_user_group_info();
1316                 return FALSE;
1317         }
1318
1319         LOGD("Leave bufmgr: %p", muse_server->bufmgr);
1320
1321         return TRUE;
1322 }
1323
1324 void ms_deinit_bufmgr(void)
1325 {
1326         LOGD("Enter");
1327
1328         muse_return_if_fail(muse_server);
1329         muse_return_if_fail(muse_server->bufmgr);
1330
1331         tbm_bufmgr_deinit(muse_server->bufmgr);
1332
1333         LOGD("Leave");
1334 }
1335
1336 void ms_cmd_dispatch_foreach_func(gpointer data, gpointer user_data)
1337 {
1338         muse_module_h m = (muse_module_h)data;
1339         ms_cmd_dispatcher_info_t *dispatch = (ms_cmd_dispatcher_info_t *)user_data;
1340         muse_module_command_e cmd;
1341         muse_external_storage_info_t *storage;
1342
1343         muse_return_if_fail(muse_server);
1344         muse_return_if_fail(m);
1345         muse_return_if_fail(dispatch);
1346
1347         cmd = dispatch->cmd;
1348
1349         if (cmd == MUSE_MODULE_COMMAND_EXTERNAL_STORAGE_STATE_CHANGED) {
1350                 storage = &dispatch->storage;
1351                 LOGD("external storage id %d state %d path %s", storage->id, storage->state, storage->path);
1352                 muse_server_set_user_data(m, (void *)storage);
1353         }
1354
1355         ms_cmd_dispatch(m, cmd);
1356         SECURE_LOGI("[%s] module %p (%s)", module_cmd[cmd], m, muse_server->conf->host[m->idx]);
1357
1358         if (cmd == MUSE_MODULE_COMMAND_EXTERNAL_STORAGE_STATE_CHANGED)
1359                 muse_server_set_user_data(m, NULL);
1360 }
1361
1362 void ms_set_state(ms_state_e state)
1363 {
1364         muse_return_if_fail(muse_server);
1365
1366         g_autoptr(GMutexLocker) locker = g_mutex_locker_new(&muse_server->state_lock);
1367
1368         muse_server->state = state;
1369 }
1370
1371 gboolean ms_is_server_ready(void)
1372 {
1373         muse_return_val_if_fail(muse_server, FALSE);
1374
1375         return muse_server->state == MUSE_SERVER_STATE_READY;
1376 }
1377
1378 gboolean ms_create_ready_file(void)
1379 {
1380         LOGD("Enter");
1381 #ifndef MUSE_USE_LWIPC
1382         int ready_fd;
1383 #endif
1384
1385 #ifdef MUSE_USE_LWIPC
1386         _ms_wait_event();
1387
1388         ms_set_state(MUSE_SERVER_STATE_READY);
1389
1390         if (LwipcEventDone(MUSE_SERVER_READY) < 0) {
1391                 LOGE("Fail to send server ready done event");
1392                 return FALSE;
1393         }
1394 #else
1395         ready_fd = creat(MUSE_SERVER_READY, 0644);
1396         if (muse_core_fd_is_valid(ready_fd)) {
1397                 LOGD("MUSE_SERVER_READY(%s) file was created", MUSE_SERVER_READY);
1398
1399                 close(ready_fd);
1400                 ms_set_state(MUSE_SERVER_STATE_READY);
1401         } else {
1402                 LOGE("[%d] Fail to create MUSE_SERVER_READY(%s)", ready_fd, MUSE_SERVER_READY);
1403                 return FALSE;
1404         }
1405 #endif
1406         LOGD("Leave");
1407
1408         return TRUE;
1409
1410 }
1411
1412 void ms_remove_ready_file(void)
1413 {
1414 #ifdef MUSE_USE_LWIPC
1415         LwipcResetEvent(MUSE_SERVER_READY);
1416 #else
1417         unlink(MUSE_SERVER_READY);
1418         unlink(MUSE_DEFAULT_PIDFILE);
1419 #endif
1420 }
1421
1422 const char *ms_get_command_string(int cmd)
1423 {
1424         if (cmd == API_CREATE)
1425                 return "connect";
1426         else if (cmd == API_DESTROY)
1427                 return "disconnect";
1428         else
1429                 LOGE("Invalid value of cmd (%d)", cmd);
1430
1431         return "Invalid value of cmd";
1432 }
1433
1434 gboolean ms_module_idx_is_valid(muse_module_h m)
1435 {
1436         return (m->idx >= 0 && m->idx < ms_config_get_host_cnt());
1437 }