static bool mia_activity_action_add(const char *owner, const char *service, const char *path, const char *interface, const char *method) { bool ack = false; /* Add D-Bus name owner monitor */ if( mce_dbus_owner_monitor_add(owner, mia_dbus_activity_action_owner_cb, &activity_action_owners, ACTIVITY_CB_MAX_MONITORED) == -1) { mce_log(LL_ERR, "Failed to add name owner monitoring for `%s'", owner); goto EXIT; } /* Add activity callback */ mia_action_t *cb = mia_action_create(owner, service, path, interface, method); activity_action_list = g_slist_prepend(activity_action_list, cb); ack = true; EXIT: return ack; }
/** * D-Bus callback for the ALS enabling method call * * @param msg The D-Bus message * @return TRUE */ static gboolean als_enable_req_dbus_cb(DBusMessage *const msg) { const char *sender; gssize retval; if( !(sender = dbus_message_get_sender(msg)) ) goto EXIT; mce_log(LL_DEBUG, "Received ALS enable request from %s", sender); retval = mce_dbus_owner_monitor_add(sender, als_owner_monitor_dbus_cb, &ext_als_enablers, ALS_MAX_MONITORED); if (retval == -1) { mce_log(LL_WARN, "Failed to add name owner monitoring" " for `%s'", sender); goto EXIT; } rethink_als_status(); EXIT: if( !dbus_message_get_no_reply(msg) ) { DBusMessage *reply = dbus_new_method_reply(msg); dbus_send_message(reply), reply = 0; } return TRUE; }
/** * Install alarm D-Bus service monitor callback. * * @param sender sender D-Bus address */ static void setup_alarm_dbus_monitor(const gchar* sender) { mce_log(LL_DEBUG, "adding dbus monitor for: '%s'" ,sender); /* No need to check return value, if it does not succeed, not much * we can do / fall back to */ mce_dbus_owner_monitor_add(sender, alarm_owner_monitor_dbus_cb, &alarm_owner_monitor_list, ALARM_MAX_MONITORED); }
/** Install/remove alarm queue D-Bus name owner monitor * * @param sender Private D-Bus name to monitor * @param monitor true/false to start/stop monitoring */ static void queue_monitor_setup(const char *sender, bool monitor) { if( monitor ) { gssize cnt = mce_dbus_owner_monitor_add(sender, queue_owner_monitor_dbus_cb, &queue_owner_monitor_list, ALARM_MAX_MONITORED); if( cnt != -1 ) { /* A owner monitor was added/renewed */ mce_log(LL_DEVEL, "monitoring dbus name: %s", sender); mce_wakelock_obtain(ALARM_IMMINENT_WAKELOCK_NAME, ALARM_IMMINENT_TIMEOUT_MS); } } else { gssize cnt = mce_dbus_owner_monitor_remove(sender, &queue_owner_monitor_list); if( cnt == 0 ) { /* The last monitor was removed */ mce_log(LL_DEVEL, "all dbus name monitors removed"); mce_wakelock_release(ALARM_IMMINENT_WAKELOCK_NAME); } } }
/** * D-Bus callback for the add activity callback method call * * @param msg The D-Bus message * @return TRUE on success, FALSE on failure */ static gboolean add_activity_callback_dbus_cb(DBusMessage *const msg) { dbus_bool_t no_reply = dbus_message_get_no_reply(msg); const gchar *sender = dbus_message_get_sender(msg); const gchar *service = NULL; const gchar *path = NULL; const gchar *interface = NULL; const gchar *method_name = NULL; activity_cb_t *tmp = NULL; gboolean result = FALSE; gboolean status = FALSE; DBusError error; /* Register error channel */ dbus_error_init(&error); if (sender == NULL) { mce_log(LL_ERR, "Received invalid add activity callback request " "(sender == NULL)"); goto EXIT; } mce_log(LL_DEVEL, "Received add activity callback request from %s", mce_dbus_get_name_owner_ident(sender)); /* Extract result */ if (dbus_message_get_args(msg, &error, DBUS_TYPE_STRING, &service, DBUS_TYPE_STRING, &path, DBUS_TYPE_STRING, &interface, DBUS_TYPE_STRING, &method_name, DBUS_TYPE_INVALID) == FALSE) { // XXX: should we return an error instead? mce_log(LL_CRIT, "Failed to get argument from %s.%s; %s", MCE_REQUEST_IF, MCE_ADD_ACTIVITY_CALLBACK_REQ, error.message); dbus_error_free(&error); goto EXIT; } if (mce_dbus_owner_monitor_add(sender, activity_cb_monitor_dbus_cb, &activity_cb_monitor_list, ACTIVITY_CB_MAX_MONITORED) == -1) { mce_log(LL_ERR, "Failed to add name owner monitoring for `%s'", sender); goto EXIT2; } tmp = g_malloc(sizeof (activity_cb_t)); tmp->owner = g_strdup(sender); tmp->service = g_strdup(service); tmp->path = g_strdup(path); tmp->interface = g_strdup(interface); tmp->method_name = g_strdup(method_name); activity_callbacks = g_slist_prepend(activity_callbacks, tmp); result = TRUE; EXIT2: if (no_reply == FALSE) { DBusMessage *reply = dbus_new_method_reply(msg); if (dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &result, DBUS_TYPE_INVALID) == FALSE) { mce_log(LL_CRIT, "Failed to append reply argument to " "D-Bus message for %s.%s", MCE_REQUEST_IF, MCE_ADD_ACTIVITY_CALLBACK_REQ); dbus_message_unref(reply); goto EXIT; } status = dbus_send_message(reply); } else { status = TRUE; } EXIT: return status; }
/** * D-Bus callback for the call state change request method call * * @param msg The D-Bus message * @return TRUE on success, FALSE on failure */ static gboolean change_call_state_dbus_cb(DBusMessage *const msg) { gboolean status = FALSE; const char *state = 0; const char *type = 0; const gchar *sender = dbus_message_get_sender(msg); call_state_t call_state = CALL_STATE_NONE; call_type_t call_type = NORMAL_CALL; DBusMessage *reply = NULL; DBusError error = DBUS_ERROR_INIT; dbus_bool_t changed = false; mce_log(LL_DEBUG, "Received set call state request"); if (dbus_message_get_args(msg, &error, DBUS_TYPE_STRING, &state, DBUS_TYPE_STRING, &type, DBUS_TYPE_INVALID) == FALSE) { // XXX: return an error! mce_log(LL_CRIT, "Failed to get argument from %s.%s: %s", MCE_REQUEST_IF, MCE_CALL_STATE_CHANGE_REQ, error.message); dbus_error_free(&error); goto EXIT; } /* Convert call state to enum */ call_state = call_state_parse(state); if (call_state == MCE_INVALID_TRANSLATION) { mce_log(LL_DEBUG, "Invalid call state received; request ignored"); goto EXIT; } /* Convert call type to enum */ call_type = call_type_parse(type); if (call_type == MCE_INVALID_TRANSLATION) { mce_log(LL_DEBUG, "Invalid call type received; request ignored"); goto EXIT; } /* reject no-call emergency calls ... */ if( call_state == CALL_STATE_NONE ) call_type = NORMAL_CALL; /* If call state isn't monitored or if the request comes from * the owner of the current state, then some additional changes * are ok */ if( call_state_monitor_list && !mce_dbus_is_owner_monitored(sender, call_state_monitor_list) ) { mce_log(LL_DEBUG, "Call state already has owner; ignoring request"); goto EXIT; } /* Only transitions to/from "none" are allowed, * and from "ringing" to "active", * to avoid race conditions; except when new tuple * is active:emergency */ if( call_state == CALL_STATE_ACTIVE && simulated.state != CALL_STATE_RINGING && call_type != EMERGENCY_CALL ) { mce_log(LL_INFO, "Call state change vetoed. Requested: %i:%i " "(current: %i:%i)", call_state, call_type, simulated.state, simulated.type); goto EXIT; } if( call_state != CALL_STATE_NONE && mce_dbus_owner_monitor_add(sender, call_state_owner_monitor_dbus_cb, &call_state_monitor_list, 1) != -1 ) { simulated.state = call_state; simulated.type = call_type; } else { mce_dbus_owner_monitor_remove(sender, &call_state_monitor_list); simulated.state = CALL_STATE_NONE; simulated.type = NORMAL_CALL; } changed = call_state_rethink_forced(); EXIT: /* Setup the reply */ reply = dbus_new_method_reply(msg); /* Append the result */ if (dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &changed, DBUS_TYPE_INVALID) == FALSE) { mce_log(LL_CRIT, "Failed to append reply arguments to D-Bus " "message for %s.%s", MCE_REQUEST_IF, MCE_CALL_STATE_CHANGE_REQ); dbus_message_unref(reply); } else { /* Send the message */ status = dbus_send_message(reply); } return status; }