static void service_set_name(GtkService *service)
{
const char *name;
char *markup;
name = connman_service_get_name(service->path);
if (name == NULL)
name = "- Hidden -";
if (connman_service_is_favorite(service->path) == TRUE) {
if (g_strcmp0(connman_service_get_type(service->path),
"wifi") == 0) {
markup = g_markup_printf_escaped(
"<b>%s</b> <i> (%s) </i>",
name,
connman_service_get_security(service->path));
} else
markup = g_markup_printf_escaped("<b>%s</b>", name);
} else {
if (g_strcmp0(connman_service_get_type(service->path),
"wifi") == 0) {
markup = g_markup_printf_escaped(
"%s <i> (%s) </i>", name,
connman_service_get_security(service->path));
} else
markup = g_markup_printf_escaped("%s", name);
}
gtk_label_set_markup(service->priv->name, markup);
g_free(markup);
}
static bool session_match_service(struct connman_session *session,
struct connman_service *service)
{
enum connman_service_type bearer_type;
enum connman_service_type service_type;
enum connman_service_type current_service_type;
GSList *list;
char *ifname;
if (policy && policy->allowed)
return policy->allowed(session, service);
current_service_type = connman_service_get_type(session->service);
for (list = session->info->config.allowed_bearers; list; list = list->next) {
bearer_type = GPOINTER_TO_INT(list->data);
service_type = connman_service_get_type(service);
ifname = connman_service_get_interface(service);
if (bearer_type == current_service_type)
return false;
if (bearer_type == service_type &&
(session->info->config.allowed_interface == NULL ||
!g_strcmp0(session->info->config.allowed_interface, "*") ||
!g_strcmp0(session->info->config.allowed_interface, ifname))) {
g_free(ifname);
return true;
}
g_free(ifname);
}
return false;
}
static void populate_service_list(struct connman_session *session)
{
struct service_entry *entry;
GSequenceIter *iter;
session->service_hash =
g_hash_table_new_full(g_direct_hash, g_direct_equal,
NULL, NULL);
session->service_list = __connman_service_get_list(session,
service_match,
create_service_entry,
destroy_service_entry);
g_sequence_sort(session->service_list, sort_services, session);
iter = g_sequence_get_begin_iter(session->service_list);
while (g_sequence_iter_is_end(iter) == FALSE) {
entry = g_sequence_get(iter);
DBG("service %p type %s name %s", entry->service,
service2bearer(connman_service_get_type(entry->service)),
entry->name);
g_hash_table_replace(session->service_hash,
entry->service, iter);
iter = g_sequence_iter_next(iter);
}
}
static struct service_entry *create_service_entry(struct connman_service *service,
const char *name,
enum connman_service_state state)
{
struct service_entry *entry;
enum connman_service_type type;
int idx;
entry = g_try_new0(struct service_entry, 1);
if (entry == NULL)
return entry;
entry->reason = CONNMAN_SESSION_REASON_UNKNOWN;
entry->state = state;
if (name != NULL)
entry->name = name;
else
entry->name = "";
entry->service = service;
idx = __connman_service_get_index(entry->service);
entry->ifname = connman_inet_ifname(idx);
if (entry->ifname == NULL)
entry->ifname = g_strdup("");
type = connman_service_get_type(entry->service);
entry->bearer = service2bearer(type);
return entry;
}
static gint sort_allowed_bearers(struct connman_service *service_a,
struct connman_service *service_b,
struct connman_session *session)
{
struct session_info *info = session->info;
GSList *list;
enum connman_service_type type_a, type_b;
int weight_a, weight_b;
type_a = connman_service_get_type(service_a);
type_b = connman_service_get_type(service_b);
for (list = info->config.allowed_bearers;
list != NULL; list = list->next) {
enum connman_service_type bearer = GPOINTER_TO_INT(list->data);
if (bearer == CONNMAN_SERVICE_TYPE_UNKNOWN) {
if (type_a != type_b) {
weight_a = service_type_weight(type_a);
weight_b = service_type_weight(type_b);
if (weight_a > weight_b)
return -1;
if (weight_a < weight_b)
return 1;
return 0;
}
}
if (type_a == bearer && type_b == bearer)
return 0;
if (type_a == bearer && type_b != bearer)
return -1;
if (type_a != bearer && type_b == bearer)
return 1;
}
return 0;
}
static void update_header(void)
{
GdkPixbuf *image = NULL;
const char *type, *info;
GtkWidget *widget;
gboolean favorite;
type = connman_service_get_type(path);
if (g_strcmp0(type, "wifi") == 0) {
uint8_t strength;
strength = connman_service_get_strength(path);
cui_theme_get_signal_icone_and_info(strength, &image, &info);
} else
cui_theme_get_type_icone_and_info(type, &image, &info);
set_image(builder, "service_type", image, info);
set_label(builder, "service_name",
connman_service_get_name(path), "- Hidden -");
if (connman_service_is_connected(path) == TRUE)
cui_theme_get_state_icone_and_info(
connman_service_get_state(path), &image, &info);
else
image = NULL;
set_image(builder, "service_state", image, info);
set_label(builder, "service_error",
connman_service_get_error(path), "");
favorite = connman_service_is_favorite(path);
set_button_toggle(builder, "service_autoconnect",
connman_service_is_autoconnect(path));
widget = set_widget_sensitive(builder,
"service_autoconnect", favorite);
if (favorite == TRUE) {
g_signal_connect(widget, "toggled",
G_CALLBACK(autoconnect_button_toggled), NULL);
}
set_button_toggle(builder, "service_favorite", favorite);
widget = set_widget_sensitive(builder, "service_favorite", favorite);
if (favorite == TRUE) {
g_signal_connect(widget, "toggled",
G_CALLBACK(favorite_button_toggled), NULL);
}
}
void __connman_notifier_default_changed(struct connman_service *service)
{
enum connman_service_type type = connman_service_get_type(service);
char *interface;
GSList *list;
technology_default(type);
interface = connman_service_get_interface(service);
__connman_tethering_update_interface(interface);
g_free(interface);
for (list = notifier_list; list; list = list->next) {
struct connman_notifier *notifier = list->data;
if (notifier->default_changed)
notifier->default_changed(service);
}
}
static bool session_match_service(struct connman_session *session,
struct connman_service *service)
{
enum connman_service_type bearer_type;
enum connman_service_type service_type;
GSList *list;
if (policy && policy->allowed)
return policy->allowed(session, service);
for (list = session->info->config.allowed_bearers; list; list = list->next) {
bearer_type = GPOINTER_TO_INT(list->data);
service_type = connman_service_get_type(service);
if (bearer_type == service_type)
return true;
}
return false;
}
static connman_bool_t service_type_match(struct connman_session *session,
struct connman_service *service)
{
struct session_info *info = session->info;
GSList *list;
for (list = info->config.allowed_bearers;
list != NULL; list = list->next) {
enum connman_service_type bearer = GPOINTER_TO_INT(list->data);
enum connman_service_type service_type;
if (bearer == CONNMAN_SERVICE_TYPE_UNKNOWN)
return TRUE;
service_type = connman_service_get_type(service);
if (bearer == service_type)
return TRUE;
}
return FALSE;
}
static void service_set_signal(GtkService *service)
{
GtkServicePrivate *priv = service->priv;
GdkPixbuf *image = NULL;
const char *type, *info;
type = connman_service_get_type(service->path);
if (g_strcmp0(type, "wifi") == 0) {
uint8_t strength;
strength = connman_service_get_strength(service->path);
cui_theme_get_signal_icone_and_info(strength, &image, &info);
} else
cui_theme_get_type_icone_and_info(type, &image, &info);
if (image == NULL)
return;
gtk_widget_set_visible((GtkWidget *)priv->signal, TRUE);
gtk_widget_set_tooltip_text((GtkWidget *)priv->signal, info);
gtk_image_set_from_pixbuf(priv->signal, image);
}
static void append_notify(DBusMessageIter *dict,
struct connman_session *session)
{
struct session_info *info = session->info;
struct session_info *info_last = session->info_last;
struct connman_service *service;
enum connman_service_type type;
const char *name, *bearer;
char *ifname;
int idx;
if (session->append_all || info->state != info_last->state) {
const char *state = state2string(info->state);
connman_dbus_dict_append_basic(dict, "State",
DBUS_TYPE_STRING,
&state);
info_last->state = info->state;
}
if (session->append_all || session->service != session->service_last) {
if (session->service) {
service = session->service;
name = __connman_service_get_name(service);
idx = __connman_service_get_index(service);
ifname = connman_inet_ifname(idx);
if (!ifname)
ifname = g_strdup("");
type = connman_service_get_type(service);
bearer = service2bearer(type);
} else {
service = NULL;
name = "";
ifname = g_strdup("");
bearer = "";
}
connman_dbus_dict_append_basic(dict, "Name",
DBUS_TYPE_STRING,
&name);
connman_dbus_dict_append_dict(dict, "IPv4",
append_ipconfig_ipv4,
service);
connman_dbus_dict_append_dict(dict, "IPv6",
append_ipconfig_ipv6,
service);
connman_dbus_dict_append_basic(dict, "Interface",
DBUS_TYPE_STRING,
&ifname);
connman_dbus_dict_append_basic(dict, "Bearer",
DBUS_TYPE_STRING,
&bearer);
g_free(ifname);
session->service_last = session->service;
}
if (session->append_all ||
info->config.type != info_last->config.type) {
const char *type = type2string(info->config.type);
connman_dbus_dict_append_basic(dict, "ConnectionType",
DBUS_TYPE_STRING,
&type);
info_last->config.type = info->config.type;
}
if (session->append_all ||
info->config.allowed_bearers != info_last->config.allowed_bearers) {
connman_dbus_dict_append_array(dict, "AllowedBearers",
DBUS_TYPE_STRING,
append_allowed_bearers,
info);
info_last->config.allowed_bearers = info->config.allowed_bearers;
}
session->append_all = false;
}
static int wispr_portal_detect(struct connman_wispr_portal_context *wp_context)
{
enum connman_service_proxy_method proxy_method;
enum connman_service_type service_type;
char *interface = NULL;
char **nameservers = NULL;
int if_index;
int err = 0;
int i;
DBG("wispr/portal context %p service %p", wp_context,
wp_context->service);
service_type = connman_service_get_type(wp_context->service);
switch (service_type) {
case CONNMAN_SERVICE_TYPE_ETHERNET:
case CONNMAN_SERVICE_TYPE_WIFI:
case CONNMAN_SERVICE_TYPE_BLUETOOTH:
case CONNMAN_SERVICE_TYPE_CELLULAR:
case CONNMAN_SERVICE_TYPE_GADGET:
break;
case CONNMAN_SERVICE_TYPE_UNKNOWN:
case CONNMAN_SERVICE_TYPE_SYSTEM:
case CONNMAN_SERVICE_TYPE_GPS:
case CONNMAN_SERVICE_TYPE_VPN:
case CONNMAN_SERVICE_TYPE_P2P:
return -EOPNOTSUPP;
}
interface = connman_service_get_interface(wp_context->service);
if (!interface)
return -EINVAL;
DBG("interface %s", interface);
if_index = connman_inet_ifindex(interface);
if (if_index < 0) {
DBG("Could not get ifindex");
err = -EINVAL;
goto done;
}
nameservers = connman_service_get_nameservers(wp_context->service);
if (!nameservers) {
DBG("Could not get nameservers");
err = -EINVAL;
goto done;
}
wp_context->web = g_web_new(if_index);
if (!wp_context->web) {
DBG("Could not set up GWeb");
err = -ENOMEM;
goto done;
}
if (getenv("CONNMAN_WEB_DEBUG"))
g_web_set_debug(wp_context->web, web_debug, "WEB");
if (wp_context->type == CONNMAN_IPCONFIG_TYPE_IPV4) {
g_web_set_address_family(wp_context->web, AF_INET);
wp_context->status_url = STATUS_URL_IPV4;
} else {
g_web_set_address_family(wp_context->web, AF_INET6);
wp_context->status_url = STATUS_URL_IPV6;
}
for (i = 0; nameservers[i]; i++)
g_web_add_nameserver(wp_context->web, nameservers[i]);
proxy_method = connman_service_get_proxy_method(wp_context->service);
if (proxy_method != CONNMAN_SERVICE_PROXY_METHOD_DIRECT) {
wp_context->token = connman_proxy_lookup(interface,
wp_context->status_url,
wp_context->service,
proxy_callback, wp_context);
if (wp_context->token == 0) {
err = -EINVAL;
free_connman_wispr_portal_context(wp_context);
}
} else if (wp_context->timeout == 0) {
wp_context->timeout = g_idle_add(no_proxy_callback, wp_context);
}
done:
g_strfreev(nameservers);
g_free(interface);
return err;
}
int __connman_connection_gateway_add(struct connman_service *service,
const char *gateway,
enum connman_ipconfig_type type,
const char *peer)
{
struct gateway_data *active_gateway = NULL;
struct gateway_data *new_gateway = NULL;
enum connman_ipconfig_type type4 = CONNMAN_IPCONFIG_TYPE_UNKNOWN,
type6 = CONNMAN_IPCONFIG_TYPE_UNKNOWN;
enum connman_service_type service_type =
connman_service_get_type(service);
int index;
index = __connman_service_get_index(service);
/*
* If gateway is NULL, it's a point to point link and the default
* gateway for ipv4 is 0.0.0.0 and for ipv6 is ::, meaning the
* interface
*/
if (!gateway && type == CONNMAN_IPCONFIG_TYPE_IPV4)
gateway = "0.0.0.0";
if (!gateway && type == CONNMAN_IPCONFIG_TYPE_IPV6)
gateway = "::";
DBG("service %p index %d gateway %s vpn ip %s type %d",
service, index, gateway, peer, type);
new_gateway = add_gateway(service, index, gateway, type);
if (!new_gateway)
return -EINVAL;
active_gateway = find_active_gateway();
DBG("active %p index %d new %p", active_gateway,
active_gateway ? active_gateway->index : -1, new_gateway);
if (type == CONNMAN_IPCONFIG_TYPE_IPV4 &&
new_gateway->ipv4_gateway) {
add_host_route(AF_INET, index, gateway, service_type);
__connman_service_nameserver_add_routes(service,
new_gateway->ipv4_gateway->gateway);
type4 = CONNMAN_IPCONFIG_TYPE_IPV4;
}
if (type == CONNMAN_IPCONFIG_TYPE_IPV6 &&
new_gateway->ipv6_gateway) {
add_host_route(AF_INET6, index, gateway, service_type);
__connman_service_nameserver_add_routes(service,
new_gateway->ipv6_gateway->gateway);
type6 = CONNMAN_IPCONFIG_TYPE_IPV6;
}
if (service_type == CONNMAN_SERVICE_TYPE_VPN) {
set_vpn_routes(new_gateway, service, gateway, type, peer,
active_gateway);
} else {
if (type == CONNMAN_IPCONFIG_TYPE_IPV4 &&
new_gateway->ipv4_gateway)
new_gateway->ipv4_gateway->vpn = false;
if (type == CONNMAN_IPCONFIG_TYPE_IPV6 &&
new_gateway->ipv6_gateway)
new_gateway->ipv6_gateway->vpn = false;
}
if (!active_gateway) {
set_default_gateway(new_gateway, type);
goto done;
}
if (type == CONNMAN_IPCONFIG_TYPE_IPV4 &&
new_gateway->ipv4_gateway &&
new_gateway->ipv4_gateway->vpn) {
if (!__connman_service_is_split_routing(new_gateway->service))
connman_inet_clear_gateway_address(
active_gateway->index,
active_gateway->ipv4_gateway->gateway);
}
if (type == CONNMAN_IPCONFIG_TYPE_IPV6 &&
new_gateway->ipv6_gateway &&
new_gateway->ipv6_gateway->vpn) {
if (!__connman_service_is_split_routing(new_gateway->service))
connman_inet_clear_ipv6_gateway_address(
active_gateway->index,
active_gateway->ipv6_gateway->gateway);
}
done:
if (type4 == CONNMAN_IPCONFIG_TYPE_IPV4)
__connman_service_ipconfig_indicate_state(service,
CONNMAN_SERVICE_STATE_READY,
CONNMAN_IPCONFIG_TYPE_IPV4);
if (type6 == CONNMAN_IPCONFIG_TYPE_IPV6)
__connman_service_ipconfig_indicate_state(service,
CONNMAN_SERVICE_STATE_READY,
CONNMAN_IPCONFIG_TYPE_IPV6);
return 0;
}
static gboolean set_connected(gpointer user_data)
{
struct connman_network *network = user_data;
struct connman_service *service;
struct connman_ipconfig *ipconfig_ipv4, *ipconfig_ipv6;
enum connman_ipconfig_method ipv4_method, ipv6_method;
service = __connman_service_lookup_from_network(network);
ipconfig_ipv4 = __connman_service_get_ip4config(service);
ipconfig_ipv6 = __connman_service_get_ip6config(service);
DBG("service %p ipv4 %p ipv6 %p", service, ipconfig_ipv4,
ipconfig_ipv6);
ipv4_method = __connman_ipconfig_get_method(ipconfig_ipv4);
ipv6_method = __connman_ipconfig_get_method(ipconfig_ipv6);
DBG("method ipv4 %d ipv6 %d", ipv4_method, ipv6_method);
DBG("network connected %d", network->connected);
if (network->connected == TRUE) {
int ret;
switch (ipv6_method) {
case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
case CONNMAN_IPCONFIG_METHOD_OFF:
break;
case CONNMAN_IPCONFIG_METHOD_AUTO:
autoconf_ipv6_set(network);
break;
case CONNMAN_IPCONFIG_METHOD_FIXED:
case CONNMAN_IPCONFIG_METHOD_MANUAL:
ret = manual_ipv6_set(network, ipconfig_ipv6);
if (ret != 0) {
connman_network_set_error(network,
CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
return FALSE;
}
break;
case CONNMAN_IPCONFIG_METHOD_DHCP:
break;
}
switch (ipv4_method) {
case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
case CONNMAN_IPCONFIG_METHOD_OFF:
case CONNMAN_IPCONFIG_METHOD_AUTO:
return FALSE;
case CONNMAN_IPCONFIG_METHOD_FIXED:
if (set_connected_fixed(network) < 0) {
connman_network_set_error(network,
CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
return FALSE;
}
return TRUE;
case CONNMAN_IPCONFIG_METHOD_MANUAL:
set_connected_manual(network);
return TRUE;
case CONNMAN_IPCONFIG_METHOD_DHCP:
if (set_connected_dhcp(network) < 0) {
connman_network_set_error(network,
CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
return FALSE;
}
}
} else {
enum connman_service_state state;
__connman_device_set_network(network->device, NULL);
switch (ipv4_method) {
case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
case CONNMAN_IPCONFIG_METHOD_OFF:
case CONNMAN_IPCONFIG_METHOD_AUTO:
case CONNMAN_IPCONFIG_METHOD_FIXED:
case CONNMAN_IPCONFIG_METHOD_MANUAL:
break;
case CONNMAN_IPCONFIG_METHOD_DHCP:
__connman_dhcp_stop(network);
break;
}
/*
* We only set the disconnect state if we were not in idle
* or in failure. It does not make sense to go to disconnect
* state if we were not connected.
*/
state = __connman_service_ipconfig_get_state(service,
CONNMAN_IPCONFIG_TYPE_IPV4);
if (state != CONNMAN_SERVICE_STATE_IDLE &&
state != CONNMAN_SERVICE_STATE_FAILURE)
__connman_service_ipconfig_indicate_state(service,
CONNMAN_SERVICE_STATE_DISCONNECT,
CONNMAN_IPCONFIG_TYPE_IPV4);
state = __connman_service_ipconfig_get_state(service,
CONNMAN_IPCONFIG_TYPE_IPV6);
if (state != CONNMAN_SERVICE_STATE_IDLE &&
state != CONNMAN_SERVICE_STATE_FAILURE)
__connman_service_ipconfig_indicate_state(service,
CONNMAN_SERVICE_STATE_DISCONNECT,
CONNMAN_IPCONFIG_TYPE_IPV6);
__connman_connection_gateway_remove(service,
CONNMAN_IPCONFIG_TYPE_ALL);
__connman_ipconfig_address_unset(ipconfig_ipv4);
__connman_ipconfig_address_unset(ipconfig_ipv6);
/*
* Special handling for IPv6 autoconfigured address.
* The simplest way to remove autoconfigured routes is to
* disable IPv6 temporarily so that kernel will do the cleanup
* automagically.
*/
if (ipv6_method == CONNMAN_IPCONFIG_METHOD_AUTO) {
__connman_ipconfig_disable_ipv6(ipconfig_ipv6);
__connman_ipconfig_enable_ipv6(ipconfig_ipv6);
}
#if defined TIZEN_EXT
if (connman_service_get_type(service) ==
CONNMAN_SERVICE_TYPE_CELLULAR) {
network->connecting = FALSE;
connman_network_set_associating(network, FALSE);
}
#endif
__connman_service_ipconfig_indicate_state(service,
CONNMAN_SERVICE_STATE_IDLE,
CONNMAN_IPCONFIG_TYPE_IPV4);
__connman_service_ipconfig_indicate_state(service,
CONNMAN_SERVICE_STATE_IDLE,
CONNMAN_IPCONFIG_TYPE_IPV6);
#if defined TIZEN_EXT
if (connman_service_get_type(service) ==
CONNMAN_SERVICE_TYPE_CELLULAR)
return FALSE;
#endif
}
network->connecting = FALSE;
connman_network_set_associating(network, FALSE);
return FALSE;
}
