int __connman_technology_add_rfkill(unsigned int index,
enum connman_service_type type,
connman_bool_t softblock,
connman_bool_t hardblock)
{
struct connman_technology *technology;
struct connman_rfkill *rfkill;
DBG("index %u type %d soft %u hard %u", index, type,
softblock, hardblock);
rfkill = g_hash_table_lookup(rfkill_list, GINT_TO_POINTER(index));
if (rfkill != NULL)
goto done;
rfkill = g_try_new0(struct connman_rfkill, 1);
if (rfkill == NULL)
return -ENOMEM;
rfkill->index = index;
rfkill->type = type;
rfkill->softblock = softblock;
rfkill->hardblock = hardblock;
g_hash_table_insert(rfkill_list, GINT_TO_POINTER(index), rfkill);
done:
technology = technology_get(type);
/* If there is no driver for this type, ignore it. */
if (technology == NULL)
return -ENXIO;
technology->rfkill_driven = TRUE;
/* If hardblocked, there is no need to handle softblocked state */
if (technology_apply_rfkill_change(technology,
softblock, hardblock, TRUE) == TRUE)
return 0;
/*
* Depending on softblocked state we unblock/block according to
* offlinemode and persistente state.
*/
if (technology->softblocked == TRUE &&
global_offlinemode == FALSE &&
technology->enable_persistent == TRUE)
return __connman_rfkill_block(type, FALSE);
else if (technology->softblocked == FALSE &&
(global_offlinemode == TRUE ||
technology->enable_persistent == FALSE))
return __connman_rfkill_block(type, TRUE);
return 0;
}
int __connman_technology_add_rfkill(unsigned int index,
enum connman_service_type type,
connman_bool_t softblock,
connman_bool_t hardblock)
{
struct connman_technology *technology;
struct connman_rfkill *rfkill;
DBG("index %u type %d soft %u hard %u", index, type,
softblock, hardblock);
technology = technology_get(type);
if (technology == NULL)
return -ENXIO;
rfkill = g_try_new0(struct connman_rfkill, 1);
if (rfkill == NULL)
return -ENOMEM;
__connman_notifier_register(type);
rfkill->index = index;
rfkill->type = type;
rfkill->softblock = softblock;
rfkill->hardblock = hardblock;
g_hash_table_replace(technology->rfkill_list, &rfkill->index, rfkill);
if (hardblock) {
DBG("%s is switched off.", get_name(type));
return 0;
}
/*
* If Offline mode is on, we softblock the device if it isnt already.
* If Offline mode is off, we rely on the persistent state of tech.
*/
if (global_offlinemode) {
if (!softblock)
return __connman_rfkill_block(type, TRUE);
} else {
if (technology->enable_persistent && softblock)
return __connman_rfkill_block(type, FALSE);
/* if technology persistent state is offline */
if (!technology->enable_persistent && !softblock)
return __connman_rfkill_block(type, TRUE);
}
return 0;
}
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;
}
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_update_rfkill(unsigned int index,
enum connman_service_type type,
connman_bool_t softblock,
connman_bool_t hardblock)
{
struct connman_technology *technology;
struct connman_rfkill *rfkill;
DBG("index %u soft %u hard %u", index, softblock, hardblock);
rfkill = g_hash_table_lookup(rfkill_list, GINT_TO_POINTER(index));
if (rfkill == NULL)
return -ENXIO;
if (rfkill->softblock == softblock &&
rfkill->hardblock == hardblock)
return 0;
rfkill->softblock = softblock;
rfkill->hardblock = hardblock;
technology = technology_find(type);
/* If there is no driver for this type, ignore it. */
if (technology == NULL)
return -ENXIO;
/* If hardblocked, there is no need to handle softblocked state */
if (technology_apply_rfkill_change(technology,
softblock, hardblock, FALSE) == TRUE)
return 0;
if (global_offlinemode == TRUE)
return 0;
/*
* Depending on softblocked state we unblock/block according to
* persistent state.
*/
if (technology->softblocked == TRUE &&
technology->enable_persistent == TRUE)
return __connman_rfkill_block(type, FALSE);
else if (technology->softblocked == FALSE &&
technology->enable_persistent == FALSE)
return __connman_rfkill_block(type, TRUE);
return 0;
}
int __connman_technology_update_rfkill(unsigned int index,
enum connman_service_type type,
connman_bool_t softblock,
connman_bool_t hardblock)
{
struct connman_technology *technology;
struct connman_rfkill *rfkill;
DBG("index %u soft %u hard %u", index, softblock, hardblock);
technology = technology_find(type);
if (technology == NULL)
return -ENXIO;
rfkill = g_hash_table_lookup(technology->rfkill_list, &index);
if (rfkill == NULL)
return -ENXIO;
if (rfkill->softblock == softblock &&
rfkill->hardblock == hardblock)
return 0;
rfkill->softblock = softblock;
rfkill->hardblock = hardblock;
if (hardblock) {
DBG("%s is switched off.", get_name(type));
return 0;
}
if (!global_offlinemode) {
if (technology->enable_persistent && softblock)
return __connman_rfkill_block(type, FALSE);
if (!technology->enable_persistent && !softblock)
return __connman_rfkill_block(type, TRUE);
}
return 0;
}
static int technology_enable(struct connman_technology *technology)
{
DBG("technology %p enable", technology);
__sync_synchronize();
if (technology->enabled == TRUE)
return -EALREADY;
if (technology->pending_reply != NULL)
return -EBUSY;
if (technology->rfkill_driven == TRUE)
return __connman_rfkill_block(technology->type, FALSE);
return technology_affect_devices(technology, TRUE);
}
static int technology_disable(struct connman_technology *technology)
{
int err;
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);
err = technology_affect_devices(technology, FALSE);
if (technology->rfkill_driven == TRUE)
err = __connman_rfkill_block(technology->type, TRUE);
return err;
}
int __connman_technology_enable(enum connman_service_type type, DBusMessage *msg)
{
struct connman_technology *technology;
GSList *list;
int err = 0;
int ret = -ENODEV;
DBusMessage *reply;
DBG("type %d enable", type);
technology = technology_find(type);
if (technology == NULL) {
err = -ENXIO;
goto done;
}
if (technology->pending_reply != NULL) {
err = -EBUSY;
goto done;
}
if (msg != NULL) {
/*
* This is a bit of a trick. When msg is not NULL it means
* thats technology_enable was invoked from the manager API. Hence we save
* the state here.
*/
technology->enable_persistent = TRUE;
save_state(technology);
}
__connman_rfkill_block(technology->type, FALSE);
/*
* An empty device list means that devices in the technology
* were rfkill blocked. The unblock above will enable the devs.
*/
if (technology->device_list == NULL)
return 0;
for (list = technology->device_list; list; list = list->next) {
struct connman_device *device = list->data;
err = __connman_device_enable(device);
/*
* err = 0 : Device was enabled right away.
* If atleast one device gets enabled, we consider
* the technology to be enabled.
*/
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;
}
