path: root/focus_server/mm_sound_focus_server.c

/*
 * libmm-sound
 *
 * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
 *
 * Contact: Seungbae Shin <seungbae.shin@samsung.com>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>
#include <getopt.h>
#include <sys/types.h>
#include <sys/stat.h>

#include <mm_debug.h>

#include <fcntl.h>
#include <semaphore.h>

#ifdef USE_LWIPC
#include <lwipc.h>
#endif

#include "../include/mm_sound_common.h"
#include "../include/mm_sound_utils.h"
#include "include/mm_sound_mgr_focus.h"
#include "include/mm_sound_mgr_focus_dbus.h"
#include "include/mm_sound_mgr_focus_socket.h"

#define USE_SYSTEM_SERVER_PROCESS_MONITORING

typedef struct {
	int startserver;
	int printlist;
	int testmode;
} server_arg;

static int _get_option(int argc, char **argv, server_arg *arg);
static int _usage(int argc, char **argv);

static GMainLoop *g_mainloop;

static void _mainloop_run()
{
	g_mainloop = g_main_loop_new(NULL, TRUE);
	if (g_mainloop == NULL)
		debug_error("g_main_loop_new() failed");

	g_main_loop_run(g_mainloop);
}

static int _get_option(int argc, char **argv, server_arg *arg)
{
	int c;
	static struct option long_options[] = {
		{"start", 0, 0, 'S'},
		{"help", 0, 0, 'H'},
		{"testmode", 0, 0, 'T'},
		{0, 0, 0, 0}
	};
	memset(arg, 0, sizeof(server_arg));

	arg->testmode = 0;

	while (1) {
		int opt_idx = 0;

		c = getopt_long (argc, argv, "SFLHRUP:Tiurd", long_options, &opt_idx);
		if (c == -1)
			break;
		switch (c) {
		case 'S': /* Start daemon */
			arg->startserver = 1;
			break;
		case 'T': /* Test mode */
			arg->testmode = 1;
			break;
		case 'H': /* help msg */
		default:
			return _usage(argc, argv);
		}
	}
	if (argc == 1)
		return _usage(argc, argv);
	return 0;
}

static int _usage(int argc, char **argv)
{
	fprintf(stderr, "Usage: %s [Options]\n", argv[0]);
	fprintf(stderr, "\t%-20s: start focus server.\n", "--start,-S");
	fprintf(stderr, "\t%-20s: help message.\n", "--help,-H");

	return 1;
}

static void _generate_ready_file(const char *path)
{
	int fd = -1;

	if (path == NULL) {
		debug_error("path is NULL");
		return;
	}

	if ((fd = creat(path, 0644)) != -1) {
		debug_warning("ready file(%s) file was created", path);
		close(fd);
	} else {
		debug_error("cannot create ready file(%s), errno(%d)", path, errno);
	}
}

static int g_socket_fd = -1;
static struct sigaction _int_old_action;
static struct sigaction _abrt_old_action;
static struct sigaction _segv_old_action;
static struct sigaction _term_old_action;
static struct sigaction _sys_old_action;
static struct sigaction _xcpu_old_action;

static void _signal_handler(int signo)
{
	debug_warning("ENTER, sig.num(%d)", signo);

	MMSoundMgrFocusDbusFini();
	MMSoundMgrFocusFini();
	MMSoundMgrFocusSocketFini(g_socket_fd);

#ifdef USE_GCOV
	mm_sound_gcov_flush();
#endif

	/* signal block -------------- */
	sigset_t old_mask, all_mask;
	sigfillset(&all_mask);
	sigprocmask(SIG_BLOCK, &all_mask, &old_mask);

	sigprocmask(SIG_SETMASK, &old_mask, NULL);
	/* signal unblock ------------ */

	switch (signo) {
	case SIGINT:
		sigaction(SIGINT, &_int_old_action, NULL);
		raise(signo);
		break;
	case SIGABRT:
		sigaction(SIGABRT, &_abrt_old_action, NULL);
		raise(signo);
		break;
	case SIGSEGV:
		sigaction(SIGSEGV, &_segv_old_action, NULL);
		raise(signo);
		break;
	case SIGTERM:
		sigaction(SIGTERM, &_term_old_action, NULL);
		raise(signo);
		break;
	case SIGSYS:
		sigaction(SIGSYS, &_sys_old_action, NULL);
		raise(signo);
		break;
	case SIGXCPU:
		sigaction(SIGXCPU, &_xcpu_old_action, NULL);
		raise(signo);
		break;
	default:
		break;
	}
	debug_warning("LEAVE");
}

static void _signal_initialize(void)
{
	struct sigaction _action;
	_action.sa_handler = _signal_handler;
	_action.sa_flags = SA_NOCLDSTOP;

	sigemptyset(&_action.sa_mask);

	sigaction(SIGINT, &_action, &_int_old_action);
	sigaction(SIGABRT, &_action, &_abrt_old_action);
	sigaction(SIGSEGV, &_action, &_segv_old_action);
	sigaction(SIGTERM, &_action, &_term_old_action);
	sigaction(SIGSYS, &_action, &_sys_old_action);
	sigaction(SIGXCPU, &_action, &_xcpu_old_action);

}

static void _signal_finalize(void)
{
	sigaction(SIGINT, &_int_old_action, NULL);
	sigaction(SIGABRT, &_abrt_old_action, NULL);
	sigaction(SIGSEGV, &_segv_old_action, NULL);
	sigaction(SIGTERM, &_term_old_action, NULL);
	sigaction(SIGSYS, &_sys_old_action, NULL);
	sigaction(SIGXCPU, &_xcpu_old_action, NULL);
}

int main(int argc, char **argv)
{
	server_arg serveropt;
#if !defined(USE_SYSTEM_SERVER_PROCESS_MONITORING)
	int pid;
#endif
	int socket_fd = -1;

	if (_get_option(argc, argv, &serveropt))
		return 1;

	debug_warning("focus_server [%d] init ", getpid());

	_signal_initialize();

	/* Daemon process create */
	if (!serveropt.testmode && serveropt.startserver) {
#if !defined(USE_SYSTEM_SERVER_PROCESS_MONITORING)
		daemon(0, 0); //chdir to ("/"), and close stdio
#endif
	}

	/* focus Server Starts!!!*/
	debug_warning("focus_server [%d] start ", getpid());

	signal(SIGPIPE, SIG_IGN); //ignore SIGPIPE

#if !defined(USE_SYSTEM_SERVER_PROCESS_MONITORING)
	while (1) {
		if ((pid = fork()) < 0) {
			fprintf(stderr, "Sub Fork Error\n");
			return 2;
		} else if (pid == 0) {
			break;
		} else if (pid > 0) {
			wait(&ret);
			fprintf(stderr, "Killed by signal [%05X]\n", ret);
			fprintf(stderr, "Daemon is run againg\n");
		}
	}
#endif

#ifdef USE_GCOV
	mm_sound_gcov_set_prefix();
#endif

	if (serveropt.startserver) {
		/* Change the file mode mask */
		umask(0);

		if (MMSoundMgrFocusSocketInit(&socket_fd)) {
			debug_error("focus_server [%d] terminating, due to the error of socket init.", getpid());
			return 0;
		}
		if (MMSoundMgrFocusSocketReadyToWork(socket_fd)) {
			debug_error("focus_server [%d] terminating, due to the error of thread init.", getpid());
			return 0;
		}
		MMSoundMgrFocusDbusInit();
		MMSoundMgrFocusInit();
		g_socket_fd = socket_fd;
	}

	debug_warning("focus_server [%d] initialization complete...now, start running!!", getpid());

	if (serveropt.startserver) {
		unlink(PA_READY); // remove pa_ready file after focus-server init.
		/* FIXME : This code is moved from sound_server temporally for TV migration
					As other modules which has dependancy on this file is cleared,
					this code will be removed */
		/* broadcast if we're ready */
#ifdef USE_LWIPC
		if (LwipcEventDone(SOUND_SERVER_READY) < 0)
			debug_error("cannot create SOUND_SERVER_READY(sound_server_ready)");
		else
			debug_warning("SOUND_SERVER_READY(%s) event was created", SOUND_SERVER_READY);
#else
		_generate_ready_file(SOUND_SERVER_READY);
#endif
		_generate_ready_file(FOCUS_SERVER_READY);
		_mainloop_run();
	}

	debug_warning("focus_server [%d] terminating ", getpid());

	if (serveropt.startserver) {
		MMSoundMgrFocusDbusFini();
		MMSoundMgrFocusFini();
		MMSoundMgrFocusSocketFini(socket_fd);
	}

	_signal_finalize();

	debug_warning("focus_server [%d] exit ----------------- END ", getpid());

	return 0;
}