static int technology_enable(struct connman_technology *technology)
{
int err = 0;
int err_dev;
DBG("technology %p enable", technology);
__sync_synchronize();
if (technology->enabled == TRUE)
return -EALREADY;
if (technology->pending_reply != NULL)
return -EBUSY;
if (connman_setting_get_bool("PersistentTetheringMode") == TRUE &&
technology->tethering == TRUE)
set_tethering(technology, TRUE);
if (technology->rfkill_driven == TRUE)
err = __connman_rfkill_block(technology->type, FALSE);
err_dev = technology_affect_devices(technology, TRUE);
if (technology->rfkill_driven == FALSE)
err = err_dev;
return err;
}
int __connman_technology_disable(enum connman_service_type type, DBusMessage *msg)
{
struct connman_technology *technology;
GSList *list;
int err = 0;
int ret = -ENODEV;
DBusMessage *reply;
DBG("type %d disable", type);
technology = technology_find(type);
if (technology == NULL) {
err = -ENXIO;
goto done;
}
if (technology->pending_reply != NULL) {
err = -EBUSY;
goto done;
}
if (technology->tethering == TRUE)
set_tethering(technology, FALSE);
if (msg != NULL) {
technology->enable_persistent = FALSE;
save_state(technology);
}
__connman_rfkill_block(technology->type, TRUE);
for (list = technology->device_list; list; list = list->next) {
struct connman_device *device = list->data;
err = __connman_device_disable(device);
if (err == 0)
ret = 0;
}
done:
if (ret == 0) {
if (msg != NULL)
g_dbus_send_reply(connection, msg, DBUS_TYPE_INVALID);
return ret;
}
if (msg != NULL) {
if (err == -EINPROGRESS) {
technology->pending_reply = dbus_message_ref(msg);
technology->pending_timeout = g_timeout_add_seconds(10,
technology_pending_reply, technology);
} else {
reply = __connman_error_failed(msg, -err);
if (reply != NULL)
g_dbus_send_message(connection, reply);
}
}
return err;
}
int __connman_technology_remove_device(struct connman_device *device)
{
struct connman_technology *technology;
enum connman_service_type type;
DBG("device %p", device);
type = __connman_device_get_service_type(device);
technology = technology_find(type);
if (technology == NULL) {
techless_device_list = g_slist_remove(techless_device_list,
device);
return -ENXIO;
}
technology->device_list = g_slist_remove(technology->device_list,
device);
if (technology->tethering == TRUE)
set_tethering(technology, FALSE);
technology_put(technology);
return 0;
}
static void enable_tethering(struct connman_technology *technology)
{
int ret;
if (connman_setting_get_bool("PersistentTetheringMode") == FALSE)
return;
ret = set_tethering(technology, TRUE);
if (ret < 0 && ret != -EALREADY)
DBG("Cannot enable tethering yet for %s (%d/%s)",
get_name(technology->type),
-ret, strerror(-ret));
}
static int technology_disable(struct connman_technology *technology)
{
DBG("technology %p disable", technology);
__sync_synchronize();
if (technology->enabled == FALSE)
return -EALREADY;
if (technology->pending_reply != NULL)
return -EBUSY;
if (technology->tethering == TRUE)
set_tethering(technology, FALSE);
if (technology->rfkill_driven == TRUE)
return __connman_rfkill_block(technology->type, TRUE);
return technology_affect_devices(technology, FALSE);
}
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);
dbus_message_iter_get_basic(&iter, &name);
dbus_message_iter_next(&iter);
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);
dbus_message_iter_get_basic(&value, &tethering);
if (technology->tethering == tethering)
return __connman_error_in_progress(msg);
err = set_tethering(technology, tethering);
if (err < 0)
return __connman_error_failed(msg, -err);
} 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);
technology->tethering_ident = g_strdup(str);
} 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)
return __connman_error_invalid_arguments(msg);
technology->tethering_passphrase = g_strdup(str);
} else
return __connman_error_invalid_property(msg);
return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
}
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);
}