DBusMessage * test_dbus_call_sync(DBusConnection *conn, const char *object_path, const char *interface, const char *method, DBusError *error, int first_arg_type, ...) { DBusMessage *message; DBusMessage *reply; va_list va; message = dbus_message_new_method_call(NULL, object_path, interface, method); verify_neq(message, NULL); va_start(va, first_arg_type); verify_eq(dbus_message_append_args_valist(message, first_arg_type, va), TRUE); va_end(va); reply = dbus_connection_send_with_reply_and_block(conn, message, -1, error); dbus_message_unref(message); return reply; }
static Bool asdbus_LogoutGNOME (int mode, int timeout) { Bool requested = False; #ifdef HAVE_DBUS_CONTEXT if (ASDBus.session_conn) { DBusMessage *message = dbus_message_new_method_call (SESSIONMANAGER_NAME, SESSIONMANAGER_PATH, SESSIONMANAGER_INTERFACE, "Logout"); if (message) { DBusMessage *replay; DBusError error; DBusMessageIter iter; dbus_uint32_t ui32_mode = mode; dbus_message_iter_init_append (message, &iter); dbus_message_iter_append_basic (&iter, DBUS_TYPE_UINT32, &ui32_mode); dbus_error_init (&error); replay = dbus_connection_send_with_reply_and_block (ASDBus.session_conn, message, timeout, &error); dbus_message_unref (message); if (!replay) { show_error ("Failed to request Logout with the Gnome Session Manager. DBus error: %s", dbus_error_is_set (&error) ? error.message : "unknown error"); } else { /* nothing is returned in replay to this message */ dbus_message_unref (replay); requested = True; } if (dbus_error_is_set (&error)) dbus_error_free (&error); } } #endif return requested; }
static int select_network(struct supplicant_task *task) { DBusMessage *message, *reply; DBusError error; _DBG_SUPPLICANT("task %p", task); if (task->netpath == NULL) return -EINVAL; message = dbus_message_new_method_call(SUPPLICANT_NAME, task->path, SUPPLICANT_INTF ".Interface", "selectNetwork"); if (message == NULL) return -ENOMEM; dbus_message_set_auto_start(message, FALSE); dbus_message_append_args(message, DBUS_TYPE_OBJECT_PATH, &task->netpath, DBUS_TYPE_INVALID); dbus_error_init(&error); reply = dbus_connection_send_with_reply_and_block(connection, message, -1, &error); if (reply == NULL) { if (dbus_error_is_set(&error) == TRUE) { connman_error("%s", error.message); dbus_error_free(&error); } else connman_error("Failed to select network"); dbus_message_unref(message); return -EIO; } dbus_message_unref(message); dbus_message_unref(reply); return 0; }
static void unregister_daemon_in_session (DBusConnection *conn) { DBusMessageIter args; DBusMessage *msg; DBusMessage *reply; DBusError derr = { 0 }; if (client_session_rule) { dbus_bus_remove_match (conn, client_session_rule, NULL); g_free (client_session_rule); client_session_rule = NULL; } if (!client_session_path) return; msg = dbus_message_new_method_call (SERVICE_SESSION_MANAGER, PATH_SESSION_MANAGER, IFACE_SESSION_MANAGER, "UnregisterClient"); g_return_if_fail (msg); dbus_message_iter_init_append (msg, &args); if (!dbus_message_iter_append_basic (&args, DBUS_TYPE_OBJECT_PATH, &client_session_path)) g_return_if_reached (); reply = dbus_connection_send_with_reply_and_block (conn, msg, 1000, &derr); dbus_message_unref (msg); if (!reply) { g_message ("dbus failure unregistering from session: %s", derr.message); return; } dbus_message_unref (reply); g_free (client_session_path); client_session_path = NULL; }
u_int32 set_pimd_rp_candidate(u_int32 flag, char *addr, u_int32 priority, u_int32 time) { DBusMessage *query = NULL, *reply = NULL; DBusError err = {0}; u_int32 op_ret = 0; u_int32 enable = 1; query = dbus_message_new_method_call(PIMD_DBUS_BUSNAME, PIMD_DBUS_OBJPATH, PIMD_DBUS_INTERFACE, PIMD_DBUS_INTERFACE_METHOD_SET_RP_CANDIDATE); dbus_error_init(&err); dbus_message_append_args(query, DBUS_TYPE_UINT32, &flag, DBUS_TYPE_STRING, &addr, DBUS_TYPE_UINT32,&priority, DBUS_TYPE_UINT32,&time, DBUS_TYPE_INVALID); reply = dbus_connection_send_with_reply_and_block(dcli_dbus_connection,query,-1, &err); dbus_message_unref(query); if (NULL == reply) { printf("failed get reply.\n"); if (dbus_error_is_set(&err)) { dbus_error_free(&err); } return 1; } if (!dbus_message_get_args(reply, &err, DBUS_TYPE_UINT32, &op_ret, DBUS_TYPE_INVALID)) { if (dbus_error_is_set(&err)) { dbus_error_free(&err); } } dbus_message_unref(reply); return op_ret; }
u_int32 get_pim_mrt_state() { DBusMessage *query = NULL, *reply = NULL; DBusError err = {0}; u_int32 op_ret = 0; query = dbus_message_new_method_call(PIMD_DBUS_BUSNAME, PIMD_DBUS_OBJPATH, PIMD_DBUS_INTERFACE, PIMD_DBUS_INTERFACE_METHOD_IPMRT_GETSTATE); dbus_error_init(&err); reply = dbus_connection_send_with_reply_and_block(dcli_dbus_connection,query,-1, &err); dbus_message_unref(query); if (NULL == reply) { printf("failed get reply.\n"); if (dbus_error_is_set(&err)) { dbus_error_free(&err); } return 1; } if (dbus_message_get_args(reply, &err, DBUS_TYPE_UINT32, &op_ret, DBUS_TYPE_INVALID)) { dbus_message_unref(reply); } else { if (dbus_error_is_set(&err)) { dbus_error_free(&err); } dbus_message_unref(reply); return 1; } return op_ret; }
static int check_authorization(DBusConnection *conn) { DBusMessage *msg, *reply; DBusMessageIter iter; DBusError err; msg = dbus_message_new_method_call(AUTHORITY_DBUS, AUTHORITY_PATH, AUTHORITY_INTF, "CheckAuthorization"); if (!msg) { fprintf(stderr, "Can't allocate new method call\n"); return -ENOMEM; } dbus_message_iter_init_append(msg, &iter); add_arguments(conn, &iter); dbus_error_init(&err); reply = dbus_connection_send_with_reply_and_block(conn, msg, -1, &err); dbus_message_unref(msg); if (!reply) { if (dbus_error_is_set(&err)) { fprintf(stderr, "%s\n", err.message); dbus_error_free(&err); } else fprintf(stderr, "Can't check authorization\n"); return -EIO; } if (dbus_message_has_signature(reply, "(bba{ss})") == TRUE) { dbus_message_iter_init(reply, &iter); print_arguments(&iter); } dbus_message_unref(reply); return 0; }
DBusMessage * dbind_send_and_allow_reentry (DBusConnection * bus, DBusMessage * message, DBusError *error) { DBusPendingCall *pending; SpiReentrantCallClosure *closure; const char *unique_name = dbus_bus_get_unique_name (bus); const char *destination = dbus_message_get_destination (message); struct timeval tv; DBusMessage *ret; if (unique_name && destination && strcmp (destination, unique_name) != 0) return dbus_connection_send_with_reply_and_block (bus, message, dbind_timeout, error); closure = g_new0 (SpiReentrantCallClosure, 1); closure->reply = NULL; atspi_dbus_connection_setup_with_g_main(bus, NULL); if (!dbus_connection_send_with_reply (bus, message, &pending, dbind_timeout)) return NULL; if (!pending) return NULL; dbus_pending_call_set_notify (pending, set_reply, (void *) closure, g_free); closure->reply = NULL; gettimeofday (&tv, NULL); dbus_pending_call_ref (pending); while (!closure->reply) { if (!dbus_connection_read_write_dispatch (bus, dbind_timeout) || time_elapsed (&tv) > dbind_timeout) { dbus_pending_call_unref (pending); return NULL; } } ret = closure->reply; dbus_pending_call_unref (pending); return ret; }
int mapi_get_running_cfg_lib(char *showStr, int index, DBusConnection *dbus_connection, char *DBUS_METHOD) { DBusMessage *query, *reply; DBusMessageIter iter; DBusError err; char *tmp_str = NULL; char BUSNAME[PATH_LEN]; char OBJPATH[PATH_LEN]; char INTERFACE[PATH_LEN]; ReInitFemtoDbusPath(localid,index,IUH_DBUS_BUSNAME,BUSNAME); ReInitFemtoDbusPath(localid,index,IUH_DBUS_OBJPATH,OBJPATH); ReInitFemtoDbusPath(localid,index,IUH_DBUS_INTERFACE,INTERFACE); //printf("aaaaa\n"); query = dbus_message_new_method_call(BUSNAME,OBJPATH,INTERFACE,DBUS_METHOD); //printf("bbbbb\n"); dbus_error_init(&err); reply = dbus_connection_send_with_reply_and_block (dbus_connection,query,-1, &err); dbus_message_unref(query); if (NULL == reply){ printf("<error> failed get reply.\n"); if (dbus_error_is_set(&err)){ printf("%s raised: %s",err.name,err.message); dbus_error_free(&err); } return -1; } dbus_message_iter_init(reply,&iter); dbus_message_iter_get_basic(&iter,&tmp_str); dbus_message_unref(reply); strncpy(showStr, tmp_str, strlen(tmp_str)); return 0; }
int mapi_femto_service_switch(unsigned int index, int islocal, int slot_id, unsigned int service_type, unsigned int service_switch, DBusConnection *dbus_connection, char *DBUS_METHOD) { DBusMessage *query, *reply; DBusMessageIter iter; DBusError err; int ret = 0; query = dbus_message_new_method_call(HMD_DBUS_BUSNAME,HMD_DBUS_OBJPATH,HMD_DBUS_INTERFACE,DBUS_METHOD); dbus_error_init(&err); dbus_message_append_args(query, DBUS_TYPE_UINT32,&service_type, DBUS_TYPE_UINT32,&service_switch, DBUS_TYPE_UINT32,&index, DBUS_TYPE_UINT32,&islocal, DBUS_TYPE_UINT32,&slot_id, DBUS_TYPE_INVALID); reply = dbus_connection_send_with_reply_and_block (dbus_connection,query,-1, &err); dbus_message_unref(query); if (NULL == reply) { printf("<error> failed get reply.\n"); if (dbus_error_is_set(&err)) { printf("%s raised: %s",err.name,err.message); dbus_error_free(&err); } return -1; } dbus_message_iter_init(reply,&iter); dbus_message_iter_get_basic(&iter,&ret); dbus_message_unref(reply); return ret; }
int rdc_log_all_sockclient( DBusConnection *connection, int hansitype,int insid) { DBusMessage *query = NULL; DBusMessage *reply = NULL; DBusError err = {0}; int iRet = 0; rdc_dbus_path_reinit(hansitype,insid); query = dbus_message_new_method_call( RDC_DBUS_NAME, RDC_DBUS_OBJPATH, RDC_DBUS_INTERFACE, RDC_DBUS_METHOD_LOG_ALL_SOCKCLIENT); dbus_error_init(&err); dbus_message_append_args( query, DBUS_TYPE_INVALID ); reply = dbus_connection_send_with_reply_and_block ( connection, query, -1, &err ); dbus_message_unref(query); if ( NULL == reply ){ if (dbus_error_is_set(&err)){ dbus_error_free(&err); } return EAG_ERR_DBUS_FAILED; }else{ dbus_message_get_args( reply, &err, DBUS_TYPE_INT32, &iRet, DBUS_TYPE_INVALID ); } dbus_message_unref(reply); return iRet; }
IBusMessage * ibus_connection_send_with_reply_and_block (IBusConnection *connection, IBusMessage *message, gint timeout_milliseconds, IBusError **error) { g_assert (IBUS_IS_CONNECTION (connection)); g_assert (message != NULL); g_assert (timeout_milliseconds > 0 || timeout_milliseconds == -1); IBusError *_error; IBusMessage *reply; IBusConnectionPrivate *priv; priv = IBUS_CONNECTION_GET_PRIVATE (connection); _error = ibus_error_new (); reply = dbus_connection_send_with_reply_and_block (priv->connection, message, timeout_milliseconds, _error); if (reply != NULL) { g_signal_emit (connection, connection_signals[IBUS_MESSAGE_SENT], 0, message); ibus_error_free (_error); } else { if (error != NULL) { *error = _error; } else { ibus_error_free (_error); } } return reply; }
int conf_drp_dbus_method_log_debug ( DBusConnection *conn, int loglevel) { DBusMessage *query, *reply; DBusError err; int iRet=DRP_ERR_UNKNOWN; query = dbus_message_new_method_call( DRP_DBUS_BUSNAME, DRP_DBUS_OBJPATH, DRP_DBUS_INTERFACE, DRP_DBUS_METHOD_LOG_DEBUG ); dbus_error_init(&err); dbus_message_append_args( query, DBUS_TYPE_INT32, &loglevel, DBUS_TYPE_INVALID ); reply = dbus_connection_send_with_reply_and_block ( conn, query, -1, &err ); dbus_message_unref(query); if ( NULL == reply ){ if (dbus_error_is_set(&err)){ dbus_error_free(&err); } return DRP_ERR_DBUS_FAILED; }else{ dbus_message_get_args( reply, &err, DBUS_TYPE_INT32, &iRet, DBUS_TYPE_INVALID ); } dbus_message_unref(reply); return iRet; }
int systemd_kodi_init(void) { DBusMessage *msg, *response; DBusError err; const char *unit_name = "kodi.service"; const char *unit_mode = "replace"; dbus_error_init(&err); conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err); if(dbus_error_is_set(&err)) { fprintf(stderr, "failed to open dbus: %s\n", err.message); return -1; } msg = dbus_message_new_method_call( "org.freedesktop.systemd1", "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "GetUnit"); if(!msg) { fprintf(stderr, "failed to create dbus message\n"); return -1; } dbus_message_append_args(msg, DBUS_TYPE_STRING, &unit_name, DBUS_TYPE_INVALID); response = dbus_connection_send_with_reply_and_block(conn, msg, -1, &err); if(dbus_error_is_set(&err)) { fprintf(stderr, "failed to get systemd unit: %s\n", err.message); dbus_message_unref(msg); return -1; } dbus_message_unref(msg); dbus_message_unref(response); return 0; }
int main() { DBusConnection *connection = NULL; DBusError error; DBusMessage *msgQuery = NULL; DBusMessage *msgReply = NULL; DBusMessageIter arg; const char *busName = "org.jinhui.dbus"; dbus_error_init(&error); connection = dbus_bus_get(DBUS_BUS_SESSION, &error); check_and_abort(&error); msgQuery = dbus_message_new_method_call( busName, "/", "org.jinhui.iface", "hello"); char *buffer="hello dbus service"; dbus_message_iter_init_append (msgQuery,&arg); if(!dbus_message_iter_append_basic (&arg,DBUS_TYPE_STRING,&buffer)){ fprintf(stderr,"Out Of Memory!/n"); return -1; } msgReply = dbus_connection_send_with_reply_and_block(connection, msgQuery, 1000, &error); check_and_abort(&error); dbus_message_unref(msgQuery); char *res; dbus_message_get_args(msgReply, &error, DBUS_TYPE_STRING, &res); printf("Received : %s\n", res); dbus_message_unref(msgReply); return 0; }
DBusMessage *manager_destroy_session(DBusConnection *connection, const char *notifier_path) { DBusMessage *message, *reply; DBusError error; DBusMessageIter array; message = dbus_message_new_method_call(CONNMAN_SERVICE, CONNMAN_MANAGER_PATH, CONNMAN_MANAGER_INTERFACE, "DestroySession"); if (!message) return NULL; dbus_error_init(&error); dbus_message_iter_init_append(message, &array); dbus_message_iter_append_basic(&array, DBUS_TYPE_OBJECT_PATH, ¬ifier_path); reply = dbus_connection_send_with_reply_and_block(connection, message, -1, &error); if (!reply) { if (dbus_error_is_set(&error)) { LOG("%s", error.message); dbus_error_free(&error); } else { LOG("%s", error.message); } dbus_message_unref(message); return NULL; } dbus_message_unref(message); return reply; }
u_int32 no_pim_bsr_candidate(void) { DBusMessage *query = NULL, *reply = NULL; DBusError err = {0}; u_int32 op_ret = 0; u_int32 enable = 0; query = dbus_message_new_method_call(PIMD_DBUS_BUSNAME, PIMD_DBUS_OBJPATH, PIMD_DBUS_INTERFACE, PIMD_DBUS_INTERFACE_METHOD_NO_BSR_CANDIDATE); dbus_error_init(&err); dbus_message_append_args(query, DBUS_TYPE_UINT32, &enable, DBUS_TYPE_INVALID); reply = dbus_connection_send_with_reply_and_block(dcli_dbus_connection,query,-1, &err); dbus_message_unref(query); if (NULL == reply) { printf("failed get reply.\n"); if (dbus_error_is_set(&err)) { dbus_error_free(&err); } return 1; } if (dbus_message_get_args(reply, &err, DBUS_TYPE_UINT32, &op_ret, DBUS_TYPE_INVALID)) { } else { if (dbus_error_is_set(&err)) { dbus_error_free(&err); } } dbus_message_unref(reply); return op_ret; }
static gboolean get_system_idle_from_ck (void) { gboolean ret; DBusError error; DBusMessage *message; DBusMessage *reply; ret = FALSE; message = dbus_message_new_method_call ("org.freedesktop.ConsoleKit", "/org/freedesktop/ConsoleKit/Manager", "org.freedesktop.ConsoleKit.Manager", "GetSystemIdleHint"); dbus_error_init (&error); reply = dbus_connection_send_with_reply_and_block (con, message, -1, &error); if (reply == NULL || dbus_error_is_set (&error)) { HAL_ERROR (("Error doing Manager.GetSystemIdleHint on ConsoleKit: %s: %s", error.name, error.message)); dbus_message_unref (message); if (reply != NULL) dbus_message_unref (reply); goto error; } if (!dbus_message_get_args (reply, NULL, DBUS_TYPE_BOOLEAN, &(system_is_idle), DBUS_TYPE_INVALID)) { HAL_ERROR (("Invalid GetSystemIdleHint reply from CK")); goto error; } dbus_message_unref (message); dbus_message_unref (reply); ret = TRUE; error: LIBHAL_FREE_DBUS_ERROR (&error); return ret; }
// here arguments are called a0 .. aN to avoid naming clashes, result is called r long timer_proxy::add_timer(const long a0) { // create caller (name, arguments) dboost::dbus_ptr<DBusMessage> msg(DBOOST_CHECK(dbus_message_new_method_call(m_bus_name.c_str(), m_obj_name.c_str(), s_ifc_name, "add_timer"))); dboost::oserializer os(msg.get()); os & a0; // call synchronously dboost::error err; dboost::dbus_ptr<DBusMessage> reply(dbus_connection_send_with_reply_and_block(m_connection.get(), msg.get(), TIMEOUT_MS, &err)); // check if there was an error DBOOST_CHECK_WITH_ERR(reply, err); if (dbus_message_get_type(reply.get()) == DBUS_MESSAGE_TYPE_ERROR) { throw dboost::exception(dbus_message_get_error_name(reply.get())); } // unpack output parameters dboost::iserializer is(reply.get()); long r; is & r; return r; }
u_int32 set_pim_rp_address(u_int32 flag, u_int32 rp_addr, u_int32 grp_addr, u_int32 mask) { DBusMessage *query = NULL, *reply = NULL; DBusError err = {0}; u_int32 op_ret = 0; query = dbus_message_new_method_call(PIMD_DBUS_BUSNAME, PIMD_DBUS_OBJPATH, PIMD_DBUS_INTERFACE, PIMD_DBUS_INTERFACE_METHOD_SET_RP_STATIC); dbus_error_init(&err); dbus_message_append_args(query, DBUS_TYPE_UINT32, &flag, DBUS_TYPE_UINT32, &rp_addr, DBUS_TYPE_UINT32, &grp_addr, DBUS_TYPE_UINT32, &mask, DBUS_TYPE_INVALID); reply = dbus_connection_send_with_reply_and_block(dcli_dbus_connection,query,-1, &err); dbus_message_unref(query); if (NULL == reply) { printf("failed get reply.\n"); if (dbus_error_is_set(&err)) { dbus_error_free(&err); } return 1; } if (!dbus_message_get_args(reply, &err, DBUS_TYPE_UINT32, &op_ret, DBUS_TYPE_INVALID)) { if (dbus_error_is_set(&err)) { dbus_error_free(&err); } } dbus_message_unref(reply); return op_ret; }
void asdbus_UnregisterSMClient (const char *sm_client_path) { #ifdef HAVE_DBUS_CONTEXT if (ASDBus.session_conn && sm_client_path) { DBusMessage *message = dbus_message_new_method_call (SESSIONMANAGER_NAME, SESSIONMANAGER_PATH, SESSIONMANAGER_INTERFACE, "UnregisterClient"); if (message) { DBusMessage *replay; DBusError error; DBusMessageIter iter; dbus_message_iter_init_append (message, &iter); dbus_message_iter_append_basic (&iter, DBUS_TYPE_OBJECT_PATH, &sm_client_path); dbus_error_init (&error); replay = dbus_connection_send_with_reply_and_block (ASDBus.session_conn, message, 200, &error); dbus_message_unref (message); if (!replay) show_error ("Failed to unregister as a client with the Gnome Session Manager. DBus error: %s", dbus_error_is_set (&error) ? error.message : "unknown error"); else { /* nothing is returned in replay to this message */ show_progress ("Unregistered from Gnome Session Manager"); dbus_message_unref (replay); } if (dbus_error_is_set (&error)) dbus_error_free (&error); } } #endif }
static void systemd_logind_ack_pause(struct systemd_logind_info *info, dbus_int32_t minor, dbus_int32_t major) { DBusError error; DBusMessage *msg = NULL; DBusMessage *reply = NULL; dbus_error_init(&error); msg = dbus_message_new_method_call("org.freedesktop.login1", info->session, "org.freedesktop.login1.Session", "PauseDeviceComplete"); if (!msg) { LogMessage(X_ERROR, "systemd-logind: out of memory\n"); goto cleanup; } if (!dbus_message_append_args(msg, DBUS_TYPE_UINT32, &major, DBUS_TYPE_UINT32, &minor, DBUS_TYPE_INVALID)) { LogMessage(X_ERROR, "systemd-logind: out of memory\n"); goto cleanup; } reply = dbus_connection_send_with_reply_and_block(info->conn, msg, DBUS_TIMEOUT, &error); if (!reply) LogMessage(X_ERROR, "systemd-logind: failed to ack pause: %s\n", error.message); cleanup: if (msg) dbus_message_unref(msg); if (reply) dbus_message_unref(reply); dbus_error_free(&error); }
char* asdbus_GetConsoleSessionType (const char *session_id) { char *session_type = NULL; #ifdef HAVE_DBUS_CONTEXT if (ASDBus.system_conn && session_id) { DBusMessage *message = dbus_message_new_method_call (CK_NAME, session_id, CK_SESSION_INTERFACE, "GetSessionType"); if (message) { DBusMessage *reply; DBusError error; dbus_error_init (&error); reply = dbus_connection_send_with_reply_and_block (ASDBus.system_conn, message, -1, &error); dbus_message_unref (message); if (reply == NULL) { if (dbus_error_is_set (&error)) show_error ("Unable to determine Console Kit Session Type: %s", error.message); } else { DBusMessageIter iter; const char *val = NULL; dbus_message_iter_init (reply, &iter); dbus_message_iter_get_basic (&iter, &val); session_type = mystrdup (val); /* show_progress ("sess_type returned = \"%s\", arg_type = \"%c\"", val, dbus_message_iter_get_arg_type (&iter)); */ dbus_message_unref (reply); } if (dbus_error_is_set (&error)) dbus_error_free (&error); } } #endif return session_type; }
sss_sifp_error sss_sifp_send_message_ex(sss_sifp_ctx *ctx, DBusMessage *msg, int timeout, DBusMessage **_reply) { DBusMessage *reply = NULL; DBusError dbus_error; sss_sifp_error ret; if (ctx == NULL || msg == NULL) { return SSS_SIFP_INVALID_ARGUMENT; } dbus_error_init(&dbus_error); reply = dbus_connection_send_with_reply_and_block(ctx->conn, msg, timeout, &dbus_error); if (dbus_error_is_set(&dbus_error)) { sss_sifp_set_io_error(ctx, &dbus_error); ret = SSS_SIFP_IO_ERROR; goto done; } if (_reply == NULL) { dbus_message_unref(reply); } else { *_reply = reply; } ret = SSS_SIFP_OK; done: dbus_error_free(&dbus_error); return ret; }
static DBusMessage *set_property(DBusConnection *connection, const char *property, int type, void *value) { DBusMessage *message, *reply; DBusError error; DBusMessageIter iter; message = dbus_message_new_method_call(CONNMAN_SERVICE, CONNMAN_MANAGER_PATH, CONNMAN_MANAGER_INTERFACE, "SetProperty"); if (!message) return NULL; dbus_message_iter_init_append(message, &iter); connman_dbus_property_append_basic(&iter, property, type, value); dbus_error_init(&error); reply = dbus_connection_send_with_reply_and_block(connection, message, -1, &error); if (!reply) { if (dbus_error_is_set(&error)) { LOG("%s", error.message); dbus_error_free(&error); } else { LOG("Failed to get properties"); } dbus_message_unref(message); return NULL; } dbus_message_unref(message); return reply; }
gboolean fun_dbus_perform_service (guint service, gchar *ip_arg, gchar **op_arg1, gchar **op_arg2) { DBusMessage *message = NULL; DBusMessage *reply = NULL; DBusError error; int reply_timeout = -1; switch (service) { case PERFORM_UPDATE: { dbus_error_init (&error); message = dbus_message_new_method_call ("org.frugalware.FWUpdateNotifier", "/org/frugalware/FWUpdateNotifier", "org.frugalware.FWUpdateNotifier", "PerformUpdate"); reply = dbus_connection_send_with_reply_and_block (fun_conn, message, reply_timeout, &error); if (dbus_error_is_set(&error)) { fprintf (stderr, "ERROR: %s\n", error.message); dbus_error_free (&error); return FALSE; } if (!dbus_message_get_args (reply, &error, DBUS_TYPE_STRING, op_arg1, DBUS_TYPE_INVALID)) { fprintf (stderr, "ERROR: %s\n", error.message); dbus_error_free (&error); return FALSE; } dbus_message_unref (reply); dbus_message_unref (message); break; } case TEST_SERVICE: { guint ret = 0; dbus_error_init (&error); message = dbus_message_new_method_call ("org.frugalware.FWUpdateNotifier", "/org/frugalware/FWUpdateNotifier", "org.frugalware.FWUpdateNotifier", "TestService"); reply = dbus_connection_send_with_reply_and_block (fun_conn, message, reply_timeout, &error); if (dbus_error_is_set(&error)) { fprintf (stderr, "ERROR: %s\n", error.message); dbus_error_free (&error); return FALSE; } if (!dbus_message_get_args (reply, &error, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID)) { fprintf (stderr, "ERROR: %s\n", error.message); dbus_error_free (&error); return FALSE; } dbus_message_unref (reply); dbus_message_unref (message); break; } case GET_PACKAGE_INFO: { dbus_error_init (&error); message = dbus_message_new_method_call ("org.frugalware.FWUpdateNotifier", "/org/frugalware/FWUpdateNotifier", "org.frugalware.FWUpdateNotifier", "GetPackageInfo"); dbus_message_append_args (message, DBUS_TYPE_STRING, &ip_arg); reply = dbus_connection_send_with_reply_and_block (fun_conn, message, reply_timeout, &error); if (dbus_error_is_set(&error)) { fprintf (stderr, "ERROR: %s\n", error.message); dbus_error_free (&error); return FALSE; } if (!dbus_message_get_args (reply, &error, DBUS_TYPE_STRING, op_arg1, DBUS_TYPE_STRING, op_arg2, DBUS_TYPE_INVALID)) { fprintf (stderr, "ERROR: %s\n", error.message); dbus_error_free (&error); return FALSE; } dbus_message_unref (reply); dbus_message_unref (message); break; } default: break; } return TRUE; }
int cras_bt_transport_release(struct cras_bt_transport *transport, unsigned int blocking) { DBusMessage *method_call, *reply; DBusPendingCall *pending_call; DBusError dbus_error; if (transport->fd < 0) return 0; /* Close the transport on our end no matter whether or not the server * gives us an error. */ close(transport->fd); transport->fd = -1; method_call = dbus_message_new_method_call( BLUEZ_SERVICE, transport->object_path, BLUEZ_INTERFACE_MEDIA_TRANSPORT, "Release"); if (!method_call) return -ENOMEM; if (blocking) { dbus_error_init(&dbus_error); reply = dbus_connection_send_with_reply_and_block( transport->conn, method_call, DBUS_TIMEOUT_USE_DEFAULT, &dbus_error); if (!reply) { syslog(LOG_ERR, "Failed to release transport %s: %s", transport->object_path, dbus_error.message); dbus_error_free(&dbus_error); dbus_message_unref(method_call); return -EIO; } dbus_message_unref(method_call); if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) { syslog(LOG_ERR, "Release returned error: %s", dbus_message_get_error_name(reply)); dbus_message_unref(reply); return -EIO; } dbus_message_unref(reply); } else { if (!dbus_connection_send_with_reply( transport->conn, method_call, &pending_call, DBUS_TIMEOUT_USE_DEFAULT)) { dbus_message_unref(method_call); return -ENOMEM; } dbus_message_unref(method_call); if (!pending_call) return -EIO; if (!dbus_pending_call_set_notify(pending_call, cras_bt_on_transport_release, transport, NULL)) { dbus_pending_call_cancel(pending_call); dbus_pending_call_unref(pending_call); return -ENOMEM; } } return 0; }
static gboolean ck_tracker_init_get_seats_and_sessions (CKTracker *tracker) { gboolean ret; DBusError error; DBusMessage *message; DBusMessage *reply; DBusMessageIter iter; DBusMessageIter iter_array; ret = FALSE; /* first build array of existing seats and sessions */ message = dbus_message_new_method_call ("org.freedesktop.ConsoleKit", "/org/freedesktop/ConsoleKit/Manager", "org.freedesktop.ConsoleKit.Manager", "GetSeats"); dbus_error_init (&error); reply = dbus_connection_send_with_reply_and_block (tracker->dbus_connection, message, -1, &error); if (reply == NULL || dbus_error_is_set (&error)) { HAL_ERROR (("Error doing GetSeats on ConsoleKit: %s: %s", error.name, error.message)); dbus_message_unref (message); if (reply != NULL) dbus_message_unref (reply); goto error; } dbus_message_iter_init (reply, &iter); if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_ARRAY) { HAL_WARNING (("Expecting an array from GetSeats on ConsoleKit.")); dbus_message_unref (message); dbus_message_unref (reply); goto error; } dbus_message_iter_recurse (&iter, &iter_array); while (dbus_message_iter_get_arg_type (&iter_array) == DBUS_TYPE_OBJECT_PATH) { const char *seat_objpath; CKSeat *seat; dbus_message_iter_get_basic (&iter_array, &seat_objpath); HAL_INFO (("got seat '%s'", seat_objpath)); seat = ck_seat_new (seat_objpath); /* get information */ if (!ck_seat_get_info (tracker, seat)) { HAL_ERROR (("Could not get information for seat '%s'", seat_objpath)); dbus_message_unref (message); dbus_message_unref (reply); goto error; } /* for each seat, get the sessions */ if (!ck_tracker_init_get_sessions_for_seat (tracker, seat)) { HAL_ERROR (("Could not get sessions for seat '%s'", seat_objpath)); dbus_message_unref (message); dbus_message_unref (reply); goto error; } tracker->seats = g_slist_prepend (tracker->seats, seat); dbus_message_iter_next (&iter_array); } dbus_message_unref (message); dbus_message_unref (reply); HAL_INFO (("Got seats")); ret = TRUE; error: if (dbus_error_is_set (&error)) dbus_error_free (&error); return ret; }
static gboolean ck_tracker_init_get_sessions_for_seat (CKTracker *tracker, CKSeat *seat) { gboolean ret; DBusError error; DBusMessage *message; DBusMessage *reply; DBusMessageIter iter; DBusMessageIter iter_array; ret = FALSE; message = dbus_message_new_method_call ("org.freedesktop.ConsoleKit", seat->seat_objpath, "org.freedesktop.ConsoleKit.Seat", "GetSessions"); dbus_error_init (&error); reply = dbus_connection_send_with_reply_and_block (tracker->dbus_connection, message, -1, &error); if (reply == NULL || dbus_error_is_set (&error)) { HAL_ERROR (("Error doing GetSeats on ConsoleKit: %s: %s", error.name, error.message)); dbus_message_unref (message); if (reply != NULL) dbus_message_unref (reply); goto error; } dbus_message_iter_init (reply, &iter); if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_ARRAY) { HAL_WARNING (("Expecting an array from GetSessions on ConsoleKit.")); dbus_message_unref (message); dbus_message_unref (reply); goto error; } dbus_message_iter_recurse (&iter, &iter_array); while (dbus_message_iter_get_arg_type (&iter_array) == DBUS_TYPE_OBJECT_PATH) { const char *session_objpath; CKSession *session; dbus_message_iter_get_basic (&iter_array, &session_objpath); HAL_INFO (("got session '%s' for seat '%s'", session_objpath, seat->seat_objpath)); session = ck_session_new (session_objpath); /* get information: is_active etc. */ if (!ck_session_get_info (tracker, session)) { HAL_ERROR (("Could not get information for session '%s'", session_objpath)); dbus_message_unref (message); dbus_message_unref (reply); goto error; } ck_seat_attach_session (seat, session); tracker->sessions = g_slist_prepend (tracker->sessions, session); dbus_message_iter_next (&iter_array); } dbus_message_unref (message); dbus_message_unref (reply); HAL_INFO (("Got all sessions on seat '%s'", seat->seat_objpath)); ret = TRUE; error: if (dbus_error_is_set (&error)) dbus_error_free (&error); return ret; }
static gboolean ck_session_get_info (CKTracker *tracker, CKSession *session) { gboolean ret; DBusError error; DBusMessage *message; DBusMessage *reply; char *hostname; ret = FALSE; message = dbus_message_new_method_call ("org.freedesktop.ConsoleKit", session->session_objpath, "org.freedesktop.ConsoleKit.Session", "IsActive"); dbus_error_init (&error); reply = dbus_connection_send_with_reply_and_block (tracker->dbus_connection, message, -1, &error); if (reply == NULL || dbus_error_is_set (&error)) { HAL_ERROR (("Error doing Session.IsActive on ConsoleKit: %s: %s", error.name, error.message)); dbus_message_unref (message); if (reply != NULL) dbus_message_unref (reply); goto error; } if (!dbus_message_get_args (reply, NULL, DBUS_TYPE_BOOLEAN, &(session->is_active), DBUS_TYPE_INVALID)) { HAL_ERROR (("Invalid IsActive reply from CK")); goto error; } dbus_message_unref (message); dbus_message_unref (reply); message = dbus_message_new_method_call ("org.freedesktop.ConsoleKit", session->session_objpath, "org.freedesktop.ConsoleKit.Session", "IsLocal"); dbus_error_init (&error); reply = dbus_connection_send_with_reply_and_block (tracker->dbus_connection, message, -1, &error); if (reply == NULL || dbus_error_is_set (&error)) { HAL_ERROR (("Error doing Session.IsLocal on ConsoleKit: %s: %s", error.name, error.message)); dbus_message_unref (message); if (reply != NULL) dbus_message_unref (reply); goto error; } if (!dbus_message_get_args (reply, NULL, DBUS_TYPE_BOOLEAN, &(session->is_local), DBUS_TYPE_INVALID)) { HAL_ERROR (("Invalid IsLocal reply from CK")); goto error; } dbus_message_unref (message); dbus_message_unref (reply); message = dbus_message_new_method_call ("org.freedesktop.ConsoleKit", session->session_objpath, "org.freedesktop.ConsoleKit.Session", "GetRemoteHostName"); dbus_error_init (&error); reply = dbus_connection_send_with_reply_and_block (tracker->dbus_connection, message, -1, &error); if (reply == NULL || dbus_error_is_set (&error)) { HAL_ERROR (("Error doing Session.GetRemoteHostName on ConsoleKit: %s: %s", error.name, error.message)); dbus_message_unref (message); if (reply != NULL) dbus_message_unref (reply); goto error; } if (!dbus_message_get_args (reply, NULL, DBUS_TYPE_STRING, &hostname, DBUS_TYPE_INVALID)) { HAL_ERROR (("Invalid GetRemoteHostName reply from CK")); goto error; } session->hostname = g_strdup (hostname); dbus_message_unref (message); dbus_message_unref (reply); message = dbus_message_new_method_call ("org.freedesktop.ConsoleKit", session->session_objpath, "org.freedesktop.ConsoleKit.Session", "GetUnixUser"); dbus_error_init (&error); reply = dbus_connection_send_with_reply_and_block (tracker->dbus_connection, message, -1, &error); if (reply == NULL || dbus_error_is_set (&error)) { HAL_ERROR (("Error doing Session.GetUnixUser on ConsoleKit: %s: %s", error.name, error.message)); dbus_message_unref (message); if (reply != NULL) dbus_message_unref (reply); goto error; } if (!dbus_message_get_args (reply, NULL, #ifdef HAVE_CK_0_3 DBUS_TYPE_UINT32, &(session->user), #else DBUS_TYPE_INT32, &(session->user), #endif DBUS_TYPE_INVALID)) { HAL_ERROR (("Invalid GetUnixUser reply from CK")); goto error; } dbus_message_unref (message); dbus_message_unref (reply); HAL_INFO (("Got active state (%s) and uid %d on session '%s'", session->is_active ? "ACTIVE" : "INACTIVE", session->user, session->session_objpath)); ret = TRUE; error: if (dbus_error_is_set (&error)) dbus_error_free (&error); return ret; }