static void ipv4ll_available_cb(GDHCPClient *dhcp_client, gpointer user_data)
{
struct connman_dhcp *dhcp = user_data;
char *address, *netmask;
struct connman_service *service;
struct connman_ipconfig *ipconfig;
unsigned char prefixlen;
DBG("IPV4LL available");
#if defined TIZEN_EXT
/*
* Description: When DHCP is failed,
* most of naive users cannot understand auto-generated IP
* (IPV4 link local) and serious troubles to make Internet connection.
*/
dhcp_invalidate(dhcp, TRUE);
service = __connman_service_lookup_from_network(dhcp->network);
if (service == NULL)
return;
__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);
return;
#endif
service = __connman_service_lookup_from_network(dhcp->network);
if (service == NULL)
return;
ipconfig = __connman_service_get_ip4config(service);
if (ipconfig == NULL)
return;
address = g_dhcp_client_get_address(dhcp_client);
netmask = g_dhcp_client_get_netmask(dhcp_client);
prefixlen = __connman_ipconfig_netmask_prefix_len(netmask);
connman_ipconfig_set_method(ipconfig, CONNMAN_IPCONFIG_METHOD_DHCP);
__connman_ipconfig_set_local(ipconfig, address);
__connman_ipconfig_set_prefixlen(ipconfig, prefixlen);
__connman_ipconfig_set_gateway(ipconfig, NULL);
dhcp_valid(dhcp);
g_free(address);
g_free(netmask);
}
static void portal_manage_status(GWebResult *result,
struct connman_wispr_portal_context *wp_context)
{
struct connman_service *service = wp_context->service;
enum connman_ipconfig_type type = wp_context->type;
const char *str = NULL;
DBG("");
/* We currently don't do anything with this info */
if (g_web_result_get_header(result, "X-ConnMan-Client-IP",
&str))
connman_info("Client-IP: %s", str);
if (g_web_result_get_header(result, "X-ConnMan-Client-Country",
&str))
connman_info("Client-Country: %s", str);
if (g_web_result_get_header(result, "X-ConnMan-Client-Region",
&str))
connman_info("Client-Region: %s", str);
if (g_web_result_get_header(result, "X-ConnMan-Client-Timezone",
&str))
connman_info("Client-Timezone: %s", str);
free_connman_wispr_portal_context(wp_context);
__connman_service_ipconfig_indicate_state(service,
CONNMAN_SERVICE_STATE_ONLINE, type);
}
static void portal_manage_status(GWebResult *result,
struct connman_wispr_portal_context *wp_context)
{
enum connman_ipconfig_type type = wp_context->type;
struct connman_service *service;
const char *str = NULL;
DBG("");
/* We currently don't do anything with this info */
if (g_web_result_get_header(result, "X-ConnMan-Client-IP",
&str))
DBG("Client-IP: %s", str);
if (g_web_result_get_header(result, "X-ConnMan-Client-Country",
&str))
DBG("Client-Country: %s", str);
if (g_web_result_get_header(result, "X-ConnMan-Client-Region",
&str))
DBG("Client-Region: %s", str);
if (g_web_result_get_header(result, "X-ConnMan-Client-Timezone",
&str))
DBG("Client-Timezone: %s", str);
/* __connman_service_ipconfig_indicate_state may end up calling
* __connman_wispr_start which would reinitialize the wispr context
* so we better free it beforehand to avoid deallocating it twice. */
service = connman_service_ref(wp_context->service);
free_connman_wispr_portal_context(wp_context);
__connman_service_ipconfig_indicate_state(service,
CONNMAN_SERVICE_STATE_ONLINE, type);
connman_service_unref(service);
}
static void dhcp_failure(struct connman_network *network)
{
struct connman_service *service;
service = __connman_service_lookup_from_network(network);
if (service == NULL)
return;
__connman_service_ipconfig_indicate_state(service,
CONNMAN_SERVICE_STATE_IDLE,
CONNMAN_IPCONFIG_TYPE_IPV4);
}
int __connman_network_clear_ipconfig(struct connman_network *network,
struct connman_ipconfig *ipconfig)
{
struct connman_service *service;
enum connman_ipconfig_method method;
enum connman_ipconfig_type type;
service = __connman_service_lookup_from_network(network);
if (service == NULL)
return -EINVAL;
method = __connman_ipconfig_get_method(ipconfig);
type = __connman_ipconfig_get_config_type(ipconfig);
switch (method) {
case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
case CONNMAN_IPCONFIG_METHOD_OFF:
case CONNMAN_IPCONFIG_METHOD_FIXED:
case CONNMAN_IPCONFIG_METHOD_AUTO:
return -EINVAL;
case CONNMAN_IPCONFIG_METHOD_MANUAL:
__connman_ipconfig_address_remove(ipconfig);
break;
case CONNMAN_IPCONFIG_METHOD_DHCP:
__connman_dhcp_stop(network);
break;
}
if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
__connman_service_ipconfig_indicate_state(service,
CONNMAN_SERVICE_STATE_CONFIGURATION,
CONNMAN_IPCONFIG_TYPE_IPV6);
else if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
__connman_service_ipconfig_indicate_state(service,
CONNMAN_SERVICE_STATE_CONFIGURATION,
CONNMAN_IPCONFIG_TYPE_IPV4);
return 0;
}
/**
* connman_network_set_associating:
* @network: network structure
* @associating: associating state
*
* Change associating state of network
*/
int connman_network_set_associating(struct connman_network *network,
connman_bool_t associating)
{
DBG("network %p associating %d", network, associating);
if (network->associating == associating)
return -EALREADY;
network->associating = associating;
if (associating == TRUE) {
struct connman_service *service;
service = __connman_service_lookup_from_network(network);
__connman_service_ipconfig_indicate_state(service,
CONNMAN_SERVICE_STATE_ASSOCIATION,
CONNMAN_IPCONFIG_TYPE_IPV4);
__connman_service_ipconfig_indicate_state(service,
CONNMAN_SERVICE_STATE_ASSOCIATION,
CONNMAN_IPCONFIG_TYPE_IPV6);
}
return 0;
}
static void set_configuration(struct connman_network *network)
{
struct connman_service *service;
DBG("network %p", network);
if (network->device == NULL)
return;
__connman_device_set_network(network->device, network);
connman_device_set_disconnected(network->device, FALSE);
service = __connman_service_lookup_from_network(network);
__connman_service_ipconfig_indicate_state(service,
CONNMAN_SERVICE_STATE_CONFIGURATION,
CONNMAN_IPCONFIG_TYPE_IPV4);
}
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;
}
