void wxWebViewWebKit::SetupWebExtensionServer()
{
char *address = g_strdup_printf("unix:tmpdir=%s", g_get_tmp_dir());
char *guid = g_dbus_generate_guid();
GDBusAuthObserver *observer = g_dbus_auth_observer_new();
GError *error = NULL;
g_signal_connect(observer, "authorize-authenticated-peer",
G_CALLBACK(wxgtk_authorize_authenticated_peer_cb), this);
m_dbusServer = g_dbus_server_new_sync(address,
G_DBUS_SERVER_FLAGS_NONE,
guid,
observer,
NULL,
&error);
if (error)
{
g_warning("Failed to start web extension server on %s: %s", address, error->message);
g_error_free(error);
}
else
{
g_signal_connect(m_dbusServer, "new-connection",
G_CALLBACK(wxgtk_new_connection_cb), &m_extension);
g_dbus_server_start(m_dbusServer);
}
g_free(address);
g_free(guid);
g_object_unref(observer);
}
/**
* @brief Initializing the GstSwitchController.
* @memberof GstSwitchController
* @see GObject
*/
static void
gst_switch_controller_init (GstSwitchController * controller)
{
gchar *guid = g_dbus_generate_guid ();
GDBusServerFlags flags = G_DBUS_SERVER_FLAGS_NONE;
GError *error = NULL;
g_mutex_init (&controller->clients_lock);
controller->clients = NULL;
flags |= G_DBUS_SERVER_FLAGS_RUN_IN_THREAD;
flags |= G_DBUS_SERVER_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS;
controller->bus_server =
g_dbus_server_new_sync (opts.controller_address, flags, guid,
/* GDBusAuthObserver */ NULL, /* GCancellable */ NULL, &error);
if (error != NULL) {
g_error ("failed to register controller: %s", error->message);
}
g_assert (controller->bus_server != NULL);
g_free (guid);
INFO ("Controller is listening at: %s",
g_dbus_server_get_client_address (controller->bus_server));
g_signal_connect (controller->bus_server, "new-connection",
G_CALLBACK (gst_switch_controller_on_new_connection), controller);
g_dbus_server_start (controller->bus_server);
return;
}
void
bus_server_init (void)
{
dbus = bus_dbus_impl_get_default ();
ibus = bus_ibus_impl_get_default ();
bus_dbus_impl_register_object (dbus, (IBusService *)ibus);
/* init server */
GDBusServerFlags flags = G_DBUS_SERVER_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS;
gchar *guid = g_dbus_generate_guid ();
server = g_dbus_server_new_sync (
g_address, /* the place where the socket file lives, e.g. /tmp, abstract namespace, etc. */
flags, guid,
NULL /* observer */,
NULL /* cancellable */,
NULL /* error */);
g_free (guid);
g_signal_connect (server, "new-connection", G_CALLBACK (bus_new_connection_cb), NULL);
g_dbus_server_start (server);
address = g_strdup_printf ("%s,guid=%s",
g_dbus_server_get_client_address (server),
g_dbus_server_get_guid (server));
/* write address to file */
ibus_write_address (address);
/* own a session bus name so that third parties can easily track our life-cycle */
g_bus_own_name (G_BUS_TYPE_SESSION, IBUS_SERVICE_IBUS, G_BUS_NAME_OWNER_FLAGS_NONE,
NULL, NULL, NULL, NULL, NULL);
}
/**
* Initialize the dbus proxy by watching for appearing dbus name.
*/
const char *ext_proxy_init(void)
{
char *address, *guid;
GDBusAuthObserver *observer;
GError *error = NULL;
address = g_strdup_printf("unix:tmpdir=%s", g_get_tmp_dir());
guid = g_dbus_generate_guid();
observer = g_dbus_auth_observer_new();
g_signal_connect(observer, "authorize-authenticated-peer",
G_CALLBACK(on_authorize_authenticated_peer), NULL);
/* Use sync call because server must be starte before the web extension
* attempt to connect */
dbusserver = g_dbus_server_new_sync(address, G_DBUS_SERVER_FLAGS_NONE,
guid, observer, NULL, &error);
if (error) {
g_warning("Failed to start web extension server on %s: %s", address, error->message);
g_error_free(error);
goto out;
}
g_signal_connect(dbusserver, "new-connection", G_CALLBACK(on_new_connection), NULL);
g_dbus_server_start(dbusserver);
out:
g_free(address);
g_free(guid);
g_object_unref(observer);
return g_dbus_server_get_client_address(dbusserver);
}
static void
ide_worker_manager_constructed (GObject *object)
{
IdeWorkerManager *self = (IdeWorkerManager *)object;
g_autofree gchar *guid = NULL;
g_autofree gchar *address = NULL;
GError *error = NULL;
g_assert (IDE_IS_WORKER_MANAGER (self));
G_OBJECT_CLASS (ide_worker_manager_parent_class)->constructed (object);
if (g_unix_socket_address_abstract_names_supported ())
{
address = g_strdup_printf ("unix:abstract=/tmp/gnome-builder-%u", (int)getpid ());
}
else
{
g_autofree gchar *tmpdir = NULL;
tmpdir = g_dir_make_tmp ("gnome-builder-worker-XXXXXX", NULL);
if (tmpdir == NULL)
{
g_error ("Failed to determine temporary directory for DBus.");
exit (EXIT_FAILURE);
}
address = g_strdup_printf ("unix:tmpdir=%s", tmpdir);
}
guid = g_dbus_generate_guid ();
self->dbus_server = g_dbus_server_new_sync (address,
G_DBUS_SERVER_FLAGS_NONE,
guid,
NULL,
NULL,
&error);
if (error != NULL)
{
g_error ("%s", error->message);
exit (EXIT_FAILURE);
}
g_signal_connect_object (self->dbus_server,
"new-connection",
G_CALLBACK (ide_worker_manager_new_connection_cb),
self,
G_CONNECT_SWAPPED);
IDE_TRACE_MSG ("GDBusServer listening at %s", address);
g_dbus_server_start (self->dbus_server);
g_assert (g_dbus_server_is_active (self->dbus_server));
}
void
bus_server_init (void)
{
GError *error = NULL;
dbus = bus_dbus_impl_get_default ();
ibus = bus_ibus_impl_get_default ();
bus_dbus_impl_register_object (dbus, (IBusService *)ibus);
/* init server */
GDBusServerFlags flags = G_DBUS_SERVER_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS;
gchar *guid = g_dbus_generate_guid ();
if (!g_str_has_prefix (g_address, "unix:tmpdir=") &&
!g_str_has_prefix (g_address, "unix:path=")) {
g_error ("Your socket address does not have the format unix:tmpdir=$DIR "
"or unix:path=$FILE; %s", g_address);
}
server = g_dbus_server_new_sync (
g_address, /* the place where the socket file lives, e.g. /tmp, abstract namespace, etc. */
flags, guid,
NULL /* observer */,
NULL /* cancellable */,
&error);
if (server == NULL) {
g_error ("g_dbus_server_new_sync() is failed with address %s "
"and guid %s: %s",
g_address, guid, error->message);
}
g_free (guid);
g_signal_connect (server, "new-connection", G_CALLBACK (bus_new_connection_cb), NULL);
g_dbus_server_start (server);
address = g_strdup_printf ("%s,guid=%s",
g_dbus_server_get_client_address (server),
g_dbus_server_get_guid (server));
/* write address to file */
ibus_write_address (address);
/* own a session bus name so that third parties can easily track our life-cycle */
g_bus_own_name (G_BUS_TYPE_SESSION, IBUS_SERVICE_IBUS,
G_BUS_NAME_OWNER_FLAGS_NONE,
bus_acquired_handler,
NULL, NULL, NULL, NULL);
}
gboolean
_gumd_dbus_server_p2p_start (
GumdDbusServer *self)
{
g_return_val_if_fail (GUMD_IS_DBUS_SERVER_P2P (self), FALSE);
DBG("Start P2P DBus Server");
GumdDbusServerP2P *server = GUMD_DBUS_SERVER_P2P (self);
if (!server->priv->bus_server) {
GError *err = NULL;
gchar *guid = g_dbus_generate_guid ();
server->priv->bus_server = g_dbus_server_new_sync (
server->priv->address, G_DBUS_SERVER_FLAGS_NONE, guid, NULL,
NULL, &err);
g_free (guid);
if (!server->priv->bus_server) {
WARN ("Failed to start server at address '%s':%s",
server->priv->address, err ? err->message : "NULL");
g_error_free (err);
return FALSE;
}
g_signal_connect (server->priv->bus_server, "new-connection",
G_CALLBACK(_on_client_request), server);
}
if (!g_dbus_server_is_active (server->priv->bus_server)) {
const gchar *path = NULL;
g_dbus_server_start (server->priv->bus_server);
path = g_strstr_len(server->priv->address, -1, "unix:path=") + 10;
if (path) {
if (g_chmod (path, S_IRUSR | S_IWUSR) < 0) {
WARN("Setting server socket permission failed with error '%s'",
strerror(errno));
}
}
}
DBG("Dbus server started at : %s", server->priv->address);
return TRUE;
}
static void
test_auth_mechanism (const gchar *allowed_client_mechanism,
const gchar *allowed_server_mechanism)
{
GDBusServer *server;
GMainLoop *loop;
GThread *client_thread;
TestAuthData data;
server = server_new_for_mechanism (allowed_server_mechanism);
loop = g_main_loop_new (NULL, FALSE);
g_signal_connect (server,
"new-connection",
G_CALLBACK (test_auth_on_new_connection),
loop);
g_timeout_add_seconds (5, test_auth_on_timeout, NULL);
data.allowed_client_mechanism = allowed_client_mechanism;
data.allowed_server_mechanism = allowed_server_mechanism;
data.address = g_dbus_server_get_client_address (server);
/* run the D-Bus client in a thread */
client_thread = g_thread_new ("gdbus-client-thread",
test_auth_client_thread_func,
&data);
g_dbus_server_start (server);
g_main_loop_run (loop);
g_dbus_server_stop (server);
g_thread_join (client_thread);
g_object_unref (server);
}
int
main (int argc, char *argv[])
{
GOptionContext *opt_context;
GError *error;
GMainLoop *loop;
GDBusServer *server;
gchar *guid;
GDBusServerFlags server_flags;
gchar *action;
gchar *message;
gint ret;
introspection_data = g_dbus_node_info_new_for_xml (introspection_xml, NULL);
g_assert (introspection_data != NULL);
users = g_array_new (FALSE,TRUE,sizeof (GUser));
guid = g_dbus_generate_guid ();
server_flags = G_DBUS_SERVER_FLAGS_NONE;
ret = 1;
g_type_init ();
error = NULL;
opt_context = g_option_context_new ("ksr-chat-server() usage:");
g_option_context_set_summary (opt_context,
"To start a local server located under tcp:host=0.0.0.0, use:\n"
" \"ksr-chat-server -a tcp:host=0.0.0.0\"");
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);
goto out;
}
if (!input_is_valid())
goto out;
server = g_dbus_server_new_sync (opt_address,
server_flags,
guid,
NULL, /* GDBusAuthObserver */
NULL, /* GCancellable */
&error);
g_dbus_server_start (server);
g_free (guid);
if (server == NULL)
{
g_printerr ("Error creating server at address %s: %s\n", opt_address, error->message);
g_error_free (error);
goto out;
}
g_print ("Server is listening at: %s\n", g_dbus_server_get_client_address (server));
g_signal_connect (server,
"new-connection",
G_CALLBACK (on_new_connection),
NULL);
loop = g_main_loop_new (NULL, FALSE);
g_main_loop_run (loop);
g_main_loop_unref (loop);
ret = 0;
out:
return ret;
}
int
main (int argc,
char *argv[])
{
GTestDBus *bus;
GError *error = NULL;
GOptionContext *context;
guint sig_term;
guint sig_int;
int i;
gchar *guid = NULL;
GDBusServer *direct_dbus_server = NULL;
GOptionEntry entries[] = {
{ NULL }
};
char *default_argv[] = {
"cockpit-bridge",
NULL
};
signal (SIGPIPE, SIG_IGN);
/* avoid gvfs (http://bugzilla.gnome.org/show_bug.cgi?id=526454) */
g_setenv ("GIO_USE_VFS", "local", TRUE);
g_setenv ("XDG_DATA_HOME", SRCDIR "/src/bridge/mock-resource/home", TRUE);
g_setenv ("XDG_DATA_DIRS", SRCDIR "/src/bridge/mock-resource/system", TRUE);
setup_path (argv[0]);
g_type_init ();
g_log_set_always_fatal (G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_ERROR);
sig_term = g_unix_signal_add (SIGTERM, on_signal_done, NULL);
sig_int = g_unix_signal_add (SIGINT, on_signal_done, NULL);
// System cockpit configuration file should not be loaded
cockpit_config_file = NULL;
context = g_option_context_new ("- test dbus json server");
g_option_context_add_main_entries (context, entries, NULL);
g_option_context_set_ignore_unknown_options (context, TRUE);
if (!g_option_context_parse (context, &argc, &argv, &error))
{
g_printerr ("test-server: %s\n", error->message);
exit (2);
}
/* This isolates us from affecting other processes during tests */
bus = g_test_dbus_new (G_TEST_DBUS_NONE);
g_test_dbus_up (bus);
bus_address = g_test_dbus_get_bus_address (bus);
guid = g_dbus_generate_guid ();
direct_dbus_server = g_dbus_server_new_sync ("unix:tmpdir=/tmp/dbus-tests",
G_DBUS_SERVER_FLAGS_NONE,
guid,
NULL,
NULL,
&error);
if (direct_dbus_server == NULL)
{
g_printerr ("test-server: %s\n", error->message);
exit (3);
}
/* Skip the program name */
argc--;
argv++;
if (argc == 0)
{
argc = 1;
argv = default_argv;
}
/* Null terminate the bridge command line */
bridge_argv = g_new0 (char *, argc + 1);
for (i = 0; i < argc; i++)
bridge_argv[i] = argv[i];
loop = g_main_loop_new (NULL, FALSE);
g_bus_own_name (G_BUS_TYPE_SESSION,
"com.redhat.Cockpit.DBusTests.Test",
G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT | G_BUS_NAME_OWNER_FLAGS_REPLACE,
on_bus_acquired,
on_name_acquired,
on_name_lost,
loop,
NULL);
g_bus_own_name (G_BUS_TYPE_SESSION,
"com.redhat.Cockpit.DBusTests.Second",
G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT | G_BUS_NAME_OWNER_FLAGS_REPLACE,
NULL,
on_second_acquired,
on_name_lost,
loop,
NULL);
g_signal_connect_object (direct_dbus_server,
"new-connection",
G_CALLBACK (on_new_direct_connection),
NULL, 0);
g_dbus_server_start (direct_dbus_server);
direct_address = g_dbus_server_get_client_address (direct_dbus_server);
g_main_loop_run (loop);
g_source_remove (sig_term);
g_source_remove (sig_int);
g_clear_object (&exported);
g_clear_object (&exported_b);
g_clear_object (&direct_dbus_server);
g_clear_object (&direct);
g_clear_object (&direct_b);
g_main_loop_unref (loop);
g_test_dbus_down (bus);
g_object_unref (bus);
g_free (bridge_argv);
g_free (guid);
return exit_code;
}
int
main (int argc, char **argv)
{
ServiceData svc = {0,};
GError *error = NULL;
const char *address = NULL;
char *guid;
#ifdef ENABLE_NLS
/* initialize i18n */
bindtextdomain (GETTEXT_PACKAGE, GNOMELOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#endif
g_type_init ();
gst_init (NULL, NULL);
g_set_prgname ("rhythmbox-metadata");
if (argv[1] != NULL && strcmp(argv[1], "--debug") == 0) {
argv++;
rb_debug_init (TRUE);
} else if (argv[1] != NULL && strcmp (argv[1], "--debug-match") == 0) {
rb_debug_init_match (argv[2]);
argv += 2;
} else {
rb_debug_init (FALSE);
}
/* bug report modes */
if (argv[1] != NULL && strcmp(argv[1], "--load") == 0) {
return test_load (argv[2]);
}
if (argv[1] != NULL && strcmp(argv[1], "--saveable-types") == 0) {
return test_saveable_types ();
}
if (argv[1] != NULL && strcmp (argv[1], "--external") == 0) {
argv++;
svc.external = TRUE;
}
if (argv[1] == NULL) {
address = "unix:tmpdir=/tmp";
} else {
address = argv[1];
}
rb_debug ("initializing metadata service; pid = %d; address = %s", getpid (), address);
svc.metadata = rb_metadata_new ();
svc.loop = g_main_loop_new (NULL, TRUE);
/* create the server */
guid = g_dbus_generate_guid ();
svc.server = g_dbus_server_new_sync (address,
G_DBUS_SERVER_FLAGS_NONE,
guid,
NULL,
NULL,
&error);
g_free (guid);
if (error != NULL) {
g_warning ("D-Bus server init failed: %s", error->message);
return -1;
}
/* set up interface info */
svc.node_info = g_dbus_node_info_new_for_xml (rb_metadata_iface_xml, &error);
if (error != NULL) {
g_warning ("D-Bus server init failed: %s", error->message);
return -1;
}
g_signal_connect (svc.server, "new-connection", G_CALLBACK (new_connection_cb), &svc);
g_dbus_server_start (svc.server);
/* write the server address back to the parent process */
{
const char *addr;
addr = g_dbus_server_get_client_address (svc.server);
rb_debug ("D-BUS server listening on address %s", addr);
printf ("%s\n", addr);
fflush (stdout);
}
/* run main loop until we get bored */
if (!svc.external)
g_timeout_add_seconds (ATTENTION_SPAN / 2, (GSourceFunc) electromagnetic_shotgun, &svc);
g_main_loop_run (svc.loop);
if (svc.connection) {
g_dbus_connection_close_sync (svc.connection, NULL, NULL);
g_object_unref (svc.connection);
}
g_object_unref (svc.metadata);
g_main_loop_unref (svc.loop);
g_dbus_server_stop (svc.server);
g_object_unref (svc.server);
gst_deinit ();
return 0;
}
int
main (int argc, char *argv[])
{
gint ret;
gboolean opt_server;
gchar *opt_address;
GOptionContext *opt_context;
gboolean opt_allow_anonymous;
GError *error;
GOptionEntry opt_entries[] =
{
{ "server", 's', 0, G_OPTION_ARG_NONE, &opt_server, "Start a server instead of a client", NULL },
{ "address", 'a', 0, G_OPTION_ARG_STRING, &opt_address, "D-Bus address to use", NULL },
{ "allow-anonymous", 'n', 0, G_OPTION_ARG_NONE, &opt_allow_anonymous, "Allow anonymous authentication", NULL },
{ NULL}
};
ret = 1;
g_type_init ();
opt_address = NULL;
opt_server = FALSE;
opt_allow_anonymous = FALSE;
opt_context = g_option_context_new ("peer-to-peer example");
error = NULL;
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;
}
if (opt_address == NULL)
{
g_printerr ("Incorrect usage, try --help.\n");
goto out;
}
if (!opt_server && opt_allow_anonymous)
{
g_printerr ("The --allow-anonymous option only makes sense when used with --server.\n");
goto out;
}
/* We are lazy here - we don't want to manually provide
* the introspection data structures - so we just build
* them from XML.
*/
introspection_data = g_dbus_node_info_new_for_xml (introspection_xml, NULL);
g_assert (introspection_data != NULL);
if (opt_server)
{
GDBusServer *server;
gchar *guid;
GMainLoop *loop;
GDBusServerFlags server_flags;
guid = g_dbus_generate_guid ();
server_flags = G_DBUS_SERVER_FLAGS_NONE;
if (opt_allow_anonymous)
server_flags |= G_DBUS_SERVER_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS;
error = NULL;
server = g_dbus_server_new_sync (opt_address,
server_flags,
guid,
NULL, /* GDBusAuthObserver */
NULL, /* GCancellable */
&error);
g_dbus_server_start (server);
g_free (guid);
if (server == NULL)
{
g_printerr ("Error creating server at address %s: %s\n", opt_address, error->message);
g_error_free (error);
goto out;
}
g_print ("Server is listening at: %s\n", g_dbus_server_get_client_address (server));
g_signal_connect (server,
"new-connection",
G_CALLBACK (on_new_connection),
NULL);
loop = g_main_loop_new (NULL, FALSE);
g_main_loop_run (loop);
g_object_unref (server);
g_main_loop_unref (loop);
}
else
{
GDBusConnection *connection;
const gchar *greeting_response;
GVariant *value;
gchar *greeting;
error = NULL;
connection = g_dbus_connection_new_for_address_sync (opt_address,
G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,
NULL, /* GDBusAuthObserver */
NULL, /* GCancellable */
&error);
if (connection == NULL)
{
g_printerr ("Error connecting to D-Bus address %s: %s\n", opt_address, error->message);
g_error_free (error);
goto out;
}
g_print ("Connected.\n"
"Negotiated capabilities: unix-fd-passing=%d\n",
g_dbus_connection_get_capabilities (connection) & G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING);
greeting = g_strdup_printf ("Hey, it's %" G_GUINT64_FORMAT " already!", (guint64) time (NULL));
value = g_dbus_connection_call_sync (connection,
NULL, /* bus_name */
"/org/gtk/GDBus/TestObject",
"org.gtk.GDBus.TestPeerInterface",
"HelloWorld",
g_variant_new ("(s)", greeting),
G_VARIANT_TYPE ("(s)"),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (value == NULL)
{
g_printerr ("Error invoking HelloWorld(): %s\n", error->message);
g_error_free (error);
goto out;
}
g_variant_get (value, "(&s)", &greeting_response);
g_print ("Server said: %s\n", greeting_response);
g_variant_unref (value);
g_object_unref (connection);
}
g_dbus_node_info_unref (introspection_data);
ret = 0;
out:
return ret;
}