switch: Add support to wildcard APN matching & dynamic Realm

access-point-name can define nameserver and force realm and service selection. This wildcard matching
can be used to define default behaviour. For example in the following configuration :

---< snip >---
!
access-point-name internet
 nameserver 1.2.3.4
 resolv-max-retry 5
 resolv-cache-update 3600
 session-lifetime 4500
 realm apn.epc.mncXXX.mccYYY.3gppnetwork.org.
 service-selection x-3gpp-pgw:x-s5-gtp:x-gn prio 20
 service-selection x-3gpp-pgw:x-s5-gtp+nc-nr prio 10
!
access-point-name *
 nameserver 1.2.3.4
 resolv-max-retry 1
 session-lifetime 15000
 realm-dynamic
 service-selection x-3gpp-pgw:x-s8-gtp:x-gp prio 10
!
---< snip >---

When Create-Session-Request is received for 'internet' APN, matching will select 'access-point-name internet'
and will then use defined realm to perform remote pGW selection.
When Create-Session-Request is received for 'op' for example, then matching will select '*' as default/last-change
selection.

'realm-dynamic' in wildcard APN refer to automatic NAPTR resolution built from GTP-C 'Access Point Name' IE
to extract PLMN and then build following request : op.apn.epc.mncXXX.mccYYY.3gppnetwork.org.

Author: acassen

src/gtp_apn.c

@@ -145,13 +145,20 @@ apn_resolv_cache_realloc(gtp_apn_t *apn)
 	int err;
 
 	/* Context init */
-	ctx = gtp_resolv_ctx_alloc(apn, apn->name);
+	ctx = gtp_resolv_ctx_alloc(apn);
 	if (!ctx)
 		return -1;
 
+	if (!ctx->realm) {
+		log_message(LOG_INFO, "%s(): no realm available to resolv naptr... keeping previous..."
+				    , __FUNCTION__);
+		gtp_resolv_ctx_destroy(ctx);
+		return -1;
+	}
+
 	/* Create temp resolv */
 	INIT_LIST_HEAD(&l);
-	err = gtp_resolv_naptr(ctx, &l);
+	err = gtp_resolv_naptr(ctx, &l, "%s.%s", apn->name, ctx->realm);
 	if (err) {
 		log_message(LOG_INFO, "%s(): Unable to update resolv cache while resolving naptr... keeping previous..."
 				    , __FUNCTION__);

src/gtp_resolv.c

@@ -26,6 +26,7 @@
 #include <sys/prctl.h>
 #include <sys/types.h>
 #include <sys/socket.h>
+#include <stdarg.h>
 #include <ctype.h>
 #include <netdb.h>
 #include <errno.h>
@@ -341,12 +342,16 @@ gtp_naptr_alloc(list_head_t *l, const u_char *rdata, size_t rdlen)
 }
 
 int
-gtp_resolv_naptr(gtp_resolv_ctx_t *ctx, list_head_t *l)
+gtp_resolv_naptr(gtp_resolv_ctx_t *ctx, list_head_t *l, const char *format, ...)
 {
+	va_list args;
 	int ret, i, err;
 
 	/* Perform Query */
-	snprintf(ctx->nsdisp, GTP_DISPLAY_BUFFER_LEN - 1, "%s.%s", ctx->apn_ni, ctx->realm);
+	va_start(args, format);
+	vsnprintf(ctx->nsdisp, GTP_DISPLAY_BUFFER_LEN, format, args);
+	va_end(args);
+
 	ret = ns_res_nquery_retry(ctx, ns_c_in, ns_t_naptr);
 	if (ret < 0) {
 		res_nclose(&ctx->ns_rs);
@@ -371,7 +376,7 @@ gtp_resolv_naptr(gtp_resolv_ctx_t *ctx, list_head_t *l)
 }
 
 gtp_resolv_ctx_t *
-gtp_resolv_ctx_alloc(gtp_apn_t *apn, const char *apn_name)
+gtp_resolv_ctx_alloc(gtp_apn_t *apn)
 {
 	gtp_resolv_ctx_t *ctx;
 	struct sockaddr_storage *addr;
@@ -390,19 +395,11 @@ gtp_resolv_ctx_alloc(gtp_apn_t *apn, const char *apn_name)
 	}
 
 	ctx->realm = (strlen(apn->realm)) ? apn->realm : daemon_data->realm;
-	if (!strlen(ctx->realm)) {
-		log_message(LOG_INFO, "%s(): No Realm configured... Ignoring..."
-				    , __FUNCTION__);
-		FREE(ctx);
-		return NULL;
-	}
 
 	res_ninit(&ctx->ns_rs);
 	ctx->ns_rs.nsaddr_list[0] = *((struct sockaddr_in *) addr);
 	ctx->ns_rs.nscount = 1;
 
-	strlcpy(ctx->apn_ni, apn_name, GTP_APN_MAX_LEN);
-
 	return ctx;
 }
 
@@ -448,6 +445,23 @@ gtp_pgw_show(vty_t *vty, list_head_t *l)
 	return 0;
 }
 
+static int
+gtp_pgw_dump(list_head_t *l)
+{
+	gtp_pgw_t *pgw;
+
+	list_for_each_entry(pgw, l, next) {
+		printf(" %s\t\t[%s]:%d\tPrio:%d Weight:%d\n",
+			pgw->srv_name,
+			inet_sockaddrtos(&pgw->addr),
+			ntohs(inet_sockaddrport(&pgw->addr)),
+			pgw->priority,
+			pgw->weight);
+	}
+
+	return 0;
+}
+
 int
 gtp_naptr_show(vty_t *vty, gtp_apn_t *apn)
 {
@@ -470,6 +484,22 @@ gtp_naptr_show(vty_t *vty, gtp_apn_t *apn)
 	return 0;
 }
 
+int
+gtp_naptr_dump(list_head_t *l)
+{
+	gtp_naptr_t *naptr;
+
+	list_for_each_entry(naptr, l, next) {
+		printf("%s\t(%s, %s, Order:%d, Pref:%d)\n",
+			naptr->server, (naptr->server_type == ns_t_srv) ? "SRV" : "A",
+			naptr->service,
+			naptr->order,
+			naptr->preference);
+		gtp_pgw_dump(&naptr->pgw);
+	}
+
+	return 0;
+}
 
 int
 gtp_naptr_destroy(list_head_t *l)

src/gtp_sched.c

@@ -80,18 +80,18 @@ gtp_sched_pgw_wlc(gtp_naptr_t *naptr, struct sockaddr_in *addr_skip)
 }
 
 static gtp_pgw_t *
-gtp_sched_naptr(gtp_apn_t *apn, const char *service, struct sockaddr_in *addr_skip)
+gtp_sched_naptr(list_head_t *l, const char *service, struct sockaddr_in *addr_skip)
 {
 	gtp_naptr_t *naptr, *least = NULL;
 	gtp_pgw_t *pgw = NULL;
 
 	/* First stage: Reset previous scheduling flags */
-	list_for_each_entry(naptr, &apn->naptr, next)
+	list_for_each_entry(naptr, l, next)
 		naptr->fl = 0;
 
 	/* Second stage : Schedule by order until pgw election */
   shoot_again:
-	list_for_each_entry(naptr, &apn->naptr, next) {
+	list_for_each_entry(naptr, l, next) {
 		if (!strstr(naptr->service, service) ||
 		    __test_bit(GTP_SCHEDULE_FL_SKIP, &naptr->fl))
 			continue;
@@ -114,24 +114,63 @@ gtp_sched_naptr(gtp_apn_t *apn, const char *service, struct sockaddr_in *addr_sk
 	return pgw;
 }
 
-int
-gtp_sched(gtp_apn_t *apn, struct sockaddr_in *addr, struct sockaddr_in *addr_skip)
+static int
+gtp_sched_generic(gtp_apn_t *apn, list_head_t *l, struct sockaddr_in *addr, struct sockaddr_in *addr_skip)
 {
 	gtp_service_t *service;
 	gtp_pgw_t *pgw = NULL;
 
 	/* Service selection list is already sorted by prio */
 	pthread_mutex_lock(&apn->mutex);
 	list_for_each_entry(service, &apn->service_selection, next) {
-		pgw = gtp_sched_naptr(apn, service->str, addr_skip);
+		pgw = gtp_sched_naptr(l, service->str, addr_skip);
 		if (pgw) {
 			*addr = *(struct sockaddr_in *) &pgw->addr;
 			pthread_mutex_unlock(&apn->mutex);
 			return 0;
 		}
-
 	}
 	pthread_mutex_unlock(&apn->mutex);
 
 	return -1;
 }
+
+int
+gtp_sched(gtp_apn_t *apn, struct sockaddr_in *addr, struct sockaddr_in *addr_skip)
+{
+	return gtp_sched_generic(apn, &apn->naptr, addr, addr_skip);
+}
+
+int
+gtp_sched_dynamic(gtp_apn_t *apn, const char *apn_name, const char *plmn, struct sockaddr_in *addr, struct sockaddr_in *addr_skip)
+{
+	gtp_resolv_ctx_t *ctx;
+	list_head_t l;
+	int err = 0;
+
+	ctx = gtp_resolv_ctx_alloc(apn);
+	if (!ctx)
+		return -1;
+
+	INIT_LIST_HEAD(&l);
+	err = gtp_resolv_naptr(ctx, &l, "%s.apn.epc.%s.3gppnetwork.org.", apn_name, plmn);
+	if (err) {
+		log_message(LOG_INFO, "%s(): Unable to resolv apn:'%s.apn.epc.%s.3gppnetwork.org.'"
+				    , __FUNCTION__, apn_name, plmn);
+		goto end;
+	}
+
+	err = gtp_resolv_pgw(ctx, &l);
+	if (err) {
+		log_message(LOG_INFO, "%s(): Unable resolv pgw for apn:'%s.apn.epc.%s.3gppnetwork.org.'"
+				    , __FUNCTION__, apn_name, plmn);
+		goto end;
+	}
+
+	err = gtp_sched_generic(apn, &l, addr, addr_skip);
+
+  end:
+	gtp_resolv_ctx_destroy(ctx);
+	gtp_naptr_destroy(&l);
+	return err;
+}

src/gtp_switch_hdl_v2.c

@@ -226,7 +226,8 @@ gtpc_create_session_request_hdl(gtp_server_worker_t *w, struct sockaddr_storage
 	uint64_t imsi;
 	uint8_t *cp;
 	char apn_str[64];
-	int ret;
+	char apn_plmn[64];
+	int err;
 
 	/* Retransmission detection: Operating in a tranparent
 	 * way in order to preserve transitivity of messages, so
@@ -258,8 +259,8 @@ gtpc_create_session_request_hdl(gtp_server_worker_t *w, struct sockaddr_storage
 
 	ie_apn = (gtp_ie_apn_t *) cp;
 	memset(apn_str, 0, 64);
-	ret = gtp_ie_apn_extract_ni(ie_apn, apn_str, 63);
-	if (ret < 0) {
+	err = gtp_ie_apn_extract_ni(ie_apn, apn_str, 63);
+	if (err) {
 		log_message(LOG_INFO, "%s(): Error parsing Access-Point-Name IE. ignoring..."
 				    , __FUNCTION__);
 		return NULL;
@@ -333,8 +334,26 @@ gtpc_create_session_request_hdl(gtp_server_worker_t *w, struct sockaddr_storage
 		goto end;
 	}
 
-	ret = gtp_sched(apn, &teid->pgw_addr, &teid->sgw_addr);
-	if (ret < 0) {
+	if (__test_bit(GTP_APN_FL_REALM_DYNAMIC, &apn->flags)) {
+		err = gtp_ie_apn_extract_plmn(ie_apn, apn_plmn, 63);
+		if (err)
+			goto end;
+
+		err = gtp_sched_dynamic(apn, apn_str, apn_plmn, &teid->pgw_addr, &teid->sgw_addr);
+		if (err) {
+			log_message(LOG_INFO, "%s(): Unable to schedule pGW for apn:'%s.apn.epc.%s.3gppnetwork.org.'"
+					    , __FUNCTION__
+					    , apn_str, apn_plmn);
+			gtp_teid_put(teid);
+			gtp_session_destroy(s);
+			teid = NULL;
+		}
+
+		goto end;
+	}
+
+	err = gtp_sched(apn, &teid->pgw_addr, &teid->sgw_addr);
+	if (err) {
 		log_message(LOG_INFO, "%s(): Unable to schedule pGW for apn:%s"
 				    , __FUNCTION__
 				    , apn->name);

src/include/gtp_resolv.h

@@ -71,7 +71,6 @@ typedef struct _gtp_service {
 } gtp_service_t;
 
 typedef struct _gtp_resolv_ctx {
-	char			apn_ni[GTP_APN_MAX_LEN];
 	char			*realm;
 	struct __res_state	ns_rs;
 	ns_msg			msg;
@@ -85,10 +84,11 @@ typedef struct _gtp_resolv_ctx {
 /* Prototypes */
 extern int gtp_naptr_destroy(list_head_t *);
 extern int gtp_naptr_show(vty_t *vty, gtp_apn_t *);
+extern int gtp_naptr_dump(list_head_t *);
 extern gtp_naptr_t *gtp_naptr_get(gtp_apn_t *, const char *);
 extern int gtp_resolv_pgw(gtp_resolv_ctx_t *, list_head_t *);
-extern int gtp_resolv_naptr(gtp_resolv_ctx_t *, list_head_t *);
-extern gtp_resolv_ctx_t *gtp_resolv_ctx_alloc(gtp_apn_t *, const char *);
+extern int gtp_resolv_naptr(gtp_resolv_ctx_t *, list_head_t *, const char *, ...);
+extern gtp_resolv_ctx_t *gtp_resolv_ctx_alloc(gtp_apn_t *);
 extern int gtp_resolv_ctx_destroy(gtp_resolv_ctx_t *);
 extern int gtp_resolv_init(void);
 extern int gtp_resolv_destroy(void);

src/include/gtp_sched.h

@@ -24,5 +24,6 @@
 
 /* Prototypes */
 extern int gtp_sched(gtp_apn_t *, struct sockaddr_in *, struct sockaddr_in *);
+extern int gtp_sched_dynamic(gtp_apn_t *, const char *, const char *, struct sockaddr_in *, struct sockaddr_in *);
 
 #endif