static gboolean resolver_refresh_cb(gpointer user_data)
{
struct entry_data *entry = user_data;
int index;
unsigned int interval;
struct connman_service *service = NULL;
/* Round up what we have left from lifetime */
interval = entry->lifetime *
(1 - RESOLVER_LIFETIME_REFRESH_THRESHOLD) + 1.0;
DBG("RDNSS start interface %s domain %s "
"server %s remaining lifetime %d",
entry->interface, entry->domain,
entry->server, interval);
entry->timeout = g_timeout_add_seconds(interval,
resolver_expire_cb, entry);
index = connman_inet_ifindex(entry->interface);
if (index >= 0) {
service = __connman_service_lookup_from_index(index);
if (service != NULL) {
/*
* Send Router Solicitation to refresh RDNSS entries
* before their lifetime expires
*/
__connman_refresh_rs_ipv6(
__connman_service_get_network(service),
index);
}
}
return FALSE;
}
/*
* __connman_timeserver_get_all function creates the timeserver
* list which will be used to determine NTP server for time corrections.
* The service settings take priority over the global timeservers.
*/
GSList *__connman_timeserver_get_all(struct connman_service *service)
{
GSList *list = NULL;
struct connman_network *network;
char **timeservers;
char **service_ts;
char **service_ts_config;
const char *service_gw;
char **fallback_ts;
int index, i;
if (__connman_clock_timeupdates() == TIME_UPDATES_MANUAL)
return NULL;
service_ts_config = connman_service_get_timeservers_config(service);
/* First add Service Timeservers.Configuration to the list */
for (i = 0; service_ts_config && service_ts_config[i];
i++)
list = __connman_timeserver_add_list(list,
service_ts_config[i]);
service_ts = connman_service_get_timeservers(service);
/* First add Service Timeservers via DHCP to the list */
for (i = 0; service_ts && service_ts[i]; i++)
list = __connman_timeserver_add_list(list, service_ts[i]);
network = __connman_service_get_network(service);
if (network) {
index = connman_network_get_index(network);
service_gw = __connman_ipconfig_get_gateway_from_index(index,
CONNMAN_IPCONFIG_TYPE_ALL);
/* Then add Service Gateway to the list */
if (service_gw)
list = __connman_timeserver_add_list(list, service_gw);
}
/* Then add Global Timeservers to the list */
timeservers = load_timeservers();
for (i = 0; timeservers && timeservers[i]; i++)
list = __connman_timeserver_add_list(list, timeservers[i]);
g_strfreev(timeservers);
fallback_ts = connman_setting_get_string_list("FallbackTimeservers");
/* Lastly add the fallback servers */
for (i = 0; fallback_ts && fallback_ts[i]; i++)
list = __connman_timeserver_add_list(list, fallback_ts[i]);
return g_slist_reverse(list);
}
static void previous_passphrase_handler(DBusMessageIter *iter,
struct connman_service *service)
{
enum connman_service_security security;
struct previous_passphrase_data data;
struct connman_network *network;
network = __connman_service_get_network(service);
data.passphrase = connman_network_get_string(network, "WiFi.PinWPS");
if (connman_network_get_bool(network, "WiFi.UseWPS") &&
data.passphrase) {
data.type = "wpspin";
} else {
data.passphrase = __connman_service_get_passphrase(service);
if (!data.passphrase)
return;
security = __connman_service_get_security(service);
switch (security) {
case CONNMAN_SERVICE_SECURITY_WEP:
data.type = "wep";
break;
case CONNMAN_SERVICE_SECURITY_PSK:
data.type = "psk";
break;
/*
* This should never happen: no passphrase is set if security
* is not one of the above. */
default:
break;
}
}
connman_dbus_dict_append_dict(iter, "PreviousPassphrase",
request_input_append_previouspassphrase, &data);
}
static void request_input_passphrase_reply(DBusPendingCall *call, void *user_data)
{
struct request_input_reply *passphrase_reply = user_data;
connman_bool_t wps = FALSE;
char *identity = NULL;
char *passphrase = NULL;
char *wpspin = NULL;
char *key;
DBusMessageIter iter, dict;
DBusMessage *reply = dbus_pending_call_steal_reply(call);
if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR)
goto done;
dbus_message_iter_init(reply, &iter);
dbus_message_iter_recurse(&iter, &dict);
while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
DBusMessageIter entry, value;
dbus_message_iter_recurse(&dict, &entry);
if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
break;
dbus_message_iter_get_basic(&entry, &key);
if (g_str_equal(key, "Identity")) {
dbus_message_iter_next(&entry);
if (dbus_message_iter_get_arg_type(&entry)
!= DBUS_TYPE_VARIANT)
break;
dbus_message_iter_recurse(&entry, &value);
dbus_message_iter_get_basic(&value, &identity);
} else if (g_str_equal(key, "Passphrase")) {
dbus_message_iter_next(&entry);
if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT)
break;
dbus_message_iter_recurse(&entry, &value);
dbus_message_iter_get_basic(&value, &passphrase);
} else if (g_str_equal(key, "WPS")) {
wps = TRUE;
dbus_message_iter_next(&entry);
if (dbus_message_iter_get_arg_type(&entry)
!= DBUS_TYPE_VARIANT)
break;
dbus_message_iter_recurse(&entry, &value);
dbus_message_iter_get_basic(&value, &wpspin);
break;
}
dbus_message_iter_next(&dict);
}
if (wps == TRUE) {
struct connman_network *network;
network = __connman_service_get_network(
passphrase_reply->service);
if (network == NULL)
goto done;
connman_network_set_bool(network, "WiFi.UseWPS", wps);
if (wpspin != NULL && strlen(wpspin) > 0)
connman_network_set_string(network,
"WiFi.PinWPS", wpspin);
else
connman_network_set_string(network,
"WiFi.PinWPS", NULL);
}
done:
passphrase_reply->callback(passphrase_reply->service, identity,
passphrase, passphrase_reply->user_data);
connman_service_unref(passphrase_reply->service);
dbus_message_unref(reply);
g_free(passphrase_reply);
}
