static gboolean initable_init (GInitable *initable, GCancellable *cancellable, GError **error) { MMManagerPrivate *priv = MM_MANAGER (initable)->priv; /* Create plugin manager */ priv->plugin_manager = mm_plugin_manager_new (error); if (!priv->plugin_manager) return FALSE; /* Export the manager interface */ if (!g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (initable), priv->connection, MM_DBUS_PATH, error)) return FALSE; /* Export the Object Manager interface */ g_dbus_object_manager_server_set_connection (priv->object_manager, priv->connection); /* All good */ return TRUE; }
static void on_bus_acquired (GDBusConnection *connection, const gchar *name, gpointer user_data) { TcmmdDbus *self = user_data; GError *error = NULL; self->priv->connection = g_object_ref (connection); self->priv->iface = tcmmd_managed_connections_skeleton_new (); g_signal_connect (self->priv->iface, "handle-set-policy", G_CALLBACK (handle_set_policy_cb), self); g_signal_connect (self->priv->iface, "handle-set-fixed-policy", G_CALLBACK (handle_set_fixed_policy_cb), self); g_signal_connect (self->priv->iface, "handle-unset-policy", G_CALLBACK (handle_unset_policy_cb), self); if (!g_dbus_interface_skeleton_export ( G_DBUS_INTERFACE_SKELETON (self->priv->iface), self->priv->connection, "/org/tcmmd/ManagedConnections", &error)) { g_critical ("Failed to export iface: %s", error->message); g_clear_error (&error); } }
static gboolean register_factory (GdmLocalDisplayFactory *factory) { GError *error = NULL; error = NULL; factory->priv->connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error); if (factory->priv->connection == NULL) { g_critical ("error getting system bus: %s", error->message); g_error_free (error); exit (1); } factory->priv->skeleton = GDM_DBUS_LOCAL_DISPLAY_FACTORY (gdm_dbus_local_display_factory_skeleton_new ()); g_signal_connect (factory->priv->skeleton, "handle-create-transient-display", G_CALLBACK (handle_create_transient_display), factory); if (!g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (factory->priv->skeleton), factory->priv->connection, GDM_LOCAL_DISPLAY_FACTORY_DBUS_PATH, &error)) { g_critical ("error exporting LocalDisplayFactory object: %s", error->message); g_error_free (error); exit (1); } return TRUE; }
static void gkd_secret_objects_register_item (GkdSecretObjects *self, const gchar *item_path) { GkdExportedItem *skeleton; GError *error = NULL; skeleton = g_hash_table_lookup (self->items_to_skeletons, item_path); if (skeleton != NULL) { g_warning ("asked to register item %s, but it's already registered", item_path); return; } skeleton = gkd_secret_item_skeleton_new (self); g_hash_table_insert (self->items_to_skeletons, g_strdup (item_path), skeleton); g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (skeleton), gkd_secret_service_get_connection (self->service), item_path, &error); if (error != NULL) { g_warning ("could not register secret item on session bus: %s", error->message); g_error_free (error); } g_signal_connect (skeleton, "handle-delete", G_CALLBACK (item_method_delete), self); g_signal_connect (skeleton, "handle-get-secret", G_CALLBACK (item_method_get_secret), self); g_signal_connect (skeleton, "handle-set-secret", G_CALLBACK (item_method_set_secret), self); }
void gkd_secret_objects_register_collection (GkdSecretObjects *self, const gchar *collection_path) { GkdExportedCollection *skeleton; GError *error = NULL; skeleton = g_hash_table_lookup (self->collections_to_skeletons, collection_path); if (skeleton != NULL) { g_warning ("asked to register collection %s, but it's already registered", collection_path); return; } skeleton = gkd_secret_collection_skeleton_new (self); g_hash_table_insert (self->collections_to_skeletons, g_strdup (collection_path), skeleton); g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (skeleton), gkd_secret_service_get_connection (self->service), collection_path, &error); if (error != NULL) { g_warning ("could not register secret collection on session bus: %s", error->message); g_error_free (error); } g_signal_connect (skeleton, "handle-create-item", G_CALLBACK (collection_method_create_item), self); g_signal_connect (skeleton, "handle-delete", G_CALLBACK (collection_method_delete), self); g_signal_connect (skeleton, "handle-search-items", G_CALLBACK (collection_method_search_items), self); gkd_secret_objects_init_collection_items (self, collection_path); }
void bus_acquired (GObject *object, GAsyncResult * res, gpointer user_data) { //g_debug("bus acquired"); GDBusConnection *bus; GError *error = NULL; bus = g_bus_get_finish (res, &error); if (!bus) { //g_warning ("unable to connect to the session bus: %s", error->message); g_error_free (error); return; } g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (autopilot_introspection), bus, AUTOPILOT_INTROSPECTION_OBJECT_PATH.c_str(), &error); if (error) { //g_warning ("unable to export autopilot introspection service on dbus: %s", error->message); g_error_free (error); return; } g_signal_connect (autopilot_introspection, "handle-get-state", G_CALLBACK(handle_get_state), NULL); g_signal_connect (autopilot_introspection, "handle-get-version", G_CALLBACK(handle_get_version), NULL); g_object_unref (bus); }
static void on_bus_acquired (GDBusConnection *connection, const gchar *name, gpointer user_data) { GError *error = NULL; g_debug ("Bus acquired, creating skeleton"); helper = flatpak_system_helper_skeleton_new (); g_object_set_data_full (G_OBJECT(helper), "track-alive", GINT_TO_POINTER(42), skeleton_died_cb); g_dbus_interface_skeleton_set_flags (G_DBUS_INTERFACE_SKELETON (helper), G_DBUS_INTERFACE_SKELETON_FLAGS_HANDLE_METHOD_INVOCATIONS_IN_THREAD); g_signal_connect (helper, "handle-deploy", G_CALLBACK (handle_deploy), NULL); g_signal_connect (helper, "handle-deploy-appstream", G_CALLBACK (handle_deploy_appstream), NULL); g_signal_connect (helper, "handle-uninstall", G_CALLBACK (handle_uninstall), NULL); g_signal_connect (helper, "handle-install-bundle", G_CALLBACK (handle_install_bundle), NULL); g_signal_connect (helper, "handle-configure-remote", G_CALLBACK (handle_configure_remote), NULL); g_signal_connect (helper, "g-authorize-method", G_CALLBACK (flatpak_authorize_method_handler), NULL); if (!g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (helper), connection, "/org/freedesktop/Flatpak/SystemHelper", &error)) { g_warning ("error: %s\n", error->message); g_error_free (error); } }
static void on_bus_acquired (GDBusConnection *connection, const gchar *name, gpointer user_data) { XdpDbusDocuments *helper; GError *error = NULL; helper = xdp_dbus_documents_skeleton_new (); g_signal_connect_swapped (helper, "handle-get-mount-point", G_CALLBACK (handle_get_mount_point), NULL); g_signal_connect_swapped (helper, "handle-add", G_CALLBACK (handle_method), portal_add); g_signal_connect_swapped (helper, "handle-add-named", G_CALLBACK (handle_method), portal_add_named); g_signal_connect_swapped (helper, "handle-grant-permissions", G_CALLBACK (handle_method), portal_grant_permissions); g_signal_connect_swapped (helper, "handle-revoke-permissions", G_CALLBACK (handle_method), portal_revoke_permissions); g_signal_connect_swapped (helper, "handle-delete", G_CALLBACK (handle_method), portal_delete); xdg_app_connection_track_name_owners (connection); if (!g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (helper), connection, "/org/freedesktop/portal/documents", &error)) { g_warning ("error: %s", error->message); g_error_free (error); } }
static void on_bus_acquired(GDBusConnection *bus, const gchar *name, gpointer user_data) { LoginKitManager *interface; GError *error = NULL; interface = login_kit_manager_skeleton_new(); g_signal_connect(interface, "handle-unlock-session", G_CALLBACK(on_handle_unlock_session), NULL); g_signal_connect(interface, "handle-list-seats", G_CALLBACK(on_handle_list_seats), NULL); g_signal_connect(interface, "handle-activate-session-on-seat", G_CALLBACK(on_handle_activate_session_on_seat), NULL); signals_subscribe(interface); if (!g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(interface), bus, "/org/freedesktop/login1", &error)) { if (NULL != error) g_error_free(error); } }
static void bus_acquired_cb(GDBusConnection *connection, const gchar *name, gpointer user_data) { GError *error = NULL; connman_agent_t *agent = user_data; agent->path = g_strdup(AGENT_DBUS_PATH); agent->interface = connman_interface_agent_skeleton_new(); g_signal_connect(agent->interface, "handle-request-input", G_CALLBACK(request_input_cb), agent); g_signal_connect(agent->interface, "handle-report-error", G_CALLBACK(report_error_cb), agent); error = NULL; if (!g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(agent->interface), connection, agent->path, &error)) { g_error("Could not export agent object: %s", error->message); g_error_free(error); } if (agent->registered_cb != NULL) { agent->registered_cb(agent->registered_data); } g_message("Agent successfully exported"); }
/** * bus_acquired_cb - handler to invoke when connected to the bus * of type bus_type or NULL. * * @connection: The GDBusConnection to a message bus * @bus_name : The name that is requested to be owned * @user_data : * * returns: * void * */ static void bus_acquired_cb(GDBusConnection *connection, const gchar *bus_name, gpointer user_data) { GError *pError = NULL; gchar *obj_path = user_data; INFO_LOG ("bus_acquired_cb ,Acquired session bus.\n"); /** Second step: Try to get a connection to the given bus. */ pSkeleton = gdbus_mcuinfo_skeleton_new(); /** Third step: Attach to dbus signals. */ (void) g_signal_connect(pSkeleton, "handle-send-mcuinfo", G_CALLBACK(method_send_mcuinfo), NULL); /** Fourth step: Export interface skeleton. */ (void) g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(pSkeleton), connection, obj_path,//AUTOLINK_GDBUS_BUS_OBJECT_PATH, &pError); if(pError != NULL){ ERR_LOG ("bus_acquired_cb: Failed to export object. Reason: %s.\n", pError->message); g_error_free(pError); g_main_loop_quit(mainloop); } }
static void nemo_dbus_manager_init (NemoDBusManager *self) { GDBusConnection *connection; connection = g_application_get_dbus_connection (g_application_get_default ()); self->object_manager = g_dbus_object_manager_server_new ("/org/Nemo"); self->file_operations = nemo_dbus_file_operations_skeleton_new (); g_signal_connect (self->file_operations, "handle-copy-uris", G_CALLBACK (handle_copy_uris), self); g_signal_connect (self->file_operations, "handle-copy-file", G_CALLBACK (handle_copy_file), self); g_signal_connect (self->file_operations, "handle-empty-trash", G_CALLBACK (handle_empty_trash), self); g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (self->file_operations), connection, "/org/Nemo", NULL); g_dbus_object_manager_server_set_connection (self->object_manager, connection); }
gboolean screenshot_init (GDBusConnection *bus, GError **error) { GDBusInterfaceSkeleton *helper; helper = G_DBUS_INTERFACE_SKELETON (xdp_impl_screenshot_skeleton_new ()); g_signal_connect (helper, "handle-screenshot", G_CALLBACK (handle_screenshot), NULL); if (!g_dbus_interface_skeleton_export (helper, bus, DESKTOP_PORTAL_OBJECT_PATH, error)) return FALSE; shell = org_gnome_shell_screenshot_proxy_new_sync (bus, G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START, "org.gnome.Shell.Screenshot", "/org/gnome/Shell/Screenshot", NULL, error); if (shell == NULL) return FALSE; g_debug ("providing %s", g_dbus_interface_skeleton_get_info (helper)->name); return TRUE; }
static gboolean gom_application_dbus_register (GApplication *application, GDBusConnection *connection, const gchar *object_path, GError **error) { GomApplication *self = GOM_APPLICATION (application); gboolean retval = FALSE; if (!G_APPLICATION_CLASS (gom_application_parent_class)->dbus_register (application, connection, object_path, error)) goto out; if (!g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (self->skeleton), connection, object_path, error)) goto out; retval = TRUE; out: return retval; }
/** * @user_data: daemon itself */ static void _on_bus_acquired (GDBusConnection *connection, const gchar *name, gpointer user_data) { RatdbProxyEngine *skeleton; GError *error = NULL; RatdbDaemonPrivate *priv = RATDB_DAEMON (user_data)->priv; g_debug ("Bus acquired"); /* /org/ratdb/Interface */ skeleton = ratdb_proxy_engine_skeleton_new (); if (error) { g_error (_("Couldn't create a skeleton for clients: %s"), error->message); g_error_free (error); } g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (skeleton), connection, "/org/ratdb/Interface", &error); if (error) { g_error (_("Failed to export symbols: %s"), error->message); g_error_free (error); } /* handle functions */ RATDB_CONNECT_DBUS_IFACE (request, ratdb_dbus_handler, priv->client_list); RATDB_CONNECT_DBUS_IFACE (remove_client, ratdb_dbus_handler, user_data); RATDB_CONNECT_DBUS_IFACE (new_database, ratdb_dbus_handler, user_data); RATDB_CONNECT_DBUS_IFACE (new_table, ratdb_dbus_handler, user_data); }
static void on_bus_acquired (GDBusConnection *connection, const gchar *name, gpointer user_data) { XdpDbusContentPortal *helper; GError *error = NULL; helper = xdp_dbus_content_portal_skeleton_new (); g_signal_connect (helper, "handle-open", G_CALLBACK (handle_open), NULL); g_signal_connect (helper, "handle-create", G_CALLBACK (handle_create), NULL); xdp_connection_track_name_owners (connection); if (!g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (helper), connection, "/org/freedesktop/portal/content", &error)) { g_warning ("error: %s\n", error->message); g_error_free (error); } }
static gboolean initable_init (GInitable *initable, GCancellable *cancellable, GError **error) { MMBaseManagerPrivate *priv = MM_BASE_MANAGER (initable)->priv; /* If autoscan enabled, list for udev events */ if (priv->auto_scan) g_signal_connect (priv->udev, "uevent", G_CALLBACK (handle_uevent), initable); /* Create plugin manager */ priv->plugin_manager = mm_plugin_manager_new (priv->plugin_dir, error); if (!priv->plugin_manager) return FALSE; /* Export the manager interface */ if (!g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (initable), priv->connection, MM_DBUS_PATH, error)) return FALSE; /* Export the Object Manager interface */ g_dbus_object_manager_server_set_connection (priv->object_manager, priv->connection); /* Setup the Test skeleton and export the interface */ if (priv->enable_test) { priv->test_skeleton = mm_gdbus_test_skeleton_new (); g_signal_connect (priv->test_skeleton, "handle-set-profile", G_CALLBACK (handle_set_profile), initable); if (!g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (priv->test_skeleton), priv->connection, MM_DBUS_PATH, error)) return FALSE; } /* All good */ return TRUE; }
static gboolean photos_thumbnailer_dbus_register (GApplication *application, GDBusConnection *connection, const gchar *object_path, GError **error) { PhotosThumbnailer *self = PHOTOS_THUMBNAILER (application); g_autoptr (GDBusAuthObserver) observer = NULL; gboolean ret_val = FALSE; g_return_val_if_fail (self->skeleton == NULL, FALSE); if (!G_APPLICATION_CLASS (photos_thumbnailer_parent_class)->dbus_register (application, connection, object_path, error)) goto out; observer = g_dbus_auth_observer_new (); g_signal_connect_swapped (observer, "authorize-authenticated-peer", G_CALLBACK (photos_thumbnailer_authorize_authenticated_peer), self); self->connection = g_dbus_connection_new_for_address_sync (self->address, G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT, observer, NULL, error); if (self->connection == NULL) goto out; self->skeleton = photos_thumbnailer_dbus_skeleton_new (); g_signal_connect_swapped (self->skeleton, "handle-cancel", G_CALLBACK (photos_thumbnailer_handle_cancel), self); g_signal_connect_swapped (self->skeleton, "handle-generate-thumbnail", G_CALLBACK (photos_thumbnailer_handle_generate_thumbnail), self); if (!g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (self->skeleton), self->connection, THUMBNAILER_PATH, error)) { g_clear_object (&self->skeleton); goto out; } ret_val = TRUE; out: return ret_val; }
static void __bt_telephony_gdbus_init(void) { GDBusConnection *g_conn; GError *g_err = NULL; BT_DBG("+"); ret_if(bluetooth_telephony_obj != NULL); g_conn = _bt_init_system_gdbus_conn(); ret_if(g_conn == NULL); bluetooth_telephony_obj = org_tizen_csd_call_instance_skeleton_new(); g_signal_connect(bluetooth_telephony_obj, "handle-answer", G_CALLBACK(bluetooth_telephony_method_answer), NULL); g_signal_connect(bluetooth_telephony_obj, "handle-release", G_CALLBACK(bluetooth_telephony_method_release), NULL); g_signal_connect(bluetooth_telephony_obj, "handle-reject", G_CALLBACK(bluetooth_telephony_method_reject), NULL); g_signal_connect(bluetooth_telephony_obj, "handle-threeway", G_CALLBACK(bluetooth_telephony_method_threeway), NULL); g_signal_connect(bluetooth_telephony_obj, "handle-send-dtmf", G_CALLBACK(bluetooth_telephony_method_send_dtmf), NULL); if (g_dbus_interface_skeleton_export( G_DBUS_INTERFACE_SKELETON(bluetooth_telephony_obj), g_conn, "/", &g_err) == FALSE) { if (g_err) { BT_ERR("Export error: %s", g_err->message); g_clear_error(&g_err); } g_object_unref(bluetooth_telephony_obj); bluetooth_telephony_obj = NULL; g_dbus_connection_close_sync(gdbus_conn, NULL, NULL); gdbus_conn = NULL; return; } gdbus_conn = g_conn; BT_DBG("-"); }
gboolean gcal_shell_search_provider_dbus_export (GcalShellSearchProvider *search_provider, GDBusConnection *connection, const gchar *object_path, GError **error) { GcalShellSearchProviderPrivate *priv = GCAL_SHELL_SEARCH_PROVIDER (search_provider)->priv; return g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (priv->skel), connection, object_path, error); }
gint main (gint argc, gchar *argv[]) { g_autoptr(GDBusConnection) connection = NULL; g_autoptr(IpcGitService) service = NULL; g_autoptr(GOutputStream) stdout_stream = NULL; g_autoptr(GInputStream) stdin_stream = NULL; g_autoptr(GIOStream) stream = NULL; g_autoptr(GMainLoop) main_loop = NULL; g_autoptr(GError) error = NULL; g_set_prgname ("gnome-builder-git"); g_set_application_name ("gnome-builder-git"); prctl (PR_SET_PDEATHSIG, SIGTERM); signal (SIGPIPE, SIG_IGN); ggit_init (); g_log_set_handler (NULL, G_LOG_LEVEL_MASK, log_func, NULL); if (!g_unix_set_fd_nonblocking (STDIN_FILENO, TRUE, &error) || !g_unix_set_fd_nonblocking (STDOUT_FILENO, TRUE, &error)) goto error; main_loop = g_main_loop_new (NULL, FALSE); stdin_stream = g_unix_input_stream_new (STDIN_FILENO, FALSE); stdout_stream = g_unix_output_stream_new (STDOUT_FILENO, FALSE); stream = g_simple_io_stream_new (stdin_stream, stdout_stream); if (!(connection = create_connection (stream, main_loop, &error))) goto error; service = ipc_git_service_impl_new (); if (!g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (service), connection, "/org/gnome/Builder/Git", &error)) goto error; g_dbus_connection_start_message_processing (connection); g_main_loop_run (main_loop); return EXIT_SUCCESS; error: if (error != NULL) g_printerr ("%s\n", error->message); return EXIT_FAILURE; }
static void export_all (GDBusObjectManagerServer *manager) { GHashTableIter iter; const gchar *object_path; RegistrationData *data; GHashTableIter iface_iter; GDBusInterfaceSkeleton *iface; GError *error; g_return_if_fail (manager->priv->connection != NULL); error = NULL; g_warn_if_fail (manager->priv->manager_reg_id == 0); manager->priv->manager_reg_id = g_dbus_connection_register_object (manager->priv->connection, manager->priv->object_path, (GDBusInterfaceInfo *) &manager_interface_info, &manager_interface_vtable, manager, NULL, /* user_data_free_func */ &error); if (manager->priv->manager_reg_id == 0) { g_warning ("%s: Error registering manager at %s: %s", G_STRLOC, manager->priv->object_path, error->message); g_error_free (error); } g_hash_table_iter_init (&iter, manager->priv->map_object_path_to_data); while (g_hash_table_iter_next (&iter, (gpointer) &object_path, (gpointer) &data)) { g_hash_table_iter_init (&iface_iter, data->map_iface_name_to_iface); while (g_hash_table_iter_next (&iface_iter, NULL, (gpointer) &iface)) { g_warn_if_fail (g_dbus_interface_skeleton_get_connection (iface) == NULL); error = NULL; if (!g_dbus_interface_skeleton_export (iface, manager->priv->connection, object_path, &error)) { g_warning ("%s: Error registering object at %s with interface %s: %s", G_STRLOC, object_path, g_dbus_interface_skeleton_get_info (iface)->name, error->message); g_error_free (error); } } } }
static void on_name_acquired(GDBusConnection *connection, const gchar *name, gpointer user_data) { vinay245BusGDBUS *interface; GError *error; interface = vinay245_bus_gdbus_skeleton_new(); g_print(" Client ==== Acquired Bus on Vinay245 "); g_signal_connect (interface, "handle-hello-client", G_CALLBACK (on_handle_hello_world), NULL); error = NULL; !g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (interface), connection, "/com/vinay245/GDBUS", &error); }
static void on_bus_acquired (GDBusConnection *connection, const char *name, gpointer user_data) { MetaMonitorManager *manager = user_data; g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (manager), connection, "/org/gnome/Mutter/DisplayConfig", NULL); }
/** * la_handler_service_start: * @service: A #LAHandlerService. * @error: Return location for error or %NULL. * * Makes @service export its #LAHandler interface so that it is available to the * #legacy-app-handler helper binary. * * Returns: %TRUE if the interface was exported successfully, otherwise %FALSE with @error * set. */ gboolean la_handler_service_start (LAHandlerService *service, GError **error) { g_return_val_if_fail (LA_HANDLER_IS_SERVICE (service), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); /* announce the org.genivi.NodeStartupController1.LegacyAppHandler service on the bus */ return g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (service->interface), service->connection, "/org/genivi/NodeStartupController1/LegacyAppHandler", error); }
/** * Initialize GATT characteristic fields. * * This function initializes the @c CAGattCharacteristic object fields. * * @param[out] c GATT characteristic information to * be initialized. * @param[in] context Object containing the D-Bus * connection to the bus on which the * characteristic will be exported, as * well as the list of connected * devices. * @param[in] s Information about GATT service * to which the characteristic * belongs. * @param[in] characteristic_path @c GattCharacteristic1 object * path. * @param[in] uuid GATT characteristic UUID. * @param[in] flag GATT characteristic property flag, * i.e. @c "write-without-response" * for the request characteristic, and * @c "notify" for the response * characteristic. * * @note This function does not allocate the @a characteristic object * itself. The caller is responsible for allocating that * memory. * * @todo Too many parameters. Perhaps pass in a pointer to a struct * instead. */ static bool CAGattCharacteristicInitialize( CAGattCharacteristic * c, CALEContext * context, CAGattService * s, char const * characteristic_path, char const * uuid, char const * flag) { // Path of the form /org/iotivity/gatt/hci0/service0/char0. c->object_path = g_strdup_printf("%s/%s", s->object_path, characteristic_path); assert(g_variant_is_object_path(c->object_path)); c->context = context; c->service = s; c->characteristic = gatt_characteristic1_skeleton_new(); gatt_characteristic1_set_uuid(c->characteristic, uuid); gatt_characteristic1_set_service(c->characteristic, s->object_path); gatt_characteristic1_set_notifying(c->characteristic, FALSE); char const * flags[] = { flag, NULL }; gatt_characteristic1_set_flags(c->characteristic, flags); CAGattRecvInfoInitialize(&c->recv_info); // Export the characteristic interface on the bus. GError * error = NULL; if (!g_dbus_interface_skeleton_export( G_DBUS_INTERFACE_SKELETON(c->characteristic), context->connection, c->object_path, &error)) { CAGattCharacteristicDestroy(c); OIC_LOG_V(ERROR, TAG, "Unable to export D-Bus GATT characteristic " "interface: %s", error->message); g_error_free(error); return false; } return true; }
/* ** DBus event: Manager bus acquired ** - Export manager interface ** - Bind manager interface methods ** - Create manager service file */ static void on_bus_acquired(GDBusConnection *conn, const gchar *name, gpointer user_data) { WarfacebotMngr *wbm = NULL; WarfacebotMngrIface *iface = NULL; GError *error = NULL; gboolean ret = FALSE; g_print ("Manager acquired message bus %s\n", name); create_service_file(API_MNGR_NAME, NULL, NULL); /* Create Manager */ connection = conn; manager = g_dbus_object_manager_server_new(API_MNGR_PATH); g_dbus_object_manager_server_set_connection(manager, connection); /* Create Custom Interface */ wbm = warfacebot_mngr_skeleton_new(); iface = WARFACEBOT_MNGR_GET_IFACE (wbm); iface->handle_create = on_handle_create; iface->handle_quit = on_handle_quit; iface->handle_instance_exit = on_handle_instance_exit; iface->handle_instance_ready = on_handle_instance_ready; ret = g_dbus_interface_skeleton_export( G_DBUS_INTERFACE_SKELETON (wbm), connection, API_MNGR_PATH, &error); if (ret == FALSE) { g_warning(error->message); return; } g_print("Manager interface exported\n"); }
NMSstpPlugin * nm_sstp_plugin_new (const char *bus_name) { NMSstpPlugin *plugin; NMSstpPluginPrivate *priv; GDBusConnection *bus; GError *error = NULL; plugin = (NMSstpPlugin *) g_initable_new (NM_TYPE_SSTP_PLUGIN, NULL, &error, NM_VPN_SERVICE_PLUGIN_DBUS_SERVICE_NAME, bus_name, NM_VPN_SERVICE_PLUGIN_DBUS_WATCH_PEER, !debug, NULL); if (plugin) { g_signal_connect (G_OBJECT (plugin), "state-changed", G_CALLBACK (state_changed_cb), NULL); } else { g_warning ("Failed to initialize a plugin instance: %s", error->message); g_error_free (error); } bus = nm_vpn_service_plugin_get_connection (NM_VPN_SERVICE_PLUGIN (plugin)), priv = NM_SSTP_PLUGIN_GET_PRIVATE (plugin); priv->dbus_skeleton = nmdbus_sstp_ppp_skeleton_new (); if (!g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (priv->dbus_skeleton), bus, NM_DBUS_PATH_SSTP_PPP, &error)) { g_warning ("Failed to export helper interface: %s", error->message); g_error_free (error); g_clear_object (&plugin); goto out; } g_dbus_connection_register_object (bus, NM_DBUS_PATH_SSTP_PPP, nmdbus_sstp_ppp_interface_info (), NULL, NULL, NULL, NULL); g_signal_connect (priv->dbus_skeleton, "handle-need-secrets", G_CALLBACK (handle_need_secrets), plugin); g_signal_connect (priv->dbus_skeleton, "handle-set-state", G_CALLBACK (handle_set_state), plugin); g_signal_connect (priv->dbus_skeleton, "handle-set-ip4-config", G_CALLBACK (handle_set_ip4_config), plugin); out: g_clear_object (&bus); return plugin; }
static void registration_data_export_interface (RegistrationData *data, GDBusInterfaceSkeleton *interface_skeleton) { GDBusInterfaceInfo *info; GError *error; const gchar *object_path; object_path = g_dbus_object_get_object_path (G_DBUS_OBJECT (data->object)); info = g_dbus_interface_skeleton_get_info (interface_skeleton); error = NULL; if (data->manager->priv->connection != NULL) { if (!g_dbus_interface_skeleton_export (interface_skeleton, data->manager->priv->connection, object_path, &error)) { g_warning ("%s: Error registering object at %s with interface %s: %s", G_STRLOC, object_path, info->name, error->message); g_error_free (error); } } g_assert (g_hash_table_lookup (data->map_iface_name_to_iface, info->name) == NULL); g_hash_table_insert (data->map_iface_name_to_iface, info->name, g_object_ref (interface_skeleton)); /* if we are already exported, then... */ if (data->exported) { const gchar *interfaces[2]; /* emit InterfacesAdded on the ObjectManager object */ interfaces[0] = info->name; interfaces[1] = NULL; g_dbus_object_manager_server_emit_interfaces_added (data->manager, data, interfaces); } }
/* * Called when a reference to the system bus is acquired. This is where you are * supposed to export your well-known name, not in name_acquired; that is too * late. */ static void on_bus_acquired (GDBusConnection *system_bus, const gchar *name, gpointer user_data) { EmerDaemon *daemon = EMER_DAEMON (user_data); EmerEventRecorderServer *server = emer_event_recorder_server_skeleton_new (); g_signal_connect (server, "handle-record-singular-event", G_CALLBACK (on_record_singular_event), daemon); g_signal_connect (server, "handle-record-aggregate-event", G_CALLBACK (on_record_aggregate_event), daemon); g_signal_connect (server, "handle-record-event-sequence", G_CALLBACK (on_record_event_sequence), daemon); g_signal_connect (server, "handle-set-enabled", G_CALLBACK (on_set_enabled), daemon); g_signal_connect (server, "handle-upload-events", G_CALLBACK (on_upload_events), daemon); g_signal_connect (server, "handle-reset-tracking-id", G_CALLBACK (on_reset_tracking_id), daemon); g_signal_connect (server, "g-authorize-method", G_CALLBACK (on_authorize_method_check), daemon); EmerPermissionsProvider *permissions = emer_daemon_get_permissions_provider (daemon); g_object_bind_property_full (permissions, "daemon-enabled", server, "enabled", G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE, sync_recorder_server_enabled_for_daemon, NULL, daemon, NULL); g_object_bind_property_full (permissions, "uploading-enabled", server, "enabled", G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE, sync_recorder_server_enabled_for_upload, NULL, daemon, NULL); GError *error = NULL; if (!g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (server), system_bus, "/com/endlessm/Metrics", &error)) g_error ("Could not export metrics interface on system bus: %s.", error->message); }