void __connman_technology_remove_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("Remove interface %s [ %s ]", name,
__connman_service_type2string(type));
technology = technology_find(type);
if (technology == NULL || technology->driver == NULL)
return;
if (technology->driver->remove_interface)
technology->driver->remove_interface(technology, index);
technology_put(technology);
}
static void technology_default(enum connman_service_type type)
{
const char *str;
str = __connman_service_type2string(type);
if (str == NULL)
str = "";
connman_dbus_property_changed_basic(CONNMAN_MANAGER_PATH,
CONNMAN_MANAGER_INTERFACE, "DefaultTechnology",
DBUS_TYPE_STRING, &str);
}
static DBusMessage *get_properties(DBusConnection *conn,
DBusMessage *message, void *user_data)
{
struct connman_technology *technology = user_data;
DBusMessage *reply;
DBusMessageIter array, dict;
const char *str;
reply = dbus_message_new_method_return(message);
if (reply == NULL)
return NULL;
dbus_message_iter_init_append(reply, &array);
connman_dbus_dict_open(&array, &dict);
str = state2string(technology->state);
if (str != NULL)
connman_dbus_dict_append_basic(&dict, "State",
DBUS_TYPE_STRING, &str);
str = get_name(technology->type);
if (str != NULL)
connman_dbus_dict_append_basic(&dict, "Name",
DBUS_TYPE_STRING, &str);
str = __connman_service_type2string(technology->type);
if (str != NULL)
connman_dbus_dict_append_basic(&dict, "Type",
DBUS_TYPE_STRING, &str);
connman_dbus_dict_append_basic(&dict, "Tethering",
DBUS_TYPE_BOOLEAN,
&technology->tethering);
if (technology->tethering_ident != NULL)
connman_dbus_dict_append_basic(&dict, "TetheringIdentifier",
DBUS_TYPE_STRING,
&technology->tethering_ident);
if (technology->tethering_passphrase != NULL)
connman_dbus_dict_append_basic(&dict, "TetheringPassphrase",
DBUS_TYPE_STRING,
&technology->tethering_passphrase);
connman_dbus_dict_close(&array, &dict);
return reply;
}
void __connman_notifier_list_enabled(DBusMessageIter *iter, void *user_data)
{
int i;
for (i = 0; i < MAX_TECHNOLOGIES; i++) {
const char *type = __connman_service_type2string(i);
if (type == NULL)
continue;
if (g_atomic_int_get(&enabled[i]) > 0)
dbus_message_iter_append_basic(iter,
DBUS_TYPE_STRING, &type);
}
}
void __connman_notifier_list_registered(DBusMessageIter *iter, void *user_data)
{
int i;
__sync_synchronize();
for (i = 0; i < MAX_TECHNOLOGIES; i++) {
const char *type = __connman_service_type2string(i);
if (type == NULL)
continue;
if (registered[i] > 0)
dbus_message_iter_append_basic(iter,
DBUS_TYPE_STRING, &type);
}
}
static void append_allowed_bearers(DBusMessageIter *iter, void *user_data)
{
struct session_info *info = user_data;
GSList *list;
for (list = info->config.allowed_bearers;
list; list = list->next) {
enum connman_service_type bearer = GPOINTER_TO_INT(list->data);
const char *name = __connman_service_type2string(bearer);
if (!name)
name = "";
dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
&name);
}
}
void __connman_technology_add_interface(enum connman_service_type type,
int index, const char *name, const char *ident)
{
struct connman_technology *technology;
GSList *tech_drivers;
struct connman_technology_driver *driver;
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_BLUETOOTH:
case CONNMAN_SERVICE_TYPE_CELLULAR:
case CONNMAN_SERVICE_TYPE_GPS:
case CONNMAN_SERVICE_TYPE_VPN:
case CONNMAN_SERVICE_TYPE_GADGET:
break;
}
connman_info("Adding interface %s [ %s ]", name,
__connman_service_type2string(type));
technology = technology_find(type);
if (technology == NULL)
return;
for (tech_drivers = technology->driver_list; tech_drivers != NULL;
tech_drivers = g_slist_next(tech_drivers)) {
driver = tech_drivers->data;
if(driver->add_interface != NULL)
driver->add_interface(technology, index, name, ident);
}
/*
* At this point we can try to enable tethering automatically as
* now the interfaces are set properly.
*/
if (technology->tethering_persistent == TRUE)
enable_tethering(technology);
}
static void append_properties(DBusMessageIter *iter,
struct connman_technology *technology)
{
DBusMessageIter dict;
const char *str;
connman_dbus_dict_open(iter, &dict);
str = get_name(technology->type);
if (str != NULL)
connman_dbus_dict_append_basic(&dict, "Name",
DBUS_TYPE_STRING, &str);
str = __connman_service_type2string(technology->type);
if (str != NULL)
connman_dbus_dict_append_basic(&dict, "Type",
DBUS_TYPE_STRING, &str);
__sync_synchronize();
connman_dbus_dict_append_basic(&dict, "Powered",
DBUS_TYPE_BOOLEAN,
&technology->enabled);
connman_dbus_dict_append_basic(&dict, "Connected",
DBUS_TYPE_BOOLEAN,
&technology->connected);
connman_dbus_dict_append_basic(&dict, "Tethering",
DBUS_TYPE_BOOLEAN,
&technology->tethering);
if (technology->tethering_ident != NULL)
connman_dbus_dict_append_basic(&dict, "TetheringIdentifier",
DBUS_TYPE_STRING,
&technology->tethering_ident);
if (technology->tethering_passphrase != NULL)
connman_dbus_dict_append_basic(&dict, "TetheringPassphrase",
DBUS_TYPE_STRING,
&technology->tethering_passphrase);
connman_dbus_dict_close(iter, &dict);
}
connman_bool_t
connman_technology_is_tethering_allowed(enum connman_service_type type)
{
static char *allowed_default[] = { "wifi", "bluetooth", "gadget",
NULL };
const char *type_str = __connman_service_type2string(type);
char **allowed;
int i;
if (type_str == NULL)
return FALSE;
allowed = connman_setting_get_string_list("TetheringTechnologies");
if (allowed == NULL)
allowed = allowed_default;
for (i = 0; allowed[i] != NULL; i++) {
if (g_strcmp0(allowed[i], type_str) == 0)
return TRUE;
}
return FALSE;
}
void __connman_technology_remove_interface(enum connman_service_type type,
int index, const char *name, const char *ident)
{
struct connman_technology *technology;
GSList *tech_drivers;
struct connman_technology_driver *driver;
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_BLUETOOTH:
case CONNMAN_SERVICE_TYPE_CELLULAR:
case CONNMAN_SERVICE_TYPE_GPS:
case CONNMAN_SERVICE_TYPE_VPN:
case CONNMAN_SERVICE_TYPE_GADGET:
break;
}
connman_info("Remove interface %s [ %s ]", name,
__connman_service_type2string(type));
technology = technology_find(type);
if (technology == NULL)
return;
for (tech_drivers = technology->driver_list; tech_drivers != NULL;
tech_drivers = g_slist_next(tech_drivers)) {
driver = tech_drivers->data;
if(driver->remove_interface != NULL)
driver->remove_interface(technology, index);
}
}
static struct connman_technology *technology_get(enum connman_service_type type)
{
struct connman_technology *technology;
struct connman_technology_driver *driver = NULL;
const char *str;
GSList *list;
int err;
DBG("type %d", type);
str = __connman_service_type2string(type);
if (str == NULL)
return NULL;
technology = technology_find(type);
if (technology != NULL)
return technology;
/* First check if we have a driver for this technology type */
for (list = driver_list; list; list = list->next) {
driver = list->data;
if (driver->type == type)
break;
else
driver = NULL;
}
if (driver == NULL) {
DBG("No matching driver found for %s.",
__connman_service_type2string(type));
return NULL;
}
technology = g_try_new0(struct connman_technology, 1);
if (technology == NULL)
return NULL;
technology->refcount = 1;
technology->type = type;
technology->path = g_strdup_printf("%s/technology/%s",
CONNMAN_PATH, str);
technology->rfkill_list = g_hash_table_new_full(g_int_hash, g_int_equal,
NULL, free_rfkill);
technology->device_list = NULL;
technology->pending_reply = NULL;
technology->state = CONNMAN_TECHNOLOGY_STATE_OFFLINE;
load_state(technology);
if (g_dbus_register_interface(connection, technology->path,
CONNMAN_TECHNOLOGY_INTERFACE,
technology_methods, technology_signals,
NULL, technology, NULL) == FALSE) {
connman_error("Failed to register %s", technology->path);
g_free(technology);
return NULL;
}
technology_list = g_slist_append(technology_list, technology);
technologies_changed();
technology->driver = driver;
err = driver->probe(technology);
if (err != 0)
DBG("Driver probe failed for technology %p", technology);
DBG("technology %p", technology);
return technology;
}
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);
}
static struct connman_technology *technology_get(enum connman_service_type type)
{
GSList *tech_drivers = NULL;
struct connman_technology_driver *driver;
struct connman_technology *technology;
const char *str;
GSList *list;
DBG("type %d", type);
str = __connman_service_type2string(type);
if (str == NULL)
return NULL;
technology = technology_find(type);
if (technology != NULL) {
__sync_fetch_and_add(&technology->refcount, 1);
return technology;
}
/* First check if we have a driver for this technology type */
for (list = driver_list; list; list = list->next) {
driver = list->data;
if (driver->type == type) {
DBG("technology %p driver %p", technology, driver);
tech_drivers = g_slist_append(tech_drivers, driver);
}
}
if (tech_drivers == NULL) {
DBG("No matching drivers found for %s.",
__connman_service_type2string(type));
return NULL;
}
technology = g_try_new0(struct connman_technology, 1);
if (technology == NULL)
return NULL;
technology->refcount = 1;
technology->rfkill_driven = FALSE;
technology->softblocked = FALSE;
technology->hardblocked = FALSE;
technology->type = type;
technology->path = g_strdup_printf("%s/technology/%s",
CONNMAN_PATH, str);
technology->device_list = NULL;
technology->pending_reply = NULL;
technology_load(technology);
if (technology_dbus_register(technology) == FALSE) {
g_free(technology);
return NULL;
}
technology_list = g_slist_prepend(technology_list, technology);
technology->driver_list = tech_drivers;
for (list = tech_drivers; list != NULL; list = g_slist_next(list)) {
driver = list->data;
if (driver->probe != NULL && driver->probe(technology) < 0)
DBG("Driver probe failed for technology %p",
technology);
}
DBG("technology %p", technology);
return technology;
}
