int __connman_technology_add_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);
__connman_notifier_register(type);
technology = technology_get(type);
if (technology == NULL)
return -ENXIO;
if (technology->enable_persistent && !global_offlinemode)
__connman_device_enable(device);
/* if technology persistent state is offline */
if (!technology->enable_persistent)
__connman_device_disable(device);
technology->device_list = g_slist_append(technology->device_list,
device);
return 0;
}
void __connman_technology_add_interface(enum connman_service_type type,
int index, const char *name, const char *ident)
{
struct connman_technology *technology;
switch (type) {
case CONNMAN_SERVICE_TYPE_UNKNOWN:
case CONNMAN_SERVICE_TYPE_SYSTEM:
return;
case CONNMAN_SERVICE_TYPE_ETHERNET:
case CONNMAN_SERVICE_TYPE_WIFI:
case CONNMAN_SERVICE_TYPE_WIMAX:
case CONNMAN_SERVICE_TYPE_BLUETOOTH:
case CONNMAN_SERVICE_TYPE_CELLULAR:
case CONNMAN_SERVICE_TYPE_GPS:
case CONNMAN_SERVICE_TYPE_VPN:
case CONNMAN_SERVICE_TYPE_GADGET:
break;
}
connman_info("Create interface %s [ %s ]", name,
__connman_service_type2string(type));
technology = technology_get(type);
if (technology == NULL || technology->driver == NULL
|| technology->driver->add_interface == NULL)
return;
technology->driver->add_interface(technology,
index, name, ident);
}
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_device(struct connman_device *device)
{
struct connman_technology *technology;
enum connman_service_type type;
type = __connman_device_get_service_type(device);
DBG("device %p type %s", device, get_name(type));
technology = technology_get(type);
if (technology == NULL) {
/*
* Since no driver can be found for this device at the moment we
* add it to the techless device list.
*/
techless_device_list = g_slist_prepend(techless_device_list,
device);
return -ENXIO;
}
__sync_synchronize();
if (technology->rfkill_driven == TRUE) {
if (technology->enabled == TRUE && global_offlinemode == FALSE)
__connman_device_enable(device);
else
__connman_device_disable(device);
goto done;
}
if (technology->enable_persistent == TRUE &&
global_offlinemode == FALSE) {
int err = __connman_device_enable(device);
/*
* connman_technology_add_device() calls __connman_device_enable()
* but since the device is already enabled, the calls does not
* propagate through to connman_technology_enabled via
* connman_device_set_powered.
*/
if (err == -EALREADY)
__connman_technology_enabled(type);
}
/* if technology persistent state is offline */
if (technology->enable_persistent == FALSE)
__connman_device_disable(device);
done:
technology->device_list = g_slist_prepend(technology->device_list,
device);
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;
}
