static void test_nat_basic1(void)
{
struct connman_service *service;
int err;
service = g_try_new0(struct connman_service, 1);
g_assert(service);
nat_notifier->default_changed(service);
err = __connman_nat_enable("bridge", "192.168.2.1", 24);
g_assert(err == 0);
/* test that table is not empty */
err = __connman_iptables_append("nat", "POSTROUTING",
"-s 192.168.2.1/24 -o eth0 -j MASQUERADE");
g_assert(err == 0);
err = __connman_iptables_commit("nat");
g_assert(err == 0);
__connman_nat_disable("bridge");
/* test that table is empty again */
err = __connman_iptables_delete("nat", "POSTROUTING",
"-s 192.168.2.1/24 -o eth0 -j MASQUERADE");
g_assert(err == 0);
err = __connman_iptables_commit("nat");
g_assert(err == 0);
g_free(service);
}
static void test_nat_basic0(void)
{
int err;
err = __connman_nat_enable("bridge", "192.168.2.1", 24);
g_assert(err == 0);
/* test that table is empty */
err = __connman_iptables_append("nat", "POSTROUTING",
"-s 192.168.2.1/24 -o eth0 -j MASQUERADE");
g_assert(err == 0);
err = __connman_iptables_commit("nat");
g_assert(err == 0);
assert_rule_exists("nat",
"-A POSTROUTING -s 192.168.2.0/24 -o eth0 -j MASQUERADE");
err = __connman_iptables_delete("nat", "POSTROUTING",
"-s 192.168.2.1/24 -o eth0 -j MASQUERADE");
g_assert(err == 0);
err = __connman_iptables_commit("nat");
g_assert(err == 0);
assert_rule_not_exists("nat",
"-A POSTROUTING -s 192.168.2.0/24 -o eth0 -j MASQUERADE");
__connman_nat_disable("bridge");
}
/**
* @brief Callback connecting network
*/
static void
network_connect_callback(DBusMessage *message, void *user_data) {
struct qmi_data *qmi = (struct qmi_data *)user_data;
DBG("qmi data %p DBusmessage %p", qmi, message);
g_return_if_fail(qmi);
if(dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_ERROR) {
const char *dbus_error = dbus_message_get_error_name(message);
/*Failure during connecting */
qmi->modem_connected = FALSE;
if(qmi->network)
connman_network_set_connected(qmi->network, FALSE);
connman_error("%s", dbus_error);
return;
}
/* Connected successfully */
qmi->modem_connected = TRUE;
connman_network_set_connected(qmi->network, TRUE);
DBG("Device %s connected %d", qmi->devpath, qmi->modem_connected);
g_assert(qmi->qmi_proxy_device);
/* Request all available properties */
g_dbus_proxy_method_call( qmi->qmi_proxy_device,
GET_PROPERTIES,
NULL,
get_properties_callback,
qmi,
NULL);
//FIXME Hack NAT enable by default
__connman_nat_enable("qmi", NULL, 0);
}
static int network_connect(struct connman_network *network) {
struct mk3_data *mk3 = NULL;
DBG("Network %p", network);
mk3 = connman_network_get_data(network);
if(!mk3) {
connman_error("Could not get device data.");
return -ENODEV;
}
DBG("Network %p %p", network, mk3);
__connman_nat_enable("mk3", NULL, 0);
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);
}
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");
}
