static void update_default_interface(struct connman_service *service)
{
GHashTableIter iter;
gpointer key, value;
char *interface;
int err;
interface = connman_service_get_interface(service);
DBG("interface %s", interface);
g_free(default_interface);
default_interface = interface;
g_hash_table_iter_init(&iter, nat_hash);
while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
const char *name = key;
struct connman_nat *nat = value;
disable_nat(nat);
err = enable_nat(nat);
if (err < 0)
DBG("Failed to enable nat for %s", name);
}
}
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 int setup_prefix_delegation(struct connman_service *service)
{
struct connman_ipconfig *ipconfig;
char *interface;
int err = 0, ifindex;
if (service == NULL) {
/*
* We do not have uplink connection. We just wait until
* default interface is updated.
*/
return -EINPROGRESS;
}
interface = connman_service_get_interface(service);
DBG("interface %s bridge_index %d", interface, bridge_index);
if (default_interface != NULL) {
stop_ra(bridge_index);
ifindex = connman_inet_ifindex(default_interface);
__connman_dhcpv6_stop_pd(ifindex);
}
g_free(default_interface);
ipconfig = __connman_service_get_ip6config(service);
if (__connman_ipconfig_ipv6_is_enabled(ipconfig) == FALSE) {
g_free(interface);
default_interface = NULL;
return -EPFNOSUPPORT;
}
default_interface = interface;
if (default_interface != NULL) {
ifindex = connman_inet_ifindex(default_interface);
/*
* Try to get a IPv6 prefix so we can start to advertise it.
*/
err = __connman_dhcpv6_start_pd(ifindex, prefixes,
dhcpv6_callback);
if (err < 0)
DBG("prefix delegation %d/%s", err, strerror(-err));
}
return err;
}
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 void create_proxy_configuration(void)
{
DBusMessage *msg;
DBusMessageIter iter, dict;
DBusPendingCall *call;
dbus_bool_t result;
char *interface;
const char *method;
const char *str;
char **str_list;
if (default_service == NULL)
return;
DBG("");
msg = dbus_message_new_method_call(PACRUNNER_SERVICE, PACRUNNER_PATH,
PACRUNNER_INTERFACE, "CreateProxyConfiguration");
if (msg == NULL)
return;
dbus_message_set_auto_start(msg, FALSE);
dbus_message_iter_init_append(msg, &iter);
connman_dbus_dict_open(&iter, &dict);
switch(connman_service_get_proxy_method(default_service)) {
case CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN:
goto done;
case CONNMAN_SERVICE_PROXY_METHOD_DIRECT:
method= "direct";
break;
case CONNMAN_SERVICE_PROXY_METHOD_MANUAL:
method = "manual";
str_list = connman_service_get_proxy_servers(default_service);
if (str_list == NULL)
goto done;
connman_dbus_dict_append_array(&dict, "Servers",
DBUS_TYPE_STRING, append_string_list,
str_list);
g_strfreev(str_list);
str_list = connman_service_get_proxy_excludes(default_service);
if (str_list == NULL)
break;
connman_dbus_dict_append_array(&dict, "Excludes",
DBUS_TYPE_STRING, append_string_list,
str_list);
g_strfreev(str_list);
break;
case CONNMAN_SERVICE_PROXY_METHOD_AUTO:
method = "auto";
str = connman_service_get_proxy_url(default_service);
if (str == NULL) {
str = connman_service_get_proxy_autoconfig(
default_service);
if (str == NULL)
goto done;
}
connman_dbus_dict_append_basic(&dict, "URL",
DBUS_TYPE_STRING, &str);
break;
}
connman_dbus_dict_append_basic(&dict, "Method",
DBUS_TYPE_STRING, &method);
interface = connman_service_get_interface(default_service);
if (interface != NULL) {
connman_dbus_dict_append_basic(&dict, "Interface",
DBUS_TYPE_STRING, &interface);
g_free(interface);
}
str = connman_service_get_domainname(default_service);
if (str != NULL)
connman_dbus_dict_append_array(&dict, "Domains",
DBUS_TYPE_STRING, append_string, &str);
str_list = connman_service_get_nameservers(default_service);
if (str_list != NULL)
connman_dbus_dict_append_array(&dict, "Nameservers",
DBUS_TYPE_STRING, append_string_list,
str_list);
connman_dbus_dict_close(&iter, &dict);
result = dbus_connection_send_with_reply(connection, msg,
&call, DBUS_TIMEOUT);
if (result == FALSE || call == NULL)
goto done;
dbus_pending_call_set_notify(call, create_config_reply, NULL, NULL);
dbus_pending_call_unref(call);
done:
dbus_message_unref(msg);
}
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;
}
