int __connman_resolver_init(connman_bool_t dnsproxy)
{
int i;
char **ns;
DBG("dnsproxy %d", dnsproxy);
if (dnsproxy == FALSE)
return 0;
if (__connman_dnsproxy_init() < 0) {
/* Fall back to resolv.conf */
return 0;
}
dnsproxy_enabled = TRUE;
ns = connman_setting_get_string_list("FallbackNameservers");
for (i = 0; ns != NULL && ns[i] != NULL; i += 1) {
DBG("server %s", ns[i]);
append_resolver(NULL, NULL, ns[i], 0, RESOLVER_FLAG_PUBLIC);
}
return 0;
}
/*
* __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);
}
bool __connman_device_isfiltered(const char *devname)
{
char **pattern;
char **blacklisted_interfaces;
bool match;
if (!device_filter)
goto nodevice;
for (pattern = device_filter, match = false; *pattern; pattern++) {
if (g_pattern_match_simple(*pattern, devname)) {
match = true;
break;
}
}
if (!match) {
// DBG("ignoring device %s (match)", devname);
return true;
}
nodevice:
if (g_pattern_match_simple("dummy*", devname)) {
// DBG("ignoring dummy networking devices");
return true;
}
if (!nodevice_filter)
goto list;
for (pattern = nodevice_filter; *pattern; pattern++) {
if (g_pattern_match_simple(*pattern, devname)) {
// DBG("ignoring device %s (no match)", devname);
return true;
}
}
list:
blacklisted_interfaces =
connman_setting_get_string_list("NetworkInterfaceBlacklist");
if (!blacklisted_interfaces)
return false;
for (pattern = blacklisted_interfaces; *pattern; pattern++) {
if (g_str_has_prefix(devname, *pattern)) {
// DBG("ignoring device %s (blacklist)", devname);
return true;
}
}
return false;
}
connman_bool_t __connman_device_isfiltered(const char *devname)
{
char **pattern;
char **blacklisted_interfaces;
if (device_filter == NULL)
goto nodevice;
for (pattern = device_filter; *pattern; pattern++) {
if (g_pattern_match_simple(*pattern, devname) == FALSE) {
DBG("ignoring device %s (match)", devname);
return TRUE;
}
}
nodevice:
if (g_pattern_match_simple("dummy*", devname) == TRUE) {
DBG("ignoring dummy networking devices");
return TRUE;
}
if (nodevice_filter == NULL)
goto list;
for (pattern = nodevice_filter; *pattern; pattern++) {
if (g_pattern_match_simple(*pattern, devname) == TRUE) {
DBG("ignoring device %s (no match)", devname);
return TRUE;
}
}
list:
blacklisted_interfaces =
connman_setting_get_string_list("NetworkInterfaceBlacklist");
if (blacklisted_interfaces == NULL)
return FALSE;
for (pattern = blacklisted_interfaces; *pattern; pattern++) {
if (g_str_has_prefix(devname, *pattern) == TRUE) {
DBG("ignoring device %s (blacklist)", devname);
return TRUE;
}
}
return FALSE;
}
static bool can_bring_down(const char *devname)
{
char **pattern =
connman_setting_get_string_list("DontBringDownAtStartup");
if (pattern) {
while (*pattern) {
if (g_str_has_prefix(devname, *pattern++)) {
DBG("%s no", devname);
return false;
}
}
}
DBG("%s yes", devname);
return true;
}
connman_bool_t
connman_technology_is_tethering_allowed(enum connman_service_type type)
{
static char *allowed_default[] = { "wifi", "bluetooth", "gadget",
NULL };
const char *type_str = __connman_service_type2string(type);
char **allowed;
int i;
if (type_str == NULL)
return FALSE;
allowed = connman_setting_get_string_list("TetheringTechnologies");
if (allowed == NULL)
allowed = allowed_default;
for (i = 0; allowed[i] != NULL; i++) {
if (g_strcmp0(allowed[i], type_str) == 0)
return TRUE;
}
return FALSE;
}
void __connman_tethering_set_enabled(void)
{
int index;
int err;
const char *gateway;
const char *broadcast;
const char *subnet_mask;
const char *start_ip;
const char *end_ip;
const char *dns;
unsigned char prefixlen;
char **ns;
DBG("enabled %d", tethering_enabled + 1);
if (__sync_fetch_and_add(&tethering_enabled, 1) != 0)
return;
err = __connman_bridge_create(BRIDGE_NAME);
if (err < 0) {
__sync_fetch_and_sub(&tethering_enabled, 1);
return;
}
index = connman_inet_ifindex(BRIDGE_NAME);
dhcp_ippool = __connman_ippool_create(index, 2, 252,
tethering_restart, NULL);
if (dhcp_ippool == NULL) {
connman_error("Fail to create IP pool");
__connman_bridge_remove(BRIDGE_NAME);
__sync_fetch_and_sub(&tethering_enabled, 1);
return;
}
gateway = __connman_ippool_get_gateway(dhcp_ippool);
broadcast = __connman_ippool_get_broadcast(dhcp_ippool);
subnet_mask = __connman_ippool_get_subnet_mask(dhcp_ippool);
start_ip = __connman_ippool_get_start_ip(dhcp_ippool);
end_ip = __connman_ippool_get_end_ip(dhcp_ippool);
err = __connman_bridge_enable(BRIDGE_NAME, gateway,
__connman_ipaddress_netmask_prefix_len(subnet_mask),
broadcast);
if (err < 0 && err != -EALREADY) {
__connman_ippool_unref(dhcp_ippool);
__connman_bridge_remove(BRIDGE_NAME);
__sync_fetch_and_sub(&tethering_enabled, 1);
return;
}
ns = connman_setting_get_string_list("FallbackNameservers");
if (ns != NULL) {
if (ns[0] != NULL) {
g_free(private_network_primary_dns);
private_network_primary_dns = g_strdup(ns[0]);
}
if (ns[1] != NULL) {
g_free(private_network_secondary_dns);
private_network_secondary_dns = g_strdup(ns[1]);
}
DBG("Fallback ns primary %s secondary %s",
private_network_primary_dns,
private_network_secondary_dns);
}
dns = gateway;
if (__connman_dnsproxy_add_listener(index) < 0) {
connman_error("Can't add listener %s to DNS proxy",
BRIDGE_NAME);
dns = private_network_primary_dns;
DBG("Serving %s nameserver to clients", dns);
}
tethering_dhcp_server = dhcp_server_start(BRIDGE_NAME,
gateway, subnet_mask,
start_ip, end_ip,
24 * 3600, dns);
if (tethering_dhcp_server == NULL) {
__connman_bridge_disable(BRIDGE_NAME);
__connman_ippool_unref(dhcp_ippool);
__connman_bridge_remove(BRIDGE_NAME);
__sync_fetch_and_sub(&tethering_enabled, 1);
return;
}
prefixlen =
__connman_ipaddress_netmask_prefix_len(subnet_mask);
__connman_nat_enable(BRIDGE_NAME, start_ip, prefixlen);
err = __connman_ipv6pd_setup(BRIDGE_NAME);
if (err < 0 && err != -EINPROGRESS)
DBG("Cannot setup IPv6 prefix delegation %d/%s", err,
strerror(-err));
DBG("tethering started");
}
