X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;ds=sidebyside;f=src%2Ftethering.c;h=c67f2007fb584c9628be2cd712790aed9440dc86;hb=230905c20905f2bc5ccf4b8fab75c1b5df2ac31d;hp=208a39f460167e13c333000bc0ec11a4f36bc0db;hpb=8333817dae08600bc2f4a84b499108ca1c39b4e2;p=framework%2Fconnectivity%2Fconnman.git

diff --git a/src/tethering.c b/src/tethering.c
index 208a39f..c67f200 100644
--- a/src/tethering.c
+++ b/src/tethering.c
@@ -2,7 +2,8 @@
  *
  *  Connection Manager
  *
- *  Copyright (C) 2007-2010  Intel Corporation. All rights reserved.
+ *  Copyright (C) 2007-2012  Intel Corporation. All rights reserved.
+ *  Copyright (C) 2011	ProFUSION embedded systems
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License version 2 as
@@ -23,112 +24,437 @@
 #include <config.h>
 #endif
 
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
 #include <unistd.h>
+#include <stdio.h>
 #include <sys/ioctl.h>
 #include <net/if.h>
 #include <linux/sockios.h>
+#include <string.h>
+#include <fcntl.h>
+#include <linux/if_tun.h>
 
 #include "connman.h"
 
-#include <connman/tethering.h>
+#include <gdhcp/gdhcp.h>
+
+#include <gdbus.h>
+
+#ifndef DBUS_TYPE_UNIX_FD
+#define DBUS_TYPE_UNIX_FD -1
+#endif
+
+#define BRIDGE_PROC_DIR "/proc/sys/net/bridge"
 
 #define BRIDGE_NAME "tether"
+#define BRIDGE_DNS "8.8.8.8"
+
+#define DEFAULT_MTU	1500
+
+#define PRIVATE_NETWORK_PRIMARY_DNS BRIDGE_DNS
+#define PRIVATE_NETWORK_SECONDARY_DNS "8.8.4.4"
+
+static volatile int tethering_enabled;
+static GDHCPServer *tethering_dhcp_server = NULL;
+static struct connman_ippool *dhcp_ippool = NULL;
+static DBusConnection *connection;
+static GHashTable *pn_hash;
+
+struct connman_private_network {
+	char *owner;
+	char *path;
+	guint watch;
+	DBusMessage *msg;
+	DBusMessage *reply;
+	int fd;
+	char *interface;
+	int index;
+	guint iface_watch;
+	struct connman_ippool *pool;
+	const char *primary_dns;
+	const char *secondary_dns;
+};
+
+const char *__connman_tethering_get_bridge(void)
+{
+	struct stat st;
 
-static connman_bool_t tethering_status = FALSE;
-gint tethering_enabled;
+	if (stat(BRIDGE_PROC_DIR, &st) < 0) {
+		connman_error("Missing support for 802.1d ethernet bridging");
+		return NULL;
+	}
 
-connman_bool_t __connman_tethering_get_status(void)
+	return BRIDGE_NAME;
+}
+
+static void dhcp_server_debug(const char *str, void *data)
+{
+	connman_info("%s: %s\n", (const char *) data, str);
+}
+
+static void dhcp_server_error(GDHCPServerError error)
 {
-	return tethering_status;
+	switch (error) {
+	case G_DHCP_SERVER_ERROR_NONE:
+		connman_error("OK");
+		break;
+	case G_DHCP_SERVER_ERROR_INTERFACE_UNAVAILABLE:
+		connman_error("Interface unavailable");
+		break;
+	case G_DHCP_SERVER_ERROR_INTERFACE_IN_USE:
+		connman_error("Interface in use");
+		break;
+	case G_DHCP_SERVER_ERROR_INTERFACE_DOWN:
+		connman_error("Interface down");
+		break;
+	case G_DHCP_SERVER_ERROR_NOMEM:
+		connman_error("No memory");
+		break;
+	case G_DHCP_SERVER_ERROR_INVALID_INDEX:
+		connman_error("Invalid index");
+		break;
+	case G_DHCP_SERVER_ERROR_INVALID_OPTION:
+		connman_error("Invalid option");
+		break;
+	case G_DHCP_SERVER_ERROR_IP_ADDRESS_INVALID:
+		connman_error("Invalid address");
+		break;
+	}
 }
 
-static int create_bridge(const char *name)
+static GDHCPServer *dhcp_server_start(const char *bridge,
+				const char *router, const char* subnet,
+				const char *start_ip, const char *end_ip,
+				unsigned int lease_time, const char *dns)
 {
-	int sk, err;
+	GDHCPServerError error;
+	GDHCPServer *dhcp_server;
+	int index;
+
+	DBG("");
 
-	DBG("name %s", name);
+	index = connman_inet_ifindex(bridge);
+	if (index < 0)
+		return NULL;
 
-	sk = socket(AF_INET, SOCK_STREAM, 0);
-	if (sk < 0)
-		return -EOPNOTSUPP;
+	dhcp_server = g_dhcp_server_new(G_DHCP_IPV4, index, &error);
+	if (dhcp_server == NULL) {
+		dhcp_server_error(error);
+		return NULL;
+	}
 
-	err = ioctl(sk, SIOCBRADDBR, name);
+	g_dhcp_server_set_debug(dhcp_server, dhcp_server_debug, "DHCP server");
 
-	close(sk);
+	g_dhcp_server_set_lease_time(dhcp_server, lease_time);
+	g_dhcp_server_set_option(dhcp_server, G_DHCP_SUBNET, subnet);
+	g_dhcp_server_set_option(dhcp_server, G_DHCP_ROUTER, router);
+	g_dhcp_server_set_option(dhcp_server, G_DHCP_DNS_SERVER, dns);
+	g_dhcp_server_set_ip_range(dhcp_server, start_ip, end_ip);
 
-	if (err < 0)
-		return -EOPNOTSUPP;
+	g_dhcp_server_start(dhcp_server);
 
-	return 0;
+	return dhcp_server;
 }
 
-static int remove_bridge(const char *name)
+static void dhcp_server_stop(GDHCPServer *server)
 {
-	int sk, err;
+	if (server == NULL)
+		return;
 
-	DBG("name %s", name);
+	g_dhcp_server_unref(server);
+}
 
-	sk = socket(AF_INET, SOCK_STREAM, 0);
-	if (sk < 0)
-		return -EOPNOTSUPP;
+static void tethering_restart(struct connman_ippool *pool, void *user_data)
+{
+	__connman_tethering_set_disabled();
+	__connman_tethering_set_enabled();
+}
+
+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;
 
-	err = ioctl(sk, SIOCBRDELBR, name);
+	DBG("enabled %d", tethering_enabled + 1);
 
-	close(sk);
+	if (__sync_fetch_and_add(&tethering_enabled, 1) != 0)
+		return;
 
+	err = __connman_bridge_create(BRIDGE_NAME);
 	if (err < 0)
-		return -EOPNOTSUPP;
+		return;
 
-	return 0;
+	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");
+		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, broadcast);
+	if (err < 0 && err != -EALREADY) {
+		__connman_bridge_remove(BRIDGE_NAME);
+		return;
+	}
+
+	dns = gateway;
+	if (__connman_dnsproxy_add_listener(BRIDGE_NAME) < 0) {
+		connman_error("Can't add listener %s to DNS proxy",
+								BRIDGE_NAME);
+		dns = BRIDGE_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_bridge_remove(BRIDGE_NAME);
+		return;
+	}
+
+	prefixlen =
+		__connman_ipconfig_netmask_prefix_len(subnet_mask);
+	__connman_nat_enable(BRIDGE_NAME, start_ip, prefixlen);
+
+	DBG("tethering started");
 }
 
-void connman_tethering_enabled(void)
+void __connman_tethering_set_disabled(void)
 {
-	if (tethering_status == FALSE)
+	DBG("enabled %d", tethering_enabled - 1);
+
+	__connman_dnsproxy_remove_listener(BRIDGE_NAME);
+
+	if (__sync_fetch_and_sub(&tethering_enabled, 1) != 1)
 		return;
 
-	DBG("enabled %d", tethering_enabled + 1);
+	__connman_nat_disable(BRIDGE_NAME);
 
-	if (g_atomic_int_exchange_and_add(&tethering_enabled, 1) == 0) {
-		/* TODO Start DHCP server and DNS proxy on the bridge */
-		DBG("tethering started");
-	}
+	dhcp_server_stop(tethering_dhcp_server);
+
+	tethering_dhcp_server = NULL;
+
+	__connman_bridge_disable(BRIDGE_NAME);
+
+	__connman_ippool_unref(dhcp_ippool);
+
+	__connman_bridge_remove(BRIDGE_NAME);
+
+	DBG("tethering stopped");
 }
 
-void connman_tethering_disabled(void)
+static void setup_tun_interface(unsigned int flags, unsigned change,
+		void *data)
 {
-	if (tethering_status == FALSE)
+	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;
 
-	DBG("enabled %d", tethering_enabled - 1);
+	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_ipconfig_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);
+	connman_dbus_dict_append_basic(&dict, "PrimaryDNS",
+					DBUS_TYPE_STRING, &pn->primary_dns);
+	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);
 
-	if (g_atomic_int_dec_and_test(&tethering_enabled) == 0) {
-		/* TODO Stop DHCP server and DNS proxy on the bridge */
-		DBG("tethering stopped");
+	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 remove_private_network(gpointer user_data)
+{
+	struct connman_private_network *pn = user_data;
+
+	__connman_nat_disable(BRIDGE_NAME);
+	connman_rtnl_remove_watch(pn->iface_watch);
+	__connman_ippool_unref(pn->pool);
+
+	if (pn->watch > 0) {
+		g_dbus_remove_watch(connection, pn->watch);
+		pn->watch = 0;
 	}
+
+	close(pn->fd);
+
+	g_free(pn->interface);
+	g_free(pn->owner);
+	g_free(pn->path);
+	g_free(pn);
+}
+
+static void owner_disconnect(DBusConnection *connection, void *user_data)
+{
+	struct connman_private_network *pn = user_data;
+
+	DBG("%s died", pn->owner);
+
+	pn->watch = 0;
+
+	g_hash_table_remove(pn_hash, pn->path);
 }
 
-int __connman_tethering_set_status(connman_bool_t status)
+static void ippool_disconnect(struct connman_ippool *pool, void *user_data)
 {
-	if (status == tethering_status)
-		return -EALREADY;
+	struct connman_private_network *pn = user_data;
+
+	DBG("block used externally");
+
+	g_hash_table_remove(pn_hash, pn->path);
+}
+
+int __connman_private_network_request(DBusMessage *msg, const char *owner)
+{
+	struct connman_private_network *pn;
+	char *iface = NULL;
+	char *path = NULL;
+	int index, fd, err;
+
+	if (DBUS_TYPE_UNIX_FD < 0)
+		return -EINVAL;
+
+	fd = connman_inet_create_tunnel(&iface);
+	if (fd < 0)
+		return fd;
+
+	path = g_strdup_printf("/tethering/%s", iface);
+
+	pn = g_hash_table_lookup(pn_hash, path);
+	if (pn) {
+		g_free(path);
+		g_free(iface);
+		close(fd);
+		return -EEXIST;
+	}
+
+	index = connman_inet_ifindex(iface);
+	if (index < 0) {
+		err = -ENODEV;
+		goto error;
+	}
+	DBG("interface %s", iface);
+
+	err = connman_inet_set_mtu(index, DEFAULT_MTU);
+
+	pn = g_try_new0(struct connman_private_network, 1);
+	if (pn == NULL) {
+		err = -ENOMEM;
+		goto error;
+	}
 
-	if (status == TRUE) {
-		create_bridge(BRIDGE_NAME);
-		__connman_technology_enable_tethering(BRIDGE_NAME);
-	} else {
-		__connman_technology_disable_tethering(BRIDGE_NAME);
-		remove_bridge(BRIDGE_NAME);
+	pn->owner = g_strdup(owner);
+	pn->path = path;
+	pn->watch = g_dbus_add_disconnect_watch(connection, pn->owner,
+					owner_disconnect, pn, NULL);
+	pn->msg = msg;
+	pn->reply = dbus_message_new_method_return(pn->msg);
+	if (pn->reply == NULL)
+		goto error;
+
+	pn->fd = fd;
+	pn->interface = iface;
+	pn->index = index;
+	pn->pool = __connman_ippool_create(pn->fd, 1, 1, ippool_disconnect, pn);
+	if (pn->pool == NULL) {
+		errno = -ENOMEM;
+		goto error;
 	}
 
-	tethering_status = status;
+	pn->primary_dns = PRIVATE_NETWORK_PRIMARY_DNS;
+	pn->secondary_dns = PRIVATE_NETWORK_SECONDARY_DNS;
+
+	pn->iface_watch = connman_rtnl_add_newlink_watch(index,
+						setup_tun_interface, pn);
+
+	g_hash_table_insert(pn_hash, pn->path, pn);
 
 	return 0;
+
+error:
+	close(fd);
+	g_free(iface);
+	g_free(path);
+	g_free(pn);
+	return err;
 }
 
-void __connman_tethering_update_interface(const char *interface)
+int __connman_private_network_release(const char *path)
 {
-	DBG("interface %s", interface);
+	struct connman_private_network *pn;
+
+	pn = g_hash_table_lookup(pn_hash, path);
+	if (pn == NULL)
+		return -EACCES;
+
+	g_hash_table_remove(pn_hash, path);
+	return 0;
 }
 
 int __connman_tethering_init(void)
@@ -137,6 +463,13 @@ int __connman_tethering_init(void)
 
 	tethering_enabled = 0;
 
+	connection = connman_dbus_get_connection();
+	if (connection == NULL)
+		return -EFAULT;
+
+	pn_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
+						NULL, remove_private_network);
+
 	return 0;
 }
 
@@ -144,6 +477,18 @@ void __connman_tethering_cleanup(void)
 {
 	DBG("");
 
-	if (tethering_status == TRUE)
-		remove_bridge(BRIDGE_NAME);
+	__sync_synchronize();
+	if (tethering_enabled == 0) {
+		if (tethering_dhcp_server)
+			dhcp_server_stop(tethering_dhcp_server);
+		__connman_bridge_disable(BRIDGE_NAME);
+		__connman_bridge_remove(BRIDGE_NAME);
+		__connman_nat_disable(BRIDGE_NAME);
+	}
+
+	if (connection == NULL)
+		return;
+
+	g_hash_table_destroy(pn_hash);
+	dbus_connection_unref(connection);
 }