/*
* Once the timeserver list (ts_list) is created, we start querying the
* servers one by one. If resolving fails on one of them, we move to the
* next one. The user can enter either an IP address or a URL for the
* timeserver. We only resolve the urls. Once we have a IP for the NTP
* server, we start querying it for time corrections.
*/
void __connman_timeserver_sync_next()
{
if (ts_current) {
g_free(ts_current);
ts_current = NULL;
}
__connman_ntp_stop();
/* Get the 1st server in the list */
if (!ts_list)
return;
ts_current = ts_list->data;
ts_list = g_slist_delete_link(ts_list, ts_list);
/* if its a IP , directly query it. */
if (connman_inet_check_ipaddress(ts_current) > 0) {
DBG("Using timeserver %s", ts_current);
__connman_ntp_start(ts_current);
return;
}
DBG("Resolving server %s", ts_current);
resolv_id = g_resolv_lookup_hostname(resolv, ts_current,
resolv_result, NULL);
return;
}
static void provider_resolv_host_addr(struct connman_provider *provider)
{
if (provider->host == NULL)
return;
if (connman_inet_check_ipaddress(provider->host) > 0)
return;
if (provider->host_ip != NULL)
return;
/*
* If the hostname is not numeric, try to resolv it. We do not wait
* the result as it might take some time. We will get the result
* before VPN will feed routes to us because VPN client will need
* the IP address also before VPN connection can be established.
*/
provider->resolv = g_resolv_new(0);
if (provider->resolv == NULL) {
DBG("Cannot resolv %s", provider->host);
return;
}
DBG("Trying to resolv %s", provider->host);
connman_provider_ref(provider);
g_resolv_lookup_hostname(provider->resolv, provider->host,
resolv_result, provider);
}
static int append_resolver(const char *interface, const char *domain,
const char *server, unsigned int lifetime,
unsigned int flags)
{
struct entry_data *entry;
unsigned int interval;
DBG("interface %s domain %s server %s lifetime %d flags %d",
interface, domain, server, lifetime, flags);
if (server == NULL && domain == NULL)
return -EINVAL;
entry = g_try_new0(struct entry_data, 1);
if (entry == NULL)
return -ENOMEM;
entry->interface = g_strdup(interface);
entry->domain = g_strdup(domain);
entry->server = g_strdup(server);
entry->flags = flags;
entry->lifetime = lifetime;
if (server != NULL)
entry->family = connman_inet_check_ipaddress(server);
if (lifetime) {
int index;
interval = lifetime * RESOLVER_LIFETIME_REFRESH_THRESHOLD;
DBG("RDNSS start interface %s domain %s "
"server %s lifetime threshold %d",
interface, domain, server, interval);
entry->timeout = g_timeout_add_seconds(interval,
resolver_refresh_cb, entry);
/*
* We update the service only for those nameservers
* that are automagically added via netlink (lifetime > 0)
*/
index = connman_inet_ifindex(interface);
if (server != NULL && index >= 0) {
struct connman_service *service;
service = __connman_service_lookup_from_index(index);
if (service != NULL)
__connman_service_nameserver_append(service,
server, TRUE);
}
}
entry_list = g_slist_append(entry_list, entry);
if (dnsproxy_enabled == TRUE)
__connman_dnsproxy_append(interface, domain, server);
else
__connman_resolvfile_append(interface, domain, server);
return 0;
}
static void resolv_host_addr(struct connection_data *data)
{
if (data->host == NULL)
return;
if (connman_inet_check_ipaddress(data->host) > 0)
return;
if (data->host_ip != NULL)
return;
data->resolv = g_resolv_new(0);
if (data->resolv == NULL) {
DBG("Cannot resolv %s", data->host);
return;
}
DBG("Trying to resolv %s", data->host);
data->resolv_id = g_resolv_lookup_hostname(data->resolv, data->host,
resolv_result, data);
}
static void get_gateway_cb(const char *gateway, int index, void *user_data)
{
struct gateway_config *config;
struct gateway_data *data;
struct get_gateway_params *params = user_data;
int family;
if (index < 0)
goto out;
DBG("phy index %d phy gw %s vpn index %d vpn gw %s", index, gateway,
params->vpn_index, params->vpn_gateway);
data = find_vpn_gateway(params->vpn_index, params->vpn_gateway);
if (!data) {
DBG("Cannot find VPN link route, index %d addr %s",
params->vpn_index, params->vpn_gateway);
goto out;
}
family = connman_inet_check_ipaddress(params->vpn_gateway);
if (family == AF_INET)
config = data->ipv4_gateway;
else if (family == AF_INET6)
config = data->ipv6_gateway;
else
goto out;
config->vpn_phy_index = index;
DBG("vpn %s phy index %d", config->vpn_ip, config->vpn_phy_index);
out:
g_free(params->vpn_gateway);
g_free(params);
}
static GSList *read_route_dict(GSList *routes, DBusMessageIter *dicts)
{
DBusMessageIter dict, value, entry;
const char *network, *netmask, *gateway;
struct vpn_route *route;
int family, type;
const char *key;
dbus_message_iter_recurse(dicts, &entry);
network = netmask = gateway = NULL;
family = PF_UNSPEC;
while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_DICT_ENTRY) {
dbus_message_iter_recurse(&entry, &dict);
dbus_message_iter_get_basic(&dict, &key);
dbus_message_iter_next(&dict);
dbus_message_iter_recurse(&dict, &value);
type = dbus_message_iter_get_arg_type(&value);
switch (type) {
case DBUS_TYPE_STRING:
if (g_str_equal(key, "ProtocolFamily") == TRUE)
dbus_message_iter_get_basic(&value, &family);
else if (g_str_equal(key, "Network") == TRUE)
dbus_message_iter_get_basic(&value, &network);
else if (g_str_equal(key, "Netmask") == TRUE)
dbus_message_iter_get_basic(&value, &netmask);
else if (g_str_equal(key, "Gateway") == TRUE)
dbus_message_iter_get_basic(&value, &gateway);
break;
}
dbus_message_iter_next(&entry);
}
DBG("family %d network %s netmask %s gateway %s", family,
network, netmask, gateway);
if (network == NULL || netmask == NULL) {
DBG("Ignoring route as network/netmask is missing");
return routes;
}
route = g_try_new(struct vpn_route, 1);
if (route == NULL) {
g_slist_free_full(routes, free_route);
return NULL;
}
if (family == PF_UNSPEC) {
family = connman_inet_check_ipaddress(network);
if (family < 0) {
DBG("Cannot get address family of %s (%d/%s)", network,
family, gai_strerror(family));
if (strstr(network, ":") != NULL) {
DBG("Guessing it is IPv6");
family = AF_INET6;
} else {
DBG("Guessing it is IPv4");
family = AF_INET;
}
}
} else {
switch (family) {
case '4':
family = AF_INET;
break;
case '6':
family = AF_INET6;
break;
default:
family = PF_UNSPEC;
break;
}
}
route->family = family;
route->network = g_strdup(network);
route->netmask = g_strdup(netmask);
route->gateway = g_strdup(gateway);
routes = g_slist_prepend(routes, route);
return routes;
}
