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;
}
