static DBusMessage *gnss_send_element(DBusConnection *conn,
DBusMessage *msg, void *data)
{
const char *caller = dbus_message_get_sender(msg);
struct ofono_gnss *gnss = data;
const char *xml;
DBG("");
if (gnss->pending)
return __ofono_error_busy(msg);
if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &xml,
DBUS_TYPE_INVALID))
return __ofono_error_invalid_args(msg);
if (gnss->posr_agent == NULL)
return __ofono_error_not_available(msg);
if (!gnss_agent_sender_matches(gnss->posr_agent, caller))
return __ofono_error_access_denied(msg);
gnss->pending = dbus_message_ref(msg);
gnss->driver->send_element(gnss, xml, gnss_send_element_cb, gnss);
return NULL;
}
static DBusMessage *gnss_unregister_agent(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct ofono_gnss *gnss = data;
const char *agent_path;
const char *agent_bus = dbus_message_get_sender(msg);
if (gnss->pending)
return __ofono_error_busy(msg);
if (dbus_message_get_args(msg, NULL,
DBUS_TYPE_OBJECT_PATH, &agent_path,
DBUS_TYPE_INVALID) == FALSE)
return __ofono_error_invalid_args(msg);
if (gnss->posr_agent == NULL)
return __ofono_error_failed(msg);
if (!gnss_agent_matches(gnss->posr_agent, agent_path, agent_bus))
return __ofono_error_access_denied(msg);
gnss->pending = dbus_message_ref(msg);
gnss->enabled = FALSE;
gnss->driver->set_position_reporting(gnss, FALSE,
gnss_unregister_agent_cb,
gnss);
return NULL;
}
static DBusMessage *message_cancel(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct message *m = data;
int res;
if (dbus_message_get_args(msg, NULL, DBUS_TYPE_INVALID) == FALSE)
return __ofono_error_invalid_args(msg);
if (m->state != MESSAGE_STATE_PENDING)
return __ofono_error_not_available(msg);
res = __ofono_sms_txq_cancel(__ofono_atom_get_data(m->atom), &m->uuid);
switch (res) {
case -ENOENT:
return __ofono_error_not_found(msg);
case -EPERM:
return __ofono_error_access_denied(msg);
case 0:
return dbus_message_new_method_return(msg);
default:
return __ofono_error_failed(msg);
}
}
static DBusMessage *location_reporting_release(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct ofono_location_reporting *lr = data;
const char *caller = dbus_message_get_sender(msg);
/*
* Avoid a race by not trying to release the device if there is a
* pending message or client already signaled it's exiting. In the
* later case, the device will eventually be released in
* client_exited_disable_cb().
*/
if (lr->pending != NULL || (lr->enabled && !lr->disconnect_watch))
return __ofono_error_busy(msg);
if (lr->enabled == FALSE)
return __ofono_error_not_available(msg);
if (g_strcmp0(caller, lr->client_owner))
return __ofono_error_access_denied(msg);
lr->pending = dbus_message_ref(msg);
lr->driver->disable(lr, location_reporting_disable_cb, lr);
return NULL;
}
static DBusMessage *set_property_lockdown(struct ofono_modem *modem,
DBusMessage *msg,
DBusMessageIter *var)
{
DBusConnection *conn = ofono_dbus_get_connection();
ofono_bool_t lockdown;
dbus_bool_t powered;
const char *caller;
int err;
if (dbus_message_iter_get_arg_type(var) != DBUS_TYPE_BOOLEAN)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(var, &lockdown);
if (modem->pending != NULL)
return __ofono_error_busy(msg);
caller = dbus_message_get_sender(msg);
if (modem->lockdown && g_strcmp0(caller, modem->lock_owner))
return __ofono_error_access_denied(msg);
if (modem->lockdown == lockdown)
return dbus_message_new_method_return(msg);
if (lockdown == FALSE) {
lockdown_remove(modem);
goto done;
}
if (ofono_modem_get_emergency_mode(modem) == TRUE)
return __ofono_error_emergency_active(msg);
modem->lock_owner = g_strdup(caller);
modem->lock_watch = g_dbus_add_disconnect_watch(conn,
modem->lock_owner, lockdown_disconnect,
modem, NULL);
if (modem->lock_watch == 0) {
g_free(modem->lock_owner);
modem->lock_owner = NULL;
return __ofono_error_failed(msg);
}
modem->lockdown = lockdown;
if (modem->powered == FALSE)
goto done;
err = set_powered(modem, FALSE);
if (err < 0) {
if (err != -EINPROGRESS) {
lockdown_remove(modem);
return __ofono_error_failed(msg);
}
modem->pending = dbus_message_ref(msg);
modem->timeout = g_timeout_add_seconds(20,
set_powered_timeout, modem);
return NULL;
}
set_online(modem, FALSE);
powered = FALSE;
ofono_dbus_signal_property_changed(conn, modem->path,
OFONO_MODEM_INTERFACE,
"Powered", DBUS_TYPE_BOOLEAN,
&powered);
done:
g_dbus_send_reply(conn, msg, DBUS_TYPE_INVALID);
ofono_dbus_signal_property_changed(conn, modem->path,
OFONO_MODEM_INTERFACE,
"Lockdown", DBUS_TYPE_BOOLEAN,
&lockdown);
return NULL;
}
static DBusMessage *modem_set_property(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct ofono_modem *modem = data;
DBusMessageIter iter, var;
const char *name;
if (dbus_message_iter_init(msg, &iter) == FALSE)
return __ofono_error_invalid_args(msg);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&iter, &name);
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
return __ofono_error_invalid_args(msg);
if (powering_down == TRUE)
return __ofono_error_failed(msg);
dbus_message_iter_recurse(&iter, &var);
if (g_str_equal(name, "Online"))
return set_property_online(modem, msg, &var);
if (g_str_equal(name, "Powered") == TRUE) {
ofono_bool_t powered;
int err;
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_BOOLEAN)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &powered);
if (modem->pending != NULL)
return __ofono_error_busy(msg);
if (modem->powered == powered)
return dbus_message_new_method_return(msg);
if (ofono_modem_get_emergency_mode(modem) == TRUE)
return __ofono_error_emergency_active(msg);
if (modem->lockdown)
return __ofono_error_access_denied(msg);
err = set_powered(modem, powered);
if (err < 0) {
if (err != -EINPROGRESS)
return __ofono_error_failed(msg);
modem->pending = dbus_message_ref(msg);
modem->timeout = g_timeout_add_seconds(20,
set_powered_timeout, modem);
return NULL;
}
g_dbus_send_reply(conn, msg, DBUS_TYPE_INVALID);
ofono_dbus_signal_property_changed(conn, modem->path,
OFONO_MODEM_INTERFACE,
"Powered", DBUS_TYPE_BOOLEAN,
&powered);
if (powered) {
modem_change_state(modem, MODEM_STATE_PRE_SIM);
/* Force SIM Ready for devies with no sim atom */
if (modem_has_sim(modem) == FALSE)
sim_state_watch(OFONO_SIM_STATE_READY, modem);
} else {
set_online(modem, FALSE);
modem_change_state(modem, MODEM_STATE_POWER_OFF);
}
return NULL;
}
if (g_str_equal(name, "Lockdown"))
return set_property_lockdown(modem, msg, &var);
return __ofono_error_invalid_args(msg);
}
