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");
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_ipaddress_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);
}
int connman_ipaddress_set_ipv4(struct connman_ipaddress *ipaddress,
const char *address, const char *netmask, const char *gateway)
{
if (ipaddress == NULL)
return -EINVAL;
ipaddress->family = AF_INET;
ipaddress->prefixlen = __connman_ipaddress_netmask_prefix_len(netmask);
g_free(ipaddress->local);
ipaddress->local = g_strdup(address);
g_free(ipaddress->gateway);
ipaddress->gateway = g_strdup(gateway);
return 0;
}
static void setup_tun_interface(unsigned int flags, unsigned change,
void *data)
{
struct connman_private_network *pn = data;
unsigned char prefixlen;
DBusMessageIter array, dict;
const char *server_ip;
const char *peer_ip;
const char *subnet_mask;
int err;
DBG("index %d flags %d change %d", pn->index, flags, change);
if (flags & IFF_UP)
return;
subnet_mask = __connman_ippool_get_subnet_mask(pn->pool);
server_ip = __connman_ippool_get_start_ip(pn->pool);
peer_ip = __connman_ippool_get_end_ip(pn->pool);
prefixlen =
__connman_ipaddress_netmask_prefix_len(subnet_mask);
if ((__connman_inet_modify_address(RTM_NEWADDR,
NLM_F_REPLACE | NLM_F_ACK, pn->index, AF_INET,
server_ip, peer_ip, prefixlen, NULL)) < 0) {
DBG("address setting failed");
return;
}
connman_inet_ifup(pn->index);
err = __connman_nat_enable(BRIDGE_NAME, server_ip, prefixlen);
if (err < 0) {
connman_error("failed to enable NAT");
goto error;
}
dbus_message_iter_init_append(pn->reply, &array);
dbus_message_iter_append_basic(&array, DBUS_TYPE_OBJECT_PATH,
&pn->path);
connman_dbus_dict_open(&array, &dict);
connman_dbus_dict_append_basic(&dict, "ServerIPv4",
DBUS_TYPE_STRING, &server_ip);
connman_dbus_dict_append_basic(&dict, "PeerIPv4",
DBUS_TYPE_STRING, &peer_ip);
if (pn->primary_dns != NULL)
connman_dbus_dict_append_basic(&dict, "PrimaryDNS",
DBUS_TYPE_STRING, &pn->primary_dns);
if (pn->secondary_dns != NULL)
connman_dbus_dict_append_basic(&dict, "SecondaryDNS",
DBUS_TYPE_STRING, &pn->secondary_dns);
connman_dbus_dict_close(&array, &dict);
dbus_message_iter_append_basic(&array, DBUS_TYPE_UNIX_FD, &pn->fd);
g_dbus_send_message(connection, pn->reply);
return;
error:
pn->reply = __connman_error_failed(pn->msg, -err);
g_dbus_send_message(connection, pn->reply);
g_hash_table_remove(pn_hash, pn->path);
}
static void lease_available_cb(GDHCPClient *dhcp_client, gpointer user_data)
{
struct connman_dhcp *dhcp = user_data;
GList *list, *option = NULL;
char *address, *netmask = NULL, *gateway = NULL;
const char *c_address, *c_gateway;
char *domainname = NULL, *hostname = NULL;
char **nameservers, **timeservers, *pac = NULL;
int ns_entries;
struct connman_ipconfig *ipconfig;
struct connman_service *service;
unsigned char prefixlen, c_prefixlen;
gboolean ip_change;
int i;
DBG("Lease available");
service = connman_service_lookup_from_network(dhcp->network);
if (service == NULL) {
connman_error("Can not lookup service");
return;
}
ipconfig = __connman_service_get_ip4config(service);
if (ipconfig == NULL) {
connman_error("Could not lookup ipconfig");
return;
}
c_address = __connman_ipconfig_get_local(ipconfig);
c_gateway = __connman_ipconfig_get_gateway(ipconfig);
c_prefixlen = __connman_ipconfig_get_prefixlen(ipconfig);
address = g_dhcp_client_get_address(dhcp_client);
__connman_ipconfig_set_dhcp_address(ipconfig, address);
DBG("last address %s", address);
option = g_dhcp_client_get_option(dhcp_client, G_DHCP_SUBNET);
if (option != NULL)
netmask = g_strdup(option->data);
option = g_dhcp_client_get_option(dhcp_client, G_DHCP_ROUTER);
if (option != NULL)
gateway = g_strdup(option->data);
prefixlen = __connman_ipaddress_netmask_prefix_len(netmask);
if (prefixlen == 255)
connman_warn("netmask: %s is invalid", netmask);
DBG("c_address %s", c_address);
if (address != NULL && c_address != NULL &&
g_strcmp0(address, c_address) != 0)
ip_change = TRUE;
else if (gateway != NULL && c_gateway != NULL &&
g_strcmp0(gateway, c_gateway) != 0)
ip_change = TRUE;
else if (prefixlen != c_prefixlen)
ip_change = TRUE;
else if (c_address == NULL || c_gateway == NULL)
ip_change = TRUE;
else
ip_change = FALSE;
option = g_dhcp_client_get_option(dhcp_client, G_DHCP_DNS_SERVER);
ns_entries = g_list_length(option);
nameservers = g_try_new0(char *, ns_entries + 1);
if (nameservers != NULL) {
for (i = 0, list = option; list; list = list->next, i++)
nameservers[i] = g_strdup(list->data);
nameservers[ns_entries] = NULL;
}
option = g_dhcp_client_get_option(dhcp_client, G_DHCP_DOMAIN_NAME);
if (option != NULL)
domainname = g_strdup(option->data);
if (connman_setting_get_bool("AllowHostnameUpdates") == TRUE) {
option = g_dhcp_client_get_option(dhcp_client,
G_DHCP_HOST_NAME);
if (option != NULL)
hostname = g_strdup(option->data);
}
option = g_dhcp_client_get_option(dhcp_client, G_DHCP_NTP_SERVER);
ns_entries = g_list_length(option);
timeservers = g_try_new0(char *, ns_entries + 1);
if (timeservers != NULL) {
for (i = 0, list = option; list; list = list->next, i++)
timeservers[i] = g_strdup(list->data);
timeservers[ns_entries] = NULL;
}
option = g_dhcp_client_get_option(dhcp_client, 252);
if (option != NULL)
pac = g_strdup(option->data);
__connman_ipconfig_set_method(ipconfig, CONNMAN_IPCONFIG_METHOD_DHCP);
if (ip_change == TRUE) {
__connman_ipconfig_set_local(ipconfig, address);
__connman_ipconfig_set_prefixlen(ipconfig, prefixlen);
__connman_ipconfig_set_gateway(ipconfig, gateway);
}
if (compare_string_arrays(nameservers, dhcp->nameservers) == FALSE) {
if (dhcp->nameservers != NULL) {
for (i = 0; dhcp->nameservers[i] != NULL; i++) {
__connman_service_nameserver_remove(service,
dhcp->nameservers[i], FALSE);
}
g_strfreev(dhcp->nameservers);
}
dhcp->nameservers = nameservers;
for (i = 0; dhcp->nameservers != NULL &&
dhcp->nameservers[i] != NULL; i++) {
__connman_service_nameserver_append(service,
dhcp->nameservers[i], FALSE);
}
} else {
g_strfreev(nameservers);
}
if (compare_string_arrays(timeservers, dhcp->timeservers) == FALSE) {
if (dhcp->timeservers != NULL) {
for (i = 0; dhcp->timeservers[i] != NULL; i++) {
__connman_service_timeserver_remove(service,
dhcp->timeservers[i]);
}
g_strfreev(dhcp->timeservers);
}
dhcp->timeservers = timeservers;
for (i = 0; dhcp->timeservers != NULL &&
dhcp->timeservers[i] != NULL; i++) {
__connman_service_timeserver_append(service,
dhcp->timeservers[i]);
}
} else {
g_strfreev(timeservers);
}
if (g_strcmp0(pac, dhcp->pac) != 0) {
g_free(dhcp->pac);
dhcp->pac = pac;
__connman_service_set_pac(service, dhcp->pac);
}
__connman_service_set_domainname(service, domainname);
if (domainname != NULL)
__connman_utsname_set_domainname(domainname);
if (hostname != NULL)
__connman_utsname_set_hostname(hostname);
if (ip_change == TRUE)
dhcp_valid(dhcp);
__connman_6to4_probe(service);
g_free(address);
g_free(netmask);
g_free(gateway);
g_free(domainname);
g_free(hostname);
}
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");
}
