static void
setup_signals (void)
{
signal (SIGPIPE, SIG_IGN);
g_unix_signal_add (SIGINT, quit_handler, NULL);
g_unix_signal_add (SIGTERM, quit_handler, NULL);
}
gint
main (gint argc,
const gchar * const argv[])
{
EmerDaemon *daemon = make_daemon (argc, argv);
if (daemon == NULL)
return EXIT_FAILURE;
GMainLoop *main_loop = g_main_loop_new (NULL, TRUE);
// Shut down on any of these signals.
g_unix_signal_add (SIGHUP, (GSourceFunc) quit_main_loop, main_loop);
g_unix_signal_add (SIGINT, (GSourceFunc) quit_main_loop, main_loop);
g_unix_signal_add (SIGTERM, (GSourceFunc) quit_main_loop, main_loop);
g_unix_signal_add (SIGUSR1, (GSourceFunc) quit_main_loop, main_loop);
g_unix_signal_add (SIGUSR2, (GSourceFunc) quit_main_loop, main_loop);
guint name_id = g_bus_own_name (G_BUS_TYPE_SYSTEM, "com.endlessm.Metrics",
G_BUS_NAME_OWNER_FLAGS_NONE,
on_bus_acquired,
NULL /* name_acquired_callback */,
on_name_lost,
daemon, NULL /* user data free func */);
g_main_loop_run (main_loop);
g_object_unref (daemon);
g_bus_unown_name (name_id);
g_main_loop_unref (main_loop);
return EXIT_SUCCESS;
}
static void
create_manager (void)
{
GsmStore *client_store;
client_store = gsm_store_new ();
manager = gsm_manager_new (client_store, failsafe);
g_object_unref (client_store);
g_unix_signal_add (SIGTERM, term_or_int_signal_cb, manager);
g_unix_signal_add (SIGINT, term_or_int_signal_cb, manager);
g_unix_signal_add (SIGUSR1, sigusr1_cb, manager);
g_unix_signal_add (SIGUSR2, sigusr2_cb, manager);
if (IS_STRING_EMPTY (session_name)) {
session_name = _gsm_manager_get_default_session (manager);
}
if (!gsm_session_fill (manager, session_name)) {
gsm_fail_whale_dialog_we_failed (FALSE, TRUE, NULL);
}
_gsm_manager_set_renderer (manager, gl_renderer);
gsm_manager_start (manager);
}
static void
initialize_signal_handler (void)
{
#ifndef G_OS_WIN32
g_unix_signal_add (SIGTERM, signal_handler, GINT_TO_POINTER (SIGTERM));
g_unix_signal_add (SIGINT, signal_handler, GINT_TO_POINTER (SIGINT));
#endif /* G_OS_WIN32 */
}
int main (int argc, char *argv[])
{
SourceAppData data;
data.port = 7236;
GOptionEntry main_entries[] =
{
{ "rtsp_port", 0, 0, G_OPTION_ARG_INT, &(data.port), "Specify optional RTSP port number, 7236 by default", "rtsp_port"},
{ NULL }
};
GOptionContext* context = g_option_context_new ("- WFD desktop source demo application\n");
g_option_context_add_main_entries (context, main_entries, NULL);
g_option_context_add_group (context, gst_init_get_option_group ());
GError* error = NULL;
if (!g_option_context_parse (context, &argc, &argv, &error)) {
g_print ("option parsing failed: %s\n", error->message);
g_option_context_free(context);
exit (1);
}
g_option_context_free(context);
GMainLoop *main_loop = g_main_loop_new(NULL, TRUE);
g_unix_signal_add(SIGINT, _sig_handler, main_loop);
g_unix_signal_add(SIGTERM, _sig_handler, main_loop);
GIOChannel* io_channel = g_io_channel_unix_new (STDIN_FILENO);
g_io_add_watch(io_channel, G_IO_IN, _user_input_handler, &data);
g_io_channel_unref(io_channel);
// Create a information element for a simple WFD Source
// FIXME: is this correct? maybe we're supposed to actively scan for
// WFD sinks instead
P2P::InformationElement ie;
auto sub_element = P2P::new_subelement(P2P::DEVICE_INFORMATION);
auto dev_info = (P2P::DeviceInformationSubelement*)sub_element;
dev_info->session_management_control_port = htons(data.port);
dev_info->maximum_throughput = htons(50);
dev_info->field1.device_type = P2P::SOURCE;
dev_info->field1.session_availability = true;
ie.add_subelement (sub_element);
std::cout << "Registering Wifi Source on port with IE " << ie.to_string() << std::endl;
// register the P2P service with connman
auto array = ie.serialize ();
data.connman.reset(new ConnmanClient (array));
if (create_source(&data))
g_main_loop_run (main_loop);
g_main_loop_unref (main_loop);
return 0;
}
/* The main() function. */
int main(int argc, char **argv)
{
struct sigaction sa;
GIOChannel *channel;
setlocale(LC_CTYPE, "");
/* Cleanup and signal handling */
atexit(cleanup);
g_unix_signal_add(SIGINT, signal_handler, NULL);
g_unix_signal_add(SIGTERM, signal_handler, NULL);
sa.sa_handler = signal_fatal;
sa.sa_flags = SA_RESETHAND;
sigemptyset(&sa.sa_mask);
sigaction(SIGABRT, &sa, 0);
sigaction(SIGBUS, &sa, 0);
sigaction(SIGFPE, &sa, 0);
sigaction(SIGILL, &sa, 0);
sigaction(SIGSEGV, &sa, 0);
/* App core */
kixterm.app = kt_app_new();
/* Preferences */
kixterm.prefs = kt_prefs_new();
/* Font */
kixterm.font = kt_font_new(kixterm.app, kixterm.prefs);
/* Color */
kixterm.color = kt_color_new(kixterm.app, kixterm.prefs);
/* Main window */
kixterm.win = kt_window_new(kixterm.app,
kixterm.prefs,
kixterm.font,
kixterm.color);
/* Watch the X file descriptor for events */
channel = g_io_channel_unix_new(kt_app_get_xfd(kixterm.app));
g_io_add_watch(channel, G_IO_IN, kt_xcb_io_cb, NULL);
g_io_channel_unref(channel);
/* Main context */
g_main_context_set_poll_func(g_main_context_default(), &kt_poll);
/* main event loop */
loop = g_main_loop_new(NULL, FALSE);
g_main_loop_run(loop);
/* Cleanup */
g_main_loop_unref(loop);
loop = NULL;
exit(EXIT_SUCCESS);
}
static void
session_ready_cb (GfSession *session,
gpointer user_data)
{
g_unix_signal_add (SIGTERM, on_term_signal, NULL);
g_unix_signal_add (SIGINT, on_int_signal, NULL);
application = gf_application_new ();
gf_session_register (session);
}
static void
_install_sighandlers (TlmLauncher *l)
{
if (signal (SIGINT, SIG_IGN) == SIG_ERR)
WARN ("failed to ignore SIGINT: %s", strerror(errno));
l->sig_source_id[0] = g_unix_signal_add (SIGTERM, _handle_quit_signal, l);
l->sig_source_id[1] = g_unix_signal_add (SIGHUP, _handle_quit_signal, l);
if (prctl(PR_SET_PDEATHSIG, SIGHUP))
WARN ("failed to set parent death signal");
}
int
sol_mainloop_impl_init(void)
{
loop = g_main_loop_new(NULL, false);
if (!loop) {
SOL_CRI("cannot create mainloop");
return errno ? -errno : -ENOENT;
}
g_unix_signal_add(SIGINT, on_signal, loop);
g_unix_signal_add(SIGTERM, on_signal, loop);
return 0;
}
GPid
pipe_stdio_to_hook(const gchar* envvar_name, GSourceFunc callback) {
gchar** argv;
gint argc;
gchar **env = g_get_environ();
env = g_environ_setenv(env, "NICE_REMOTE_HOSTNAME", remote_hostname, TRUE);
gchar* cmd = g_getenv(envvar_name);
g_debug("pipe_stdio_to_hook('%s')=%s\n", envvar_name, cmd);
if(cmd == NULL || strlen(cmd) == 0)
return -1;
// parse command line to argv array
if(!g_shell_parse_argv(cmd, &argc, &argv, NULL)) {
g_critical("Error parsing command line '%s'", cmd);
exit(1);
}
gboolean spawned;
GPid pid;
gint stdio[2];
GError* error = NULL;
g_debug("Executing '%s'\n", cmd);
spawned = g_spawn_async_with_pipes(".", argv, env, G_SPAWN_CHILD_INHERITS_STDIN, NULL, NULL,
&pid, NULL, NULL, NULL, &error);
if(error != NULL) {
g_critical("Error executing '%s': %s", cmd, error->message);
return pid;
}
if(callback != NULL) {
// no SIGCHLD, so we cannot
// g_child_watch_add(pid, callback, NULL);
gint interval_ms = 500;
g_timeout_add(interval_ms, callback, (gpointer) pid);
}
g_unix_signal_add(SIGTERM, terminate_child_and_exit, (gpointer) pid);
g_unix_signal_add(SIGINT, terminate_child_and_exit, (gpointer) pid);
g_assert(spawned);
return pid;
}
int
main (int argc, char *argv[])
{
SnraClient *client = NULL;
int ret = 1;
const gchar *server = NULL;
gst_init (&argc, &argv);
if (argc > 1) {
/* Connect directly to the requested server, no avahi */
server = argv[1];
}
avahi_set_allocator (avahi_glib_allocator ());
g_unix_signal_add (SIGINT, sigint_handler, NULL);
client = snra_client_new (server);
if (client == NULL)
goto fail;
ml = g_main_loop_new (NULL, FALSE);
g_main_loop_run (ml);
ret = 0;
fail:
if (client)
g_object_unref (client);
if (ml)
g_main_loop_unref (ml);
return ret;
}
int
main (int argc,
char **argv)
{
GError *error;
GOptionContext *opt_context = NULL;
gint ret = 1;
guint name_owner_id = 0;
setlocale (LC_ALL, "");
bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
opt_context = g_option_context_new ("GNOME Online Accounts daemon");
g_option_context_add_main_entries (opt_context, opt_entries, NULL);
error = NULL;
if (!g_option_context_parse (opt_context, &argc, &argv, &error))
{
g_critical ("Error parsing options: %s", error->message);
g_error_free (error);
goto out;
}
g_message ("goa-daemon version %s starting", PACKAGE_VERSION);
loop = g_main_loop_new (NULL, FALSE);
if (!opt_no_sigint)
{
g_unix_signal_add (SIGINT, on_sigint, NULL);
}
name_owner_id = g_bus_own_name (G_BUS_TYPE_SESSION,
"org.gnome.OnlineAccounts",
G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT |
(opt_replace ? G_BUS_NAME_OWNER_FLAGS_REPLACE : 0),
on_bus_acquired,
on_name_acquired,
on_name_lost,
NULL,
NULL);
g_debug ("Entering main event loop");
g_main_loop_run (loop);
ret = 0;
out:
g_clear_object (&the_daemon);
if (name_owner_id != 0)
g_bus_unown_name (name_owner_id);
g_clear_pointer (&loop, (GDestroyNotify) g_main_loop_unref);
g_clear_pointer (&opt_context, (GDestroyNotify) g_option_context_free);
g_message ("goa-daemon version %s exiting", PACKAGE_VERSION);
return ret;
}
static void
korva_server_init (KorvaServer *self)
{
self->priv = korva_server_get_instance_private (self);
self->priv->loop = g_main_loop_new (NULL, FALSE);
self->priv->bus_id = g_bus_own_name (G_BUS_TYPE_SESSION,
"org.jensge.Korva",
G_BUS_NAME_OWNER_FLAGS_NONE,
korva_server_on_bus_aquired,
korva_server_on_name_aquired,
korva_server_on_name_lost,
g_object_ref (self),
g_object_unref);
self->priv->tags = g_hash_table_new_full (g_str_hash,
(GEqualFunc) g_str_equal,
g_free,
g_free);
#ifdef G_OS_UNIX
g_unix_signal_add (SIGINT, korva_server_signal_handler, self);
#endif
korva_server_reset_timeout (self);
}
int
main (int argc, char ** argv)
{
GMainLoop * loop = NULL;
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
setlocale (LC_ALL, "");
bindtextdomain (GETTEXT_PACKAGE, GNOMELOCALEDIR);
/* Build Mainloop */
loop = g_main_loop_new(NULL, FALSE);
g_unix_signal_add(SIGTERM, sigterm_handler, loop);
/* Initialize libnotify */
notify_init ("indicator-sound");
g_bus_own_name(G_BUS_TYPE_SESSION,
"com.canonical.indicator.sound",
G_BUS_NAME_OWNER_FLAGS_NONE,
on_bus_acquired,
NULL, /* name acquired */
on_name_lost,
loop,
NULL);
g_main_loop_run(loop);
g_clear_object(&service);
g_clear_pointer(&pgloop, pa_glib_mainloop_free);
notify_uninit();
return 0;
}
gint
main (gint argc,
const gchar * const argv[])
{
prev_time_set = emtr_util_get_current_time (CLOCK_MONOTONIC, &prev_time);
g_datalist_init (&humanity_by_session_id);
GDBusProxy *systemd_dbus_proxy = systemd_dbus_proxy_new ();
GDBusProxy *login_dbus_proxy = login_dbus_proxy_new ();
GDBusProxy *network_dbus_proxy = network_dbus_proxy_new ();
GFileMonitor *location_file_monitor = location_file_monitor_new ();
GMainLoop *main_loop = g_main_loop_new (NULL, TRUE);
g_idle_add ((GSourceFunc) record_location_metric, NULL);
g_idle_add ((GSourceFunc) record_os_version, NULL);
g_idle_add ((GSourceFunc) increment_boot_count, NULL);
g_idle_add ((GSourceFunc) record_live_boot, NULL);
g_idle_add ((GSourceFunc) record_image_version, NULL);
g_idle_add ((GSourceFunc) record_location_label, NULL);
g_idle_add ((GSourceFunc) record_network_id, GINT_TO_POINTER (TRUE));
g_idle_add ((GSourceFunc) record_windows_licenses, NULL);
g_timeout_add_seconds (RECORD_UPTIME_INTERVAL_SECONDS / 2,
(GSourceFunc) record_uptime, NULL);
eins_hwinfo_start ();
g_unix_signal_add (SIGHUP, (GSourceFunc) quit_main_loop, main_loop);
g_unix_signal_add (SIGINT, (GSourceFunc) quit_main_loop, main_loop);
g_unix_signal_add (SIGTERM, (GSourceFunc) quit_main_loop, main_loop);
g_unix_signal_add (SIGUSR1, (GSourceFunc) quit_main_loop, main_loop);
g_unix_signal_add (SIGUSR2, (GSourceFunc) quit_main_loop, main_loop);
g_main_loop_run (main_loop);
record_logout_for_all_remaining_sessions ();
record_shutdown ();
g_main_loop_unref (main_loop);
g_clear_object (&systemd_dbus_proxy);
g_clear_object (&login_dbus_proxy);
g_clear_object (&network_dbus_proxy);
g_clear_object (&location_file_monitor);
return EXIT_SUCCESS;
}
static void
let_me_quit (GMainLoop *loop)
{
g_unix_signal_add (SIGINT, (GSourceFunc) g_main_loop_quit, loop);
if (!quiet)
g_printf ("Hit Control-C to stop logging.\n");
}
int
main (int argc, char *argv[])
{
ArgsInfo args_info = { &nm_cli, argc, argv };
/* Set locale to use environment variables */
setlocale (LC_ALL, "");
#ifdef GETTEXT_PACKAGE
/* Set i18n stuff */
bindtextdomain (GETTEXT_PACKAGE, NMCLI_LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#endif
nm_g_type_init ();
/* Save terminal settings */
tcgetattr (STDIN_FILENO, &termios_orig);
g_unix_signal_add (SIGTERM, signal_handler, GINT_TO_POINTER (SIGTERM));
g_unix_signal_add (SIGINT, signal_handler, GINT_TO_POINTER (SIGINT));
nmc_value_transforms_register ();
nmc_init (&nm_cli);
g_idle_add (start, &args_info);
loop = g_main_loop_new (NULL, FALSE); /* create main loop */
g_main_loop_run (loop); /* run main loop */
if (nm_cli.complete) {
/* Remove error statuses from command completion runs. */
if (nm_cli.return_value < NMC_RESULT_COMPLETE_FILE)
nm_cli.return_value = NMC_RESULT_SUCCESS;
} else if (nm_cli.return_value != NMC_RESULT_SUCCESS) {
/* Print result descripting text */
g_printerr ("%s\n", nm_cli.return_text->str);
}
g_main_loop_unref (loop);
nmc_cleanup (&nm_cli);
return nm_cli.return_value;
}
int
main (int argc, char *argv[])
{
GError *err;
PiGlow *pig;
GMainLoop *loop;
PiGlowFunc func;
gint interval;
if (argc < 3 || argc > 4) {
g_printerr ("usage: piglow <device> <effect> "
"[<interval in millisec>]\n");
return 1;
}
func = get_effect_func (argv[2]);
if (!func)
return 1;
interval = (argc == 4) ? atoi (argv[3]) : 200;
if (interval <= 0) {
g_printerr ("Invalid interval\n");
return 1;
}
err = NULL;
pig = pi_glow_new (argv[1], &err);
if (!pig)
goto errexit;
if (!pi_glow_animate (pig, interval, func, NULL))
goto errexit;
loop = g_main_loop_new (NULL, TRUE);
g_unix_signal_add (SIGINT, (GSourceFunc)g_main_loop_quit, loop);
g_print ("Press Ctrl-C to quit\n");
g_main_loop_run (loop);
g_clear_object (&pig);
g_main_loop_unref (loop);
return 0;
errexit:
g_printerr ("Error: %s\n", err ? err->message :
"something went wrong\n");
g_clear_error (&err);
g_clear_object (&pig);
return 1;
}
/*
* _gjs_profiler_setup_signals:
* @context: a #GjsContext with a profiler attached
*
* If you want to simply allow profiling of your process with minimal
* fuss, simply call gjs_profiler_setup_signals(). This will allow
* enabling and disabling the profiler with SIGUSR2. You must call
* this from main() immediately when your program starts and must not
* block SIGUSR2 from your signal mask.
*
* If this is not sufficient, use gjs_profiler_chain_signal() from your
* own signal handler to pass the signal to a GjsProfiler.
*/
void
_gjs_profiler_setup_signals(GjsProfiler *self,
GjsContext *context)
{
g_return_if_fail(context == profiling_context);
#ifdef ENABLE_PROFILER
if (self->sigusr2_id != 0)
return;
self->sigusr2_id = g_unix_signal_add(SIGUSR2, gjs_profiler_sigusr2, context);
#else /* !ENABLE_PROFILER */
g_message("Profiler is disabled. Not setting up signals.");
#endif /* ENABLE_PROFILER */
}
/* function implementation */
zathura_t*
zathura_create(void)
{
zathura_t* zathura = g_try_malloc0(sizeof(zathura_t));
if (zathura == NULL) {
return NULL;
}
/* global settings */
zathura->global.search_direction = FORWARD;
/* plugins */
zathura->plugins.manager = zathura_plugin_manager_new();
if (zathura->plugins.manager == NULL) {
goto error_out;
}
/* UI */
zathura->ui.session = girara_session_create();
if (zathura->ui.session == NULL) {
goto error_out;
}
#ifdef G_OS_UNIX
/* signal handler */
zathura->signals.sigterm = g_unix_signal_add(SIGTERM, zathura_signal_sigterm, zathura);
#endif
/* MIME type detection */
zathura->content_type_context = zathura_content_type_new();
zathura->ui.session->global.data = zathura;
return zathura;
error_out:
zathura_free(zathura);
return NULL;
}
int
main (int argc, char *argv[])
{
SnraManager *manager;
char *config_file = NULL;
gst_init (&argc, &argv);
if (argc > 1)
config_file = argv[1];
g_unix_signal_add (SIGINT, sigint_handler, NULL);
manager = snra_manager_new(config_file);
if (manager == NULL)
return -1;
ml = g_main_loop_new(NULL, FALSE);
g_main_loop_run(ml);
g_object_unref (manager);
return 0;
}
static int
run_bridge (const gchar *interactive)
{
CockpitTransport *transport;
CockpitBridge *bridge;
gboolean terminated = FALSE;
gboolean interupted = FALSE;
gboolean closed = FALSE;
gboolean init_received = FALSE;
guint sig_term;
guint sig_int;
int outfd;
cockpit_set_journal_logging (G_LOG_DOMAIN, !isatty (2));
/*
* This process talks on stdin/stdout. However lots of stuff wants to write
* to stdout, such as g_debug, and uses fd 1 to do that. Reroute fd 1 so that
* it goes to stderr, and use another fd for stdout.
*/
outfd = dup (1);
if (outfd < 0 || dup2 (2, 1) < 1)
{
g_warning ("bridge couldn't redirect stdout to stderr");
outfd = 1;
}
sig_term = g_unix_signal_add (SIGTERM, on_signal_done, &terminated);
sig_int = g_unix_signal_add (SIGINT, on_signal_done, &interupted);
g_type_init ();
cockpit_dbus_json_allow_external = FALSE;
packages = cockpit_packages_new ();
cockpit_dbus_internal_startup (interactive != NULL);
if (interactive)
{
/* Allow skipping the init message when interactive */
init_received = TRUE;
transport = cockpit_interact_transport_new (0, outfd, interactive);
}
else
{
transport = cockpit_pipe_transport_new_fds ("stdio", 0, outfd);
}
g_resources_register (cockpitassets_get_resource ());
cockpit_web_failure_resource = "/org/cockpit-project/Cockpit/fail.html";
bridge = cockpit_bridge_new (transport, payload_types, init_received);
cockpit_dbus_environment_startup ();
g_signal_connect (transport, "closed", G_CALLBACK (on_closed_set_flag), &closed);
send_init_command (transport);
while (!terminated && !closed && !interupted)
g_main_context_iteration (NULL, TRUE);
g_object_unref (bridge);
g_object_unref (transport);
cockpit_packages_free (packages);
packages = NULL;
g_source_remove (sig_term);
g_source_remove (sig_int);
/* So the caller gets the right signal */
if (terminated)
raise (SIGTERM);
return 0;
}
int main(int argc, char *argv[])
{
GMainLoop *main_loop = NULL;
GObject *scgi_server = NULL;
static gchar *conf_dir = NULL;
static gboolean debug = FALSE;
#ifdef G_OS_UNIX
static gchar *user = NULL;
static gchar *group = NULL;
#endif /* G_OS_UNIX */
static GOptionEntry option_entries[] =
{
{ "conf", 'c', 0, G_OPTION_ARG_STRING, &conf_dir, "Config directory", NULL},
#ifdef G_OS_UNIX
{ "user", 'u', 0, G_OPTION_ARG_STRING, &user, "User name", NULL},
{ "group", 'g', 0, G_OPTION_ARG_STRING, &group, "Group name", NULL},
#endif /* G_OS_UNIX */
{ "debug", 'd', 0, G_OPTION_ARG_NONE, &debug, "Debug mode", NULL},
{ NULL }
};
GOptionContext *option_context = NULL;
GError *error = NULL;
#ifndef GLIB_VERSION_2_36
g_type_init();
#endif
if(!g_module_supported())
g_error("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__);
option_context = g_option_context_new("");
g_option_context_add_main_entries(option_context,
option_entries, NULL);
if(!g_option_context_parse(option_context, &argc, &argv, &error))
{
g_error("%s:%d[%s]=>(%s)", __FILE__, __LINE__, __FUNCTION__,
error->message);
g_error_free(error);
}
g_option_context_free(option_context);
#ifdef G_OS_UNIX
if(group)
{
struct group *grp = NULL;
if(NULL == (grp = getgrnam(group)))
g_error("%s:%d[%s]=>(%s)", __FILE__, __LINE__,
__FUNCTION__, "Get group failed!");
if(-1 == setgid(grp->gr_gid))
g_error("%s:%d[%s]=>(%s)", __FILE__, __LINE__,
__FUNCTION__, "Set gid failed!");
if(-1 == setgroups(0, NULL))
g_error("%s:%d[%s]=>(%s)", __FILE__, __LINE__,
__FUNCTION__, "Set groups failed!");
if(user)
{
if(-1 == initgroups(user, grp->gr_gid))
g_error("%s:%d[%s]=>(%s)", __FILE__, __LINE__,
__FUNCTION__, "Init groups failed!");
}
}
if(user)
{
struct passwd *pwd = NULL;
if(NULL == (pwd = getpwnam(user)))
g_error("%s:%d[%s]=>(%s)", __FILE__, __LINE__,
__FUNCTION__, "Get user failed!");
if(-1 == setuid(pwd->pw_uid))
g_error("%s:%d[%s]=>(%s)", __FILE__, __LINE__,
__FUNCTION__, "Set uid failed!");
}
#endif /* G_OS_UNIX */
if(!debug)
{
g_log_set_handler(NULL, G_LOG_LEVEL_DEBUG,
debug_log_handler, NULL);
#ifdef G_OS_UNIX
daemon(1, 1);
#endif /* G_OS_UNIX */
}
main_loop = g_main_loop_new(NULL, FALSE);
if(!main_loop)
g_error("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__);
scgi_server = hev_scgi_server_new(conf_dir);
if(!scgi_server)
g_error("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__);
hev_scgi_server_start(HEV_SCGI_SERVER(scgi_server));
#ifdef G_OS_UNIX
g_unix_signal_add(SIGINT, unix_signal_handler, main_loop);
g_unix_signal_add(SIGTERM, unix_signal_handler, main_loop);
#endif /* G_OS_UNIX */
g_main_loop_run(main_loop);
hev_scgi_server_stop(HEV_SCGI_SERVER(scgi_server));
g_object_unref(G_OBJECT(scgi_server));
g_main_loop_unref(main_loop);
return 0;
}
int main ( int argc, char *argv[] )
{
TIMINGS_START ();
cmd_set_arguments ( argc, argv );
// Version
if ( find_arg ( "-v" ) >= 0 || find_arg ( "-version" ) >= 0 ) {
#ifdef GIT_VERSION
fprintf ( stdout, "Version: "GIT_VERSION "\n" );
#else
fprintf ( stdout, "Version: "VERSION "\n" );
#endif
exit ( EXIT_SUCCESS );
}
// Detect if we are in dmenu mode.
// This has two possible causes.
// 1 the user specifies it on the command-line.
if ( find_arg ( "-dmenu" ) >= 0 ) {
dmenu_mode = TRUE;
}
// 2 the binary that executed is called dmenu (e.g. symlink to rofi)
else{
// Get the base name of the executable called.
char *base_name = g_path_get_basename ( argv[0] );
const char * const dmenu_str = "dmenu";
dmenu_mode = ( strcmp ( base_name, dmenu_str ) == 0 );
// Free the basename for dmenu detection.
g_free ( base_name );
}
TICK ();
// Get the path to the cache dir.
cache_dir = g_get_user_cache_dir ();
// Create pid file path.
const char *path = g_get_user_runtime_dir ();
if ( path ) {
pidfile = g_build_filename ( path, "rofi.pid", NULL );
}
config_parser_add_option ( xrm_String, "pid", (void * *) &pidfile, "Pidfile location" );
if ( find_arg ( "-config" ) < 0 ) {
const char *cpath = g_get_user_config_dir ();
if ( cpath ) {
config_path = g_build_filename ( cpath, "rofi", "config", NULL );
}
}
else {
char *c = NULL;
find_arg_str ( "-config", &c );
config_path = rofi_expand_path ( c );
}
TICK ();
// Register cleanup function.
atexit ( cleanup );
TICK ();
// Get DISPLAY, first env, then argument.
char *display_str = getenv ( "DISPLAY" );
find_arg_str ( "-display", &display_str );
if ( setlocale ( LC_ALL, "" ) == NULL ) {
fprintf ( stderr, "Failed to set locale.\n" );
return EXIT_FAILURE;
}
xcb->connection = xcb_connect ( display_str, &xcb->screen_nbr );
if ( xcb_connection_has_error ( xcb->connection ) ) {
fprintf ( stderr, "Failed to open display: %s", display_str );
return EXIT_FAILURE;
}
TICK_N ( "Open Display" );
xcb->screen = xcb_aux_get_screen ( xcb->connection, xcb->screen_nbr );
xcb_intern_atom_cookie_t *ac = xcb_ewmh_init_atoms ( xcb->connection, &xcb->ewmh );
xcb_generic_error_t *errors = NULL;
xcb_ewmh_init_atoms_replies ( &xcb->ewmh, ac, &errors );
if ( errors ) {
fprintf ( stderr, "Failed to create EWMH atoms\n" );
free ( errors );
}
if ( xkb_x11_setup_xkb_extension ( xcb->connection, XKB_X11_MIN_MAJOR_XKB_VERSION, XKB_X11_MIN_MINOR_XKB_VERSION,
XKB_X11_SETUP_XKB_EXTENSION_NO_FLAGS, NULL, NULL, &xkb.first_event, NULL ) < 0 ) {
fprintf ( stderr, "cannot setup XKB extension!\n" );
return EXIT_FAILURE;
}
xkb.context = xkb_context_new ( XKB_CONTEXT_NO_FLAGS );
if ( xkb.context == NULL ) {
fprintf ( stderr, "cannot create XKB context!\n" );
return EXIT_FAILURE;
}
xkb.xcb_connection = xcb->connection;
xkb.device_id = xkb_x11_get_core_keyboard_device_id ( xcb->connection );
enum
{
required_events =
( XCB_XKB_EVENT_TYPE_NEW_KEYBOARD_NOTIFY |
XCB_XKB_EVENT_TYPE_MAP_NOTIFY |
XCB_XKB_EVENT_TYPE_STATE_NOTIFY ),
required_nkn_details =
( XCB_XKB_NKN_DETAIL_KEYCODES ),
required_map_parts =
( XCB_XKB_MAP_PART_KEY_TYPES |
XCB_XKB_MAP_PART_KEY_SYMS |
XCB_XKB_MAP_PART_MODIFIER_MAP |
XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS |
XCB_XKB_MAP_PART_KEY_ACTIONS |
XCB_XKB_MAP_PART_VIRTUAL_MODS |
XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP ),
required_state_details =
( XCB_XKB_STATE_PART_MODIFIER_BASE |
XCB_XKB_STATE_PART_MODIFIER_LATCH |
XCB_XKB_STATE_PART_MODIFIER_LOCK |
XCB_XKB_STATE_PART_GROUP_BASE |
XCB_XKB_STATE_PART_GROUP_LATCH |
XCB_XKB_STATE_PART_GROUP_LOCK ),
};
static const xcb_xkb_select_events_details_t details = {
.affectNewKeyboard = required_nkn_details,
.newKeyboardDetails = required_nkn_details,
.affectState = required_state_details,
.stateDetails = required_state_details,
};
xcb_xkb_select_events ( xcb->connection, xkb.device_id, required_events, /* affectWhich */
0, /* clear */
required_events, /* selectAll */
required_map_parts, /* affectMap */
required_map_parts, /* map */
&details );
xkb.keymap = xkb_x11_keymap_new_from_device ( xkb.context, xcb->connection, xkb.device_id, XKB_KEYMAP_COMPILE_NO_FLAGS );
if ( xkb.keymap == NULL ) {
fprintf ( stderr, "Failed to get Keymap for current keyboard device.\n" );
return EXIT_FAILURE;
}
xkb.state = xkb_x11_state_new_from_device ( xkb.keymap, xcb->connection, xkb.device_id );
if ( xkb.state == NULL ) {
fprintf ( stderr, "Failed to get state object for current keyboard device.\n" );
return EXIT_FAILURE;
}
xkb.compose.table = xkb_compose_table_new_from_locale ( xkb.context, setlocale ( LC_CTYPE, NULL ), 0 );
if ( xkb.compose.table != NULL ) {
xkb.compose.state = xkb_compose_state_new ( xkb.compose.table, 0 );
}
else {
fprintf ( stderr, "Failed to get keyboard compose table. Trying to limp on.\n" );
}
if ( xcb_connection_has_error ( xcb->connection ) ) {
fprintf ( stderr, "Connection has error\n" );
exit ( EXIT_FAILURE );
}
x11_setup ( &xkb );
if ( xcb_connection_has_error ( xcb->connection ) ) {
fprintf ( stderr, "Connection has error\n" );
exit ( EXIT_FAILURE );
}
const xcb_query_extension_reply_t *er = xcb_get_extension_data ( xcb->connection, &xcb_xinerama_id );
if ( er ) {
if ( er->present ) {
xcb_xinerama_is_active_cookie_t is_active_req = xcb_xinerama_is_active ( xcb->connection );
xcb_xinerama_is_active_reply_t *is_active = xcb_xinerama_is_active_reply ( xcb->connection, is_active_req, NULL );
xcb->has_xinerama = is_active->state;
free ( is_active );
}
}
main_loop = g_main_loop_new ( NULL, FALSE );
TICK_N ( "Setup mainloop" );
// startup not.
xcb->sndisplay = sn_xcb_display_new ( xcb->connection, error_trap_push, error_trap_pop );
if ( xcb_connection_has_error ( xcb->connection ) ) {
fprintf ( stderr, "Connection has error\n" );
exit ( EXIT_FAILURE );
}
if ( xcb->sndisplay != NULL ) {
xcb->sncontext = sn_launchee_context_new_from_environment ( xcb->sndisplay, xcb->screen_nbr );
}
if ( xcb_connection_has_error ( xcb->connection ) ) {
fprintf ( stderr, "Connection has error\n" );
exit ( EXIT_FAILURE );
}
TICK_N ( "Startup Notification" );
// Initialize Xresources subsystem.
config_parse_xresource_init ();
TICK_N ( "Initialize Xresources system" );
// Setup keybinding
setup_abe ();
TICK_N ( "Setup abe" );
if ( find_arg ( "-no-config" ) < 0 ) {
load_configuration ( );
}
if ( !dmenu_mode ) {
// setup_modi
setup_modi ();
}
if ( find_arg ( "-no-config" ) < 0 ) {
// Reload for dynamic part.
load_configuration_dynamic ( );
}
// Dump.
// catch help request
if ( find_arg ( "-h" ) >= 0 || find_arg ( "-help" ) >= 0 || find_arg ( "--help" ) >= 0 ) {
help ( argc, argv );
exit ( EXIT_SUCCESS );
}
if ( find_arg ( "-dump-xresources" ) >= 0 ) {
config_parse_xresource_dump ();
exit ( EXIT_SUCCESS );
}
if ( find_arg ( "-dump-xresources-theme" ) >= 0 ) {
config_parse_xresources_theme_dump ();
exit ( EXIT_SUCCESS );
}
main_loop_source = g_water_xcb_source_new_for_connection ( NULL, xcb->connection, main_loop_x11_event_handler, NULL, NULL );
TICK_N ( "X11 Setup " );
rofi_view_workers_initialize ();
// Setup signal handling sources.
// SIGINT
g_unix_signal_add ( SIGINT, main_loop_signal_handler_int, NULL );
g_idle_add ( startup, NULL );
// Start mainloop.
g_main_loop_run ( main_loop );
return return_code;
}
int
main (int argc,
char **argv)
{
CockpitTransport *transport;
gboolean terminated = FALSE;
gboolean interupted = FALSE;
gboolean closed = FALSE;
GOptionContext *context;
GError *error = NULL;
guint sig_term;
guint sig_int;
int outfd;
static GOptionEntry entries[] = {
{ "lower", 0, 0, G_OPTION_ARG_NONE, &opt_lower, "Lower case channel type", NULL },
{ "upper", 0, 0, G_OPTION_ARG_NONE, &opt_upper, "Upper case channel type", NULL },
{ NULL }
};
signal (SIGPIPE, SIG_IGN);
g_setenv ("GSETTINGS_BACKEND", "memory", TRUE);
g_setenv ("GIO_USE_PROXY_RESOLVER", "dummy", TRUE);
g_setenv ("GIO_USE_VFS", "local", TRUE);
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
g_option_context_set_description (context, "mock-bridge as used in tests\n");
g_option_context_parse (context, &argc, &argv, &error);
g_option_context_free (context);
if (error)
{
g_printerr ("mock-bridge: %s\n", error->message);
g_error_free (error);
return 1;
}
outfd = dup (1);
if (outfd < 0 || dup2 (2, 1) < 1)
{
g_warning ("bridge couldn't redirect stdout to stderr");
outfd = 1;
}
sig_term = g_unix_signal_add (SIGTERM, on_signal_done, &terminated);
sig_int = g_unix_signal_add (SIGINT, on_signal_done, &interupted);
g_type_init ();
transport = cockpit_pipe_transport_new_fds ("stdio", 0, outfd);
g_signal_connect (transport, "control", G_CALLBACK (on_transport_control), NULL);
g_signal_connect (transport, "closed", G_CALLBACK (on_closed_set_flag), &closed);
send_init_command (transport);
/* Owns the channels */
channels = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref);
while (!terminated && !closed && !interupted)
g_main_context_iteration (NULL, TRUE);
g_object_unref (transport);
g_hash_table_destroy (channels);
g_source_remove (sig_term);
g_source_remove (sig_int);
/* So the caller gets the right signal */
if (terminated)
raise (SIGTERM);
return 0;
}
int main(int argc, char *argv[])
{
history = g_queue_new();
displayed = g_queue_new();
queue = g_queue_new();
cmdline_load(argc, argv);
if (cmdline_get_bool("-v/-version", false, "Print version")
|| cmdline_get_bool("--version", false, "Print version")) {
print_version();
}
char *cmdline_config_path;
cmdline_config_path =
cmdline_get_string("-conf/-config", NULL,
"Path to configuration file");
load_settings(cmdline_config_path);
if (cmdline_get_bool("-h/-help", false, "Print help")
|| cmdline_get_bool("--help", false, "Print help")) {
usage(EXIT_SUCCESS);
}
int owner_id = initdbus();
x_setup();
if (settings.startup_notification) {
notification *n = malloc(sizeof(notification));
if(n == NULL) {
die("Unable to allocate memory", EXIT_FAILURE);
}
n->appname = strdup("dunst");
n->summary = strdup("startup");
n->body = strdup("dunst is up and running");
n->progress = 0;
n->timeout = 10;
n->allow_markup = false;
n->plain_text = true;
n->urgency = LOW;
n->icon = NULL;
n->raw_icon = NULL;
n->category = NULL;
n->msg = NULL;
n->dbus_client = NULL;
n->color_strings[0] = NULL;
n->color_strings[1] = NULL;
n->actions = NULL;
n->urls = NULL;
notification_init(n, 0);
}
mainloop = g_main_loop_new(NULL, FALSE);
GPollFD dpy_pollfd = { xctx.dpy->fd,
G_IO_IN | G_IO_HUP | G_IO_ERR, 0
};
GSourceFuncs x11_source_funcs = {
x_mainloop_fd_prepare,
x_mainloop_fd_check,
x_mainloop_fd_dispatch,
NULL,
NULL,
NULL
};
GSource *x11_source =
g_source_new(&x11_source_funcs, sizeof(x11_source_t));
((x11_source_t *) x11_source)->dpy = xctx.dpy;
((x11_source_t *) x11_source)->w = xctx.win;
g_source_add_poll(x11_source, &dpy_pollfd);
g_source_attach(x11_source, NULL);
g_unix_signal_add(SIGUSR1, pause_signal, NULL);
g_unix_signal_add(SIGUSR2, unpause_signal, NULL);
run(NULL);
g_main_loop_run(mainloop);
dbus_tear_down(owner_id);
return 0;
}
int S52_utils_initSIG(void)
// init signal handler
{
#ifdef S52_USE_MINGW
signal(SIGINT, _trapSIG); // 2 - Interrupt (ANSI).
signal(SIGSEGV, _trapSIG); // 11 - Segmentation violation (ANSI).
#else // S52_USE_MINGW
//struct sigaction sa;
//memset(&sa, 0, sizeof(sa));
//sa.sa_sigaction = _trapSIG;
//sigemptyset(&sa.sa_mask);
//sa.sa_flags = SA_SIGINFO; // -std=c99 -D_POSIX_C_SOURCE=199309L
guint eventID = 0;
// 1 - SIGHUP: (POSIX) controlling terminal is closed.
eventID = g_unix_signal_add(SIGHUP, _trapSIG, GINT_TO_POINTER(SIGHUP));
if (0 >= eventID) {
PRINTF("WARNING: GLib Signal add SIG(%i) failed\n", SIGHUP);
}
// 2 - SIGINT: Interrupt (ANSI) - Ctrl-C
// abort long running process in _draw(), _drawLast() and _suppLineOverlap()
g_atomic_int_set(&_atomicAbort, FALSE);
//sigaction(SIGINT, &sa, &_old_signal_handler_SIGINT);
eventID = g_unix_signal_add(SIGINT, _trapSIG, GINT_TO_POINTER(SIGINT));
if (0 >= eventID) {
PRINTF("WARNING: GLib Signal add SIG(%i) failed\n", SIGINT);
}
// 3 - Quit (POSIX)
//sigaction(SIGQUIT, &sa, &_old_signal_handler_SIGQUIT);
// 5 - Trap (ANSI)
//sigaction(SIGTRAP, &sa, &_old_signal_handler_SIGTRAP);
// 6 - Abort (ANSI)
//sigaction(SIGABRT, &sa, &_old_signal_handler_SIGABRT);
// 9 - Kill, unblock-able (POSIX)
//sigaction(SIGKILL, &sa, &_old_signal_handler_SIGKILL);
// 11 - Segmentation violation (ANSI).
//sigaction(SIGSEGV, &sa, &_old_signal_handler_SIGSEGV); // loop in android
// 15 - SIGTERM: Termination (ANSI)
//sigaction(SIGTERM, &sa, &_old_signal_handler_SIGTERM);
eventID = g_unix_signal_add(SIGTERM, _trapSIG, GINT_TO_POINTER(SIGTERM));
if (0 >= eventID) {
PRINTF("WARNING: GLib Signal add SIG(%i) failed\n", SIGTERM);
}
// 10 - SIGUSR1
//sigaction(SIGUSR1, &sa, &_old_signal_handler_SIGUSR1);
eventID = g_unix_signal_add(SIGUSR1, _trapSIG, GINT_TO_POINTER(SIGUSR1));
if (0 >= eventID) {
PRINTF("WARNING: GLib Signal add SIG(%i) failed\n", SIGUSR1);
}
// 12 - SIGUSR2
//sigaction(SIGUSR2, &sa, &_old_signal_handler_SIGUSR2);
eventID = g_unix_signal_add(SIGUSR2, _trapSIG, GINT_TO_POINTER(SIGUSR2));
if (0 >= eventID) {
PRINTF("WARNING: GLib Signal add SIG(%i) failed\n", SIGUSR2);
}
// 28 - SIGWINCH: window full-screen - glib 2.54
//eventID = g_unix_signal_add(SIGWINCH, _trapSIG, GINT_TO_POINTER(SIGWINCH));
//if (0 >= eventID) {
// PRINTF("WARNING: GLib Signal add SIG(%i) failed\n", SIGWINCH);
//}
#endif // S52_USE_MINGW
return TRUE;
}
int
main (int argc, char **argv)
{
int i;
char *pid_string;
gchar *seat = NULL;
gchar *mir_id = NULL;
gchar *lock_filename;
gboolean sharevts = FALSE;
int lock_file;
GString *status_text;
#if !defined(GLIB_VERSION_2_36)
g_type_init ();
#endif
loop = g_main_loop_new (NULL, FALSE);
g_unix_signal_add (SIGINT, sigint_cb, NULL);
g_unix_signal_add (SIGTERM, sigterm_cb, NULL);
g_unix_signal_add (SIGHUP, sighup_cb, NULL);
for (i = 1; i < argc; i++)
{
char *arg = argv[i];
if (arg[0] == ':')
{
display_number = atoi (arg + 1);
}
else if (strcmp (arg, "-auth") == 0)
{
auth_path = argv[i+1];
i++;
}
else if (strcmp (arg, "-nolisten") == 0)
{
char *protocol = argv[i+1];
i++;
if (strcmp (protocol, "tcp") == 0)
;//listen_tcp = FALSE;
else if (strcmp (protocol, "unix") == 0)
;//listen_unix = FALSE;
}
else if (strcmp (arg, "-nr") == 0)
{
}
else if (strcmp (arg, "-background") == 0)
{
/* Ignore arg */
i++;
}
else if (g_str_has_prefix (arg, "vt"))
{
vt_number = atoi (arg + 2);
}
else if (strcmp (arg, "-novtswitch") == 0)
{
/* Ignore VT args */
}
else if (strcmp (arg, "-seat") == 0)
{
seat = argv[i+1];
i++;
}
else if (strcmp (arg, "-sharevts") == 0)
{
sharevts = TRUE;
}
else if (strcmp (arg, "-mir") == 0)
{
mir_id = argv[i+1];
i++;
}
else if (strcmp (arg, "-mirSocket") == 0)
{
/* FIXME */
i++;
}
else
{
g_printerr ("Unrecognized option: %s\n"
"Use: %s [:<display>] [option]\n"
"-auth file Select authorization file\n"
"-nolisten protocol Don't listen on protocol\n"
"-background [none] Create root window with no background\n"
"-nr (Ubuntu-specific) Synonym for -background none\n"
"-seat string seat to run on\n"
"-sharevts share VTs with another X server\n"
"-mir id Mir ID to use\n"
"-mirSocket name Mir socket to use\n"
"vtxx Use virtual terminal xx instead of the next available\n",
arg, argv[0]);
return EXIT_FAILURE;
}
}
id = g_strdup_printf ("XMIR-%d", display_number);
status_connect (request_cb, id);
xserver = x_server_new (display_number);
g_signal_connect (xserver, X_SERVER_SIGNAL_CLIENT_CONNECTED, G_CALLBACK (client_connected_cb), NULL);
g_signal_connect (xserver, X_SERVER_SIGNAL_CLIENT_DISCONNECTED, G_CALLBACK (client_disconnected_cb), NULL);
status_text = g_string_new ("");
g_string_printf (status_text, "%s START", id);
if (vt_number >= 0)
g_string_append_printf (status_text, " VT=%d", vt_number);
if (seat != NULL)
g_string_append_printf (status_text, " SEAT=%s", seat);
if (sharevts)
g_string_append (status_text, " SHAREVTS=TRUE");
if (mir_id != NULL)
g_string_append_printf (status_text, " MIR-ID=%s", mir_id);
status_notify ("%s", status_text->str);
g_string_free (status_text, TRUE);
config = g_key_file_new ();
g_key_file_load_from_file (config, g_build_filename (g_getenv ("LIGHTDM_TEST_ROOT"), "script", NULL), G_KEY_FILE_NONE, NULL);
if (g_key_file_has_key (config, "test-xserver-config", "return-value", NULL))
{
int return_value = g_key_file_get_integer (config, "test-xserver-config", "return-value", NULL);
status_notify ("%s EXIT CODE=%d", id, return_value);
return return_value;
}
lock_filename = g_strdup_printf (".X%d-lock", display_number);
lock_path = g_build_filename (g_getenv ("LIGHTDM_TEST_ROOT"), "tmp", lock_filename, NULL);
g_free (lock_filename);
lock_file = open (lock_path, O_CREAT | O_EXCL | O_WRONLY, 0444);
if (lock_file < 0)
{
char *lock_contents = NULL;
if (g_file_get_contents (lock_path, &lock_contents, NULL, NULL))
{
gchar *proc_filename;
pid_t pid;
pid = atol (lock_contents);
g_free (lock_contents);
proc_filename = g_strdup_printf ("/proc/%d", pid);
if (!g_file_test (proc_filename, G_FILE_TEST_EXISTS))
{
gchar *socket_dir;
gchar *socket_filename;
gchar *socket_path;
socket_dir = g_build_filename (g_getenv ("LIGHTDM_TEST_ROOT"), "tmp", ".X11-unix", NULL);
g_mkdir_with_parents (socket_dir, 0755);
socket_filename = g_strdup_printf ("X%d", display_number);
socket_path = g_build_filename (socket_dir, socket_filename, NULL);
g_printerr ("Breaking lock on non-existant process %d\n", pid);
unlink (lock_path);
unlink (socket_path);
g_free (socket_dir);
g_free (socket_filename);
g_free (socket_path);
}
g_free (proc_filename);
lock_file = open (lock_path, O_CREAT | O_EXCL | O_WRONLY, 0444);
}
}
if (lock_file < 0)
{
fprintf (stderr,
"Fatal server error:\n"
"Server is already active for display %d\n"
" If this server is no longer running, remove %s\n"
" and start again.\n", display_number, lock_path);
g_free (lock_path);
lock_path = NULL;
return EXIT_FAILURE;
}
pid_string = g_strdup_printf ("%10ld", (long) getpid ());
if (write (lock_file, pid_string, strlen (pid_string)) < 0)
{
g_warning ("Error writing PID file: %s", strerror (errno));
return EXIT_FAILURE;
}
g_free (pid_string);
if (!x_server_start (xserver))
return EXIT_FAILURE;
g_main_loop_run (loop);
cleanup ();
return exit_status;
}
int
main (int argc, char **argv)
{
g_debug (G_STRLOC ": %s", G_STRFUNC);
DasomServer *server;
GMainLoop *loop;
GError *error = NULL;
gboolean is_no_daemon = FALSE;
gboolean is_debug = FALSE;
gboolean is_version = FALSE;
GOptionContext *context;
GOptionEntry entries[] = {
{"no-daemon", 0, 0, G_OPTION_ARG_NONE, &is_no_daemon, N_("Do not daemonize"), NULL},
{"debug", 0, 0, G_OPTION_ARG_NONE, &is_debug, N_("Log debugging message"), NULL},
{"version", 0, 0, G_OPTION_ARG_NONE, &is_version, N_("Version"), NULL},
{NULL}
};
context = g_option_context_new ("- Dasom Input Method Daemon");
g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
g_option_context_parse (context, &argc, &argv, &error);
g_option_context_free (context);
if (error != NULL)
{
g_warning ("%s", error->message);
g_error_free (error);
return EXIT_FAILURE;
}
#if ENABLE_NLS
bindtextdomain (GETTEXT_PACKAGE, DASOM_LOCALE_DIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#endif
if (is_version)
{
g_print ("%s %s\n", argv[0], VERSION);
exit (EXIT_SUCCESS);
}
if (is_no_daemon == FALSE)
{
openlog (g_get_prgname (), LOG_PID | LOG_PERROR, LOG_DAEMON);
syslog_initialized = TRUE;
g_log_set_default_handler ((GLogFunc) dasom_log_default_handler, &is_debug);
if (daemon (0, 0) != 0)
{
g_critical ("Couldn't daemonize.");
return EXIT_FAILURE;
}
}
server = dasom_server_new ("unix:abstract=dasom", &error);
if (server == NULL)
{
g_critical ("%s", error->message);
g_clear_error (&error);
return EXIT_FAILURE;
}
dasom_server_start (server);
loop = g_main_loop_new (NULL, FALSE);
g_unix_signal_add (SIGINT, (GSourceFunc) g_main_loop_quit, loop);
g_unix_signal_add (SIGTERM, (GSourceFunc) g_main_loop_quit, loop);
g_main_loop_run (loop);
g_main_loop_unref (loop);
g_object_unref (server);
if (syslog_initialized)
closelog ();
return EXIT_SUCCESS;
}
static void
initialize_signal_handler (GMainLoop *loop)
{
#ifndef G_OS_WIN32
g_unix_signal_add (SIGTERM, signal_handler, loop);
g_unix_signal_add (SIGINT, signal_handler, loop);
#endif /* G_OS_WIN32 */
}