static void set_offlinemode(struct connman_device *device,
connman_bool_t offlinemode)
{
connman_bool_t powered;
DBG("device %p name %s", device, device->name);
if (device == NULL)
return;
device->offlinemode = offlinemode;
if (device->blocked == TRUE)
return;
powered = (offlinemode == TRUE) ? FALSE : TRUE;
if (device->powered == powered)
return;
if (device->powered_persistent == FALSE)
powered = FALSE;
set_powered(device, powered);
}
void manager_cleanup(struct manager *mgr)
{
DBusConnection *conn = get_dbus_connection();
if (mgr->state == ONLINE)
set_powered(conn, mgr, FALSE);
g_dbus_unregister_interface(conn, SAMSUNG_MODEM_MANAGER_PATH,
SAMSUNG_MODEM_MANAGER_INTERFACE);
ipc_client_free(mgr->client);
rfs_manager_free(mgr->rfs);
g_free(mgr);
}
static DBusMessage *manager_set_property(DBusConnection *conn, DBusMessage *msg,
void *data)
{
DBusMessageIter iter;
DBusMessageIter var;
const char *property;
struct manager *mgr = data;
if (!dbus_message_iter_init(msg, &iter))
return __dbus_error_invalid_args(msg);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return __dbus_error_invalid_args(msg);
dbus_message_iter_get_basic(&iter, &property);
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
return __dbus_error_invalid_args(msg);
dbus_message_iter_recurse(&iter, &var);
if (g_str_equal(property, "Powered") == TRUE) {
gboolean powered = FALSE;
int err;
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_BOOLEAN)
return __dbus_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &powered);
if (mgr->state == INITIALIZING)
return __dbus_error_busy(msg);
if (mgr->powered == powered)
return dbus_message_new_method_return(msg);
g_dbus_send_reply(conn, msg, DBUS_TYPE_INVALID);
err = set_powered(conn, mgr, powered);
if (err < 0)
return NULL;
return NULL;
}
return __dbus_error_invalid_args(msg);
}
static void property_set_powered(const GDBusPropertyTable *property,
DBusMessageIter *value,
GDBusPendingPropertySet id, void *data)
{
dbus_bool_t powered;
if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_BOOLEAN) {
g_dbus_pending_property_error(id,
NFC_ERROR_INTERFACE ".InvalidArguments",
"Invalid arguments in method call");
return;
}
dbus_message_iter_get_basic(value, &powered);
set_powered(id, powered, data);
}
int __connman_device_set_blocked(struct connman_device *device,
connman_bool_t blocked)
{
connman_bool_t powered;
DBG("device %p blocked %d", device, blocked);
device->blocked = blocked;
if (device->offlinemode == TRUE)
return 0;
connman_info("%s {rfkill} blocked %d", device->interface, blocked);
if (blocked == FALSE)
powered = device->powered_persistent;
else
powered = FALSE;
return set_powered(device, powered);
}
void ofono_modem_reset(struct ofono_modem *modem)
{
int err;
DBG("%p", modem);
if (modem->pending) {
DBusMessage *reply = __ofono_error_failed(modem->pending);
__ofono_dbus_pending_reply(&modem->pending, reply);
}
if (modem->modem_state == MODEM_STATE_ONLINE)
modem->get_online = TRUE;
ofono_modem_set_powered(modem, FALSE);
err = set_powered(modem, TRUE);
if (err == -EINPROGRESS)
return;
modem_change_state(modem, MODEM_STATE_PRE_SIM);
}
void __ofono_modem_shutdown(void)
{
struct ofono_modem *modem;
GSList *l;
powering_down = TRUE;
for (l = g_modem_list; l; l = l->next) {
modem = l->data;
if (modem->driver == NULL)
continue;
if (modem->powered == FALSE && modem->powered_pending == FALSE)
continue;
if (set_powered(modem, FALSE) == -EINPROGRESS)
modems_remaining += 1;
}
if (modems_remaining == 0)
__ofono_exit();
}
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 void modem_unregister(struct ofono_modem *modem)
{
DBusConnection *conn = ofono_dbus_get_connection();
DBG("%p", modem);
if (modem->powered == TRUE)
set_powered(modem, FALSE);
__ofono_watchlist_free(modem->atom_watches);
modem->atom_watches = NULL;
__ofono_watchlist_free(modem->online_watches);
modem->online_watches = NULL;
__ofono_watchlist_free(modem->powered_watches);
modem->powered_watches = NULL;
modem->sim_watch = 0;
modem->sim_ready_watch = 0;
g_slist_foreach(modem->interface_list, (GFunc) g_free, NULL);
g_slist_free(modem->interface_list);
modem->interface_list = NULL;
g_slist_foreach(modem->feature_list, (GFunc) g_free, NULL);
g_slist_free(modem->feature_list);
modem->feature_list = NULL;
if (modem->timeout) {
g_source_remove(modem->timeout);
modem->timeout = 0;
}
if (modem->pending) {
dbus_message_unref(modem->pending);
modem->pending = NULL;
}
if (modem->interface_update) {
g_source_remove(modem->interface_update);
modem->interface_update = 0;
}
if (modem->lock_watch) {
lockdown_remove(modem);
ofono_dbus_signal_property_changed(conn, modem->path,
OFONO_MODEM_INTERFACE,
"Lockdown", DBUS_TYPE_BOOLEAN,
&modem->lockdown);
}
g_dbus_unregister_interface(conn, modem->path, OFONO_MODEM_INTERFACE);
if (modem->driver && modem->driver->remove)
modem->driver->remove(modem);
g_hash_table_destroy(modem->properties);
modem->properties = NULL;
modem->driver = NULL;
emit_modem_removed(modem);
call_modemwatches(modem, FALSE);
}
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);
}
static DBusMessage *set_property(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct connman_technology *technology = data;
DBusMessageIter iter, value;
const char *name;
int type;
DBG("conn %p", conn);
if (dbus_message_iter_init(msg, &iter) == FALSE)
return __connman_error_invalid_arguments(msg);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return __connman_error_invalid_arguments(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 __connman_error_invalid_arguments(msg);
dbus_message_iter_recurse(&iter, &value);
type = dbus_message_iter_get_arg_type(&value);
DBG("property %s", name);
if (g_str_equal(name, "Tethering") == TRUE) {
int err;
connman_bool_t tethering;
if (type != DBUS_TYPE_BOOLEAN)
return __connman_error_invalid_arguments(msg);
if (connman_technology_is_tethering_allowed(technology->type)
== FALSE) {
DBG("%s tethering not allowed by config file",
__connman_service_type2string(technology->type));
return __connman_error_not_supported(msg);
}
dbus_message_iter_get_basic(&value, &tethering);
if (technology->tethering == tethering) {
if (tethering == FALSE)
return __connman_error_already_disabled(msg);
else
return __connman_error_already_enabled(msg);
}
err = set_tethering(technology, tethering);
if (err < 0)
return __connman_error_failed(msg, -err);
technology->tethering_persistent = tethering;
technology_save(technology);
} else if (g_str_equal(name, "TetheringIdentifier") == TRUE) {
const char *str;
dbus_message_iter_get_basic(&value, &str);
if (technology->type != CONNMAN_SERVICE_TYPE_WIFI)
return __connman_error_not_supported(msg);
if (strlen(str) < 1 || strlen(str) > 32)
return __connman_error_invalid_arguments(msg);
if (g_strcmp0(technology->tethering_ident, str) != 0) {
g_free(technology->tethering_ident);
technology->tethering_ident = g_strdup(str);
technology_save(technology);
connman_dbus_property_changed_basic(technology->path,
CONNMAN_TECHNOLOGY_INTERFACE,
"TetheringIdentifier",
DBUS_TYPE_STRING,
&technology->tethering_ident);
}
} else if (g_str_equal(name, "TetheringPassphrase") == TRUE) {
const char *str;
dbus_message_iter_get_basic(&value, &str);
if (technology->type != CONNMAN_SERVICE_TYPE_WIFI)
return __connman_error_not_supported(msg);
if (strlen(str) < 8 || strlen(str) > 63)
return __connman_error_passphrase_required(msg);
if (g_strcmp0(technology->tethering_passphrase, str) != 0) {
g_free(technology->tethering_passphrase);
technology->tethering_passphrase = g_strdup(str);
technology_save(technology);
connman_dbus_property_changed_basic(technology->path,
CONNMAN_TECHNOLOGY_INTERFACE,
"TetheringPassphrase",
DBUS_TYPE_STRING,
&technology->tethering_passphrase);
}
} else if (g_str_equal(name, "Powered") == TRUE) {
connman_bool_t enable;
if (type != DBUS_TYPE_BOOLEAN)
return __connman_error_invalid_arguments(msg);
dbus_message_iter_get_basic(&value, &enable);
return set_powered(technology, msg, enable);
} else
return __connman_error_invalid_property(msg);
return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
}
