int main(int argc, char **argv)
{
GOptionContext *context;
GError *err = NULL;
DBusConnection *conn;
DBusError error;
guint signal;
#ifdef NEED_THREADS
if (g_thread_supported() == FALSE)
g_thread_init(NULL);
#endif
context = g_option_context_new(NULL);
g_option_context_add_main_entries(context, options, NULL);
if (g_option_context_parse(context, &argc, &argv, &err) == FALSE) {
if (err != NULL) {
g_printerr("%s\n", err->message);
g_error_free(err);
return 1;
}
g_printerr("An unknown error occurred\n");
return 1;
}
g_option_context_free(context);
if (option_version == TRUE) {
printf("%s\n", VERSION);
exit(0);
}
if (option_detach == TRUE) {
if (daemon(0, 0)) {
perror("Can't start daemon");
return 1;
}
}
event_loop = g_main_loop_new(NULL, FALSE);
#ifdef NEED_THREADS
if (dbus_threads_init_default() == FALSE) {
fprintf(stderr, "Can't init usage of threads\n");
exit(1);
}
#endif
signal = setup_signalfd();
__ofono_log_init(argv[0], option_debug, option_detach);
dbus_error_init(&error);
conn = g_dbus_setup_bus(DBUS_BUS_SYSTEM, OFONO_SERVICE, &error);
if (conn == NULL) {
if (dbus_error_is_set(&error) == TRUE) {
ofono_error("Unable to hop onto D-Bus: %s",
error.message);
dbus_error_free(&error);
} else {
ofono_error("Unable to hop onto D-Bus");
}
goto cleanup;
}
g_dbus_set_disconnect_function(conn, system_bus_disconnected,
NULL, NULL);
__ofono_dbus_init(conn);
__ofono_modemwatch_init();
__ofono_manager_init();
__ofono_plugin_init(option_plugin, option_noplugin);
g_free(option_plugin);
g_free(option_noplugin);
g_main_loop_run(event_loop);
__ofono_plugin_cleanup();
__ofono_manager_cleanup();
__ofono_modemwatch_cleanup();
__ofono_dbus_cleanup();
dbus_connection_unref(conn);
cleanup:
g_source_remove(signal);
g_main_loop_unref(event_loop);
__ofono_log_cleanup();
g_free(option_debug);
return 0;
}
int
main (int argc, char *argv[])
{
GMainLoop *inner;
GError *err = NULL;
guint name_id;
g_type_init ();
/* Setup application context */
mm_context_init (argc, argv);
if (!mm_log_setup (mm_context_get_log_level (),
mm_context_get_log_file (),
mm_context_get_timestamps (),
mm_context_get_relative_timestamps (),
mm_context_get_debug (),
&err)) {
g_warning ("Failed to set up logging: %s", err->message);
g_error_free (err);
exit (1);
}
g_unix_signal_add (SIGTERM, quit_cb, NULL);
g_unix_signal_add (SIGINT, quit_cb, NULL);
mm_info ("ModemManager (version " MM_DIST_VERSION ") starting in %s bus...",
mm_context_get_test_session () ? "session" : "system");
/* Acquire name, don't allow replacement */
name_id = g_bus_own_name (mm_context_get_test_session () ? G_BUS_TYPE_SESSION : G_BUS_TYPE_SYSTEM,
MM_DBUS_SERVICE,
G_BUS_NAME_OWNER_FLAGS_NONE,
bus_acquired_cb,
name_acquired_cb,
name_lost_cb,
NULL,
NULL);
/* Go into the main loop */
loop = g_main_loop_new (NULL, FALSE);
g_main_loop_run (loop);
/* Clear the global variable, so that subsequent requests to
* exit succeed. */
inner = loop;
loop = NULL;
if (manager) {
GTimer *timer;
mm_base_manager_shutdown (manager);
/* Wait for all modems to be disabled and removed, but don't wait
* forever: if disabling the modems takes longer than 20s, just
* shutdown anyway. */
timer = g_timer_new ();
while (mm_base_manager_num_modems (manager) &&
g_timer_elapsed (timer, NULL) < (gdouble)MAX_SHUTDOWN_TIME_SECS) {
GMainContext *ctx = g_main_loop_get_context (inner);
g_main_context_iteration (ctx, FALSE);
g_usleep (50);
}
if (mm_base_manager_num_modems (manager))
mm_warn ("Disabling modems took too long, "
"shutting down with '%u' modems around",
mm_base_manager_num_modems (manager));
g_object_unref (manager);
g_timer_destroy (timer);
}
g_main_loop_unref (inner);
g_bus_unown_name (name_id);
mm_info ("ModemManager is shut down");
mm_log_shutdown ();
return 0;
}
Player::Backend::~Backend() {
gst_element_set_state (pipeline_, GST_STATE_NULL);
gst_object_unref (GST_OBJECT (pipeline_));
g_main_loop_unref (loop_);
}
static gpointer
provider_thread (gpointer data)
{
GstV4l2DeviceProvider *provider = data;
GMainContext *context = NULL;
GMainLoop *loop = NULL;
GUdevClient *client;
GList *devices;
static const gchar *subsystems[] = { "video4linux", NULL };
GST_OBJECT_LOCK (provider);
if (provider->context)
context = g_main_context_ref (provider->context);
if (provider->loop)
loop = g_main_loop_ref (provider->loop);
if (context == NULL || loop == NULL) {
provider->started = TRUE;
g_cond_broadcast (&provider->started_cond);
GST_OBJECT_UNLOCK (provider);
return NULL;
}
GST_OBJECT_UNLOCK (provider);
g_main_context_push_thread_default (context);
client = g_udev_client_new (subsystems);
g_signal_connect (client, "uevent", G_CALLBACK (uevent_cb), provider);
devices = g_udev_client_query_by_subsystem (client, "video4linux");
while (devices) {
GUdevDevice *udev_device = devices->data;
GstDevice *gstdev;
devices = g_list_remove (devices, udev_device);
if (g_udev_device_get_property_as_int (udev_device, "ID_V4L_VERSION") == 2) {
gstdev =
gst_v4l2_device_provider_device_from_udev (provider, udev_device);
if (gstdev)
gst_device_provider_device_add (GST_DEVICE_PROVIDER (provider), gstdev);
}
g_object_unref (udev_device);
}
GST_OBJECT_LOCK (provider);
provider->started = TRUE;
g_cond_broadcast (&provider->started_cond);
GST_OBJECT_UNLOCK (provider);
g_main_loop_run (loop);
g_main_loop_unref (loop);
g_object_unref (client);
g_main_context_unref (context);
gst_object_unref (provider);
return NULL;
}
int
main (int argc, char **argv)
{
GError *error = NULL;
gint ret = 1;
GOptionContext *opt_context = NULL;
guint name_owner_id = 0;
guint sigint_id = 0;
gboolean verbose = FALSE;
GOptionEntry opt_entries[] = {
{ "verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose,
_("Show extra debugging information"), NULL },
{ "replace", 'r', 0, G_OPTION_ARG_NONE, &opt_replace,
"Replace existing daemon", NULL},
{ "no-sigint", 's', 0, G_OPTION_ARG_NONE, &opt_no_sigint,
"Do not handle SIGINT for controlled shutdown", NULL},
{ "session", 'S', 0, G_OPTION_ARG_NONE, &opt_session,
_("Use the session D-Bus (for testing)"), NULL},
{NULL }
};
#if !GLIB_CHECK_VERSION(2,36,0)
g_type_init ();
#endif /* glib < 2.36 */
/* avoid gvfs (http://bugzilla.gnome.org/show_bug.cgi?id=526454) */
if (!g_setenv ("GIO_USE_VFS", "local", TRUE)) {
g_printerr ("Error setting GIO_USE_GVFS\n");
goto out;
}
opt_context = g_option_context_new ("printer daemon");
g_option_context_add_main_entries (opt_context, opt_entries, NULL);
if (!g_option_context_parse (opt_context, &argc, &argv, &error)) {
g_printerr ("Error parsing options: %s\n", error->message);
g_error_free (error);
goto out;
}
/* verbose? */
if (verbose) {
g_log_set_fatal_mask (NULL, G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL);
g_log_set_handler ("printerd",
G_LOG_LEVEL_ERROR |
G_LOG_LEVEL_CRITICAL |
G_LOG_LEVEL_DEBUG |
G_LOG_LEVEL_WARNING,
pd_log_handler_cb, NULL);
} else {
g_log_set_fatal_mask (NULL, G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL);
g_log_set_handler ("printerd", G_LOG_LEVEL_DEBUG,
pd_log_ignore_cb, NULL);
}
loop = g_main_loop_new (NULL, FALSE);
if (!opt_no_sigint) {
sigint_id = g_unix_signal_add_full (G_PRIORITY_DEFAULT,
SIGINT,
on_sigint,
NULL, /* user_data */
NULL); /* GDestroyNotify */
}
name_owner_id = g_bus_own_name (opt_session ?
G_BUS_TYPE_SESSION : G_BUS_TYPE_SYSTEM,
"org.freedesktop.printerd",
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);
/* success */
ret = 0;
out:
if (sigint_id > 0)
g_source_remove (sigint_id);
if (the_daemon != NULL)
g_object_unref (the_daemon);
if (name_owner_id != 0)
g_bus_unown_name (name_owner_id);
if (loop != NULL)
g_main_loop_unref (loop);
if (opt_context != NULL)
g_option_context_free (opt_context);
g_debug ("printerd daemon version %s exiting", PACKAGE_VERSION);
return ret;
}
int main(int argc, char **argv)
{
GOptionContext *context;
GError *error = NULL;
DBusConnection *conn;
DBusError err;
guint watch;
struct sigaction sa;
#ifdef NEED_THREADS
if (g_thread_supported() == FALSE)
g_thread_init(NULL);
#endif
context = g_option_context_new(NULL);
g_option_context_add_main_entries(context, options, NULL);
if (g_option_context_parse(context, &argc, &argv, &error) == FALSE) {
if (error != NULL) {
g_printerr("%s\n", error->message);
g_error_free(error);
} else
g_printerr("An unknown error occurred\n");
exit(1);
}
g_option_context_free(context);
if (option_version == TRUE) {
printf("%s\n", VERSION);
exit(0);
}
main_loop = g_main_loop_new(NULL, FALSE);
#ifdef NEED_THREADS
if (dbus_threads_init_default() == FALSE) {
fprintf(stderr, "Can't init usage of threads\n");
exit(1);
}
#endif
dbus_error_init(&err);
conn = g_dbus_setup_bus(DBUS_BUS_SYSTEM, NULL, &err);
if (conn == NULL) {
if (dbus_error_is_set(&err) == TRUE) {
fprintf(stderr, "%s\n", err.message);
dbus_error_free(&err);
} else
fprintf(stderr, "Can't register with system bus\n");
exit(1);
}
g_dbus_set_disconnect_function(conn, disconnect_callback, NULL, NULL);
memset(&sa, 0, sizeof(sa));
sa.sa_handler = sig_term;
sigaction(SIGINT, &sa, NULL);
sigaction(SIGTERM, &sa, NULL);
watch = g_dbus_add_service_watch(conn, OFONO_SERVICE,
ofono_connect, ofono_disconnect, NULL, NULL);
g_main_loop_run(main_loop);
g_dbus_remove_watch(conn, watch);
if (ofono_running == TRUE)
ofono_disconnect(conn, NULL);
dbus_connection_unref(conn);
g_main_loop_unref(main_loop);
return 0;
}
int main (void)
{
NiceAgent *lagent, *ragent; /* agent's L and R */
NiceAddress baseaddr;
int result;
guint timer_id;
const char *stun_server = NULL, *stun_server_port = NULL;
#ifdef G_OS_WIN32
WSADATA w;
WSAStartup(0x0202, &w);
#endif
g_type_init ();
g_thread_init(NULL);
global_mainloop = g_main_loop_new (NULL, FALSE);
/* Note: impl limits ...
* - no multi-stream support
* - no IPv6 support
*/
/* step: create the agents L and R */
lagent = nice_agent_new (g_main_loop_get_context (global_mainloop), NICE_COMPATIBILITY_RFC5245);
ragent = nice_agent_new (g_main_loop_get_context (global_mainloop), NICE_COMPATIBILITY_RFC5245);
/* step: add a timer to catch state changes triggered by signals */
timer_id = g_timeout_add (30000, timer_cb, NULL);
/* step: specify which local interface to use */
if (!nice_address_set_from_string (&baseaddr, "127.0.0.1"))
g_assert_not_reached ();
nice_agent_add_local_address (lagent, &baseaddr);
nice_agent_add_local_address (ragent, &baseaddr);
g_signal_connect (G_OBJECT (lagent), "candidate-gathering-done",
G_CALLBACK (cb_candidate_gathering_done), (gpointer)1);
g_signal_connect (G_OBJECT (ragent), "candidate-gathering-done",
G_CALLBACK (cb_candidate_gathering_done), (gpointer)2);
g_signal_connect (G_OBJECT (lagent), "component-state-changed",
G_CALLBACK (cb_component_state_changed), (gpointer)1);
g_signal_connect (G_OBJECT (ragent), "component-state-changed",
G_CALLBACK (cb_component_state_changed), (gpointer)2);
g_signal_connect (G_OBJECT (lagent), "new-selected-pair",
G_CALLBACK (cb_new_selected_pair), (gpointer)1);
g_signal_connect (G_OBJECT (ragent), "new-selected-pair",
G_CALLBACK (cb_new_selected_pair), (gpointer)2);
g_signal_connect (G_OBJECT (lagent), "new-candidate",
G_CALLBACK (cb_new_candidate), (gpointer)1);
g_signal_connect (G_OBJECT (ragent), "new-candidate",
G_CALLBACK (cb_new_candidate), (gpointer)2);
g_signal_connect (G_OBJECT (lagent), "initial-binding-request-received",
G_CALLBACK (cb_initial_binding_request_received), (gpointer)1);
g_signal_connect (G_OBJECT (ragent), "initial-binding-request-received",
G_CALLBACK (cb_initial_binding_request_received), (gpointer)2);
stun_server = getenv ("NICE_STUN_SERVER");
stun_server_port = getenv ("NICE_STUN_SERVER_PORT");
if (stun_server) {
g_object_set (G_OBJECT (lagent), "stun-server", stun_server, NULL);
g_object_set (G_OBJECT (lagent), "stun-server-port", atoi (stun_server_port), NULL);
g_object_set (G_OBJECT (ragent), "stun-server", stun_server, NULL);
g_object_set (G_OBJECT (ragent), "stun-server-port", atoi (stun_server_port), NULL);
}
/* step: run test the first time */
g_debug ("test-restart: TEST STARTS / restart test");
result = run_restart_test (lagent, ragent, &baseaddr);
priv_print_global_status ();
g_assert (result == 0);
g_assert (global_lagent_state == NICE_COMPONENT_STATE_READY);
g_assert (global_ragent_state == NICE_COMPONENT_STATE_READY);
g_object_unref (lagent);
g_object_unref (ragent);
g_main_loop_unref (global_mainloop);
global_mainloop = NULL;
g_source_remove (timer_id);
#ifdef G_OS_WIN32
WSACleanup();
#endif
return result;
}
static void
ibus_impanel_start (void)
{
ibus_init ();
bus = ibus_bus_new ();
if (!ibus_bus_is_connected (bus)) {
exit (-1);
}
g_signal_connect (bus, "disconnected", G_CALLBACK (ibus_disconnected_cb), NULL);
impanel = ibus_panel_impanel_new (ibus_bus_get_connection (bus));
ibus_bus_request_name (bus, IBUS_SERVICE_PANEL, 0);
ibus_panel_impanel_set_bus(impanel, bus);
#if !IBUS_CHECK_VERSION(1,4,99)
ibus_main ();
#else
Display* dpy = XOpenDisplay(0);
Window root = DefaultRootWindow(dpy);
XEvent ev;
unsigned int modifiers = ControlMask;
int keycode = XKeysymToKeycode(dpy, XK_space);
XGrabKey(dpy, keycode, modifiers, root, False, GrabModeAsync, GrabModeAsync);
XGrabKey(dpy, keycode, modifiers | LockMask, root, False, GrabModeAsync, GrabModeAsync); // capslock
XGrabKey(dpy, keycode, modifiers | Mod2Mask, root, False, GrabModeAsync, GrabModeAsync); // numlock
XGrabKey(dpy, keycode, modifiers | LockMask | Mod2Mask, root, False, GrabModeAsync, GrabModeAsync);
XSelectInput(dpy, root, KeyPressMask);
// XCloseDisplay(dpy);
main_loop = g_main_loop_new(NULL, FALSE);
int dpyfd = ConnectionNumber(dpy);
GPollFD dpy_pollfd = {dpyfd, G_IO_IN | G_IO_HUP | G_IO_ERR, 0};
GSourceFuncs x11_source_funcs = {
x11_fd_prepare,
x11_fd_check,
x11_fd_dispatch,
NULL, /* finalize */
NULL, /* closure_callback */
NULL /* closure_marshal */
};
GSource *x11_source = g_source_new(&x11_source_funcs, sizeof(x11_source_t));
((x11_source_t*)x11_source)->dpy = dpy;
g_source_add_poll(x11_source, &dpy_pollfd);
g_source_set_can_recurse(x11_source, TRUE);
g_source_attach(x11_source, NULL);
g_main_loop_run (main_loop);
g_main_loop_unref (main_loop);
main_loop = NULL;
XUngrabKey(dpy, keycode, modifiers, root);
XUngrabKey(dpy, keycode, modifiers | LockMask, root);
XUngrabKey(dpy, keycode, modifiers | Mod2Mask, root);
XUngrabKey(dpy, keycode, modifiers | LockMask | Mod2Mask, root);
XCloseDisplay(dpy);
#endif
}
void
app_run (const gchar *full_prog_name,
const gchar **filenames,
const gchar *alternate_system_gimprc,
const gchar *alternate_gimprc,
const gchar *session_name,
const gchar *batch_interpreter,
const gchar **batch_commands,
gboolean as_new,
gboolean no_interface,
gboolean no_data,
gboolean no_fonts,
gboolean no_splash,
gboolean be_verbose,
gboolean use_shm,
gboolean use_cpu_accel,
gboolean console_messages,
gboolean use_debug_handler,
GimpStackTraceMode stack_trace_mode,
GimpPDBCompatMode pdb_compat_mode)
{
GimpInitStatusFunc update_status_func = NULL;
Gimp *gimp;
GimpGeglConfig *config;
GMainLoop *loop;
gboolean swap_is_ok;
/* Create an instance of the "Gimp" object which is the root of the
* core object system
*/
gimp = gimp_new (full_prog_name,
session_name,
be_verbose,
no_data,
no_fonts,
no_interface,
use_shm,
console_messages,
stack_trace_mode,
pdb_compat_mode);
errors_init (gimp, full_prog_name, use_debug_handler, stack_trace_mode);
units_init (gimp);
/* Check if the user's gimp_directory exists
*/
if (! g_file_test (gimp_directory (), G_FILE_TEST_IS_DIR))
{
GimpUserInstall *install = gimp_user_install_new (be_verbose);
#ifdef GIMP_CONSOLE_COMPILATION
gimp_user_install_run (install);
#else
if (! (no_interface ?
gimp_user_install_run (install) :
user_install_dialog_run (install)))
exit (EXIT_FAILURE);
#endif
gimp_user_install_free (install);
}
gimp_load_config (gimp, alternate_system_gimprc, alternate_gimprc);
config = GIMP_GEGL_CONFIG (gimp->config);
/* change the locale if a language if specified */
language_init (gimp->config->language);
/* initialize lowlevel stuff */
swap_is_ok = base_init (config, be_verbose, use_cpu_accel);
gimp_gegl_init (gimp);
#ifndef GIMP_CONSOLE_COMPILATION
if (! no_interface)
update_status_func = gui_init (gimp, no_splash);
#endif
if (! update_status_func)
update_status_func = app_init_update_noop;
/* Create all members of the global Gimp instance which need an already
* parsed gimprc, e.g. the data factories
*/
gimp_initialize (gimp, update_status_func);
/* Load all data files
*/
gimp_restore (gimp, update_status_func);
/* display a warning when no test swap file could be generated */
if (! swap_is_ok)
{
gchar *path = gimp_config_path_expand (config->swap_path, FALSE, NULL);
g_message (_("Unable to open a test swap file.\n\n"
"To avoid data loss, please check the location "
"and permissions of the swap directory defined in "
"your Preferences (currently \"%s\")."), path);
g_free (path);
}
/* enable autosave late so we don't autosave when the
* monitor resolution is set in gui_init()
*/
gimp_rc_set_autosave (GIMP_RC (gimp->edit_config), TRUE);
/* Load the images given on the command-line.
*/
if (filenames)
{
gint i;
for (i = 0; filenames[i] != NULL; i++)
file_open_from_command_line (gimp, filenames[i], as_new);
}
batch_run (gimp, batch_interpreter, batch_commands);
loop = g_main_loop_new (NULL, FALSE);
g_signal_connect_after (gimp, "exit",
G_CALLBACK (app_exit_after_callback),
loop);
gimp_threads_leave (gimp);
g_main_loop_run (loop);
gimp_threads_enter (gimp);
g_main_loop_unref (loop);
g_object_unref (gimp);
gimp_debug_instances ();
errors_exit ();
gegl_exit ();
base_exit ();
}
static void dom_document_fixture_teardown(DomDocumentFixture* fixture, gconstpointer data)
{
if (fixture->webView)
g_object_unref(fixture->webView);
g_main_loop_unref(fixture->loop);
}
~DownloadTest()
{
g_signal_handlers_disconnect_matched(m_webContext, G_SIGNAL_MATCH_DATA, 0, 0, 0, 0, this);
g_main_loop_unref(m_mainLoop);
}
int
main (int argc, char **argv)
{
SoupSession *session;
SoupMessage *msg;
const char *base_uri;
char *uri;
gboolean authenticated;
int i, ntests;
test_init (argc, argv, NULL);
apache_init ();
base_uri = "http://127.0.0.1:47524/";
/* Main tests */
current_tests = main_tests;
ntests = G_N_ELEMENTS (main_tests);
do_batch_tests (base_uri, ntests);
/* Re-login tests */
current_tests = relogin_tests;
ntests = G_N_ELEMENTS (relogin_tests);
do_batch_tests (base_uri, ntests);
/* And now for some regression tests */
loop = g_main_loop_new (NULL, TRUE);
debug_printf (1, "Testing pipelined auth (bug 271540):\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
authenticated = FALSE;
g_signal_connect (session, "authenticate",
G_CALLBACK (bug271540_authenticate), &authenticated);
uri = g_strconcat (base_uri, "Basic/realm1/", NULL);
for (i = 0; i < 10; i++) {
msg = soup_message_new (SOUP_METHOD_GET, uri);
g_object_set_data (G_OBJECT (msg), "#", GINT_TO_POINTER (i + 1));
g_signal_connect (msg, "wrote_headers",
G_CALLBACK (bug271540_sent), &authenticated);
soup_session_queue_message (session, msg,
bug271540_finished, &i);
}
g_free (uri);
g_main_loop_run (loop);
soup_test_session_abort_unref (session);
debug_printf (1, "\nTesting digest nonce expiration:\n");
/* We test two different things here:
*
* 1. If we get a 401 response with
* "WWW-Authenticate: Digest stale=true...", we should
* retry and succeed *without* the session asking for a
* password again.
*
* 2. If we get a successful response with
* "Authentication-Info: nextnonce=...", we should update
* the nonce automatically so as to avoid getting a
* stale nonce error on the next request.
*
* In our Apache config, /Digest/realm1 and
* /Digest/realm1/expire are set up to use the same auth info,
* but only the latter has an AuthDigestNonceLifetime (of 2
* seconds). The way nonces work in Apache, a nonce received
* from /Digest/realm1 will still expire in
* /Digest/realm1/expire, but it won't issue a nextnonce for a
* request in /Digest/realm1. This lets us test both
* behaviors.
*
* The expected conversation is:
*
* First message
* GET /Digest/realm1
*
* 401 Unauthorized
* WWW-Authenticate: Digest nonce=A
*
* [emit 'authenticate']
*
* GET /Digest/realm1
* Authorization: Digest nonce=A
*
* 200 OK
* [No Authentication-Info]
*
* [sleep 2 seconds: nonce A is no longer valid, but we have no
* way of knowing that]
*
* Second message
* GET /Digest/realm1/expire/
* Authorization: Digest nonce=A
*
* 401 Unauthorized
* WWW-Authenticate: Digest stale=true nonce=B
*
* GET /Digest/realm1/expire/
* Authorization: Digest nonce=B
*
* 200 OK
* Authentication-Info: nextnonce=C
*
* [sleep 1 second]
*
* Third message
* GET /Digest/realm1/expire/
* Authorization: Digest nonce=C
* [nonce=B would work here too]
*
* 200 OK
* Authentication-Info: nextnonce=D
*
* [sleep 1 second; nonces B and C are no longer valid, but D is]
*
* Fourth message
* GET /Digest/realm1/expire/
* Authorization: Digest nonce=D
*
* 200 OK
* Authentication-Info: nextnonce=D
*
*/
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
uri = g_strconcat (base_uri, "Digest/realm1/", NULL);
do_digest_nonce_test (session, "First", uri, TRUE, TRUE);
g_free (uri);
sleep (2);
uri = g_strconcat (base_uri, "Digest/realm1/expire/", NULL);
do_digest_nonce_test (session, "Second", uri, TRUE, FALSE);
sleep (1);
do_digest_nonce_test (session, "Third", uri, FALSE, FALSE);
sleep (1);
do_digest_nonce_test (session, "Fourth", uri, FALSE, FALSE);
g_free (uri);
soup_test_session_abort_unref (session);
/* Async auth */
do_async_auth_test (base_uri);
/* Selecting correct auth when multiple auth types are available */
do_select_auth_test ();
g_main_loop_unref (loop);
test_cleanup ();
return errors != 0;
}
/**
* Main entry point for sleepd - runs the initialization hooks installed at program load time
*
* A bit counter-intuitively, this is not the first part of this program which
* is run.
*
* First, everything which uses the {@link INIT_FUNC} macro in init.h are run,
* which registers a bunch of hooks with the initialization system so that
* individual modules can be registered without touching the main sleepd
* initialization code. Then, once all of those hooks are installed, execution
* proceeds to this function which actually runs those hooks.
*
* - Initializes sleepd.
* - Attaches as a Luna service under com.palm.sleep.
* - Attaches to Nyx.
* - Subscribes to events related to the charger being plugged and unplugged from the com.palm.power service.
* - Calls {@link TheOneInit()} to finish initialization of the service.
* - Issues a request to the com.palm.power service to check on the plugged/unplugged status of the charger.
*
* @param argc Number of command-line arguments.
* @param argv List of command-line arguments.
*
* @todo Move the logging initialization functionality into {@link TheOneInit()}.
*/
int
main(int argc, char **argv)
{
bool retVal;
/*
* Register a function to be able to gracefully handle termination signals
* from the OS or other processes.
*/
signal(SIGTERM, term_handler);
signal(SIGINT, term_handler);
#if !GLIB_CHECK_VERSION(2,32,0)
if (!g_thread_supported())
{
g_thread_init(NULL);
}
#endif
mainloop = g_main_loop_new(NULL, FALSE);
/*
* initialize the lunaservice and we want it before all the init
* stuff happening.
*/
LSError lserror;
LSErrorInit(&lserror);
/*
* Register ourselves as the com.palm.sleep service.
*/
retVal = LSRegisterPalmService("com.palm.sleep", &psh, &lserror);
if (retVal)
{
/*
* Attach our main loop to the service so we can process IPC messages addressed to us.
*/
retVal = LSGmainAttachPalmService(psh, mainloop, &lserror);
if (retVal)
{
/*
* Get our private bus for our service so we can pass a message to com.palm.power.
*/
private_sh = LSPalmServiceGetPrivateConnection(psh);
/*
* Register with com.palm.power for events regarding changes in status
* to the plug/unplug state of any chargers which may be attached to our
* device.
*/
retVal = LSCall(private_sh, "luna://com.palm.lunabus/signal/addmatch",
"{\"category\":\"/com/palm/power\","
"\"method\":\"USBDockStatus\"}", ChargerStatus, NULL, NULL, &lserror);
if (retVal)
{
/*
* Connect to Nyx so we can use it later.
*/
int ret = nyx_device_open(NYX_DEVICE_SYSTEM, "Main", &nyxSystem);
if (ret != NYX_ERROR_NONE)
{
SLEEPDLOG_CRITICAL(MSGID_NYX_DEVICE_OPEN_FAIL, 1,
PMLOGKS(CAUSE, "Unable to open the nyx device system"), "");
abort();
}
/*
* Call our main initialization function - this is the function which
* is supposed to handle initializing pretty much everything for us.
*/
TheOneInit();
/*
* Now that we've got something listening for charger status changes,
* request the current state of the charger from com.palm.power.
*/
LSCall(private_sh, "luna://com.palm.power/com/palm/power/chargerStatusQuery",
"{}", ChargerStatus, NULL, NULL, &lserror);
SLEEPDLOG_DEBUG("Sleepd daemon started");
g_main_loop_run(mainloop);
}
}
}
else
{
SLEEPDLOG_CRITICAL(MSGID_SRVC_REGISTER_FAIL, 1, PMLOGKS(ERRTEXT,
lserror.message), "Could not initialize sleepd");
LSErrorFree(&lserror);
}
g_main_loop_unref(mainloop);
return 0;
}
int
main (int argc, char *argv[])
{
GstBus *bus;
gint watch_id;
gst_init (NULL, NULL);
loop = g_main_loop_new (NULL, TRUE);
pipeline = gst_pipeline_new ("pipeline");
#ifdef ASYNC_VERSION
/* this enables messages of individual elements inside the pipeline */
g_object_set (pipeline, "message-forward", TRUE, NULL);
#endif
/* make a bin with the playback elements this is a non-live pipeline */
play_bin = gst_bin_new ("play_bin");
play_source = gst_element_factory_make ("audiotestsrc", "play_source");
play_sink = gst_element_factory_make ("autoaudiosink", "play_sink");
gst_bin_add (GST_BIN (play_bin), play_source);
gst_bin_add (GST_BIN (play_bin), play_sink);
gst_element_link (play_source, play_sink);
/* make bin with the record elements, this is a live pipeline */
rec_bin = gst_bin_new ("rec_bin");
rec_source = gst_element_factory_make ("autoaudiosrc", "rec_source");
rec_sink = gst_element_factory_make ("fakesink", "rec_sink");
gst_bin_add (GST_BIN (rec_bin), rec_source);
gst_bin_add (GST_BIN (rec_bin), rec_sink);
gst_element_link (rec_source, rec_sink);
gst_bin_add (GST_BIN (pipeline), play_bin);
gst_bin_add (GST_BIN (pipeline), rec_bin);
bus = gst_element_get_bus (pipeline);
watch_id = gst_bus_add_watch (bus, message_handler, NULL);
gst_object_unref (bus);
g_print ("going to PAUSED\n");
/* returns NO_PREROLL because we have a live element */
if (gst_element_set_state (pipeline,
GST_STATE_PAUSED) != GST_STATE_CHANGE_NO_PREROLL) {
g_warning ("Expected state change NO_PREROLL result");
}
g_print ("waiting for playback preroll\n");
#ifndef ASYNC_VERSION
/* sync wait for preroll on the playback bin and then go to PLAYING */
if (gst_element_get_state (play_bin, NULL, NULL,
GST_CLOCK_TIME_NONE) != GST_STATE_CHANGE_SUCCESS) {
g_warning ("Error while waiting for state change");
}
g_print ("prerolled, starting synchronized playback and recording\n");
/* returns ASYNC because the sink linked to the live source is not
* prerolled */
if (gst_element_set_state (pipeline,
GST_STATE_PLAYING) != GST_STATE_CHANGE_ASYNC) {
g_warning ("Expected state change NO_PREROLL result");
}
#endif
g_main_loop_run (loop);
g_source_remove (watch_id);
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_object_unref (pipeline);
g_main_loop_unref (loop);
return 0;
}
int
main(int argc, char *argv[])
{
gboolean print_version = FALSE;
gboolean one_shot = FALSE;
gchar *output_plugin = NULL;
gchar **servers_desc = NULL;
gchar **streams_desc = NULL;
gchar **input_plugins = NULL;
gchar **order = NULL;
gchar *config = NULL;
int retval = 0;
GError *error = NULL;
GOptionContext *option_context = NULL;
GOptionGroup *option_group;
#if DEBUG
g_setenv("G_MESSAGES_DEBUG", "all", FALSE);
#endif /* ! DEBUG */
setlocale(LC_ALL, "");
#ifdef ENABLE_NLS
bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
#endif /* ENABLE_NLS */
#if DEBUG
const gchar *debug_log_filename = g_getenv("J4STATUS_DEBUG_LOG_FILENAME");
GDataOutputStream *debug_stream = NULL;
if ( debug_log_filename != NULL )
{
GFile *debug_log;
debug_log = g_file_new_for_path(debug_log_filename);
GError *error = NULL;
GFileOutputStream *debug_log_stream;
debug_log_stream = g_file_append_to(debug_log, G_FILE_CREATE_NONE, NULL, &error);
if ( debug_log_stream == NULL )
{
g_warning("Couldn't open debug log file: %s", error->message);
g_clear_error(&error);
}
else
{
debug_stream = g_data_output_stream_new(G_OUTPUT_STREAM(debug_log_stream));
g_object_unref(debug_log_stream);
g_log_set_default_handler(_j4status_core_debug_log_handler, debug_stream);
}
g_object_unref(debug_log);
}
#endif /* DEBUG */
GOptionEntry entries[] =
{
{ "output", 'o', 0, G_OPTION_ARG_STRING, &output_plugin, "Output plugin to use", "<plugin>" },
{ "listen", 'l', 0, G_OPTION_ARG_STRING_ARRAY, &servers_desc, "Socket to listen on, will create a stream on connection (may be specified several times)", "<listen description>" },
{ "stream", 't', 0, G_OPTION_ARG_STRING_ARRAY, &streams_desc, "Stream to read from/write to (may be specified several times)", "<stream description>" },
{ "input", 'i', 0, G_OPTION_ARG_STRING_ARRAY, &input_plugins, "Input plugins to use (may be specified several times)", "<plugin>" },
{ "order", 'O', 0, G_OPTION_ARG_STRING_ARRAY, &order, "Order of sections, specified once a section (see man)", "<section id>" },
{ "one-shot", '1', 0, G_OPTION_ARG_NONE, &one_shot, "Tells j4status to stop right after starting", NULL },
{ "config", 'c', 0, G_OPTION_ARG_STRING, &config, "Config file to use", "<config>" },
{ "version", 'V', 0, G_OPTION_ARG_NONE, &print_version, "Print version", NULL },
{ NULL }
};
option_context = g_option_context_new("- status line generator");
option_group = g_option_group_new(NULL, NULL, NULL, NULL, NULL);
g_option_group_set_translation_domain(option_group, GETTEXT_PACKAGE);
g_option_group_add_entries(option_group, entries);
g_option_context_set_main_group(option_context, option_group);
if ( ! g_option_context_parse(option_context, &argc, &argv, &error) )
{
g_warning("Option parsing failed: %s\n", error->message);
g_clear_error(&error);
retval = 1;
goto end;
}
g_option_context_free(option_context);
if ( print_version )
{
g_fprintf(stdout, PACKAGE_NAME " " PACKAGE_VERSION "\n");
goto end;
}
if ( config != NULL )
{
g_setenv("J4STATUS_CONFIG_FILE", config, TRUE);
g_free(config);
}
GKeyFile *key_file;
key_file = j4status_config_get_key_file("Plugins");
if ( key_file != NULL )
{
if ( output_plugin == NULL )
output_plugin = g_key_file_get_string(key_file, "Plugins", "Output", NULL);
if ( input_plugins == NULL )
input_plugins = g_key_file_get_string_list(key_file, "Plugins", "Input", NULL, NULL);
if ( order == NULL )
order = g_key_file_get_string_list(key_file, "Plugins", "Order", NULL, NULL);
g_key_file_free(key_file);
}
J4statusCoreContext *context;
context = g_new0(J4statusCoreContext, 1);
J4statusCoreInterface interface = {
.context = context,
.add_section = _j4status_core_add_section,
.remove_section = _j4status_core_remove_section,
.trigger_generate = _j4status_core_trigger_generate,
.trigger_action = _j4status_core_trigger_action,
};
#ifdef G_OS_UNIX
g_unix_signal_add(SIGTERM, _j4status_core_source_quit, context);
g_unix_signal_add(SIGINT, _j4status_core_source_quit, context);
g_unix_signal_add(SIGUSR1, _j4status_core_signal_usr1, context);
g_unix_signal_add(SIGUSR2, _j4status_core_signal_usr2, context);
/* Ignore SIGPIPE as it is useless */
signal(SIGPIPE, SIG_IGN);
#endif /* G_OS_UNIX */
context->output_plugin = j4status_plugins_get_output_plugin(&interface, output_plugin);
if ( context->output_plugin == NULL )
{
g_warning("No usable output plugin, tried '%s'", output_plugin);
retval = 10;
goto end;
}
gchar *header = NULL;
if ( context->output_plugin->interface.generate_header != NULL )
header = context->output_plugin->interface.generate_header(context->output_plugin->context);
/* Creating input/output stream */
context->io = j4status_io_new(context, header, (const gchar * const *) servers_desc, (const gchar * const *) streams_desc);
if ( context->io == NULL )
{
g_warning("Couldn't create input/output streams");
retval = 2;
goto end;
}
if ( order != NULL )
{
context->order_weights = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
gchar **id;
for ( id = order ; *id != NULL ; ++id )
g_hash_table_insert(context->order_weights, *id, GINT_TO_POINTER(1 + id - order));
g_free(order);
}
context->sections_hash = g_hash_table_new(g_str_hash, g_str_equal);
context->input_plugins = j4status_plugins_get_input_plugins(&interface, input_plugins);
if ( context->input_plugins == NULL )
{
g_warning("No input plugins, will stop early");
one_shot = TRUE;
retval = 11;
}
context->sections = g_list_reverse(context->sections);
if ( context->order_weights != NULL )
context->sections = g_list_sort(context->sections, _j4status_core_compare_sections);
_j4status_core_start(context);
if ( one_shot )
g_idle_add(_j4status_core_source_quit, context);
context->loop = g_main_loop_new(NULL, FALSE);
g_main_loop_run(context->loop);
g_main_loop_unref(context->loop);
context->loop = NULL;
GList *input_plugin_;
J4statusInputPlugin *input_plugin;
for ( input_plugin_ = context->input_plugins ; input_plugin_ != NULL ; input_plugin_ = g_list_next(input_plugin_) )
{
input_plugin = input_plugin_->data;
input_plugin->interface.uninit(input_plugin->context);
}
if ( context->output_plugin->interface.uninit != NULL )
context->output_plugin->interface.uninit(context->output_plugin->context);
j4status_io_free(context->io);
if ( context->order_weights != NULL )
g_hash_table_unref(context->order_weights);
g_hash_table_unref(context->sections_hash);
end:
#if DEBUG
if ( debug_stream != NULL )
g_object_unref(debug_stream);
#endif /* DEBUG */
return retval;
}
int main (int argc, char **argv)
{
GMainLoop *loop = NULL;
GstElement *pipeline = NULL;
GstBus *bus = NULL;
GstElement *conf = NULL;
FsParticipant *part = NULL;
GError *error = NULL;
GInputStream *istream = NULL;
gchar *send_socket, *recv_socket;
TestSession *ses;
gst_init (&argc, &argv);
if (argc != 3)
{
g_print ("Usage: %s <send socket> <recv_socket>\n", argv[0]);
return 1;
}
send_socket = argv[1];
recv_socket = argv[2];
if (unlink (send_socket) < 0 && errno != ENOENT)
{
g_print ("Could not delete send or recv sockets");
return 2;
}
g_print ("Press ENTER when the other side is ready\n");
loop = g_main_loop_new (NULL, FALSE);
pipeline = gst_pipeline_new (NULL);
bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
gst_bus_add_watch (bus, async_bus_cb, pipeline);
gst_object_unref (bus);
conf = gst_element_factory_make ("fsrtpconference", NULL);
g_assert (conf);
part = fs_conference_new_participant (FS_CONFERENCE (conf), "test@ignore",
&error);
print_error (error);
g_assert (part);
g_assert (gst_bin_add (GST_BIN (pipeline), conf));
istream = g_unix_input_stream_new (0, FALSE);
ses = add_audio_session (pipeline, FS_CONFERENCE (conf), 1, part, send_socket,
recv_socket);
g_input_stream_skip_async (istream, 1, G_PRIORITY_DEFAULT, NULL, skipped_cb,
ses);
g_assert (gst_element_set_state (pipeline, GST_STATE_PLAYING) !=
GST_STATE_CHANGE_FAILURE);
g_main_loop_run (loop);
g_assert (gst_element_set_state (pipeline, GST_STATE_NULL) !=
GST_STATE_CHANGE_FAILURE);
g_object_unref (part);
g_object_unref (istream);
free_session (ses);
gst_object_unref (pipeline);
g_main_loop_unref (loop);
return 0;
}
int main (int argc, char *argv[])
{
//Force line-only buffering so we can see the output during hangs
setvbuf(stdout, NULL, _IOLBF, 0);
setvbuf(stderr, NULL, _IOLBF, 0);
GOOGLE_PROTOBUF_VERIFY_VERSION;
hu_log_library_versions();
hu_install_crash_handler();
DBus::_init_threading();
gst_init(&argc, &argv);
try
{
MazdaCommandServerCallbacks commandCallbacks;
CommandServer commandServer(commandCallbacks);
printf("headunit version: %s \n", commandCallbacks.GetVersion().c_str());
if (!commandServer.Start())
{
loge("Command server failed to start");
return 1;
}
if (argc >= 2 && strcmp(argv[1], "test") == 0)
{
//test mode from the installer, if we got here it's ok
printf("###TESTMODE_OK###\n");
return 0;
}
config::readConfig();
printf("Looping\n");
while (true)
{
//Make a new one instead of using the default so we can clean it up each run
run_on_thread_main_context = g_main_context_new();
//Recreate this each time, it makes the error handling logic simpler
DBus::Glib::BusDispatcher dispatcher;
dispatcher.attach(run_on_thread_main_context);
printf("DBus::Glib::BusDispatcher attached\n");
DBus::default_dispatcher = &dispatcher;
printf("Making debug connections\n");
DBus::Connection hmiBus(HMI_BUS_ADDRESS, false);
hmiBus.register_bus();
DBus::Connection serviceBus(SERVICE_BUS_ADDRESS, false);
serviceBus.register_bus();
hud_start();
MazdaEventCallbacks callbacks(serviceBus, hmiBus);
HUServer headunit(callbacks);
g_hu = &headunit.GetAnyThreadInterface();
commandCallbacks.eventCallbacks = &callbacks;
//Wait forever for a connection
int ret = headunit.hu_aap_start(config::transport_type, true);
if (ret < 0) {
loge("Something bad happened");
continue;
}
gst_app.loop = g_main_loop_new(run_on_thread_main_context, FALSE);
callbacks.connected = true;
std::condition_variable quitcv;
std::mutex quitmutex;
std::mutex hudmutex;
std::thread nm_thread([&quitcv, &quitmutex](){ nightmode_thread_func(quitcv, quitmutex); } );
std::thread gp_thread([&quitcv, &quitmutex](){ gps_thread_func(quitcv, quitmutex); } );
std::thread hud_thread([&quitcv, &quitmutex, &hudmutex](){ hud_thread_func(quitcv, quitmutex, hudmutex); } );
/* Start gstreamer pipeline and main loop */
printf("Starting Android Auto...\n");
g_main_loop_run (gst_app.loop);
commandCallbacks.eventCallbacks = nullptr;
callbacks.connected = false;
callbacks.videoFocus = false;
callbacks.audioFocus = AudioManagerClient::FocusType::NONE;
callbacks.inCall = false;
printf("quitting...\n");
//wake up night mode and gps polling threads
quitcv.notify_all();
printf("waiting for nm_thread\n");
nm_thread.join();
printf("waiting for gps_thread\n");
gp_thread.join();
printf("waiting for hud_thread\n");
hud_thread.join();
printf("shutting down\n");
g_main_loop_unref(gst_app.loop);
gst_app.loop = nullptr;
/* Stop AA processing */
ret = headunit.hu_aap_shutdown();
if (ret < 0) {
printf("hu_aap_shutdown() ret: %d\n", ret);
return ret;
}
g_main_context_unref(run_on_thread_main_context);
run_on_thread_main_context = nullptr;
g_hu = nullptr;
DBus::default_dispatcher = nullptr;
}
}
catch(DBus::Error& error)
{
loge("DBUS Error: %s: %s", error.name(), error.message());
return 1;
}
return 0;
}
void
app_run (const gchar *full_prog_name,
const gchar **filenames,
GFile *alternate_system_gimprc,
GFile *alternate_gimprc,
const gchar *session_name,
const gchar *batch_interpreter,
const gchar **batch_commands,
gboolean as_new,
gboolean no_interface,
gboolean no_data,
gboolean no_fonts,
gboolean no_splash,
gboolean be_verbose,
gboolean use_shm,
gboolean use_cpu_accel,
gboolean console_messages,
gboolean use_debug_handler,
gboolean show_playground,
GimpStackTraceMode stack_trace_mode,
GimpPDBCompatMode pdb_compat_mode)
{
GimpInitStatusFunc update_status_func = NULL;
Gimp *gimp;
GMainLoop *loop;
GMainLoop *run_loop;
GFile *default_folder = NULL;
GFile *gimpdir;
if (filenames && filenames[0] && ! filenames[1] &&
g_file_test (filenames[0], G_FILE_TEST_IS_DIR))
{
if (g_path_is_absolute (filenames[0]))
{
default_folder = g_file_new_for_path (filenames[0]);
}
else
{
gchar *absolute = g_build_path (G_DIR_SEPARATOR_S,
g_get_current_dir (),
filenames[0],
NULL);
default_folder = g_file_new_for_path (absolute);
g_free (absolute);
}
filenames = NULL;
}
/* Create an instance of the "Gimp" object which is the root of the
* core object system
*/
gimp = gimp_new (full_prog_name,
session_name,
default_folder,
be_verbose,
no_data,
no_fonts,
no_interface,
use_shm,
use_cpu_accel,
console_messages,
show_playground,
stack_trace_mode,
pdb_compat_mode);
if (default_folder)
g_object_unref (default_folder);
gimp_cpu_accel_set_use (use_cpu_accel);
errors_init (gimp, full_prog_name, use_debug_handler, stack_trace_mode);
units_init (gimp);
/* Check if the user's gimp_directory exists
*/
gimpdir = gimp_directory_file (NULL);
if (g_file_query_file_type (gimpdir, G_FILE_QUERY_INFO_NONE, NULL) !=
G_FILE_TYPE_DIRECTORY)
{
GimpUserInstall *install = gimp_user_install_new (be_verbose);
#ifdef GIMP_CONSOLE_COMPILATION
gimp_user_install_run (install);
#else
if (! (no_interface ?
gimp_user_install_run (install) :
user_install_dialog_run (install)))
exit (EXIT_FAILURE);
#endif
gimp_user_install_free (install);
}
g_object_unref (gimpdir);
gimp_load_config (gimp, alternate_system_gimprc, alternate_gimprc);
/* change the locale if a language if specified */
language_init (gimp->config->language);
/* initialize lowlevel stuff */
gimp_gegl_init (gimp);
/* Connect our restore_after callback before gui_init() connects
* theirs, so ours runs first and can grab the initial monitor
* before the GUI's restore_after callback resets it.
*/
g_signal_connect_after (gimp, "restore",
G_CALLBACK (app_restore_after_callback),
NULL);
#ifndef GIMP_CONSOLE_COMPILATION
if (! no_interface)
update_status_func = gui_init (gimp, no_splash);
#endif
if (! update_status_func)
update_status_func = app_init_update_noop;
/* Create all members of the global Gimp instance which need an already
* parsed gimprc, e.g. the data factories
*/
gimp_initialize (gimp, update_status_func);
/* Load all data files
*/
gimp_restore (gimp, update_status_func);
/* enable autosave late so we don't autosave when the
* monitor resolution is set in gui_init()
*/
gimp_rc_set_autosave (GIMP_RC (gimp->edit_config), TRUE);
loop = run_loop = g_main_loop_new (NULL, FALSE);
g_signal_connect_after (gimp, "exit",
G_CALLBACK (app_exit_after_callback),
&run_loop);
/* Load the images given on the command-line.
*/
if (filenames)
{
gint i;
for (i = 0; filenames[i] != NULL; i++)
{
if (run_loop)
{
GFile *file = g_file_new_for_commandline_arg (filenames[i]);
file_open_from_command_line (gimp, file, as_new,
initial_screen,
initial_monitor);
g_object_unref (file);
}
}
}
if (run_loop)
batch_run (gimp, batch_interpreter, batch_commands);
if (run_loop)
{
gimp_threads_leave (gimp);
g_main_loop_run (loop);
gimp_threads_enter (gimp);
}
g_main_loop_unref (loop);
g_object_unref (gimp);
gimp_debug_instances ();
errors_exit ();
gegl_exit ();
}
int main(int argc, char *argv[])
{
GOptionContext *context;
GError *error = NULL;
DBusConnection *conn;
DBusError err;
struct sigaction sa;
mode_t old_umask;
#ifdef NEED_THREADS
if (g_thread_supported() == FALSE)
g_thread_init(NULL);
#endif
context = g_option_context_new(NULL);
g_option_context_add_main_entries(context, options, NULL);
if (g_option_context_parse(context, &argc, &argv, &error) == FALSE) {
if (error != NULL) {
g_printerr("%s\n", error->message);
g_error_free(error);
} else
g_printerr("An unknown error occurred\n");
exit(1);
}
g_option_context_free(context);
if (option_version == TRUE) {
printf("%s\n", VERSION);
exit(0);
}
if (option_detach == TRUE) {
if (daemon(0, 0)) {
perror("Can't start daemon");
exit(1);
}
}
if (mkdir(STATEDIR, S_IRUSR | S_IWUSR | S_IXUSR |
S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) < 0) {
if (errno != EEXIST)
perror("Failed to create state directory");
}
if (mkdir(STORAGEDIR, S_IRUSR | S_IWUSR | S_IXUSR |
S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) < 0) {
if (errno != EEXIST)
perror("Failed to create storage directory");
}
old_umask = umask(077);
main_loop = g_main_loop_new(NULL, FALSE);
#ifdef NEED_THREADS
if (dbus_threads_init_default() == FALSE) {
fprintf(stderr, "Can't init usage of threads\n");
exit(1);
}
#endif
dbus_error_init(&err);
conn = g_dbus_setup_bus(DBUS_BUS_SYSTEM, CONNMAN_SERVICE, &err);
if (conn == NULL) {
if (dbus_error_is_set(&err) == TRUE) {
fprintf(stderr, "%s\n", err.message);
dbus_error_free(&err);
} else
fprintf(stderr, "Can't register with system bus\n");
exit(1);
}
g_dbus_set_disconnect_function(conn, disconnect_callback, NULL, NULL);
if (option_compat == TRUE) {
if (g_dbus_request_name(conn, NM_SERVICE, NULL) == FALSE) {
fprintf(stderr, "Can't register compat service\n");
option_compat = FALSE;
}
}
__connman_log_init(option_detach, option_debug ? DBG_ANY : 0);
if (option_selftest == TRUE) {
if (__connman_selftest() < 0) {
connman_error("Self testing routines failed");
goto selftest;
}
}
__connman_dbus_init(conn);
__connman_storage_init();
__connman_element_init(option_device, option_nodevice);
__connman_agent_init();
__connman_manager_init(option_compat);
__connman_profile_init();
__connman_resolver_init();
__connman_ipconfig_init();
__connman_rtnl_init();
__connman_udev_init();
__connman_task_init();
__connman_plugin_init(option_plugin, option_noplugin);
__connman_element_start();
g_free(option_device);
g_free(option_plugin);
g_free(option_nodevice);
g_free(option_noplugin);
memset(&sa, 0, sizeof(sa));
sa.sa_handler = sig_term;
sigaction(SIGINT, &sa, NULL);
sigaction(SIGTERM, &sa, NULL);
g_main_loop_run(main_loop);
__connman_element_stop();
__connman_plugin_cleanup();
__connman_task_cleanup();
__connman_udev_cleanup();
__connman_rtnl_cleanup();
__connman_ipconfig_cleanup();
__connman_resolver_cleanup();
__connman_profile_cleanup();
__connman_manager_cleanup();
__connman_agent_cleanup();
__connman_element_cleanup();
__connman_storage_cleanup();
__connman_dbus_cleanup();
selftest:
__connman_log_cleanup();
dbus_connection_unref(conn);
g_main_loop_unref(main_loop);
return 0;
}
int
main (int argc,
char **argv)
{
GError *error;
GOptionContext *opt_context;
gint ret;
guint name_owner_id;
guint sigint_id;
ret = 1;
loop = NULL;
opt_context = NULL;
name_owner_id = 0;
sigint_id = 0;
/* Ignore SIGPIPE, it's not useful in daemons */
signal (SIGPIPE, SIG_IGN);
g_type_init ();
g_setenv ("GIO_USE_PROXY_RESOLVER", "dummy", TRUE);
/* avoid gvfs (http://bugzilla.gnome.org/show_bug.cgi?id=526454) */
if (!g_setenv ("GIO_USE_VFS", "local", TRUE))
{
g_printerr ("Error setting GIO_USE_GVFS\n");
goto out;
}
opt_context = g_option_context_new ("cockpit storage 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_printerr ("Error parsing options: %s\n", error->message);
g_error_free (error);
goto out;
}
if (g_getenv ("PATH") == NULL)
g_setenv ("PATH", "/usr/bin:/bin:/usr/sbin:/sbin", TRUE);
cockpit_set_journal_logging (!isatty (2));
g_info ("cockpit daemon version %s starting", PACKAGE_VERSION);
loop = g_main_loop_new (NULL, FALSE);
sigint_id = 0;
if (!opt_no_sigint)
{
sigint_id = g_unix_signal_add_full (G_PRIORITY_DEFAULT,
SIGINT,
on_sigint,
NULL, /* user_data */
NULL); /* GDestroyNotify */
}
name_owner_id = g_bus_own_name (G_BUS_TYPE_SESSION,
"com.redhat.Cockpit",
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_main_loop_run (loop);
ret = 0;
out:
if (sigint_id > 0)
g_source_remove (sigint_id);
if (the_daemon != NULL)
g_object_unref (the_daemon);
if (name_owner_id != 0)
g_bus_unown_name (name_owner_id);
if (loop != NULL)
g_main_loop_unref (loop);
if (opt_context != NULL)
g_option_context_free (opt_context);
g_info ("cockpit daemon version %s exiting", PACKAGE_VERSION);
return ret;
}
int
main (AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char *argv[])
{
GMainLoop *loop = NULL;
const AvahiPoll *poll_api;
AvahiGLibPoll *glib_poll;
AvahiClient *client;
struct timeval tv;
const char *version;
int error;
/* Optional: Tell avahi to use g_malloc and g_free */
avahi_set_allocator (avahi_glib_allocator ());
/* Create the GLIB main loop */
loop = g_main_loop_new (NULL, FALSE);
/* Create the GLIB Adaptor */
glib_poll = avahi_glib_poll_new (NULL, G_PRIORITY_DEFAULT);
poll_api = avahi_glib_poll_get (glib_poll);
/* Example, schedule a timeout event with the Avahi API */
avahi_elapse_time (&tv, /* timeval structure */
1000, /* 1 second */
0); /* "jitter" - Random additional delay from 0 to this value */
poll_api->timeout_new (poll_api, /* The AvahiPoll object */
&tv, /* struct timeval indicating when to go activate */
avahi_timeout_event, /* Pointer to function to call */
NULL); /* User data to pass to function */
/* Schedule a timeout event with the glib api */
g_timeout_add (5000, /* 5 seconds */
avahi_timeout_event_glib, /* Pointer to function callback */
loop); /* User data to pass to function */
/* Create a new AvahiClient instance */
client = avahi_client_new (poll_api, /* AvahiPoll object from above */
0,
avahi_client_callback, /* Callback function for Client state changes */
loop, /* User data */
&error); /* Error return */
/* Check the error return code */
if (client == NULL)
{
/* Print out the error string */
g_warning ("Error initializing Avahi: %s", avahi_strerror (error));
goto fail;
}
/* Make a call to get the version string from the daemon */
version = avahi_client_get_version_string (client);
/* Check if the call suceeded */
if (version == NULL)
{
g_warning ("Error getting version string: %s", avahi_strerror (avahi_client_errno (client)));
goto fail;
}
g_message ("Avahi Server Version: %s", version);
/* Start the GLIB Main Loop */
g_main_loop_run (loop);
fail:
/* Clean up */
g_main_loop_unref (loop);
avahi_client_free (client);
avahi_glib_poll_free (glib_poll);
return 0;
}
int
main(int argc, char **argv)
{
bool retVal;
int opt;
bool invertCarrier = false;
LSPalmService * lsps = NULL;
while ((opt = getopt(argc, argv, "chdst")) != -1)
{
switch (opt) {
case 'c':
invertCarrier = true;
break;
case 'd':
setLogLevel(G_LOG_LEVEL_DEBUG);
break;
case 's':
setUseSyslog(true);
break;
case 'h':
default:
PrintUsage(argv[0]);
return EXIT_SUCCESS;
}
}
// make sure we aren't already running.
if (!LockProcess("storaged")) {
g_error("%s: %s daemon is already running.\n", __func__, argv[0]);
exit(EXIT_FAILURE);
}
g_log_set_default_handler(logFilter, NULL);
g_debug( "entering %s in %s", __func__, __FILE__ );
signal(SIGTERM, term_handler);
g_mainloop = g_main_loop_new(NULL, FALSE);
int ret = nyx_device_open(NYX_DEVICE_SYSTEM, "Main", &nyxSystem);
if(ret != NYX_ERROR_NONE)
{
g_critical("Unable to open the nyx device system");
abort();
}
else
g_debug("Initialized nyx system device");
/**
* initialize the lunaservice and we want it before all the init
* stuff happening.
*/
LSError lserror;
LSErrorInit(&lserror);
retVal = LSRegisterPalmService("com.palm.storage", &lsps, &lserror);
if (!retVal)
{
g_critical ("failed in function %s with erro %s", lserror.func, lserror.message);
LSErrorFree(&lserror);
return EXIT_FAILURE;
}
SignalsInit( lsps );
LSHandle *lsh_priv = LSPalmServiceGetPrivateConnection(lsps);
LSHandle *lsh_pub = LSPalmServiceGetPublicConnection(lsps);
DiskModeInterfaceInit( g_mainloop, lsh_priv, lsh_pub, invertCarrier );
EraseInit(g_mainloop, lsh_priv);
retVal = LSGmainAttach( lsh_priv, g_mainloop, &lserror );
if ( !retVal )
{
g_critical( "LSGmainAttach private returned %s", lserror.message );
LSErrorFree(&lserror);
}
retVal = LSGmainAttach( lsh_pub, g_mainloop, &lserror );
if ( !retVal )
{
g_critical( "LSGmainAttach public returned %s", lserror.message );
LSErrorFree(&lserror);
}
g_main_loop_run(g_mainloop);
g_main_loop_unref(g_mainloop);
if (!LSUnregister( lsh_priv, &lserror)) {
g_critical( "LSUnregister private returned %s", lserror.message );
}
if (!LSUnregister( lsh_pub, &lserror)) {
g_critical( "LSUnregister public returned %s", lserror.message );
}
UnlockProcess();
g_debug( "exiting %s in %s", __func__, __FILE__ );
if (!retVal)
return EXIT_FAILURE;
else
return EXIT_SUCCESS;
}
int
main (int argc,
char *argv[])
{
gint ret = 1;
CockpitWebServer *server = NULL;
GOptionContext *context;
CockpitHandlerData data;
GTlsCertificate *certificate = NULL;
GError *local_error = NULL;
GError **error = &local_error;
gchar **roots = NULL;
gchar *cert_path = NULL;
GMainLoop *loop = NULL;
gchar *login_html = NULL;
gchar *login_po_html = NULL;
CockpitPipe *pipe = NULL;
int outfd = -1;
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);
/* Any interaction with a krb5 ccache should be explicit */
g_setenv ("KRB5CCNAME", "FILE:/dev/null", TRUE);
g_setenv ("G_TLS_GNUTLS_PRIORITY", "SECURE128:%LATEST_RECORD_VERSION:-VERS-SSL3.0:-VERS-TLS1.0", FALSE);
memset (&data, 0, sizeof (data));
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, cmd_entries, NULL);
if (!g_option_context_parse (context, &argc, &argv, error))
{
goto out;
}
if (opt_version)
{
print_version ();
ret = 0;
goto out;
}
/*
* 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_printerr ("ws couldn't redirect stdout to stderr");
if (outfd > -1)
close (outfd);
goto out;
}
cockpit_set_journal_logging (NULL, !isatty (2));
if (opt_local_session || opt_no_tls)
{
/* no certificate */
}
else
{
cert_path = cockpit_certificate_locate (FALSE, error);
if (cert_path != NULL)
certificate = cockpit_certificate_load (cert_path, error);
if (certificate == NULL)
goto out;
g_info ("Using certificate: %s", cert_path);
}
loop = g_main_loop_new (NULL, FALSE);
data.os_release = cockpit_system_load_os_release ();
data.auth = cockpit_auth_new (opt_local_ssh);
roots = setup_static_roots (data.os_release);
data.branding_roots = (const gchar **)roots;
login_html = g_strdup (DATADIR "/cockpit/static/login.html");
data.login_html = (const gchar *)login_html;
login_po_html = g_strdup (DATADIR "/cockpit/static/login.po.html");
data.login_po_html = (const gchar *)login_po_html;
server = cockpit_web_server_new (opt_address,
opt_port,
certificate,
NULL,
error);
if (server == NULL)
{
g_prefix_error (error, "Error starting web server: ");
goto out;
}
cockpit_web_server_set_redirect_tls (server, !cockpit_conf_bool ("WebService", "AllowUnencrypted", FALSE));
if (cockpit_conf_string ("WebService", "UrlRoot"))
{
g_object_set (server, "url-root",
cockpit_conf_string ("WebService", "UrlRoot"),
NULL);
}
if (cockpit_web_server_get_socket_activated (server))
g_signal_connect_swapped (data.auth, "idling", G_CALLBACK (g_main_loop_quit), loop);
/* Ignores stuff it shouldn't handle */
g_signal_connect (server, "handle-stream",
G_CALLBACK (cockpit_handler_socket), &data);
/* External channels, ignore stuff they shouldn't handle */
g_signal_connect (server, "handle-stream",
G_CALLBACK (cockpit_handler_external), &data);
/* Don't redirect to TLS for /ping */
g_object_set (server, "ssl-exception-prefix", "/ping", NULL);
g_signal_connect (server, "handle-resource::/ping",
G_CALLBACK (cockpit_handler_ping), &data);
/* Files that cannot be cache-forever, because of well known names */
g_signal_connect (server, "handle-resource::/favicon.ico",
G_CALLBACK (cockpit_handler_root), &data);
g_signal_connect (server, "handle-resource::/apple-touch-icon.png",
G_CALLBACK (cockpit_handler_root), &data);
/* The fallback handler for everything else */
g_signal_connect (server, "handle-resource",
G_CALLBACK (cockpit_handler_default), &data);
if (opt_local_session)
{
struct passwd *pwd;
if (g_str_equal (opt_local_session, "-"))
{
pipe = cockpit_pipe_new (opt_local_session, 0, outfd);
outfd = -1;
}
else
{
const gchar *args[] = { opt_local_session, NULL };
pipe = cockpit_pipe_spawn (args, NULL, NULL, COCKPIT_PIPE_FLAGS_NONE);
}
/* Spawn a local session as a bridge */
pwd = getpwuid (geteuid ());
if (!pwd)
{
g_printerr ("Failed to resolve current user id %u\n", geteuid ());
goto out;
}
cockpit_auth_local_async (data.auth, pwd->pw_name, pipe, on_local_ready, g_object_ref (server));
g_object_unref (pipe);
}
else
{
/* When no local bridge, start serving immediately */
cockpit_web_server_start (server);
}
/* Debugging issues during testing */
#if WITH_DEBUG
signal (SIGABRT, cockpit_test_signal_backtrace);
signal (SIGSEGV, cockpit_test_signal_backtrace);
#endif
g_main_loop_run (loop);
ret = 0;
out:
if (outfd >= 0)
close (outfd);
if (loop)
g_main_loop_unref (loop);
if (local_error)
{
g_printerr ("cockpit-ws: %s\n", local_error->message);
g_error_free (local_error);
}
g_clear_object (&server);
g_clear_object (&data.auth);
if (data.os_release)
g_hash_table_unref (data.os_release);
g_clear_object (&certificate);
g_free (cert_path);
g_strfreev (roots);
g_free (login_po_html);
g_free (login_html);
g_free (opt_address);
g_free (opt_local_session);
cockpit_conf_cleanup ();
return ret;
}
int
main (int argc, char *argv[])
{
App *app = &s_app;
GError *error = NULL;
GstBus *bus;
gst_init (&argc, &argv);
GST_DEBUG_CATEGORY_INIT (appsrc_playbin_debug, "appsrc-playbin", 0,
"appsrc playbin example");
if (argc < 2) {
g_print ("usage: %s <filename>\n", argv[0]);
return -1;
}
/* try to open the file as an mmapped file */
app->file = g_mapped_file_new (argv[1], FALSE, &error);
if (error) {
g_print ("failed to open file: %s\n", error->message);
g_error_free (error);
return -2;
}
/* get some vitals, this will be used to read data from the mmapped file and
* feed it to appsrc. */
app->length = g_mapped_file_get_length (app->file);
app->data = (guint8 *) g_mapped_file_get_contents (app->file);
app->offset = 0;
/* create a mainloop to get messages */
app->loop = g_main_loop_new (NULL, TRUE);
app->playbin = gst_element_factory_make ("playbin2", NULL);
g_assert (app->playbin);
bus = gst_pipeline_get_bus (GST_PIPELINE (app->playbin));
/* add watch for messages */
gst_bus_add_watch (bus, (GstBusFunc) bus_message, app);
/* set to read from appsrc */
g_object_set (app->playbin, "uri", "appsrc://", NULL);
/* get notification when the source is created so that we get a handle to it
* and can configure it */
g_signal_connect (app->playbin, "deep-notify::source",
(GCallback) found_source, app);
/* go to playing and wait in a mainloop. */
gst_element_set_state (app->playbin, GST_STATE_PLAYING);
/* this mainloop is stopped when we receive an error or EOS */
g_main_loop_run (app->loop);
GST_DEBUG ("stopping");
gst_element_set_state (app->playbin, GST_STATE_NULL);
/* free the file */
g_mapped_file_free (app->file);
gst_object_unref (bus);
g_main_loop_unref (app->loop);
return 0;
}
GST_END_TEST
GST_START_TEST (check_emit_encoded_media)
{
guint bus_watch_id1, bus_watch_id2;
GstBus *srcbus, *testbus;
GstCaps *caps;
GST_INFO ("Running test check_push_buffer");
loop = g_main_loop_new (NULL, FALSE);
/* Create source pipeline */
src_pipeline = gst_pipeline_new ("src-pipeline");
uridecodebin = gst_element_factory_make ("uridecodebin", NULL);
appsink = gst_element_factory_make ("appsink", NULL);
srcbus = gst_pipeline_get_bus (GST_PIPELINE (src_pipeline));
bus_watch_id1 = gst_bus_add_watch (srcbus, gst_bus_async_signal_func, NULL);
g_signal_connect (srcbus, "message", G_CALLBACK (bus_msg_cb), src_pipeline);
g_object_unref (srcbus);
gst_bin_add_many (GST_BIN (src_pipeline), uridecodebin, appsink, NULL);
caps = gst_caps_new_any ();
g_object_set (G_OBJECT (uridecodebin), "uri", VIDEO_PATH, "caps", caps, NULL);
gst_caps_unref (caps);
g_signal_connect (G_OBJECT (uridecodebin), "pad-added", G_CALLBACK (link_pad),
appsink);
g_object_set (appsink, "emit-signals", TRUE, NULL);
g_signal_connect (appsink, "new-sample", G_CALLBACK (post_recv_sample), NULL);
g_signal_connect (appsink, "eos", G_CALLBACK (appsink_eos_cb), NULL);
/* Create test pipeline */
test_pipeline = gst_pipeline_new ("test-pipeline");
httpep = gst_element_factory_make ("httppostendpoint", NULL);
g_object_set (httpep, "use-encoded-media", TRUE, NULL);
testbus = gst_pipeline_get_bus (GST_PIPELINE (test_pipeline));
bus_watch_id2 = gst_bus_add_watch (testbus, gst_bus_async_signal_func, NULL);
g_signal_connect (testbus, "message", G_CALLBACK (bus_msg_cb), test_pipeline);
g_object_unref (testbus);
gst_bin_add (GST_BIN (test_pipeline), httpep);
g_signal_connect (G_OBJECT (httpep), "eos", G_CALLBACK (http_eos_cb), NULL);
/* Set pipeline to start state */
gst_element_set_state (test_pipeline, GST_STATE_PLAYING);
g_object_get (G_OBJECT (httpep), "http-method", &method, NULL);
GST_INFO ("Http end point configured as %d", method);
mark_point ();
g_timeout_add_seconds (WAIT_TIMEOUT, timer_cb, NULL);
g_main_loop_run (loop);
mark_point ();
GST_DEBUG ("Main loop stopped");
GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS (GST_BIN (src_pipeline),
GST_DEBUG_GRAPH_SHOW_ALL, "src_after_main_loop");
GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS (GST_BIN (test_pipeline),
GST_DEBUG_GRAPH_SHOW_ALL, "test_after_main_loop");
gst_element_set_state (src_pipeline, GST_STATE_NULL);
gst_object_unref (GST_OBJECT (src_pipeline));
gst_element_set_state (test_pipeline, GST_STATE_NULL);
gst_object_unref (GST_OBJECT (test_pipeline));
g_source_remove (bus_watch_id1);
g_source_remove (bus_watch_id2);
g_main_loop_unref (loop);
}
gint
main (gint argc,
gchar *argv[])
{
GstStateChangeReturn ret;
GstElement *pipeline, *filesrc, *decoder, *filter, *sink;
GstElement *convert1, *convert2, *resample;
GMainLoop *loop;
GstBus *bus;
guint watch_id;
/* initialization */
gst_init (&argc, &argv);
loop = g_main_loop_new (NULL, FALSE);
if (argc != 2) {
g_print ("Usage: %s <mp3 filename>\n", argv[0]);
return 01;
}
/* create elements */
pipeline = gst_pipeline_new ("my_pipeline");
/* watch for messages on the pipeline's bus (note that this will only
* work like this when a GLib main loop is running) */
bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
watch_id = gst_bus_add_watch (bus, bus_call, loop);
gst_object_unref (bus);
filesrc = gst_element_factory_make ("filesrc", "my_filesource");
decoder = gst_element_factory_make ("mad", "my_decoder");
/* putting an audioconvert element here to convert the output of the
* decoder into a format that my_filter can handle (we are assuming it
* will handle any sample rate here though) */
convert1 = gst_element_factory_make ("audioconvert", "audioconvert1");
/* use "identity" here for a filter that does nothing */
filter = gst_element_factory_make ("myfilter", "my_filter");
/* there should always be audioconvert and audioresample elements before
* the audio sink, since the capabilities of the audio sink usually vary
* depending on the environment (output used, sound card, driver etc.) */
convert2 = gst_element_factory_make ("audioconvert", "audioconvert2");
resample = gst_element_factory_make ("audioresample", "audioresample");
sink = gst_element_factory_make ("pulsesink", "audiosink");
if (!sink || !decoder) {
g_print ("Decoder or output could not be found - check your install\n");
return -1;
} else if (!convert1 || !convert2 || !resample) {
g_print ("Could not create audioconvert or audioresample element, "
"check your installation\n");
return -1;
} else if (!filter) {
g_print ("Your self-written filter could not be found. Make sure it "
"is installed correctly in $(libdir)/gstreamer-1.0/ or "
"~/.gstreamer-1.0/plugins/ and that gst-inspect-1.0 lists it. "
"If it doesn't, check with 'GST_DEBUG=*:2 gst-inspect-1.0' for "
"the reason why it is not being loaded.");
return -1;
}
g_object_set (G_OBJECT (filesrc), "location", argv[1], NULL);
gst_bin_add_many (GST_BIN (pipeline), filesrc, decoder, convert1, filter,
convert2, resample, sink, NULL);
/* link everything together */
if (!gst_element_link_many (filesrc, decoder, convert1, filter, convert2,
resample, sink, NULL)) {
g_print ("Failed to link one or more elements!\n");
return -1;
}
/* run */
ret = gst_element_set_state (pipeline, GST_STATE_PLAYING);
if (ret == GST_STATE_CHANGE_FAILURE) {
GstMessage *msg;
g_print ("Failed to start up pipeline!\n");
/* check if there is an error message with details on the bus */
msg = gst_bus_poll (bus, GST_MESSAGE_ERROR, 0);
if (msg) {
GError *err = NULL;
gst_message_parse_error (msg, &err, NULL);
g_print ("ERROR: %s\n", err->message);
g_error_free (err);
gst_message_unref (msg);
}
return -1;
}
g_main_loop_run (loop);
/* clean up */
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_object_unref (pipeline);
g_source_remove (watch_id);
g_main_loop_unref (loop);
return 0;
}
int
main (int argc, char **argv)
{
GError *err = NULL;
GstDiscoverer *dc;
gint timeout = 10;
GOptionEntry options[] = {
{"async", 'a', 0, G_OPTION_ARG_NONE, &async,
"Run asynchronously", NULL},
{"silent", 's', 0, G_OPTION_ARG_NONE, &silent,
"Don't output the information structure", NULL},
{"timeout", 't', 0, G_OPTION_ARG_INT, &timeout,
"Specify timeout (in seconds, default 10)", "T"},
/* {"elem", 'e', 0, G_OPTION_ARG_NONE, &elem_seek, */
/* "Seek on elements instead of pads", NULL}, */
{"verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose,
"Verbose properties", NULL},
{NULL}
};
GOptionContext *ctx;
if (!g_thread_supported ())
g_thread_init (NULL);
ctx =
g_option_context_new
("- discover files synchronously with GstDiscoverer");
g_option_context_add_main_entries (ctx, options, NULL);
g_option_context_add_group (ctx, gst_init_get_option_group ());
if (!g_option_context_parse (ctx, &argc, &argv, &err)) {
g_print ("Error initializing: %s\n", err->message);
exit (1);
}
g_option_context_free (ctx);
if (argc < 2) {
g_print ("usage: %s <uris>\n", argv[0]);
exit (-1);
}
dc = gst_discoverer_new (timeout * GST_SECOND, &err);
if (G_UNLIKELY (dc == NULL)) {
g_print ("Error initializing: %s\n", err->message);
exit (1);
}
if (async == FALSE) {
gint i;
for (i = 1; i < argc; i++)
process_file (dc, argv[i]);
} else {
PrivStruct *ps = g_new0 (PrivStruct, 1);
GMainLoop *ml = g_main_loop_new (NULL, FALSE);
ps->dc = dc;
ps->argc = argc;
ps->argv = argv;
/* adding uris will be started when the mainloop runs */
g_idle_add ((GSourceFunc) _run_async, ps);
/* connect signals */
g_signal_connect (dc, "discovered", G_CALLBACK (_new_discovered_uri), NULL);
g_signal_connect (dc, "finished", G_CALLBACK (_discoverer_finished), ml);
gst_discoverer_start (dc);
/* run mainloop */
g_main_loop_run (ml);
gst_discoverer_stop (dc);
g_free (ps);
g_main_loop_unref (ml);
}
g_object_unref (dc);
return 0;
}
int
main(int argc, char *argv[])
{
GOptionContext *context;
GError *error = NULL;
memset (&the_rebinder, 0, sizeof (Rebinder));
g_type_init ();
/* Options */
context = g_option_context_new ("- key rebinder");
g_option_context_add_main_entries (context, entries, NULL);
if (!g_option_context_parse (context, &argc, &argv, &error))
{
g_print ("Failed to parse options: %s\n", error->message);
g_error_free (error);
return EXIT_FAILURE;
}
#ifdef REBINDER_ENABLE_DEBUG
rebinder_debug_init ();
#endif
if (opt_configure)
{
/* lauched in configuration mode */
if (request_dbus_name (MEX_REBINDER_CONFIGURE_DBUS_INTERFACE) == FALSE)
{
g_message ("Could not request DBus name");
return EXIT_SUCCESS;
}
clutter_init (&argc, &argv);
/* we expect to be build against clutter-glx */
the_rebinder.dpy = clutter_x11_get_default_display ();
the_rebinder.config = rebinder_configure (&the_rebinder,
NULL,
is_evdev_enabled (),
is_fullscreen_enabled ());
clutter_main ();
rebinder_configure_free (the_rebinder.config);
}
else
{
/* launched in daemon mode */
MexRebinder *rebinder;
gboolean registered;
rebinder = mex_rebinder_new ();
registered = mex_rebinder_register (rebinder,
MEX_REBINDER_DBUS_INTERFACE,
MEX_REBINDER_DBUS_PATH,
&error);
if (registered == FALSE)
{
const gchar prefix[] = "Could not request DBus name";
if (error)
g_message ("%s: %s", prefix, error->message);
else
g_message ("%s", prefix);
return EXIT_FAILURE;
}
g_signal_connect (rebinder, "quit",
G_CALLBACK (on_rebinder_quit), &the_rebinder);
the_rebinder.dpy = XOpenDisplay (NULL);
if (G_UNLIKELY (the_rebinder.dpy == NULL))
{
g_error ("Could not open display");
return EXIT_FAILURE;
}
the_rebinder.fake = fakekey_init (the_rebinder.dpy);
if (G_UNLIKELY (the_rebinder.fake == NULL))
{
g_error ("Could not initialize fakekey");
return EXIT_FAILURE;
}
if (opt_no_daemon == FALSE)
daemon (0, 0);
signal (SIGINT, on_int_term_signaled);
signal (SIGTERM, on_int_term_signaled);
the_rebinder.original_bindings =
g_array_new (FALSE, FALSE, sizeof (Binding));
/* listens to evdev events and setup everything needed */
if (is_evdev_enabled ())
{
the_rebinder.evdev_manager = rebinder_evdev_manager_get_default ();
rebinder_evdev_manager_set_key_notifier (the_rebinder.evdev_manager,
on_evdev_key_pressed,
&the_rebinder);
the_rebinder.evdev_bindings =
g_ptr_array_new_with_free_func (free_binding);
}
load_bindings (&the_rebinder);
setup_monitor (&the_rebinder);
the_rebinder.mainloop = g_main_loop_new (NULL, TRUE);
g_main_loop_run (the_rebinder.mainloop);
restore_bindings (&the_rebinder);
g_main_loop_unref (the_rebinder.mainloop);
g_object_unref (the_rebinder.monitor);
}
return EXIT_SUCCESS;
}
static void
test_pipeline (const char *pipeline)
{
GstElement *bin, *sink;
GstPad *pad, *sinkpad;
GstBus *bus;
GError *error = NULL;
GMainLoop *loop;
GstPadLinkReturn linkret;
guint bus_watch = 0;
bin = gst_parse_launch (pipeline, &error);
fail_unless (bin != NULL, "Error parsing pipeline: %s",
error ? error->message : "(invalid error)");
pad = gst_bin_find_unlinked_pad (GST_BIN (bin), GST_PAD_SRC);
fail_unless (pad != NULL, "Could not locate free src pad");
/* connect the fake sink */
sink = gst_element_factory_make ("fakesink", "fake_sink");
fail_unless (sink != NULL, "Could create fakesink");
fail_unless (gst_bin_add (GST_BIN (bin), sink), "Could not insert fakesink");
sinkpad = gst_element_get_static_pad (sink, "sink");
fail_unless (sinkpad != NULL, "Could not get fakesink src pad");
linkret = gst_pad_link (pad, sinkpad);
fail_unless (GST_PAD_LINK_SUCCESSFUL (linkret),
"Could not link to fake sink");
gst_object_unref (sinkpad);
/* run until we receive EOS */
loop = g_main_loop_new (NULL, FALSE);
bus = gst_element_get_bus (bin);
bus_watch = gst_bus_add_watch (bus, (GstBusFunc) eos_watch, loop);
gst_object_unref (bus);
start_pipeline (bin, pad);
g_main_loop_run (loop);
/* we're EOS now; make sure oggmux out caps have stream headers on them */
{
GstStructure *s;
GstCaps *muxcaps;
muxcaps = gst_pad_get_negotiated_caps (sinkpad);
fail_unless (muxcaps != NULL);
s = gst_caps_get_structure (muxcaps, 0);
fail_unless (gst_structure_has_name (s, "application/ogg"));
fail_unless (gst_structure_has_field (s, "streamheader"));
fail_unless (gst_structure_has_field_typed (s, "streamheader",
GST_TYPE_ARRAY));
gst_caps_unref (muxcaps);
}
stop_pipeline (bin, pad);
/* clean up */
g_main_loop_unref (loop);
g_source_remove (bus_watch);
gst_object_unref (pad);
gst_object_unref (bin);
}
int main(int argc, char *argv[])
{
GOptionContext *context;
GError *err = NULL;
guint signal;
set_version();
context = g_option_context_new(NULL);
g_option_context_add_main_entries(context, options, NULL);
if (g_option_context_parse(context, &argc, &argv, &err) == FALSE) {
if (err != NULL) {
g_printerr("%s\n", err->message);
g_error_free(err);
} else
g_printerr("An unknown error occurred\n");
exit(EXIT_FAILURE);
}
g_option_context_free(context);
if (option_version == TRUE) {
printf("%s\n", VERSION);
exit(EXIT_SUCCESS);
}
signal = setup_signalfd();
if (!signal)
return EXIT_FAILURE;
if (option_dbg || option_mgmt_dbg)
__btd_log_init("*", 0);
else
__btd_log_init(NULL, 0);
if (!set_capabilities()) {
__btd_log_cleanup();
g_source_remove(signal);
return EXIT_FAILURE;
}
quit_timeout = g_timeout_add_seconds(STARTUP_GRACE_SECONDS,
quit_eventloop, NULL);
if (quit_timeout == 0) {
error("Failed to init startup timeout");
__btd_log_cleanup();
g_source_remove(signal);
return EXIT_FAILURE;
}
if (!bt_bluetooth_start(option_index, option_mgmt_dbg, adapter_ready)) {
__btd_log_cleanup();
g_source_remove(quit_timeout);
g_source_remove(signal);
return EXIT_FAILURE;
}
/* Use params: mtu = 0, flags = 0 */
start_sdp_server(0, 0);
DBG("Entering main loop");
event_loop = g_main_loop_new(NULL, FALSE);
g_main_loop_run(event_loop);
g_source_remove(signal);
if (quit_timeout > 0)
g_source_remove(quit_timeout);
cleanup_services();
stop_sdp_server();
bt_bluetooth_cleanup();
g_main_loop_unref(event_loop);
/* If no adapter was initialized, hal_ipc is NULL */
if (hal_ipc) {
ipc_unregister(hal_ipc, HAL_SERVICE_ID_CORE);
ipc_cleanup(hal_ipc);
}
info("Exit");
__btd_log_cleanup();
free(config_vendor);
free(config_model);
free(config_name);
free(config_serial);
free(config_fw_rev);
free(config_hw_rev);
return EXIT_SUCCESS;
}
