void cpc_tasks_create_pm(cpc_task_t *task, cpc_pm_manager_t *pm_manager) { CPC_ERR_MANAGE; gchar *path; GDBusConnection *connection = g_dbus_method_invocation_get_connection(task->invocation); const gchar *client_name = g_dbus_method_invocation_get_sender(task->invocation); CPC_FAIL(cpc_pm_manager_new_message(pm_manager, client_name, connection, task->wp_message, task->wp_message_len, &path)); CPC_LOGF("New Push Message object created %s", path); syslog(LOG_INFO, "New Push Message object created %s", path); g_dbus_method_invocation_return_value( task->invocation, g_variant_new("(o)", path)); g_free(path); task->invocation = NULL; return; CPC_ON_ERR: CPC_LOGF("Failed to create Push Message object"); syslog(LOG_INFO, "Failed to create Push Message object"); g_dbus_method_invocation_return_dbus_error( task->invocation, cpc_dbus_error_map(CPC_ERR), ""); task->invocation = NULL; }
bool cpc_tasks_apply(cpc_task_t *task, cpc_pm_manager_t *pm_manager, cpc_cb_t finished, void *finished_data, cpc_tasks_handle_t *handle) { CPC_ERR_MANAGE; cpc_task_data_t *callback_data; const gchar *client_name = g_dbus_method_invocation_get_sender(task->invocation); callback_data = g_new(cpc_task_data_t, 1); callback_data->finished = finished; callback_data->finished_data = finished_data; callback_data->invocation = task->invocation; CPC_FAIL(cpc_pm_manager_apply(pm_manager, task->path, client_name, task->pin, prv_task_finished, callback_data, handle)); task->invocation = NULL; syslog(LOG_INFO, "Starting Apply task"); CPC_LOGF("Starting Apply task"); return true; CPC_ON_ERR: g_free(callback_data); g_dbus_method_invocation_return_dbus_error( task->invocation, cpc_dbus_error_map(CPC_ERR), ""); task->invocation = NULL; return false; }
static gboolean handle_file_chooser_close (XdpFileChooser *object, GDBusMethodInvocation *invocation, const gchar *arg_sender, const gchar *arg_app_id, const gchar *arg_handle) { FileDialogHandle *handle; handle = (FileDialogHandle *)dialog_handle_find (arg_sender, arg_app_id, arg_handle, XDP_TYPE_FILE_CHOOSER_SKELETON); if (handle != NULL) { file_dialog_handle_close (handle); xdp_file_chooser_complete_close (object, invocation); } else { g_dbus_method_invocation_return_dbus_error (invocation, "org.freedesktop.Flatpak.Error.NotFound", "No such handle"); } return TRUE; }
bool cpc_tasks_parsecp(cpc_task_t *task, cpc_cb_t finished, void *finished_data, cpc_handle_t *handle) { CPC_ERR_MANAGE; cpc_task_data_t *callback_data; callback_data = g_new(cpc_task_data_t, 1); callback_data->finished = finished; callback_data->finished_data = finished_data; callback_data->invocation = task->invocation; CPC_LOGF("Starting ParseCP task"); syslog(LOG_INFO, "Starting ParseCP task"); CPC_FAIL(cpc_provision_cp_apply(task->path, prv_task_finished, callback_data, handle)); task->invocation = NULL; return true; CPC_ON_ERR: g_free(callback_data); g_dbus_method_invocation_return_dbus_error( task->invocation, cpc_dbus_error_map(CPC_ERR), ""); task->invocation = NULL; return false; }
/** * Handle @c org.bluez.GattCharacterstic1.WriteValue() method call. * * This handler is triggered when the * @c org.bluez.GattCharacterstic1.WriteValue() method is called by a * client on the BlueZ-based OIC GATT request characteristic. In * particular, IoTivity request data is sent by the GATT client to the * GATT server through this call. The server will retrieve the data * that was sent from the @a value argument. Reassembly of any * request data fragments will begin here. * * @param[in] object @c org.bluez.GattCharacteristic1 skeleton * object associated with this method call. * @param[in] invocation D-Bus method invocation related object used * when sending results/errors asynchronously. * @param[in] value The @c GVariant containing the byte array * (ay) with th request data inside. * @param[in] user_data Pointer to request * @c CAGattCharacteristic object. * * @return @c TRUE to indicate that * @c org.bluez.Characteristic.WriteValue() method is * implemented. */ static gboolean CAGattCharacteristicHandleWriteValue( GattCharacteristic1 * object, GDBusMethodInvocation * invocation, GVariant * value, gpointer user_data) { /* This method is only trigged in a GATT server when receiving data sent by a GATT client, i.e. the client wrote a value to the server, and the server is handling that write request. */ // GLib maps an octet to a guchar, which is of size 1. gsize len = 0; gconstpointer const data = g_variant_get_fixed_array(value, &len, 1); CAGattCharacteristic * const c = user_data; if (CAGattRecv(&c->recv_info, data, (uint32_t) len)) { gatt_characteristic1_complete_write_value(object, invocation); } else { g_dbus_method_invocation_return_dbus_error( invocation, "org.bluez.Error.Failed", "Error when handling GATT request data fragment"); } return TRUE; }
/** Handle "Request" @user_data: priv->client_list */ static gboolean ratdb_dbus_handler_request (RatdbProxyEngine *skeleton, GDBusMethodInvocation *invocation, const gchar *type, gpointer user_data) { GHashTable *clients = (GHashTable *)user_data; const gchar *uuid = NULL; RatdbClient *client = ratdb_client_new (type); if (!client) { g_dbus_method_invocation_return_dbus_error (invocation, "org.ratdb.Daemon.Error", _("failed to create a backend")); return TRUE; } uuid = ratdb_client_get_uuid (client); /* we don't take the refcount */ g_hash_table_insert (clients, g_strdup (uuid), client); /* Called successfully */ ratdb_proxy_engine_complete_request (skeleton, invocation, uuid); g_debug ("Object for new client created"); return TRUE; }
static void _bus_method_call (GDBusConnection * connection, const gchar * sender, const gchar * object_path, const gchar * interface, const gchar * method, GVariant * params, GDBusMethodInvocation * invocation, gpointer user_data) { g_debug ("bus_method_call"); GVariant * retval = NULL; GError * error = NULL; if (g_strcmp0 (method, "get_pinyin") == 0) { const gchar *buf = NULL; gchar* pinyin = NULL; g_variant_get (params, "(s)", &buf); pinyin = get_pinyin (buf); retval = g_variant_new("(s)", pinyin ? pinyin : ""); } else if (g_strcmp0 (method, "finalize_dbus_loop") == 0) { finalize_dbus_loop(); } else if (g_strcmp0 (method, "create_pinyin_trie") == 0) { const gchar* data = NULL; gchar* md5 = NULL; g_variant_get (params, "(s)", &data); md5 = create_pinyin_trie (data); retval = g_variant_new ("(s)", md5 ? md5 : ""); } else if (g_strcmp0 (method, "get_ret_via_keys") == 0) { const gchar* keys = NULL; const gchar* md5 = NULL; gchar* str_ret = NULL; g_variant_get (params, "(ss)", &keys, &md5); str_ret = get_ret_via_keys (keys, md5); retval = g_variant_new ("(s)", str_ret ? str_ret : ""); } else if (g_strcmp0 (method, "finalize_data_trie") == 0) { const gchar* md5 = NULL; g_variant_get (params, "(s)", &md5); finalize_data_trie (md5); } else { g_warning ("Calling method '%s' on lock and it's unknown", method); } if (error != NULL) { g_dbus_method_invocation_return_dbus_error (invocation, "com.deepin.dde.lock.Error", error->message); g_error_free (error); } else { g_dbus_method_invocation_return_value (invocation, retval); } }
/** * bus_installer_install_local_cb: */ static gboolean bus_installer_install_local_cb (LiProxyManager *mgr_bus, GDBusMethodInvocation *context, const gchar *fname, LiHelperDaemon *helper) { GError *error = NULL; LiInstaller *inst = NULL; PolkitAuthorizationResult *pres = NULL; PolkitSubject *subject; const gchar *sender; sender = g_dbus_method_invocation_get_sender (context); subject = polkit_system_bus_name_new (sender); pres = polkit_authority_check_authorization_sync (helper->authority, subject, "org.freedesktop.limba.install-package-local", NULL, POLKIT_CHECK_AUTHORIZATION_FLAGS_ALLOW_USER_INTERACTION, NULL, &error); g_object_unref (subject); if (error != NULL) { g_dbus_method_invocation_take_error (context, error); goto out; } if (!polkit_authorization_result_get_is_authorized (pres)) { g_dbus_method_invocation_return_dbus_error (context, "org.freedesktop.Limba.Installer.Error.NotAuthorized", "Authorization failed."); goto out; } /* initialize our job, in case it is idling */ if (!li_daemon_init_job (helper, mgr_bus, context)) goto out; /* do the thing */ li_daemon_job_run_install_local (helper->job, fname); li_proxy_manager_complete_install_local (mgr_bus, context); out: if (inst != NULL) g_object_unref (inst); if (pres != NULL) g_object_unref (pres); li_daemon_reset_timer (helper); return TRUE; }
void cpc_tasks_get_props(cpc_task_t *task, cpc_pm_manager_t *pm_manager) { CPC_ERR_MANAGE; GVariantBuilder *vb; const gchar *pin_required_str; cpc_props_t props; const gchar *client_name = g_dbus_method_invocation_get_sender(task->invocation); CPC_FAIL(cpc_pm_manager_get_properties(pm_manager, task->path, client_name, &props)); pin_required_str = props.pin_required ? "Yes" : "No"; CPC_LOGF("Pin Required %s", pin_required_str); CPC_LOGF("Settings %s", props.settings); CPC_LOGF("Sec Type %s", props.sec_type); CPC_LOGF("Start Sessions with %s", props.start_sessions); syslog(LOG_INFO, "GetProps (%s, %s, %s %s) succeeded.", pin_required_str, props.settings, props.sec_type, props.start_sessions); vb = g_variant_builder_new(G_VARIANT_TYPE("a{ss}")); g_variant_builder_add(vb, "{ss}", "PinRequired", pin_required_str); g_variant_builder_add(vb, "{ss}", "Settings", props.settings); g_variant_builder_add(vb, "{ss}", "SecType", props.sec_type); g_variant_builder_add(vb, "{ss}", "StartSessionsWith", props.start_sessions); cpc_props_free(&props); g_dbus_method_invocation_return_value( task->invocation, g_variant_new("(@a{ss})", g_variant_builder_end(vb))); g_variant_builder_unref(vb); task->invocation = NULL; return; CPC_ON_ERR: CPC_LOGF("Failed to retrieve properties for %s err %u", task->path, CPC_ERR); syslog(LOG_INFO, "Failed to retrieve properties for %s err %u", task->path, CPC_ERR); g_dbus_method_invocation_return_dbus_error( task->invocation, cpc_dbus_error_map(CPC_ERR), ""); task->invocation = NULL; }
/** * li_daemon_init_job: */ gboolean li_daemon_init_job (LiHelperDaemon *helper, LiProxyManager *mgr_bus, GDBusMethodInvocation *context) { gboolean ret; /* we don't have a job queue, so we error out in case someone tries to start * multiple jobs at the same time */ if (li_daemon_job_is_running (helper->job)) { g_dbus_method_invocation_return_dbus_error (context, "org.freedesktop.Limba.Manager.Error.Failed", "Another job is running at time, Please wait for it to complete."); return FALSE; } ret = li_daemon_job_prepare (helper->job, mgr_bus); return ret; }
static gboolean handle_get_slave_bus_name (GdmDBusDisplay *skeleton, GDBusMethodInvocation *invocation, GdmDisplay *display) { if (display->priv->slave_bus_name != NULL) { gdm_dbus_display_complete_get_slave_bus_name (skeleton, invocation, display->priv->slave_bus_name); } else { g_dbus_method_invocation_return_dbus_error (invocation, "org.gnome.DisplayManager.NotReady", "Slave is not yet registered"); } return TRUE; }
/** * g_dbus_method_invocation_return_gerror: * @invocation: A #GDBusMethodInvocation. * @error: A #GError. * * Like g_dbus_method_invocation_return_error() but takes a #GError * instead of the error domain, error code and message. * * This method will free @invocation, you cannot use it afterwards. * * Since: 2.26 */ void g_dbus_method_invocation_return_gerror (GDBusMethodInvocation *invocation, const GError *error) { gchar *dbus_error_name; g_return_if_fail (G_IS_DBUS_METHOD_INVOCATION (invocation)); g_return_if_fail (error != NULL); dbus_error_name = g_dbus_error_encode_gerror (error); g_dbus_method_invocation_return_dbus_error (invocation, dbus_error_name, error->message); g_free (dbus_error_name); }
static gboolean report_error_cb(ConnmanInterfaceAgent *interface, GDBusMethodInvocation *invocation, const char *path, const char *error_message, gpointer user_data) { connman_agent_t *agent = user_data; if (agent->report_error_cb == NULL) { g_dbus_method_invocation_return_dbus_error(invocation, AGENT_ERROR_CANCELED, "No handler available"); } else { agent->report_error_cb(error_message, agent->report_error_data); } return TRUE; }
static void input_req_event(void *opaque, event_t *e) { connman_service_t *cs = opaque; if(cs->cs_input_req_inv == NULL) return; if(event_is_action(e, ACTION_OK)) { rstr_t *username = prop_get_string(cs->cs_input_req_prop, "username", NULL); rstr_t *password = prop_get_string(cs->cs_input_req_prop, "password", NULL); GVariant *result; GVariantBuilder *builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}")); g_variant_builder_add(builder, "{sv}", "Passphrase", g_variant_new_string(rstr_get(password))); if(cs->cs_input_req_want_identity) g_variant_builder_add(builder, "{sv}", "Identity", g_variant_new_string(rstr_get(username))); result = g_variant_new("(a{sv})", builder); TRACE(TRACE_DEBUG, "CONNMAN", "Auth response: %s", g_variant_print(result, TRUE)); g_dbus_method_invocation_return_value(cs->cs_input_req_inv, result); g_variant_builder_unref(builder); rstr_release(username); rstr_release(password); connman_stop_input_request(cs); } if(event_is_action(e, ACTION_CANCEL)) { g_dbus_method_invocation_return_dbus_error(cs->cs_input_req_inv, "net.connman.Agent.Error.Canceled", "Canceled by user"); connman_stop_input_request(cs); } }
static void prv_task_finished(int result, void *user_data) { cpc_task_data_t *callback_data = user_data; if (result == CPC_ERR_NONE) g_dbus_method_invocation_return_value(callback_data->invocation, NULL); else g_dbus_method_invocation_return_dbus_error( callback_data->invocation, cpc_dbus_error_map(result), ""); CPC_LOGF("Async task finished with err %u", result); syslog(LOG_INFO, "Async task finished with err %u", result); callback_data->finished(result, callback_data->finished_data); g_free(callback_data); }
static gboolean ratdb_dbus_handler_new_table (RatdbProxyEngine *skeleton, GDBusMethodInvocation *invocation, const gchar *uuid, const gchar *name, gpointer iface_user_data, gpointer user_data) { RatdbEngine *engine = ratdb_client_get_engine (ratdb_daemon_get_client (RATDB_DAEMON (user_data), uuid)); if (ratdb_engine_new_table (engine, name, iface_user_data)) { ratdb_proxy_engine_complete_new_table (skeleton, invocation); } else { g_dbus_method_invocation_return_dbus_error (invocation, "org.ratdb.Daemon.Error", _("creating new table failed")); } return TRUE; }
static gboolean on_set_power_state(ControlPower *pwr, GDBusMethodInvocation *invocation, guint state, gpointer user_data) { Control* control = object_get_control((Object*)user_data); if(state > 1) { g_dbus_method_invocation_return_dbus_error(invocation, "org.openbmc.ControlPower.Error.Failed", "Invalid power state"); return TRUE; } // return from method call control_power_complete_set_power_state(pwr,invocation); if(state == control_power_get_state(pwr)) { g_print("Power already at requested state: %d\n",state); } else { int error = 0; do { if(state == 1) { control_emit_goto_system_state(control,"HOST_POWERING_ON"); } else { control_emit_goto_system_state(control,"HOST_POWERING_OFF"); } error = gpio_open(&power_pin); if(error != GPIO_OK) { break; } error = gpio_write(&power_pin,!state); if(error != GPIO_OK) { break; } gpio_close(&power_pin); control_power_set_state(pwr,state); } while(0); if(error != GPIO_OK) { printf("ERROR PowerControl: GPIO set power state (rc=%d)\n",error); } } return TRUE; }
static gboolean request_input_cb(ConnmanInterfaceAgent *interface, GDBusMethodInvocation *invocation, const gchar *path, GVariant *fields, gpointer user_data) { connman_agent_t *agent = user_data; GVariant *response = NULL; if (agent->request_input_cb == NULL) { g_dbus_method_invocation_return_dbus_error(invocation, AGENT_ERROR_CANCELED, "No handler available"); } else { response = agent->request_input_cb(fields, agent->request_input_data); connman_interface_agent_complete_request_input(agent->interface, invocation, response); } return TRUE; }
static void dbus_lua_call_finished(lua_State* L,int result,void* data) { GDBusMethodInvocation *invocation = (GDBusMethodInvocation*)data; if(result == LUA_OK) { if(lua_isnil(L, -1)) { g_dbus_method_invocation_return_value(invocation, g_variant_new("(s)", "")); } else { const char *checkres = luaL_checkstring(L, -1); g_dbus_method_invocation_return_value(invocation, g_variant_new("(s)", checkres)); } } else { const char *msg = luaL_checkstring(L, -1); g_dbus_method_invocation_return_dbus_error(invocation, "org.darktable.Error.LuaError", msg); dt_lua_check_print_error(L,result); } }
/* ** DBus method call: "InstanceExit" -- Called from an instance */ static gboolean on_handle_instance_exit(WarfacebotMngr *wbm, GDBusMethodInvocation *invocation, const gchar *BusName) { g_print("Instance wants to exit: %s\n", BusName); if (!g_dbus_is_name(BusName)) { g_dbus_method_invocation_return_dbus_error( invocation, "org.freedesktop.DBus.Error.ServiceUnknown", "Invalid BusName"); return FALSE; } delete_service_file(BusName); warfacebot_mngr_complete_instance_exit( wbm, invocation); return TRUE; }
static void handle_method_call(GDBusConnection *connection, const gchar *sender, const gchar *object_path, const gchar *interface_name, const gchar *method_name, GVariant *parameters, GDBusMethodInvocation *invocation, gpointer user_data) { printf("call method: '%s'\n", method_name); if (!g_strcmp0(method_name, "HelloWorld")) { const gchar *greeting; g_variant_get(parameters, "(&s)", &greeting); gchar *response; response = g_strdup_printf("You greeted me with '%s'. Thanks!", greeting); g_dbus_method_invocation_return_value (invocation, g_variant_new("(s)", response)); g_free (response); } else { g_dbus_method_invocation_return_dbus_error(invocation, "org.gtk.GDBus.Failed", "Your message bus daemon does not support file descriptor passing (need D-Bus >= 1.3.0)"); } }
void cpc_tasks_close_pm(cpc_task_t *task, cpc_pm_manager_t *pm_manager) { CPC_ERR_MANAGE; const gchar *client_name = g_dbus_method_invocation_get_sender(task->invocation); CPC_FAIL(cpc_pm_manager_remove_message(pm_manager, task->path, client_name)); CPC_LOGF("Push Message object %s removed", task->path); syslog(LOG_INFO, "Push Message object %s removed", task->path); g_dbus_method_invocation_return_value(task->invocation, NULL); task->invocation = NULL; return; CPC_ON_ERR: CPC_LOGF("Failed to remove Push Message Object %s", task->path); syslog(LOG_INFO, "Failed to remove Push Message Object %s", task->path); g_dbus_method_invocation_return_dbus_error( task->invocation, cpc_dbus_error_map(CPC_ERR), ""); task->invocation = NULL; }
static void handle_method_call (GDBusConnection *connection, const gchar *sender, const gchar *object_path, const gchar *interface_name, const gchar *method_name, GVariant *parameters, GDBusMethodInvocation *invocation, gpointer user_data) { if (g_strcmp0 (method_name, "HelloWorld") == 0) { const gchar *greeting; g_variant_get (parameters, "(&s)", &greeting); if (g_strcmp0 (greeting, "Return Unregistered") == 0) { g_dbus_method_invocation_return_error (invocation, G_IO_ERROR, G_IO_ERROR_FAILED_HANDLED, "As requested, here's a GError not registered (G_IO_ERROR_FAILED_HANDLED)"); } else if (g_strcmp0 (greeting, "Return Registered") == 0) { g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_MATCH_RULE_NOT_FOUND, "As requested, here's a GError that is registered (G_DBUS_ERROR_MATCH_RULE_NOT_FOUND)"); } else if (g_strcmp0 (greeting, "Return Raw") == 0) { g_dbus_method_invocation_return_dbus_error (invocation, "org.gtk.GDBus.SomeErrorName", "As requested, here's a raw D-Bus error"); } else { gchar *response; response = g_strdup_printf ("You greeted me with '%s'. Thanks!", greeting); g_dbus_method_invocation_return_value (invocation, g_variant_new ("(s)", response)); g_free (response); } } else if (g_strcmp0 (method_name, "EmitSignal") == 0) { GError *local_error; gdouble speed_in_mph; gchar *speed_as_string; g_variant_get (parameters, "(d)", &speed_in_mph); speed_as_string = g_strdup_printf ("%g mph!", speed_in_mph); local_error = NULL; g_dbus_connection_emit_signal (connection, NULL, object_path, interface_name, "VelocityChanged", g_variant_new ("(ds)", speed_in_mph, speed_as_string), &local_error); g_assert_no_error (local_error); g_free (speed_as_string); g_dbus_method_invocation_return_value (invocation, NULL); } else if (g_strcmp0 (method_name, "GimmeStdout") == 0) { #ifdef G_OS_UNIX if (g_dbus_connection_get_capabilities (connection) & G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING) { GDBusMessage *reply; GUnixFDList *fd_list; GError *error; fd_list = g_unix_fd_list_new (); error = NULL; g_unix_fd_list_append (fd_list, STDOUT_FILENO, &error); g_assert_no_error (error); reply = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation)); g_dbus_message_set_unix_fd_list (reply, fd_list); error = NULL; g_dbus_connection_send_message (connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, /* out_serial */ &error); g_assert_no_error (error); g_object_unref (invocation); g_object_unref (fd_list); g_object_unref (reply); } else { g_dbus_method_invocation_return_dbus_error (invocation, "org.gtk.GDBus.Failed", "Your message bus daemon does not support file descriptor passing (need D-Bus >= 1.3.0)"); } #else g_dbus_method_invocation_return_dbus_error (invocation, "org.gtk.GDBus.NotOnUnix", "Your OS does not support file descriptor passing"); #endif } }
/** * Handle @c org.bluez.GattCharacterstic1.StopNotify() method call. * * This handler is triggered when the * @c org.bluez.GattCharacterstic1.StopNotify() method is called by a * client on the BlueZ-based OIC GATT response characteristic. It * sets the @c org.bluez.GattCharacterstic1.Notifying property to * @c FALSE, and disables responses from the server. * * @param[in] object @c org.bluez.GattCharacteristic1 skeleton * object associated with this method call. * @param[in] invocation D-Bus method invocation related object used * when sending results/errors asynchronously. * @param[in] user_data Pointer to the response * @c CAGattCharacteristic object. * * @return @c TRUE to indicate that * @c org.bluez.Characteristic.StopNotify() method is * implemented. */ static gboolean CAGattCharacteristicHandleStopNotify( GattCharacteristic1 * object, GDBusMethodInvocation * invocation, gpointer user_data) { assert(user_data != NULL); /** * @todo Does BlueZ already prevent redundant calls to * @c org.bluez.GattCharacteristic1.StopNotify()? */ if (!gatt_characteristic1_get_notifying(object)) { g_dbus_method_invocation_return_dbus_error( invocation, "org.bluez.Error.Failed", "Notifications were not previously enabled."); return TRUE; } CAGattCharacteristic * const characteristic = user_data; // Clear the client endpoint from the request characteristic. CAGattRecvInfo * const recv_info = &characteristic->service->request_characteristic.recv_info; /* Remove the appropriate entry from the endpoint-to-characteristic map so that attempts to send a response through it will fail. */ CALEContext * const context = characteristic->context; ca_mutex_lock(context->lock); bool const removed = g_hash_table_remove(context->characteristic_map, recv_info->peer); ca_mutex_unlock(context->lock); CAGattRecvInfoDestroy(recv_info); /** * @todo Do we need to explicitly emit the @c GObject @c notify or * @c org.freedesktop.Dbus.Properties.PropertiesChanged * signal here? */ gatt_characteristic1_set_notifying(object, FALSE); if (removed) { gatt_characteristic1_complete_stop_notify(object, invocation); } else { g_dbus_method_invocation_return_dbus_error( invocation, "org.bluez.Error.Failed", "Error removing peer address information"); } return TRUE; }
/** * Handle @c org.bluez.GattCharacterstic1.StartNotify() method call. * * This handler is triggered when the * @c org.bluez.GattCharacterstic1.StartNotify() method is called by a * client on the BlueZ-based OIC GATT response characteristic. It * sets the @c org.bluez.GattCharacterstic1.Notifying property to * @c TRUE, and enables responses from the server. * * @note This handler is not available in the OIC GATT request * characteristic implementation. * * @param[in] object @c org.bluez.GattCharacteristic1 skeleton * object associated with this method call. * @param[in] invocation D-Bus method invocation related object used * when sending results/errors asynchronously. * @param[in] user_data Pointer to the response * @c CAGattCharacteristic object. * * @return @c TRUE to indicate that * @c org.bluez.Characteristic.StartNotify() method is * implemented. */ static gboolean CAGattCharacteristicHandleStartNotify( GattCharacteristic1 * object, GDBusMethodInvocation * invocation, gpointer user_data) { /** * Only allow the client to start notifications once. * * @todo Does BlueZ already prevent redundant calls to * @c org.bluez.GattCharacteristic1.StartNotify()? */ if (gatt_characteristic1_get_notifying(object)) { g_dbus_method_invocation_return_dbus_error( invocation, "org.bluez.Error.Failed", "Notifications are already enabled."); return TRUE; } // Retrieve the response characteristic information. CAGattCharacteristic * const characteristic = user_data; char * const peer = CAGattCharacteristicMakePeerAddress(characteristic); if (peer == NULL) { g_dbus_method_invocation_return_dbus_error( invocation, "org.bluez.Error.Failed", "Error creating peer endpoint information"); return TRUE; } /* Create an entry in the endpoint-to-characteristic map so that responses may be sent to the GATT client through the OIC GATT response characteristic through this BLE adapter's CAAdapterSendUnicastData() implementation. */ CALEContext * const context = characteristic->context; ca_mutex_lock(context->lock); #if GLIB_CHECK_VERSION(2,40,0) /* GLib hash table functions started returning a boolean result in version 2.40.x. */ bool const inserted = #endif g_hash_table_insert(context->characteristic_map, peer, characteristic); ca_mutex_unlock(context->lock); #if GLIB_CHECK_VERSION(2,40,0) if (!inserted) { g_dbus_method_invocation_return_dbus_error( invocation, "org.bluez.Error.Failed", "Unable to set response endpoint."); OICFree(peer); return TRUE; } #endif /** * @todo Do we need to explicitly emit the @c GObject @c notify or * @c org.freedesktop.Dbus.Properties.PropertiesChanged * signal here? */ gatt_characteristic1_set_notifying(object, TRUE); /* Set the client endpoint field in the request characteristic so that it may pass the appropriate endpoint object up the stack through the CA request/response callback once a request has been completely received and reassembled. */ CAGattRecvInfo * const recv_info = &characteristic->service->request_characteristic.recv_info; recv_info->peer = peer; ca_mutex_lock(context->lock); recv_info->on_packet_received = context->on_server_received_data; recv_info->context = context; ca_mutex_unlock(context->lock); gatt_characteristic1_complete_start_notify(object, invocation); return TRUE; }
/** * @brief Create function handler * @param[in] object * @param[in] invocation * @param[in] instance * @param[in] type * @return true if metod handled */ static gboolean handle_create_function(GadgetdGadgetFunctionManager *object, GDBusMethodInvocation *invocation, const gchar *instance, const gchar *type) { gchar _cleanup_g_free_ *function_path = NULL; const gchar *msg = NULL; GadgetFunctionManager *func_manager = GADGET_FUNCTION_MANAGER(object); GadgetdFunctionObject *function_object; GadgetDaemon *daemon; struct gd_gadget *gadget = func_manager->gadget; const gchar *gadget_name = usbg_get_gadget_name(gadget->g); gchar _cleanup_g_free_ *instance_path = NULL; gchar _cleanup_g_free_ *type_path = NULL; struct gd_function *func = NULL; gint ret; daemon = gadget_function_manager_get_daemon(GADGET_FUNCTION_MANAGER(object)); INFO("handled create function"); if (gadget == NULL || gadget_name == NULL) { msg = "Unable to get gadget"; goto err; } ret = make_valid_object_path_part(instance, &instance_path); if (ret != GD_SUCCESS) { msg = "Invalid instance name"; goto err; } ret = make_valid_object_path_part(type, &type_path); if (ret != GD_SUCCESS) { msg = "Invalid type name"; goto err; } function_path = g_strdup_printf("%s/Function/%s/%s", func_manager->gadget_path, type_path, instance_path); if (function_path == NULL || !g_variant_is_object_path(function_path)) { msg = "Invalid function instance or type"; goto err; } ret = gd_create_function(gadget, type, instance, &func, &msg); if (ret != GD_SUCCESS) goto err; function_object = gadgetd_function_object_new(function_path, func); if (function_object == NULL) { msg = "Unable to create function object"; goto err; } g_dbus_object_manager_server_export(gadget_daemon_get_object_manager(daemon), G_DBUS_OBJECT_SKELETON(function_object)); /* send function path*/ g_dbus_method_invocation_return_value(invocation, g_variant_new("(o)", function_path)); return TRUE; err: g_dbus_method_invocation_return_dbus_error(invocation, func_manager_iface, msg); return TRUE; }
/* ** DBus method call: "InstanceReady" -- Called from an instance ** - Create an instance interface in the manager bus ** - Watch the instance bus */ static gboolean on_handle_instance_ready(WarfacebotMngr *wbm, GDBusMethodInvocation *invocation, const gchar *Nickname, const gchar *Server, const gchar *BusName) { ObjectSkeleton *skeleton = NULL; WarfacebotMngrInstance *wbi = NULL; struct watch_instance *watch = NULL; if (!g_dbus_is_name(BusName)) { g_dbus_method_invocation_return_dbus_error( invocation, "org.freedesktop.DBus.Error.ServiceUnknown", "Invalid BusName"); return FALSE; } g_print("Notification from instance: %s\n", BusName); watch = g_new0(struct watch_instance, 1); watch->name = g_strdup(BusName); watch->path = g_strdup_printf(API_MNGR_PATH "/%03d", ++uniq_id); skeleton = object_skeleton_new(watch->path); wbi = warfacebot_mngr_instance_skeleton_new(); warfacebot_mngr_instance_set_nickname(wbi, Nickname); warfacebot_mngr_instance_set_server(wbi, Server); warfacebot_mngr_instance_set_bus_name(wbi, BusName); warfacebot_mngr_instance_set_starttime(wbi, time(NULL)); object_skeleton_set_warfacebot_mngr_instance(skeleton, wbi); g_dbus_object_manager_server_export( manager, G_DBUS_OBJECT_SKELETON (skeleton)); g_object_unref(skeleton); create_service_file(BusName, Nickname, Server); watch->id = g_bus_watch_name( G_BUS_TYPE_SESSION, BusName, G_BUS_NAME_WATCHER_FLAGS_AUTO_START, on_instance_name_appeared, on_instance_name_vanished, watch, NULL); g_print("Watching instance: %s\n", BusName); warfacebot_mngr_complete_instance_ready( wbm, invocation); return TRUE; }
static void handle_method_call (GDBusConnection *connection, const gchar *sender, const gchar *object_path, const gchar *interface_name, const gchar *method_name, GVariant *parameters, GDBusMethodInvocation *invocation, gpointer user_data) { App *app = user_data; if (g_strcmp0 (method_name, "GetEvents") == 0) { GVariantBuilder builder; GHashTableIter hash_iter; CalendarAppointment *a; gint64 since; gint64 until; gboolean force_reload; gboolean window_changed; g_variant_get (parameters, "(xxb)", &since, &until, &force_reload); if (until < since) { g_dbus_method_invocation_return_dbus_error (invocation, "org.gnome.Shell.CalendarServer.Error.Failed", "until cannot be before since"); goto out; } print_debug ("Handling GetEvents (since=%" G_GINT64_FORMAT ", until=%" G_GINT64_FORMAT ", force_reload=%s)", since, until, force_reload ? "true" : "false"); window_changed = FALSE; if (!(app->until == until && app->since == since)) { GVariantBuilder *builder; GVariantBuilder *invalidated_builder; app->until = until; app->since = since; window_changed = TRUE; builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}")); invalidated_builder = g_variant_builder_new (G_VARIANT_TYPE ("as")); g_variant_builder_add (builder, "{sv}", "Until", g_variant_new_int64 (app->until)); g_variant_builder_add (builder, "{sv}", "Since", g_variant_new_int64 (app->since)); g_dbus_connection_emit_signal (app->connection, NULL, /* destination_bus_name */ "/org/gnome/Shell/CalendarServer", "org.freedesktop.DBus.Properties", "PropertiesChanged", g_variant_new ("(sa{sv}as)", "org.gnome.Shell.CalendarServer", builder, invalidated_builder), NULL); /* GError** */ } /* reload events if necessary */ if (window_changed || force_reload || app->cache_invalid) { app_load_events (app); } /* The a{sv} is used as an escape hatch in case we want to provide more * information in the future without breaking ABI */ g_variant_builder_init (&builder, G_VARIANT_TYPE ("a(sssbxxa{sv})")); g_hash_table_iter_init (&hash_iter, app->appointments); while (g_hash_table_iter_next (&hash_iter, NULL, (gpointer) &a)) { GVariantBuilder extras_builder; GSList *l; for (l = a->occurrences; l; l = l->next) { CalendarOccurrence *o = l->data; time_t start_time = o->start_time; time_t end_time = o->end_time; if ((start_time >= app->since && start_time < app->until) || (start_time <= app->since && (end_time - 1) > app->since)) { g_variant_builder_init (&extras_builder, G_VARIANT_TYPE ("a{sv}")); g_variant_builder_add (&builder, "(sssbxxa{sv})", a->uid, a->summary != NULL ? a->summary : "", a->description != NULL ? a->description : "", (gboolean) a->is_all_day, (gint64) start_time, (gint64) end_time, extras_builder); } } } g_dbus_method_invocation_return_value (invocation, g_variant_new ("(a(sssbxxa{sv}))", &builder)); } else { g_assert_not_reached (); } out: ; }
/** * @brief find function by name handler * @param[in] object * @param[in] invocation * @param[in] function_name * @return true if metod handled */ static gboolean handle_find_function_by_name(GadgetdGadgetFunctionManager *object, GDBusMethodInvocation *invocation, const gchar *type, const gchar *instance) { const gchar *path = NULL; const gchar *msg; gchar _cleanup_g_free_ *function_name = NULL; GadgetDaemon *daemon; GDBusObjectManager *object_manager; GList *objects; GList *l; struct gd_function *gd_func; GadgetFunctionManager *func_manager = GADGET_FUNCTION_MANAGER(object); INFO("find function by name handler"); daemon = gadget_function_manager_get_daemon(GADGET_FUNCTION_MANAGER(object)); if (daemon == NULL) { msg = "Failed to get daemon"; goto out2; } object_manager = G_DBUS_OBJECT_MANAGER(gadget_daemon_get_object_manager(daemon)); if (object_manager == NULL) { ERROR("Failed to get object manager"); goto out2; } msg = "Failed to find function"; objects = g_dbus_object_manager_get_objects(object_manager); for (l = objects; l != NULL; l = l->next) { GadgetdObject *gobj = GADGETD_OBJECT (l->data); path = g_dbus_object_get_object_path(G_DBUS_OBJECT(gobj)); if (!GADGETD_IS_FUNCTION_OBJECT(G_DBUS_OBJECT(gobj)) || !g_str_has_prefix(path, func_manager->gadget_path)) continue; gd_func = gadgetd_function_object_get_function(GADGETD_FUNCTION_OBJECT(gobj)); if (gd_func == NULL) { msg = "Failed to get function"; break; } if (g_strcmp0(gd_func->type, type) == 0 && (strcmp(gd_func->instance, instance)== 0)) { path = g_dbus_object_get_object_path(G_DBUS_OBJECT(gobj)); msg = NULL; goto out; } } if (path == NULL) msg = "Failed to find function"; g_list_foreach(objects, (GFunc)g_object_unref, NULL); g_list_free(objects); out2: if (msg != NULL) { ERROR("%s", msg); g_dbus_method_invocation_return_dbus_error(invocation, func_manager_iface, msg); return TRUE; } out: /* send gadget path */ g_dbus_method_invocation_return_value(invocation, g_variant_new("(o)", path)); return TRUE; }
static void handleMethodCall(GDBusConnection *connection, const gchar *sender, const gchar *object_path, const gchar *interface_name, const gchar *method_name, GVariant *parameters, GDBusMethodInvocation *invocation, gpointer user_data) { AutomotiveManager* manager = static_cast<AutomotiveManager*>(user_data); std::string method = method_name; if(method == "findProperty") { DebugOut(DebugOut::Warning)<<"org.automotive.Manager.findProperty() is deprecated. Use org.automotive.Manager.FindObject() instead."<<endl; gchar* arg; g_variant_get(parameters,"(s)",&arg); std::string objectToFind = arg; if(objectToFind == "") { g_dbus_method_invocation_return_error(invocation,G_DBUS_ERROR,G_DBUS_ERROR_INVALID_ARGS, "Invalid argument."); return; } std::list<AbstractDBusInterface*> interfaces = AbstractDBusInterface::getObjectsForProperty(objectToFind); if(!interfaces.size()) { g_dbus_method_invocation_return_dbus_error(invocation,"org.automotive.Manager.PropertyNotFound", "Object not found"); return; } auto itr = interfaces.begin(); g_dbus_method_invocation_return_value(invocation, g_variant_new("(o)",(*itr)->objectPath().c_str())); ///TODO: we might need to clean up stuff there (like var) } else if(method == "FindObject") { gchar* arg; g_variant_get(parameters,"(s)",&arg); std::string objectToFind = arg; if(objectToFind == "") { g_dbus_method_invocation_return_error(invocation,G_DBUS_ERROR,G_DBUS_ERROR_INVALID_ARGS, "Invalid argument."); return; } std::list<AbstractDBusInterface*> interfaces = AbstractDBusInterface::getObjectsForProperty(objectToFind); if(!interfaces.size()) { g_dbus_method_invocation_return_dbus_error(invocation,"org.automotive.Manager.ObjectNotFound", "Object not found"); return; } GVariantBuilder params; g_variant_builder_init(¶ms, G_VARIANT_TYPE_ARRAY); for(auto itr = interfaces.begin(); itr != interfaces.end(); itr++) { AbstractDBusInterface* t = *itr; if(!t->isSupported()) continue; GVariant *newvar = g_variant_new("o",t->objectPath().c_str()); g_variant_builder_add_value(¶ms, newvar); } //GVariant* var = g_variant_builder_end(¶ms); g_dbus_method_invocation_return_value(invocation, g_variant_new("(ao)",¶ms)); ///TODO: we might need to clean up stuff there (like var) } else if(method == "FindObjectForZone") { gchar* arg; int zone; g_variant_get(parameters,"(si)", &arg, &zone); std::string propertyToFind = arg; if(propertyToFind == "") { g_dbus_method_invocation_return_error(invocation,G_DBUS_ERROR,G_DBUS_ERROR_INVALID_ARGS, "Invalid argument."); return; } std::list<AbstractDBusInterface*> interfaces = AbstractDBusInterface::getObjectsForProperty(propertyToFind); if(!interfaces.size()) { g_dbus_method_invocation_return_dbus_error(invocation,"org.automotive.Manager.ObjectNotFound", "Property not found"); return; } for(auto itr = interfaces.begin(); itr != interfaces.end(); itr++) { AbstractDBusInterface* t = *itr; if(t->zone() == (Zone::Type)zone) { g_dbus_method_invocation_return_value(invocation,g_variant_new("(o)", t->objectPath().c_str())); return; } } g_dbus_method_invocation_return_dbus_error(invocation,"org.automotive.Manager.ObjectNotFound", "Property not found"); } else if (method == "ZonesForObjectName") { gchar* arg; g_variant_get(parameters,"(s)",&arg); std::string propertyToFind = arg; if(propertyToFind == "") { g_dbus_method_invocation_return_error(invocation, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "Invalid argument."); return; } std::list<AbstractDBusInterface*> interfaces = AbstractDBusInterface::getObjectsForProperty(propertyToFind); if(!interfaces.size()) { g_dbus_method_invocation_return_dbus_error(invocation,"org.automotive.Manager.ObjectNotFound", "Property not found"); return; } GVariantBuilder params; g_variant_builder_init(¶ms, G_VARIANT_TYPE_ARRAY); for(auto itr = interfaces.begin(); itr != interfaces.end(); itr++) { AbstractDBusInterface* t = *itr; GVariant *newvar = g_variant_new("i",t->zone()); g_variant_builder_add_value(¶ms, newvar); } g_dbus_method_invocation_return_value(invocation,g_variant_new("(ai)",¶ms)); } else if(method == "List") { std::list<AbstractDBusInterface*> list = AbstractDBusInterface::interfaces(); if(!list.size()) { g_dbus_method_invocation_return_dbus_error(invocation,"org.automotive.Manager.Error", "No supported objects"); return; } GVariantBuilder builder; g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY); for(auto itr = list.begin(); itr != list.end(); itr++) { if(!(*itr)->isSupported()) continue; std::string objectName = (*itr)->objectName(); g_variant_builder_add(&builder, "s", objectName.c_str()); } g_dbus_method_invocation_return_value(invocation,g_variant_new("(as)",&builder)); } g_dbus_method_invocation_return_error(invocation,G_DBUS_ERROR,G_DBUS_ERROR_UNKNOWN_METHOD, "Unknown method."); }