diff --git a/ggsn/ggsn.c b/ggsn/ggsn.c
index d865707..2bf3d7e 100644
--- a/ggsn/ggsn.c
+++ b/ggsn/ggsn.c
@@ -1,6 +1,7 @@
 /* 
  * OpenGGSN - Gateway GPRS Support Node
  * Copyright (C) 2002, 2003, 2004 Mondru AB.
+ * Copyright (C) 2017 by Harald Welte <laforge@gnumonks.org>
  * 
  * The contents of this file may be used under the terms of the GNU
  * General Public License Version 2, provided that the above copyright
@@ -19,42 +20,43 @@
 
 #include "../config.h"
 
-#include <osmocom/core/application.h>
-
 #ifdef HAVE_STDINT_H
 #include <stdint.h>
 #endif
 
+#include <getopt.h>
 #include <ctype.h>
-#include <netdb.h>
 #include <signal.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
+#include <unistd.h>
+#include <inttypes.h>
+#include <errno.h>
 #include <sys/types.h>
-#include <sys/socket.h>
+#include <sys/ioctl.h>
+
+#include <net/if.h>
+#include <arpa/inet.h>
 #include <netinet/in.h>
 #include <netinet/ip.h>
 #include <netinet/ip6.h>
-#include <arpa/inet.h>
-#include <sys/wait.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <inttypes.h>
-#include <sys/socket.h>
-#include <sys/ioctl.h>
-#include <net/if.h>
-#include <net/if.h>
 
-#include <errno.h>
-
-#include <time.h>
-
+#include <osmocom/core/application.h>
 #include <osmocom/core/select.h>
+#include <osmocom/core/stats.h>
+#include <osmocom/core/rate_ctr.h>
+#include <osmocom/core/timer.h>
 #include <osmocom/ctrl/control_if.h>
 #include <osmocom/ctrl/control_cmd.h>
+#include <osmocom/ctrl/control_vty.h>
 #include <osmocom/ctrl/ports.h>
+#include <osmocom/vty/telnet_interface.h>
+#include <osmocom/vty/logging.h>
+#include <osmocom/vty/stats.h>
+#include <osmocom/vty/ports.h>
+#include <osmocom/vty/command.h>
+#include <osmocom/gsm/apn.h>
 
 #include "../lib/tun.h"
 #include "../lib/ippool.h"
@@ -62,82 +64,188 @@
 #include "../lib/in46_addr.h"
 #include "../gtp/pdp.h"
 #include "../gtp/gtp.h"
-#include "cmdline.h"
 #include "gtp-kernel.h"
 #include "icmpv6.h"
+#include "ggsn.h"
 
-int end = 0;
-int maxfd = 0;			/* For select()            */
+void *tall_ggsn_ctx;
 
-struct in_addr listen_;
-struct in46_addr netaddr, destaddr, net;	/* Network interface       */
-size_t prefixlen;
-struct in46_addr dns1, dns2;	/* PCO DNS address         */
-char *ipup, *ipdown;		/* Filename of scripts     */
-int debug;			/* Print debug output      */
-struct ul255_t pco;
+static int end = 0;
+static int daemonize = 0;
+static struct ctrl_handle *g_ctrlh;
+
 struct ul255_t qos;
 struct ul255_t apn;
 
-struct gsn_t *gsn;		/* GSN instance            */
-struct tun_t *tun;		/* TUN instance            */
-struct ippool_t *ippool;	/* Pool of IP addresses    */
+#define LOGPAPN(level, apn, fmt, args...)			\
+	LOGP(DGGSN, level, "APN(%s): " fmt, (apn)->cfg.name, ## args)
 
-/* To exit gracefully. Used with GCC compilation flag -pg and gprof */
-void signal_handler(int s)
+#define LOGPGGSN(level, ggsn, fmt, args...)			\
+	LOGP(DGGSN, level, "GGSN(%s): " fmt, (ggsn)->cfg.name, ## args)
+
+#define LOGPPDP(level, pdp, fmt, args...)			\
+	LOGP(DGGSN, level, "PDP(%s:%u): " fmt, imsi_gtp2str(&(pdp)->imsi), (pdp)->nsapi, ## args)
+
+static int ggsn_tun_fd_cb(struct osmo_fd *fd, unsigned int what);
+static int cb_tun_ind(struct tun_t *tun, void *pack, unsigned len);
+
+
+static void pool_close_all_pdp(struct ippool_t *pool)
 {
-	DEBUGP(DGGSN, "Received signal %d, exiting.\n", s);
-	end = 1;
-}
+	unsigned int i;
 
-/* Used to write process ID to file. Assume someone else will delete */
-void log_pid(char *pidfile)
-{
-	FILE *file;
-	mode_t oldmask;
-
-	oldmask = umask(022);
-	file = fopen(pidfile, "w");
-	umask(oldmask);
-	if (!file) {
-		SYS_ERR(DGGSN, LOGL_ERROR, 0,
-			"Failed to create process ID file: %s!", pidfile);
+	if (!pool)
 		return;
+
+	for (i = 0; i < pool->listsize; i++) {
+		struct ippoolm_t *member = &pool->member[i];
+		struct pdp_t *pdp;
+
+		if (!member->inuse)
+			continue;
+		pdp = member->peer;
+		if (!pdp)
+			continue;
+		LOGPPDP(LOGL_DEBUG, pdp, "Sending DELETE PDP CTX due to shutdown\n");
+		gtp_delete_context_req(pdp->gsn, pdp, NULL, 1);
 	}
-	fprintf(file, "%d\n", (int)getpid());
-	fclose(file);
 }
 
-#if defined(__sun__)
-int daemon(int nochdir, int noclose)
+int apn_stop(struct apn_ctx *apn, bool force)
 {
-	int fd;
+	if (!apn->started)
+		return 0;
 
-	switch (fork()) {
-	case -1:
-		return (-1);
-	case 0:
+	LOGPAPN(LOGL_NOTICE, apn, "%sStopping\n", force ? "FORCED " : "");
+	/* check if pools have any active PDP contexts and bail out */
+	pool_close_all_pdp(apn->v4.pool);
+	pool_close_all_pdp(apn->v6.pool);
+
+	/* shutdown whatever old state might be left */
+	if (apn->tun.tun) {
+		/* run ip-down script */
+		if (apn->tun.cfg.ipdown_script) {
+			LOGPAPN( LOGL_INFO, apn, "Running %s\n", apn->tun.cfg.ipdown_script);
+			tun_runscript(apn->tun.tun, apn->tun.cfg.ipdown_script);
+		}
+		/* release tun device */
+		LOGPAPN(LOGL_INFO, apn, "Closing TUN device\n");
+		osmo_fd_unregister(&apn->tun.fd);
+		tun_free(apn->tun.tun);
+		apn->tun.tun = NULL;
+	}
+
+	if (apn->v4.pool) {
+		LOGPAPN(LOGL_INFO, apn, "Releasing IPv4 pool\n");
+		ippool_free(apn->v4.pool);
+		apn->v4.pool = NULL;
+	}
+	if (apn->v6.pool) {
+		LOGPAPN(LOGL_INFO, apn, "Releasing IPv6 pool\n");
+		ippool_free(apn->v6.pool);
+		apn->v6.pool = NULL;
+	}
+
+	apn->started = false;
+	return 0;
+}
+
+/* actually start the APN with its current config */
+int apn_start(struct apn_ctx *apn)
+{
+	if (apn->started)
+		return 0;
+
+	LOGPAPN(LOGL_INFO, apn, "Starting\n");
+	switch (apn->cfg.gtpu_mode) {
+	case APN_GTPU_MODE_TUN:
+		LOGPAPN(LOGL_INFO, apn, "Opening TUN device %s\n", apn->tun.cfg.dev_name);
+		if (tun_new(&apn->tun.tun, apn->tun.cfg.dev_name)) {
+			LOGPAPN(LOGL_ERROR, apn, "Failed to configure tun device\n");
+			return -1;
+		}
+		LOGPAPN(LOGL_INFO, apn, "Opened TUN device %s\n", apn->tun.tun->devname);
+
+		/* Register with libosmcoore */
+		osmo_fd_setup(&apn->tun.fd, apn->tun.tun->fd, BSC_FD_READ, ggsn_tun_fd_cb, apn, 0);
+		osmo_fd_register(&apn->tun.fd);
+
+		/* Set TUN library callback */
+		tun_set_cb_ind(apn->tun.tun, cb_tun_ind);
+
+		if (apn->v4.cfg.ifconfig_prefix.addr.len) {
+			LOGPAPN(LOGL_INFO, apn, "Setting tun IP address %s\n",
+				in46p_ntoa(&apn->v4.cfg.ifconfig_prefix));
+			if (tun_setaddr(apn->tun.tun, &apn->v4.cfg.ifconfig_prefix.addr, NULL,
+					apn->v4.cfg.ifconfig_prefix.prefixlen)) {
+				LOGPAPN(LOGL_ERROR, apn, "Failed to set tun IPv4 address %s: %s\n",
+					in46p_ntoa(&apn->v4.cfg.ifconfig_prefix), strerror(errno));
+				apn_stop(apn, false);
+				return -1;
+			}
+		}
+
+		if (apn->v6.cfg.ifconfig_prefix.addr.len) {
+			LOGPAPN(LOGL_INFO, apn, "Setting tun IPv6 address %s\n",
+				in46p_ntoa(&apn->v6.cfg.ifconfig_prefix));
+			if (tun_setaddr(apn->tun.tun, &apn->v6.cfg.ifconfig_prefix.addr, NULL,
+					apn->v6.cfg.ifconfig_prefix.prefixlen)) {
+				LOGPAPN(LOGL_ERROR, apn, "Failed to set tun IPv6 address %s: %s\n",
+					in46p_ntoa(&apn->v6.cfg.ifconfig_prefix), strerror(errno));
+				apn_stop(apn, false);
+				return -1;
+			}
+		}
+
+		if (apn->tun.cfg.ipup_script) {
+			LOGPAPN(LOGL_INFO, apn, "Running ip-up script %s\n",
+				apn->tun.cfg.ipup_script);
+			tun_runscript(apn->tun.tun, apn->tun.cfg.ipup_script);
+		}
+		/* set back-pointer from TUN device to APN */
+		apn->tun.tun->priv = apn;
+		break;
+	case APN_GTPU_MODE_KERNEL_GTP:
+		LOGPAPN(LOGL_ERROR, apn, "FIXME: Kernel GTP\n");
+#if 0
+		/* use GTP kernel module for data packet encapsulation */
+		if (gtp_kernel_init(gsn, &net.v4, prefixlen, net_arg) < 0)
+			goto err;
+#endif
 		break;
 	default:
-		_exit(0);
+		LOGPAPN(LOGL_ERROR, apn, "Unknown GTPU Mode %d\n", apn->cfg.gtpu_mode);
+		return -1;
 	}
 
-	if (setsid() == -1)
-		return (-1);
-
-	if (!nochdir)
-		chdir("/");
-
-	if (!noclose && (fd = open("/dev/null", O_RDWR, 0)) != -1) {
-		dup2(fd, STDIN_FILENO);
-		dup2(fd, STDOUT_FILENO);
-		dup2(fd, STDERR_FILENO);
-		if (fd > 2)
-			close(fd);
+	/* Create IPv4 pool */
+	if (apn->v4.cfg.dynamic_prefix.addr.len) {
+		LOGPAPN(LOGL_INFO, apn, "Creating IPv4 pool %s\n",
+			in46p_ntoa(&apn->v4.cfg.dynamic_prefix));
+		if (ippool_new(&apn->v4.pool, &apn->v4.cfg.dynamic_prefix,
+				&apn->v4.cfg.static_prefix, 0)) {
+			LOGPAPN(LOGL_ERROR, apn, "Failed to create IPv4 pool\n");
+			apn_stop(apn, false);
+			return -1;
+		}
 	}
-	return (0);
+
+	/* Create IPv6 pool */
+	if (apn->v6.cfg.dynamic_prefix.addr.len) {
+		LOGPAPN(LOGL_INFO, apn, "Creating IPv6 pool %s\n",
+			in46p_ntoa(&apn->v6.cfg.dynamic_prefix));
+		if (ippool_new(&apn->v6.pool, &apn->v6.cfg.dynamic_prefix,
+				&apn->v6.cfg.static_prefix, 0)) {
+			LOGPAPN(LOGL_ERROR, apn, "Failed to create IPv6 pool\n");
+			apn_stop(apn, false);
+			return -1;
+		}
+	}
+
+	LOGPAPN(LOGL_NOTICE, apn, "Successfully started\n");
+	apn->started = true;
+	return 0;
 }
-#endif
 
 static bool send_trap(const struct gsn_t *gsn, const struct pdp_t *pdp, const struct ippoolm_t *member, const char *var)
 {
@@ -148,27 +256,29 @@
 
 	snprintf(val, sizeof(val), "%s,%s", imsi_gtp2str(&pdp->imsi), addrstr);
 
-	if (ctrl_cmd_send_trap(gsn->priv, var, val) < 0) {
-		LOGP(DGGSN, LOGL_ERROR, "Failed to create and send TRAP for IMSI %" PRIu64 " [%s].\n", pdp->imsi, var);
+	if (ctrl_cmd_send_trap(g_ctrlh, var, val) < 0) {
+		LOGPPDP(LOGL_ERROR, pdp, "Failed to create and send TRAP %s\n", var);
 		return false;
 	}
 	return true;
 }
 
-int delete_context(struct pdp_t *pdp)
+static int delete_context(struct pdp_t *pdp)
 {
-	DEBUGP(DGGSN, "Deleting PDP context\n");
+	struct gsn_t *gsn = pdp->gsn;
+	struct ippoolm_t *ipp = (struct ippoolm_t *)pdp->peer;
+
+	LOGPPDP(LOGL_INFO, pdp, "Deleting PDP context\n");
 	struct ippoolm_t *member = pdp->peer;
 
 	if (pdp->peer) {
 		send_trap(gsn, pdp, member, "imsi-rem-ip"); /* TRAP with IP removal */
-		ippool_freeip(ippool, (struct ippoolm_t *)pdp->peer);
+		ippool_freeip(ipp->pool, ipp);
 	} else
-		SYS_ERR(DGGSN, LOGL_ERROR, 0, "Peer not defined!");
+		LOGPPDP(LOGL_ERROR, pdp, "Cannot find/free IP Pool member\n");
 
 	if (gtp_kernel_tunnel_del(pdp)) {
-		SYS_ERR(DGGSN, LOGL_ERROR, 0,
-			"Cannot delete tunnel from kernel: %s\n",
+		LOGPPDP(LOGL_ERROR, pdp, "Cannot delete tunnel from kernel:%s\n",
 			strerror(errno));
 	}
 
@@ -236,31 +346,74 @@
 		return false;
 }
 
+/* construct an IPCP PCO from up to two given DNS addreses */
+static int build_ipcp_pco(struct msgb *msg, uint8_t id, const struct in46_addr *dns1,
+			  const struct in46_addr *dns2)
+{
+	uint8_t *len1, *len2;
+	uint8_t *start = msg->tail;
+	unsigned int len_appended;
+
+	/* Three byte T16L header */
+	msgb_put_u16(msg, 0x8021);	/* IPCP */
+	len1 = msgb_put(msg, 1);	/* Length of contents: delay */
+
+	msgb_put_u8(msg, 0x02);		/* ACK */
+	msgb_put_u8(msg, id);		/* ID: Needs to match request */
+	msgb_put_u8(msg, 0x00);		/* Length MSB */
+	len2 = msgb_put(msg, 1);	/* Length LSB: delay */
+
+	if (dns1 && dns1->len == 4) {
+		msgb_put_u8(msg, 0x81);		/* DNS1 Tag */
+		msgb_put_u8(msg, 2 + dns1->len);/* DNS1 Length, incl. TL */
+		msgb_put_u32(msg, dns1->v4.s_addr);
+	}
+
+	if (dns2 && dns2->len == 4) {
+		msgb_put_u8(msg, 0x83);		/* DNS2 Tag */
+		msgb_put_u8(msg, 2 + dns2->len);/* DNS2 Length, incl. TL */
+		msgb_put_u32(msg, dns2->v4.s_addr);
+	}
+
+	/* patch in length values */
+	len_appended = msg->tail - start;
+	*len1 = len_appended - 3;
+	*len2 = len_appended - 3;
+
+	return 0;
+}
+
 /* process one PCO request from a MS/UE, putting together the proper responses */
-static void process_pco(struct pdp_t *pdp)
+static void process_pco(struct apn_ctx *apn, struct pdp_t *pdp)
 {
 	struct msgb *msg = msgb_alloc(256, "PCO");
+	unsigned int i;
+
+	OSMO_ASSERT(msg);
 	msgb_put_u8(msg, 0x80); /* ext-bit + configuration protocol byte */
 
 	/* FIXME: also check if primary / secondary DNS was requested */
 	if (pdp_has_v4(pdp) && pco_contains_proto(&pdp->pco_req, PCO_P_IPCP)) {
 		/* FIXME: properly implement this for IPCP */
-		uint8_t *cur = msgb_put(msg, pco.l-1);
-		memcpy(cur, pco.v+1, pco.l-1);
+		build_ipcp_pco(msg, 0, &apn->v4.cfg.dns[0], &apn->v4.cfg.dns[1]);
 	}
 
 	if (pco_contains_proto(&pdp->pco_req, PCO_P_DNS_IPv6_ADDR)) {
-		if (dns1.len == 16)
-			msgb_t16lv_put(msg, PCO_P_DNS_IPv6_ADDR, dns1.len, dns1.v6.s6_addr);
-		if (dns2.len == 16)
-			msgb_t16lv_put(msg, PCO_P_DNS_IPv6_ADDR, dns2.len, dns2.v6.s6_addr);
+		for (i = 0; i < ARRAY_SIZE(apn->v6.cfg.dns); i++) {
+			struct in46_addr *i46a = &apn->v6.cfg.dns[i];
+			if (i46a->len != 16)
+				continue;
+			msgb_t16lv_put(msg, PCO_P_DNS_IPv6_ADDR, i46a->len, i46a->v6.s6_addr);
+		}
 	}
 
 	if (pco_contains_proto(&pdp->pco_req, PCO_P_DNS_IPv4_ADDR)) {
-		if (dns1.len == 4)
-			msgb_t16lv_put(msg, PCO_P_DNS_IPv4_ADDR, dns1.len, (uint8_t *)&dns1.v4);
-		if (dns2.len == 4)
-			msgb_t16lv_put(msg, PCO_P_DNS_IPv4_ADDR, dns2.len, (uint8_t *)&dns2.v4);
+		for (i = 0; i < ARRAY_SIZE(apn->v4.cfg.dns); i++) {
+			struct in46_addr *i46a = &apn->v4.cfg.dns[i];
+			if (i46a->len != 4)
+				continue;
+			msgb_t16lv_put(msg, PCO_P_DNS_IPv4_ADDR, i46a->len, (uint8_t *)&i46a->v4);
+		}
 	}
 
 	if (msgb_length(msg) > 1) {
@@ -274,11 +427,29 @@
 
 int create_context_ind(struct pdp_t *pdp)
 {
+	static char name_buf[256];
+	struct gsn_t *gsn = pdp->gsn;
+	struct ggsn_ctx *ggsn = gsn->priv;
 	struct in46_addr addr;
 	struct ippoolm_t *member;
+	struct apn_ctx *apn;
 	int rc;
 
-	DEBUGP(DGGSN, "Received create PDP context request\n");
+	osmo_apn_to_str(name_buf, pdp->apn_req.v, pdp->apn_req.l);
+
+	LOGPPDP(LOGL_DEBUG, pdp, "Processing create PDP context request for APN '%s'\n", name_buf);
+
+	/* First find an exact APN name match */
+	apn = ggsn_find_apn(ggsn, name_buf);
+	/* then try default (if any) */
+	if (!apn)
+		apn = ggsn->cfg.default_apn;
+	if (!apn) {
+		/* no APN found for what user requested */
+		LOGPPDP(LOGL_NOTICE, pdp, "Unknown APN '%s', rejecting\n", name_buf);
+		gtp_create_context_resp(gsn, pdp, GTPCAUSE_MISSING_APN);
+		return 0;
+	}
 
 	/* FIXME: we manually force all context requests to dynamic here! */
 	if (pdp->eua.l > 2)
@@ -290,21 +461,30 @@
 	pdp->qos_neg.l = pdp->qos_req.l;
 
 	if (in46a_from_eua(&pdp->eua, &addr)) {
-		SYS_ERR(DGGSN, LOGL_ERROR, 0, "Cannot decode EUA from MS/SGSN: %s",
+		LOGPPDP(LOGL_ERROR, pdp, "Cannot decode EUA from MS/SGSN: %s\n",
 			osmo_hexdump(pdp->eua.v, pdp->eua.l));
 		gtp_create_context_resp(gsn, pdp, GTPCAUSE_UNKNOWN_PDP);
 		return 0;
 	}
 
-	rc = ippool_newip(ippool, &member, &addr, 0);
-	if (rc < 0) {
-		SYS_ERR(DGGSN, LOGL_ERROR, 0, "Cannot allocate IP address in pool\n");
-		gtp_create_context_resp(gsn, pdp, -rc);
-		return 0;	/* Allready in use, or no more available */
-	}
+	if (addr.len == sizeof(struct in_addr)) {
+		rc = ippool_newip(apn->v4.pool, &member, &addr, 0);
+		if (rc < 0)
+			goto err_pool_full;
+		in46a_to_eua(&member->addr, &pdp->eua);
 
-	if (addr.len == sizeof(struct in6_addr)) {
+		/* TODO: In IPv6, EUA doesn't contain the actual IP addr/prefix! */
+		if (gtp_kernel_tunnel_add(pdp) < 0) {
+			LOGPPDP(LOGL_ERROR, pdp, "Cannot add tunnel to kernel: %s\n", strerror(errno));
+			gtp_create_context_resp(gsn, pdp, GTPCAUSE_SYS_FAIL);
+			return 0;
+		}
+	} else if (addr.len == sizeof(struct in6_addr)) {
 		struct in46_addr tmp;
+		rc = ippool_newip(apn->v6.pool, &member, &addr, 0);
+		if (rc < 0)
+			goto err_pool_full;
+
 		/* IPv6 doesn't really send the real/allocated address at this point, but just
 		 * the link-identifier which the MS shall use for router solicitation */
 		tmp.len = addr.len;
@@ -314,43 +494,46 @@
 		memcpy(tmp.v6.s6_addr+8, &member->addr.v6, 8);
 		in46a_to_eua(&tmp, &pdp->eua);
 	} else
-		in46a_to_eua(&member->addr, &pdp->eua);
-	pdp->peer = member;
-	pdp->ipif = tun;	/* TODO */
-	member->peer = pdp;
+		OSMO_ASSERT(0);
 
-	/* TODO: In IPv6, EUA doesn't contain the actual IP addr/prefix! */
-	if (gtp_kernel_tunnel_add(pdp) < 0) {
-		SYS_ERR(DGGSN, LOGL_ERROR, 0,
-			"Cannot add tunnel to kernel: %s\n", strerror(errno));
-		gtp_create_context_resp(gsn, pdp, GTPCAUSE_SYS_FAIL);
-		return 0;
-	}
+	pdp->peer = member;
+	pdp->ipif = apn->tun.tun;	/* TODO */
+	member->peer = pdp;
 
 	if (!send_trap(gsn, pdp, member, "imsi-ass-ip")) { /* TRAP with IP assignment */
 		gtp_create_context_resp(gsn, pdp, GTPCAUSE_NO_RESOURCES);
 		return 0;
 	}
 
-	process_pco(pdp);
+	process_pco(apn, pdp);
 
+	LOGPPDP(LOGL_INFO, pdp, "Successful PDP Context Creation: APN=%s(%s), TEIC=%u, IP=%s\n",
+		name_buf, apn->cfg.name, pdp->teic_own, in46a_ntoa(&member->addr));
 	gtp_create_context_resp(gsn, pdp, GTPCAUSE_ACC_REQ);
 	return 0;		/* Success */
+
+err_pool_full:
+	LOGPPDP(LOGL_ERROR, pdp, "Cannot allocate IP address from pool (full!)\n");
+	gtp_create_context_resp(gsn, pdp, -rc);
+	return 0;	/* Already in use, or no more available */
 }
 
-/* Callback for receiving messages from tun */
-int cb_tun_ind(struct tun_t *tun, void *pack, unsigned len)
+/* Internet-originated IP packet, needs to be sent via GTP towards MS */
+static int cb_tun_ind(struct tun_t *tun, void *pack, unsigned len)
 {
+	struct apn_ctx *apn = tun->priv;
 	struct ippoolm_t *ipm;
 	struct in46_addr dst;
 	struct iphdr *iph = (struct iphdr *)pack;
 	struct ip6_hdr *ip6h = (struct ip6_hdr *)pack;
+	struct ippool_t *pool;
 
 	if (iph->version == 4) {
 		if (len < sizeof(*iph) || len < 4*iph->ihl)
 			return -1;
 		dst.len = 4;
 		dst.v4.s_addr = iph->daddr;
+		pool = apn->v4.pool;
 	} else if (iph->version == 6) {
 		/* Due to the fact that 3GPP requires an allocation of a
 		 * /64 prefix to each MS, we must instruct
@@ -358,20 +541,25 @@
 		 * prefix, i.e. the first 8 bytes of the address */
 		dst.len = 8;
 		dst.v6 = ip6h->ip6_dst;
+		pool = apn->v6.pool;
 	} else {
-		LOGP(DGGSN, LOGL_NOTICE, "non-IPv packet received from tun\n");
+		LOGP(DTUN, LOGL_NOTICE, "non-IPv packet received from tun\n");
 		return -1;
 	}
 
-	DEBUGP(DGGSN, "Received packet from tun!\n");
+	/* IPv6 packet but no IPv6 pool, or IPv4 packet with no IPv4 pool */
+	if (!pool)
+		return 0;
 
-	if (ippool_getip(ippool, &ipm, &dst)) {
-		DEBUGP(DGGSN, "Received packet with no destination!!!\n");
+	DEBUGP(DTUN, "Received packet from tun!\n");
+
+	if (ippool_getip(pool, &ipm, &dst)) {
+		DEBUGP(DTUN, "Received packet with no PDP contex!!\n");
 		return 0;
 	}
 
 	if (ipm->peer)		/* Check if a peer protocol is defined */
-		gtp_data_req(gsn, (struct pdp_t *)ipm->peer, pack, len);
+		gtp_data_req(apn->ggsn->gsn, (struct pdp_t *)ipm->peer, pack, len);
 	return 0;
 }
 
@@ -380,435 +568,303 @@
 	.s6_addr = { 0xff,0x02,0,0,  0,0,0,0, 0,0,0,0,  0,0,0,2 }
 };
 
-int encaps_tun(struct pdp_t *pdp, void *pack, unsigned len)
+/* MS-originated GTP1-U packet, needs to be sent via TUN device */
+static int encaps_tun(struct pdp_t *pdp, void *pack, unsigned len)
 {
 	struct iphdr *iph = (struct iphdr *)pack;
 	struct ip6_hdr *ip6h = (struct ip6_hdr *)pack;
 
-	DEBUGP(DGGSN, "encaps_tun. Packet received: forwarding to tun\n");
+	LOGPPDP(LOGL_DEBUG, pdp, "Packet received: forwarding to tun\n");
 
 	switch (iph->version) {
 	case 6:
 		/* daddr: all-routers multicast addr */
 		if (IN6_ARE_ADDR_EQUAL(&ip6h->ip6_dst, &all_router_mcast_addr))
-			return handle_router_mcast(gsn, pdp, pack, len);
+			return handle_router_mcast(pdp->gsn, pdp, pack, len);
 		break;
 	case 4:
 		break;
 	default:
-		LOGP(DGGSN, LOGL_ERROR, "Packet from MS is neither IPv4 nor IPv6\n");
+		LOGPPDP(LOGL_ERROR, pdp, "Packet from MS is neither IPv4 nor IPv6: %s\n",
+			osmo_hexdump(pack, len));
 		return -1;
 	}
 	return tun_encaps((struct tun_t *)pdp->ipif, pack, len);
 }
 
+static char *config_file = "openggsn.cfg";
+
+/* callback for tun device osmocom select loop integration */
+static int ggsn_tun_fd_cb(struct osmo_fd *fd, unsigned int what)
+{
+	struct apn_ctx *apn = fd->data;
+
+	OSMO_ASSERT(what & BSC_FD_READ);
+
+	return tun_decaps(apn->tun.tun);
+}
+
+/* callback for libgtp osmocom select loop integration */
+static int ggsn_gtp_fd_cb(struct osmo_fd *fd, unsigned int what)
+{
+	struct ggsn_ctx *ggsn = fd->data;
+	int rc;
+
+	OSMO_ASSERT(what & BSC_FD_READ);
+
+	switch (fd->priv_nr) {
+	case 0:
+		rc = gtp_decaps0(ggsn->gsn);
+		break;
+	case 1:
+		rc = gtp_decaps1c(ggsn->gsn);
+		break;
+	case 2:
+		rc = gtp_decaps1u(ggsn->gsn);
+		break;
+	default:
+		OSMO_ASSERT(0);
+		break;
+	}
+	return rc;
+}
+
+static void ggsn_gtp_tmr_start(struct ggsn_ctx *ggsn)
+{
+	struct timeval next;
+
+	/* Retrieve next retransmission as timeval */
+	gtp_retranstimeout(ggsn->gsn, &next);
+
+	/* re-schedule the timer */
+	osmo_timer_schedule(&ggsn->gtp_timer, next.tv_sec, next.tv_usec/1000);
+}
+
+/* timer callback for libgtp retransmission and ping */
+static void ggsn_gtp_tmr_cb(void *data)
+{
+	struct ggsn_ctx *ggsn = data;
+
+	/* do all the retransmissions as needed */
+	gtp_retrans(ggsn->gsn);
+
+	ggsn_gtp_tmr_start(ggsn);
+}
+
+/* To exit gracefully. Used with GCC compilation flag -pg and gprof */
+static void signal_handler(int s)
+{
+	LOGP(DGGSN, LOGL_NOTICE, "signal %d received\n", s);
+	switch (s) {
+	case SIGINT:
+		LOGP(DGGSN, LOGL_NOTICE, "SIGINT received, shutting down\n");
+		end = 1;
+		break;
+	case SIGABRT:
+	case SIGUSR1:
+		talloc_report(tall_vty_ctx, stderr);
+		talloc_report_full(tall_ggsn_ctx, stderr);
+		break;
+	case SIGUSR2:
+		talloc_report_full(tall_vty_ctx, stderr);
+		break;
+	default:
+		break;
+	}
+}
+
+
+/* Start a given GGSN */
+int ggsn_start(struct ggsn_ctx *ggsn)
+{
+	struct apn_ctx *apn;
+	int rc;
+
+	if (ggsn->started)
+		return 0;
+
+	LOGPGGSN(LOGL_INFO, ggsn, "Starting GGSN\n");
+
+	/* Start libgtp listener */
+	if (gtp_new(&ggsn->gsn, ggsn->cfg.state_dir, &ggsn->cfg.listen_addr.v4, GTP_MODE_GGSN)) {
+		LOGPGGSN(LOGL_ERROR, ggsn, "Failed to create GTP: %s\n", strerror(errno));
+		return -1;
+	}
+	ggsn->gsn->priv = ggsn;
+
+	/* Register File Descriptors */
+	osmo_fd_setup(&ggsn->gtp_fd0, ggsn->gsn->fd0, BSC_FD_READ, ggsn_gtp_fd_cb, ggsn, 0);
+	rc = osmo_fd_register(&ggsn->gtp_fd0);
+	OSMO_ASSERT(rc == 0);
+
+	osmo_fd_setup(&ggsn->gtp_fd1c, ggsn->gsn->fd1c, BSC_FD_READ, ggsn_gtp_fd_cb, ggsn, 1);
+	rc = osmo_fd_register(&ggsn->gtp_fd1c);
+	OSMO_ASSERT(rc == 0);
+
+	osmo_fd_setup(&ggsn->gtp_fd1u, ggsn->gsn->fd1u, BSC_FD_READ, ggsn_gtp_fd_cb, ggsn, 2);
+	rc = osmo_fd_register(&ggsn->gtp_fd1u);
+	OSMO_ASSERT(rc == 0);
+
+	/* Start GTP re-transmission timer */
+	osmo_timer_setup(&ggsn->gtp_timer, ggsn_gtp_tmr_cb, ggsn);
+
+	gtp_set_cb_data_ind(ggsn->gsn, encaps_tun);
+	gtp_set_cb_delete_context(ggsn->gsn, delete_context);
+	gtp_set_cb_create_context_ind(ggsn->gsn, create_context_ind);
+
+	LOGPGGSN(LOGL_NOTICE, ggsn, "Successfully started\n");
+	ggsn->started = true;
+
+	llist_for_each_entry(apn, &ggsn->apn_list, list)
+		apn_start(apn);
+
+	return 0;
+}
+
+/* Stop a given GGSN */
+int ggsn_stop(struct ggsn_ctx *ggsn)
+{
+	struct apn_ctx *apn;
+
+	if (!ggsn->started)
+		return 0;
+
+	/* iterate over all APNs and stop them */
+	llist_for_each_entry(apn, &ggsn->apn_list, list)
+		apn_stop(apn, true);
+
+	osmo_timer_del(&ggsn->gtp_timer);
+
+	osmo_fd_unregister(&ggsn->gtp_fd1u);
+	osmo_fd_unregister(&ggsn->gtp_fd1c);
+	osmo_fd_unregister(&ggsn->gtp_fd0);
+
+	if (ggsn->gsn) {
+		gtp_free(ggsn->gsn);
+		ggsn->gsn = NULL;
+	}
+
+	ggsn->started = false;
+	return 0;
+}
+
+static void print_usage()
+{
+	printf("Usage: osmo-ggsn [-h] [-D] [-c configfile] [-V]\n");
+}
+
+static void print_help()
+{
+	printf(	"  Some useful help...\n"
+		"  -h --help		This help text\n"
+		"  -D --daemonize	Fork the process into a background daemon\n"
+		"  -c --config-file	filename The config file to use\n"
+		"  -V --version		Print the version of OsmoGGSN\n"
+		);
+}
+
+static void handle_options(int argc, char **argv)
+{
+	while (1) {
+		int option_index = 0, c;
+		static struct option long_options[] = {
+			{ "help", 0, 0, 'h' },
+			{ "daemonize", 0, 0, 'D' },
+			{ "config-file", 1, 0, 'c' },
+			{ "version", 0, 0, 'V' },
+			{ 0, 0, 0, 0 }
+		};
+
+		c = getopt_long(argc, argv, "hdc:V", long_options, &option_index);
+		if (c == -1)
+			break;
+
+		switch (c) {
+		case 'h':
+			print_usage();
+			print_help();
+			exit(0);
+		case 'D':
+			daemonize = 1;
+			break;
+		case 'c':
+			config_file = optarg;
+			break;
+		case 'V':
+			print_version(1);
+			exit(0);
+			break;
+		}
+	}
+}
+
 int main(int argc, char **argv)
 {
-	/* gengeopt declarations */
-	struct gengetopt_args_info args_info;
-
-	struct hostent *host;
+	struct ggsn_ctx *ggsn;
+	int rc;
 
 	/* Handle keyboard interrupt SIGINT */
-	struct sigaction s;
-	s.sa_handler = (void *)signal_handler;
-	if ((0 != sigemptyset(&s.sa_mask)) && debug)
-		printf("sigemptyset failed.\n");
-	s.sa_flags = SA_RESETHAND;
-	if ((sigaction(SIGINT, &s, NULL) != 0) && debug)
-		printf("Could not register SIGINT signal handler.\n");
+	tall_ggsn_ctx = talloc_named_const(NULL, 0, "openggsn");
+	msgb_talloc_ctx_init(tall_ggsn_ctx, 0);
 
-	fd_set fds;		/* For select() */
-	struct timeval idleTime;	/* How long to select() */
+	signal(SIGINT, &signal_handler);
+	signal(SIGABRT, &signal_handler);
+	signal(SIGUSR1, &signal_handler);
+	signal(SIGUSR2, &signal_handler);
 
-	int timelimit;		/* Number of seconds to be connected */
-	int starttime;		/* Time program was started */
-
+	osmo_init_ignore_signals();
 	osmo_init_logging(&log_info);
+	osmo_stats_init(tall_ggsn_ctx);
 
-	if (cmdline_parser(argc, argv, &args_info) != 0)
-		exit(1);
-	if (args_info.debug_flag) {
-		printf("listen: %s\n", args_info.listen_arg);
-		if (args_info.conf_arg)
-			printf("conf: %s\n", args_info.conf_arg);
-		printf("fg: %d\n", args_info.fg_flag);
-		printf("debug: %d\n", args_info.debug_flag);
-		printf("qos: %#08x\n", args_info.qos_arg);
-		if (args_info.apn_arg)
-			printf("apn: %s\n", args_info.apn_arg);
-		if (args_info.net_arg)
-			printf("net: %s\n", args_info.net_arg);
-		if (args_info.dynip_arg)
-			printf("dynip: %s\n", args_info.dynip_arg);
-		if (args_info.statip_arg)
-			printf("statip: %s\n", args_info.statip_arg);
-		if (args_info.ipup_arg)
-			printf("ipup: %s\n", args_info.ipup_arg);
-		if (args_info.ipdown_arg)
-			printf("ipdown: %s\n", args_info.ipdown_arg);
-		if (args_info.pidfile_arg)
-			printf("pidfile: %s\n", args_info.pidfile_arg);
-		if (args_info.statedir_arg)
-			printf("statedir: %s\n", args_info.statedir_arg);
-		if (args_info.gtp_linux_flag)
-			printf("gtp_linux: %d\n", args_info.gtp_linux_flag);
-		printf("timelimit: %d\n", args_info.timelimit_arg);
+	vty_init(&g_vty_info);
+	logging_vty_add_cmds(NULL);
+	osmo_stats_vty_add_cmds(&log_info);
+	ggsn_vty_init();
+	ctrl_vty_init(tall_ggsn_ctx);
+
+	handle_options(argc, argv);
+
+	rate_ctr_init(tall_ggsn_ctx);
+
+	rc = vty_read_config_file(config_file, NULL);
+	if (rc < 0) {
+		fprintf(stderr, "Failed to open config file: '%s'\n", config_file);
+		exit(2);
 	}
 
-	/* Try out our new parser */
-
-	if (cmdline_parser_configfile(args_info.conf_arg, &args_info, 0, 0, 0)
-	    != 0)
+	rc = telnet_init_dynif(tall_ggsn_ctx, NULL, vty_get_bind_addr(), OSMO_VTY_PORT_GGSN);
+	if (rc < 0)
 		exit(1);
 
-	/* Open a log file */
-	if (args_info.logfile_arg) {
-		struct log_target *tgt;
-		int lvl;
-
-		tgt = log_target_find(LOG_TGT_TYPE_FILE, args_info.logfile_arg);
-		if (!tgt) {
-			tgt = log_target_create_file(args_info.logfile_arg);
-			if (!tgt) {
-				LOGP(DGGSN, LOGL_ERROR,
-					"Failed to create logfile: %s\n",
-					args_info.logfile_arg);
-				exit(1);
-			}
-			log_add_target(tgt);
-		}
-		log_set_all_filter(tgt, 1);
-		log_set_use_color(tgt, 0);
-
-		if (args_info.loglevel_arg) {
-			lvl = log_parse_level(args_info.loglevel_arg);
-			log_set_log_level(tgt, lvl);
-			LOGP(DGGSN, LOGL_NOTICE,
-				"Set file log level to %s\n",
-				log_level_str(lvl));
-		}
-	}
-
-	if (args_info.debug_flag) {
-		printf("cmdline_parser_configfile\n");
-		printf("listen: %s\n", args_info.listen_arg);
-		printf("conf: %s\n", args_info.conf_arg);
-		printf("fg: %d\n", args_info.fg_flag);
-		printf("debug: %d\n", args_info.debug_flag);
-		printf("qos: %#08x\n", args_info.qos_arg);
-		if (args_info.apn_arg)
-			printf("apn: %s\n", args_info.apn_arg);
-		if (args_info.net_arg)
-			printf("net: %s\n", args_info.net_arg);
-		if (args_info.dynip_arg)
-			printf("dynip: %s\n", args_info.dynip_arg);
-		if (args_info.statip_arg)
-			printf("statip: %s\n", args_info.statip_arg);
-		if (args_info.ipup_arg)
-			printf("ipup: %s\n", args_info.ipup_arg);
-		if (args_info.ipdown_arg)
-			printf("ipdown: %s\n", args_info.ipdown_arg);
-		if (args_info.pidfile_arg)
-			printf("pidfile: %s\n", args_info.pidfile_arg);
-		if (args_info.statedir_arg)
-			printf("statedir: %s\n", args_info.statedir_arg);
-		if (args_info.gtp_linux_flag)
-			printf("gtp-linux: %d\n", args_info.gtp_linux_flag);
-		printf("timelimit: %d\n", args_info.timelimit_arg);
-	}
-
-	/* Handle each option */
-
-	/* debug                                                        */
-	debug = args_info.debug_flag;
-
-	/* listen                                                       */
-	/* Do hostname lookup to translate hostname to IP address       */
-	/* Any port listening is not possible as a valid address is     */
-	/* required for create_pdp_context_response messages            */
-	if (args_info.listen_arg) {
-		if (!(host = gethostbyname(args_info.listen_arg))) {
-			SYS_ERR(DGGSN, LOGL_ERROR, 0,
-				"Invalid listening address: %s!",
-				args_info.listen_arg);
-			exit(1);
-		} else {
-			memcpy(&listen_.s_addr, host->h_addr, host->h_length);
-		}
-	} else {
-		SYS_ERR(DGGSN, LOGL_ERROR, 0,
-			"Listening address must be specified! "
-			"Please use command line option --listen or "
-			"edit %s configuration file\n", args_info.conf_arg);
+	g_ctrlh = ctrl_interface_setup(NULL, OSMO_CTRL_PORT_GGSN, NULL);
+	if (!g_ctrlh) {
+		LOGP(DGGSN, LOGL_ERROR, "Failed to create CTRL interface.\n");
 		exit(1);
 	}
 
-	/* net                                                          */
-	/* Store net as in_addr net and mask                            */
-	if (args_info.net_arg) {
-		if (ippool_aton(&net, &prefixlen, args_info.net_arg, 0)) {
-			SYS_ERR(DGGSN, LOGL_ERROR, 0,
-				"Invalid network address: %s!",
-				args_info.net_arg);
-			exit(1);
-		}
-		/* default for network + destination address = net + 1 */
-		netaddr = net;
-		in46a_inc(&netaddr);
-		destaddr = netaddr;
-	} else {
-		SYS_ERR(DGGSN, LOGL_ERROR, 0,
-			"Network address must be specified: %s!",
-			args_info.net_arg);
-		exit(1);
-	}
-
-	/* dynip                                                        */
-	struct in46_prefix i46p;
-	size_t prefixlen;
-	if (!args_info.dynip_arg) {
-		if (ippool_aton(&i46p.addr, &prefixlen, args_info.net_arg, 0)) {
-			SYS_ERR(DIP, LOGL_ERROR, 0, "Failed to parse dynamic pool");
-			exit(1);
-		}
-	} else {
-		if (ippool_aton(&i46p.addr, &prefixlen, args_info.dynip_arg, 0)) {
-			SYS_ERR(DIP, LOGL_ERROR, 0, "Failed to parse dynamic pool");
-			exit(1);
-		}
-	}
-	i46p.prefixlen = prefixlen;
-	if (ippool_new(&ippool, &i46p, NULL, IPPOOL_NONETWORK | IPPOOL_NOGATEWAY | IPPOOL_NOBROADCAST)) {
-		SYS_ERR(DGGSN, LOGL_ERROR, 0, "Failed to allocate IP pool!");
-		exit(1);
-	}
-
-	/* DNS1 and DNS2 */
-	memset(&dns1, 0, sizeof(dns1));
-	if (args_info.pcodns1_arg) {
-		size_t tmp;
-		if (ippool_aton(&dns1, &tmp, args_info.pcodns1_arg, 0) != 0) {
-			SYS_ERR(DGGSN, LOGL_ERROR, 0,
-				"Failed to convert pcodns1!");
-			exit(1);
-		}
-	}
-	memset(&dns2, 0, sizeof(dns2));
-	if (args_info.pcodns2_arg) {
-		size_t tmp;
-		if (ippool_aton(&dns2, &tmp, args_info.pcodns2_arg, 0) != 0) {
-			SYS_ERR(DGGSN, LOGL_ERROR, 0,
-				"Failed to convert pcodns2!");
+	if (daemonize) {
+		rc = osmo_daemonize();
+		if (rc < 0) {
+			perror("Error during daemonize");
 			exit(1);
 		}
 	}
 
-	unsigned int cur = 0;
-	pco.v[cur++] = 0x80;	/* x0000yyy x=1, yyy=000: PPP */
-	pco.v[cur++] = 0x80;	/* IPCP */
-	pco.v[cur++] = 0x21;
-	pco.v[cur++] = 0xFF;	/* Length of contents */
-	pco.v[cur++] = 0x02;	/* ACK */
-	pco.v[cur++] = 0x00;	/* ID: Need to match request */
-	pco.v[cur++] = 0x00;	/* Length */
-	pco.v[cur++] = 0xFF;	/* overwritten  */
-	if (dns1.len == 4) {
-		pco.v[cur++] = 0x81;	/* DNS 1 */
-		pco.v[cur++] = 2 + dns1.len;
-		if (dns1.len == 4)
-			memcpy(&pco.v[cur], &dns1.v4, dns1.len);
-		else
-			memcpy(&pco.v[cur], &dns1.v6, dns1.len);
-		cur += dns1.len;
-	}
-	if (dns2.len == 4) {
-		pco.v[cur++] = 0x83;
-		pco.v[cur++] = 2 + dns2.len;	/* DNS 2 */
-		if (dns2.len == 4)
-			memcpy(&pco.v[cur], &dns2.v4, dns2.len);
-		else
-			memcpy(&pco.v[cur], &dns2.v6, dns2.len);
-		cur += dns2.len;
-	}
-	pco.l = cur;
-	/* patch in length values */
-	pco.v[3] = pco.l - 4;
-	pco.v[7] = pco.l - 4;
-
-	/* ipup */
-	ipup = args_info.ipup_arg;
-
-	/* ipdown */
-	ipdown = args_info.ipdown_arg;
-
-	/* Timelimit                                                       */
-	timelimit = args_info.timelimit_arg;
-	starttime = time(NULL);
-
+#if 0
 	/* qos                                                             */
 	qos.l = 3;
 	qos.v[2] = (args_info.qos_arg) & 0xff;
 	qos.v[1] = ((args_info.qos_arg) >> 8) & 0xff;
 	qos.v[0] = ((args_info.qos_arg) >> 16) & 0xff;
+#endif
 
-	/* apn                                                             */
-	if (strlen(args_info.apn_arg) > (sizeof(apn.v) - 1)) {
-		LOGP(DGGSN, LOGL_ERROR, "Invalid APN\n");
-		return -1;
-	}
-	apn.l = strlen(args_info.apn_arg) + 1;
-	apn.v[0] = (char)strlen(args_info.apn_arg);
-	strncpy((char *)&apn.v[1], args_info.apn_arg, sizeof(apn.v) - 1);
-
-	/* foreground                                                   */
-	/* If flag not given run as a daemon                            */
-	if (!args_info.fg_flag) {
-		FILE *f;
-		int rc;
-		/* Close the standard file descriptors. */
-		/* Is this really needed ? */
-		f = freopen("/dev/null", "w", stdout);
-		if (f == NULL) {
-			SYS_ERR(DGGSN, LOGL_NOTICE, 0,
-				"Could not redirect stdout to /dev/null");
-		}
-		f = freopen("/dev/null", "w", stderr);
-		if (f == NULL) {
-			SYS_ERR(DGGSN, LOGL_NOTICE, 0,
-				"Could not redirect stderr to /dev/null");
-		}
-		f = freopen("/dev/null", "r", stdin);
-		if (f == NULL) {
-			SYS_ERR(DGGSN, LOGL_NOTICE, 0,
-				"Could not redirect stdin to /dev/null");
-		}
-		rc = daemon(0, 0);
-		if (rc != 0) {
-			SYS_ERR(DGGSN, LOGL_ERROR, rc,
-				"Could not daemonize");
-			exit(1);
-		}
+	/* Main select loop */
+	while (!end) {
+		osmo_select_main(0);
 	}
 
-	/* pidfile */
-	/* This has to be done after we have our final pid */
-	if (args_info.pidfile_arg) {
-		log_pid(args_info.pidfile_arg);
-	}
-
-	DEBUGP(DGGSN, "gtpclient: Initialising GTP tunnel\n");
-
-	if (gtp_new(&gsn, args_info.statedir_arg, &listen_, GTP_MODE_GGSN)) {
-		SYS_ERR(DGGSN, LOGL_ERROR, 0, "Failed to create gtp");
-		exit(1);
-	}
-	if (gsn->fd0 > maxfd)
-		maxfd = gsn->fd0;
-	if (gsn->fd1c > maxfd)
-		maxfd = gsn->fd1c;
-	if (gsn->fd1u > maxfd)
-		maxfd = gsn->fd1u;
-
-	/* use GTP kernel module for data packet encapsulation */
-	if (args_info.gtp_linux_given) {
-		if (gtp_kernel_init(gsn, &net.v4, prefixlen, args_info.net_arg) < 0) {
-			SYS_ERR(DGGSN, LOGL_ERROR, 0, "Failed to initialize kernel GTP\n");
-			goto err;
-		}
-	}
-
-	gtp_set_cb_data_ind(gsn, encaps_tun);
-	gtp_set_cb_delete_context(gsn, delete_context);
-	gtp_set_cb_create_context_ind(gsn, create_context_ind);
-
-	gsn->priv = ctrl_interface_setup(NULL, OSMO_CTRL_PORT_GGSN, NULL);
-	if (!gsn->priv) {
-		LOGP(DGGSN, LOGL_ERROR, "Failed to create CTRL interface.\n");
-		exit(1);
-	}
-
-	/* skip the configuration of the tun0 if we're using the gtp0 device */
-	if (gtp_kernel_enabled())
-		goto skip_tun;
-
-	/* Create a tunnel interface */
-	DEBUGP(DGGSN, "Creating tun interface\n");
-	if (tun_new((struct tun_t **)&tun)) {
-		SYS_ERR(DGGSN, LOGL_ERROR, 0, "Failed to create tun");
-		exit(1);
-	}
-
-	DEBUGP(DGGSN, "Setting tun IP address\n");
-	if (tun_setaddr(tun, &netaddr, &destaddr, prefixlen)) {
-		SYS_ERR(DGGSN, LOGL_ERROR, 0, "Failed to set tun IP address");
-		exit(1);
-	}
-
-	tun_set_cb_ind(tun, cb_tun_ind);
-	if (tun->fd > maxfd)
-		maxfd = tun->fd;
-
-	if (ipup)
-		tun_runscript(tun, ipup);
-
-skip_tun:
-
-  /******************************************************************/
-	/* Main select loop                                               */
-  /******************************************************************/
-
-	while ((((starttime + timelimit) > time(NULL)) || (0 == timelimit))
-	       && (!end)) {
-
-		FD_ZERO(&fds);
-		if (tun)
-			FD_SET(tun->fd, &fds);
-		FD_SET(gsn->fd0, &fds);
-		FD_SET(gsn->fd1c, &fds);
-		FD_SET(gsn->fd1u, &fds);
-
-		gtp_retranstimeout(gsn, &idleTime);
-		switch (select(maxfd + 1, &fds, NULL, NULL, &idleTime)) {
-		case -1:	/* errno == EINTR : unblocked signal */
-			SYS_ERR(DGGSN, LOGL_ERROR, 0,
-				"select() returned -1");
-			/* On error, select returns without modifying fds */
-			FD_ZERO(&fds);
-			break;
-		case 0:
-			/* printf("Select returned 0\n"); */
-			gtp_retrans(gsn);	/* Only retransmit if nothing else */
-			break;
-		default:
-			break;
-		}
-
-		if (tun && tun->fd != -1 && FD_ISSET(tun->fd, &fds) &&
-		    tun_decaps(tun) < 0) {
-			SYS_ERR(DGGSN, LOGL_ERROR, 0,
-				"TUN read failed (fd)=(%d)", tun->fd);
-		}
-
-		if (FD_ISSET(gsn->fd0, &fds))
-			gtp_decaps0(gsn);
-
-		if (FD_ISSET(gsn->fd1c, &fds))
-			gtp_decaps1c(gsn);
-
-		if (FD_ISSET(gsn->fd1u, &fds))
-			gtp_decaps1u(gsn);
-
-		osmo_select_main(1);
-	}
-err:
-	gtp_kernel_stop();
-	cmdline_parser_free(&args_info);
-	ippool_free(ippool);
-	gtp_free(gsn);
-	if (tun)
-		tun_free(tun);
+	llist_for_each_entry(ggsn, &g_ggsn_list, list)
+		ggsn_stop(ggsn);
 
 	return 1;
-
 }