diff --git a/openbsc/src/gprs/gb_proxy_tlli.c b/openbsc/src/gprs/gb_proxy_tlli.c
index 70f2bfb..14ce7d8 100644
--- a/openbsc/src/gprs/gb_proxy_tlli.c
+++ b/openbsc/src/gprs/gb_proxy_tlli.c
@@ -32,140 +32,140 @@
 #include <osmocom/core/rate_ctr.h>
 #include <osmocom/core/talloc.h>
 
-struct gbproxy_tlli_info *gbproxy_tlli_info_by_tlli(struct gbproxy_peer *peer,
+struct gbproxy_link_info *gbproxy_link_info_by_tlli(struct gbproxy_peer *peer,
 					    uint32_t tlli)
 {
-	struct gbproxy_tlli_info *tlli_info;
+	struct gbproxy_link_info *link_info;
 	struct gbproxy_patch_state *state = &peer->patch_state;
 
-	llist_for_each_entry(tlli_info, &state->enabled_tllis, list)
-		if (tlli_info->tlli.current == tlli ||
-		    tlli_info->tlli.assigned == tlli)
-			return tlli_info;
+	llist_for_each_entry(link_info, &state->enabled_tllis, list)
+		if (link_info->tlli.current == tlli ||
+		    link_info->tlli.assigned == tlli)
+			return link_info;
 
 	return NULL;
 }
 
-struct gbproxy_tlli_info *gbproxy_tlli_info_by_ptmsi(
+struct gbproxy_link_info *gbproxy_link_info_by_ptmsi(
 	struct gbproxy_peer *peer,
 	uint32_t ptmsi)
 {
-	struct gbproxy_tlli_info *tlli_info;
+	struct gbproxy_link_info *link_info;
 	struct gbproxy_patch_state *state = &peer->patch_state;
 
-	llist_for_each_entry(tlli_info, &state->enabled_tllis, list)
-		if (tlli_info->tlli.ptmsi == ptmsi)
-			return tlli_info;
+	llist_for_each_entry(link_info, &state->enabled_tllis, list)
+		if (link_info->tlli.ptmsi == ptmsi)
+			return link_info;
 
 	return NULL;
 }
 
-struct gbproxy_tlli_info *gbproxy_tlli_info_by_any_sgsn_tlli(
+struct gbproxy_link_info *gbproxy_link_info_by_any_sgsn_tlli(
 	struct gbproxy_peer *peer,
 	uint32_t tlli)
 {
-	struct gbproxy_tlli_info *tlli_info;
+	struct gbproxy_link_info *link_info;
 	struct gbproxy_patch_state *state = &peer->patch_state;
 
 	/* Don't care about the NSEI */
-	llist_for_each_entry(tlli_info, &state->enabled_tllis, list)
-		if (tlli_info->sgsn_tlli.current == tlli ||
-		     tlli_info->sgsn_tlli.assigned == tlli)
-			return tlli_info;
+	llist_for_each_entry(link_info, &state->enabled_tllis, list)
+		if (link_info->sgsn_tlli.current == tlli ||
+		     link_info->sgsn_tlli.assigned == tlli)
+			return link_info;
 
 	return NULL;
 }
 
-struct gbproxy_tlli_info *gbproxy_tlli_info_by_sgsn_tlli(
+struct gbproxy_link_info *gbproxy_link_info_by_sgsn_tlli(
 	struct gbproxy_peer *peer,
 	uint32_t tlli, uint32_t sgsn_nsei)
 {
-	struct gbproxy_tlli_info *tlli_info;
+	struct gbproxy_link_info *link_info;
 	struct gbproxy_patch_state *state = &peer->patch_state;
 
-	llist_for_each_entry(tlli_info, &state->enabled_tllis, list)
-		if ((tlli_info->sgsn_tlli.current == tlli ||
-		     tlli_info->sgsn_tlli.assigned == tlli) &&
-		    tlli_info->sgsn_nsei == sgsn_nsei)
-			return tlli_info;
+	llist_for_each_entry(link_info, &state->enabled_tllis, list)
+		if ((link_info->sgsn_tlli.current == tlli ||
+		     link_info->sgsn_tlli.assigned == tlli) &&
+		    link_info->sgsn_nsei == sgsn_nsei)
+			return link_info;
 
 	return NULL;
 }
 
-struct gbproxy_tlli_info *gbproxy_tlli_info_by_imsi(
+struct gbproxy_link_info *gbproxy_link_info_by_imsi(
 	struct gbproxy_peer *peer,
 	const uint8_t *imsi,
 	size_t imsi_len)
 {
-	struct gbproxy_tlli_info *tlli_info;
+	struct gbproxy_link_info *link_info;
 	struct gbproxy_patch_state *state = &peer->patch_state;
 
 	if (!gprs_is_mi_imsi(imsi, imsi_len))
 		return NULL;
 
-	llist_for_each_entry(tlli_info, &state->enabled_tllis, list) {
-		if (tlli_info->imsi_len != imsi_len)
+	llist_for_each_entry(link_info, &state->enabled_tllis, list) {
+		if (link_info->imsi_len != imsi_len)
 			continue;
-		if (memcmp(tlli_info->imsi, imsi, imsi_len) != 0)
+		if (memcmp(link_info->imsi, imsi, imsi_len) != 0)
 			continue;
 
-		return tlli_info;
+		return link_info;
 	}
 
 	return NULL;
 }
 
-void gbproxy_tlli_info_discard_messages(struct gbproxy_tlli_info *tlli_info)
+void gbproxy_link_info_discard_messages(struct gbproxy_link_info *link_info)
 {
 	struct msgb *msg, *nxt;
 
-	llist_for_each_entry_safe(msg, nxt, &tlli_info->stored_msgs, list) {
+	llist_for_each_entry_safe(msg, nxt, &link_info->stored_msgs, list) {
 		llist_del(&msg->list);
 		msgb_free(msg);
 	}
 }
 
-void gbproxy_delete_tlli_info(struct gbproxy_peer *peer,
-			 struct gbproxy_tlli_info *tlli_info)
+void gbproxy_delete_link_info(struct gbproxy_peer *peer,
+			 struct gbproxy_link_info *link_info)
 {
 	struct gbproxy_patch_state *state = &peer->patch_state;
 
-	gbproxy_tlli_info_discard_messages(tlli_info);
+	gbproxy_link_info_discard_messages(link_info);
 
-	llist_del(&tlli_info->list);
-	talloc_free(tlli_info);
+	llist_del(&link_info->list);
+	talloc_free(link_info);
 	state->enabled_tllis_count -= 1;
 
 	peer->ctrg->ctr[GBPROX_PEER_CTR_TLLI_CACHE_SIZE].current =
 		state->enabled_tllis_count;
 }
 
-void gbproxy_delete_tlli_infos(struct gbproxy_peer *peer)
+void gbproxy_delete_link_infos(struct gbproxy_peer *peer)
 {
-	struct gbproxy_tlli_info *tlli_info, *nxt;
+	struct gbproxy_link_info *link_info, *nxt;
 	struct gbproxy_patch_state *state = &peer->patch_state;
 
-	llist_for_each_entry_safe(tlli_info, nxt, &state->enabled_tllis, list)
-		gbproxy_delete_tlli_info(peer, tlli_info);
+	llist_for_each_entry_safe(link_info, nxt, &state->enabled_tllis, list)
+		gbproxy_delete_link_info(peer, link_info);
 
 	OSMO_ASSERT(state->enabled_tllis_count == 0);
 	OSMO_ASSERT(llist_empty(&state->enabled_tllis));
 }
 
-void gbproxy_attach_tlli_info(struct gbproxy_peer *peer, time_t now,
-			      struct gbproxy_tlli_info *tlli_info)
+void gbproxy_attach_link_info(struct gbproxy_peer *peer, time_t now,
+			      struct gbproxy_link_info *link_info)
 {
 	struct gbproxy_patch_state *state = &peer->patch_state;
 
-	tlli_info->timestamp = now;
-	llist_add(&tlli_info->list, &state->enabled_tllis);
+	link_info->timestamp = now;
+	llist_add(&link_info->list, &state->enabled_tllis);
 	state->enabled_tllis_count += 1;
 
 	peer->ctrg->ctr[GBPROX_PEER_CTR_TLLI_CACHE_SIZE].current =
 		state->enabled_tllis_count;
 }
 
-int gbproxy_remove_stale_tlli_infos(struct gbproxy_peer *peer, time_t now)
+int gbproxy_remove_stale_link_infos(struct gbproxy_peer *peer, time_t now)
 {
 	struct gbproxy_patch_state *state = &peer->patch_state;
 	int exceeded_max_len = 0;
@@ -179,27 +179,27 @@
 	check_for_age = peer->cfg->tlli_max_age > 0;
 
 	for (; exceeded_max_len > 0; exceeded_max_len--) {
-		struct gbproxy_tlli_info *tlli_info;
+		struct gbproxy_link_info *link_info;
 		OSMO_ASSERT(!llist_empty(&state->enabled_tllis));
-		tlli_info = llist_entry(state->enabled_tllis.prev,
-					struct gbproxy_tlli_info,
+		link_info = llist_entry(state->enabled_tllis.prev,
+					struct gbproxy_link_info,
 					list);
 		LOGP(DGPRS, LOGL_INFO,
 		     "Removing TLLI %08x from list "
 		     "(stale, length %d, max_len exceeded)\n",
-		     tlli_info->tlli.current, state->enabled_tllis_count);
+		     link_info->tlli.current, state->enabled_tllis_count);
 
-		gbproxy_delete_tlli_info(peer, tlli_info);
+		gbproxy_delete_link_info(peer, link_info);
 		deleted_count += 1;
 	}
 
 	while (check_for_age && !llist_empty(&state->enabled_tllis)) {
 		time_t age;
-		struct gbproxy_tlli_info *tlli_info;
-		tlli_info = llist_entry(state->enabled_tllis.prev,
-					struct gbproxy_tlli_info,
+		struct gbproxy_link_info *link_info;
+		link_info = llist_entry(state->enabled_tllis.prev,
+					struct gbproxy_link_info,
 					list);
-		age = now - tlli_info->timestamp;
+		age = now - link_info->timestamp;
 		/* age < 0 only happens after system time jumps, discard entry */
 		if (age <= peer->cfg->tlli_max_age && age >= 0) {
 			check_for_age = 0;
@@ -209,35 +209,35 @@
 		LOGP(DGPRS, LOGL_INFO,
 		     "Removing TLLI %08x from list "
 		     "(stale, age %d, max_age exceeded)\n",
-		     tlli_info->tlli.current, (int)age);
+		     link_info->tlli.current, (int)age);
 
-		gbproxy_delete_tlli_info(peer, tlli_info);
+		gbproxy_delete_link_info(peer, link_info);
 		deleted_count += 1;
 	}
 
 	return deleted_count;
 }
 
-struct gbproxy_tlli_info *gbproxy_tlli_info_alloc( struct gbproxy_peer *peer)
+struct gbproxy_link_info *gbproxy_link_info_alloc( struct gbproxy_peer *peer)
 {
-	struct gbproxy_tlli_info *tlli_info;
+	struct gbproxy_link_info *link_info;
 
-	tlli_info = talloc_zero(peer, struct gbproxy_tlli_info);
-	tlli_info->tlli.ptmsi = GSM_RESERVED_TMSI;
-	tlli_info->sgsn_tlli.ptmsi = GSM_RESERVED_TMSI;
+	link_info = talloc_zero(peer, struct gbproxy_link_info);
+	link_info->tlli.ptmsi = GSM_RESERVED_TMSI;
+	link_info->sgsn_tlli.ptmsi = GSM_RESERVED_TMSI;
 
-	INIT_LLIST_HEAD(&tlli_info->stored_msgs);
+	INIT_LLIST_HEAD(&link_info->stored_msgs);
 
-	return tlli_info;
+	return link_info;
 }
 
-void gbproxy_detach_tlli_info(
+void gbproxy_detach_link_info(
 	struct gbproxy_peer *peer,
-	struct gbproxy_tlli_info *tlli_info)
+	struct gbproxy_link_info *link_info)
 {
 	struct gbproxy_patch_state *state = &peer->patch_state;
 
-	llist_del(&tlli_info->list);
+	llist_del(&link_info->list);
 	OSMO_ASSERT(state->enabled_tllis_count > 0);
 	state->enabled_tllis_count -= 1;
 
@@ -245,17 +245,17 @@
 		state->enabled_tllis_count;
 }
 
-void gbproxy_update_tlli_info(struct gbproxy_tlli_info *tlli_info,
+void gbproxy_update_link_info(struct gbproxy_link_info *link_info,
 			      const uint8_t *imsi, size_t imsi_len)
 {
 	if (!gprs_is_mi_imsi(imsi, imsi_len))
 		return;
 
-	tlli_info->imsi_len = imsi_len;
-	tlli_info->imsi =
-		talloc_realloc_size(tlli_info, tlli_info->imsi, imsi_len);
-	OSMO_ASSERT(tlli_info->imsi != NULL);
-	memcpy(tlli_info->imsi, imsi, imsi_len);
+	link_info->imsi_len = imsi_len;
+	link_info->imsi =
+		talloc_realloc_size(link_info, link_info->imsi, imsi_len);
+	OSMO_ASSERT(link_info->imsi != NULL);
+	memcpy(link_info->imsi, imsi, imsi_len);
 }
 
 void gbproxy_reassign_tlli(struct gbproxy_tlli_state *tlli_state,
@@ -275,16 +275,16 @@
 }
 
 uint32_t gbproxy_map_tlli(uint32_t other_tlli,
-			  struct gbproxy_tlli_info *tlli_info, int to_bss)
+			  struct gbproxy_link_info *link_info, int to_bss)
 {
 	uint32_t tlli = 0;
 	struct gbproxy_tlli_state *src, *dst;
 	if (to_bss) {
-		src = &tlli_info->sgsn_tlli;
-		dst = &tlli_info->tlli;
+		src = &link_info->sgsn_tlli;
+		dst = &link_info->tlli;
 	} else {
-		src = &tlli_info->tlli;
-		dst = &tlli_info->sgsn_tlli;
+		src = &link_info->tlli;
+		dst = &link_info->sgsn_tlli;
 	}
 	if (src->current == other_tlli)
 		tlli = dst->current;
@@ -326,78 +326,78 @@
 	tlli_state->assigned = 0;
 }
 
-static void gbproxy_touch_tlli_info(struct gbproxy_peer *peer,
-				    struct gbproxy_tlli_info *tlli_info,
+static void gbproxy_touch_link_info(struct gbproxy_peer *peer,
+				    struct gbproxy_link_info *link_info,
 				    time_t now)
 {
-	gbproxy_detach_tlli_info(peer, tlli_info);
-	gbproxy_attach_tlli_info(peer, now, tlli_info);
+	gbproxy_detach_link_info(peer, link_info);
+	gbproxy_attach_link_info(peer, now, link_info);
 }
 
-static void gbproxy_unregister_tlli_info(struct gbproxy_peer *peer,
-					 struct gbproxy_tlli_info *tlli_info)
+static void gbproxy_unregister_link_info(struct gbproxy_peer *peer,
+					 struct gbproxy_link_info *link_info)
 {
-	if (!tlli_info)
+	if (!link_info)
 		return;
 
-	if (tlli_info->tlli.ptmsi == GSM_RESERVED_TMSI && !tlli_info->imsi_len) {
+	if (link_info->tlli.ptmsi == GSM_RESERVED_TMSI && !link_info->imsi_len) {
 		LOGP(DGPRS, LOGL_INFO,
 		     "Removing TLLI %08x from list (P-TMSI or IMSI are not set)\n",
-		     tlli_info->tlli.current);
-		gbproxy_delete_tlli_info(peer, tlli_info);
+		     link_info->tlli.current);
+		gbproxy_delete_link_info(peer, link_info);
 		return;
 	}
 
-	tlli_info->tlli.current = 0;
-	tlli_info->tlli.assigned = 0;
-	tlli_info->sgsn_tlli.current = 0;
-	tlli_info->sgsn_tlli.assigned = 0;
+	link_info->tlli.current = 0;
+	link_info->tlli.assigned = 0;
+	link_info->sgsn_tlli.current = 0;
+	link_info->sgsn_tlli.assigned = 0;
 
-	tlli_info->is_deregistered = 1;
+	link_info->is_deregistered = 1;
 
 	return;
 }
 
 int gbproxy_imsi_matches(struct gbproxy_peer *peer,
-		       struct gbproxy_tlli_info *tlli_info)
+		       struct gbproxy_link_info *link_info)
 {
 	if (!peer->cfg->check_imsi)
 		return 1;
 
-	return tlli_info != NULL && tlli_info->imsi_matches;
+	return link_info != NULL && link_info->imsi_matches;
 }
 
 void gbproxy_assign_imsi(struct gbproxy_peer *peer,
-			 struct gbproxy_tlli_info *tlli_info,
+			 struct gbproxy_link_info *link_info,
 			 struct gprs_gb_parse_context *parse_ctx)
 {
 	int imsi_matches;
-	struct gbproxy_tlli_info *other_tlli_info;
+	struct gbproxy_link_info *other_link_info;
 
 	/* Make sure that there is a second entry with the same IMSI */
-	other_tlli_info = gbproxy_tlli_info_by_imsi(
+	other_link_info = gbproxy_link_info_by_imsi(
 		peer, parse_ctx->imsi, parse_ctx->imsi_len);
 
-	if (other_tlli_info && other_tlli_info != tlli_info) {
+	if (other_link_info && other_link_info != link_info) {
 		char mi_buf[200];
 		mi_buf[0] = '\0';
 		gsm48_mi_to_string(mi_buf, sizeof(mi_buf),
 				   parse_ctx->imsi, parse_ctx->imsi_len);
 		LOGP(DGPRS, LOGL_INFO,
 		     "Removing TLLI %08x from list (IMSI %s re-used)\n",
-		     other_tlli_info->tlli.current, mi_buf);
-		gbproxy_delete_tlli_info(peer, other_tlli_info);
+		     other_link_info->tlli.current, mi_buf);
+		gbproxy_delete_link_info(peer, other_link_info);
 	}
 
 	/* Update the IMSI field */
-	gbproxy_update_tlli_info(tlli_info,
+	gbproxy_update_link_info(link_info,
 				 parse_ctx->imsi, parse_ctx->imsi_len);
 
 	/* Check, whether the IMSI matches */
 	imsi_matches = gbproxy_check_imsi(peer, parse_ctx->imsi,
 					     parse_ctx->imsi_len);
 	if (imsi_matches >= 0)
-		tlli_info->imsi_matches = imsi_matches;
+		link_info->imsi_matches = imsi_matches;
 }
 
 static int gbproxy_tlli_match(const struct gbproxy_tlli_state *a,
@@ -415,43 +415,43 @@
 	return 0;
 }
 
-static void gbproxy_remove_matching_tlli_infos(
-	struct gbproxy_peer *peer, struct gbproxy_tlli_info *tlli_info)
+static void gbproxy_remove_matching_link_infos(
+	struct gbproxy_peer *peer, struct gbproxy_link_info *link_info)
 {
-	struct gbproxy_tlli_info *info, *nxt;
+	struct gbproxy_link_info *info, *nxt;
 	struct gbproxy_patch_state *state = &peer->patch_state;
 
 	/* Make sure that there is no second entry with the same P-TMSI or TLLI */
 	llist_for_each_entry_safe(info, nxt, &state->enabled_tllis, list) {
-		if (info == tlli_info)
+		if (info == link_info)
 			continue;
 
-		if (!gbproxy_tlli_match(&tlli_info->tlli, &info->tlli) &&
-		    (tlli_info->sgsn_nsei != info->sgsn_nsei ||
-		     !gbproxy_tlli_match(&tlli_info->sgsn_tlli, &info->sgsn_tlli)))
+		if (!gbproxy_tlli_match(&link_info->tlli, &info->tlli) &&
+		    (link_info->sgsn_nsei != info->sgsn_nsei ||
+		     !gbproxy_tlli_match(&link_info->sgsn_tlli, &info->sgsn_tlli)))
 			continue;
 
 		LOGP(DGPRS, LOGL_INFO,
 		     "Removing TLLI %08x from list (P-TMSI/TLLI re-used)\n",
 		     info->tlli.current);
-		gbproxy_delete_tlli_info(peer, info);
+		gbproxy_delete_link_info(peer, info);
 	}
 }
 
-struct gbproxy_tlli_info *gbproxy_get_tlli_info_ul(
+struct gbproxy_link_info *gbproxy_get_link_info_ul(
 	struct gbproxy_peer *peer,
 	struct gprs_gb_parse_context *parse_ctx)
 {
-	struct gbproxy_tlli_info *tlli_info = NULL;
+	struct gbproxy_link_info *link_info = NULL;
 
 	if (parse_ctx->tlli_enc)
-		tlli_info = gbproxy_tlli_info_by_tlli(peer, parse_ctx->tlli);
+		link_info = gbproxy_link_info_by_tlli(peer, parse_ctx->tlli);
 
-	if (!tlli_info && parse_ctx->imsi)
-		tlli_info = gbproxy_tlli_info_by_imsi(
+	if (!link_info && parse_ctx->imsi)
+		link_info = gbproxy_link_info_by_imsi(
 			peer, parse_ctx->imsi, parse_ctx->imsi_len);
 
-	if (!tlli_info && parse_ctx->ptmsi_enc && !parse_ctx->old_raid_is_foreign) {
+	if (!link_info && parse_ctx->ptmsi_enc && !parse_ctx->old_raid_is_foreign) {
 		uint32_t bss_ptmsi;
 		if (!gprs_parse_mi_tmsi(parse_ctx->ptmsi_enc, GSM48_TMSI_LEN,
 					&bss_ptmsi))
@@ -459,78 +459,78 @@
 			     "Failed to parse P-TMSI (TLLI is %08x)\n",
 			     parse_ctx->tlli);
 		else
-			tlli_info = gbproxy_tlli_info_by_ptmsi(peer, bss_ptmsi);
+			link_info = gbproxy_link_info_by_ptmsi(peer, bss_ptmsi);
 	}
 
-	if (tlli_info)
-		tlli_info->is_deregistered = 0;
+	if (link_info)
+		link_info->is_deregistered = 0;
 
-	return tlli_info;
+	return link_info;
 }
 
-struct gbproxy_tlli_info *gbproxy_update_tlli_state_ul(
+struct gbproxy_link_info *gbproxy_update_link_state_ul(
 	struct gbproxy_peer *peer,
 	time_t now,
 	struct gprs_gb_parse_context *parse_ctx)
 {
-	struct gbproxy_tlli_info *tlli_info;
+	struct gbproxy_link_info *link_info;
 
-	tlli_info = gbproxy_get_tlli_info_ul(peer, parse_ctx);
+	link_info = gbproxy_get_link_info_ul(peer, parse_ctx);
 
 	if (parse_ctx->tlli_enc && parse_ctx->llc) {
 		uint32_t sgsn_tlli;
-		if (!tlli_info) {
+		if (!link_info) {
 			LOGP(DGPRS, LOGL_INFO, "Adding TLLI %08x to list\n",
 			    parse_ctx->tlli);
-			tlli_info = gbproxy_tlli_info_alloc(peer);
-			gbproxy_attach_tlli_info(peer, now, tlli_info);
+			link_info = gbproxy_link_info_alloc(peer);
+			gbproxy_attach_link_info(peer, now, link_info);
 
 			/* Setup TLLIs */
-			sgsn_tlli = gbproxy_make_sgsn_tlli(peer, tlli_info,
+			sgsn_tlli = gbproxy_make_sgsn_tlli(peer, link_info,
 							   parse_ctx->tlli);
-			tlli_info->sgsn_tlli.current = sgsn_tlli;
-			tlli_info->tlli.current = parse_ctx->tlli;;
-		} else if (!tlli_info->tlli.current) {
+			link_info->sgsn_tlli.current = sgsn_tlli;
+			link_info->tlli.current = parse_ctx->tlli;;
+		} else if (!link_info->tlli.current) {
 			/* New TLLI (info found by IMSI or P-TMSI) */
-			tlli_info->tlli.current = parse_ctx->tlli;
-			tlli_info->sgsn_tlli.current =
-				gbproxy_make_sgsn_tlli(peer, tlli_info,
+			link_info->tlli.current = parse_ctx->tlli;
+			link_info->sgsn_tlli.current =
+				gbproxy_make_sgsn_tlli(peer, link_info,
 						       parse_ctx->tlli);
-			gbproxy_touch_tlli_info(peer, tlli_info, now);
+			gbproxy_touch_link_info(peer, link_info, now);
 		} else {
-			sgsn_tlli = gbproxy_map_tlli(parse_ctx->tlli, tlli_info, 0);
+			sgsn_tlli = gbproxy_map_tlli(parse_ctx->tlli, link_info, 0);
 			if (!sgsn_tlli)
-				sgsn_tlli = gbproxy_make_sgsn_tlli(peer, tlli_info,
+				sgsn_tlli = gbproxy_make_sgsn_tlli(peer, link_info,
 								   parse_ctx->tlli);
 
-			gbproxy_validate_tlli(&tlli_info->tlli,
+			gbproxy_validate_tlli(&link_info->tlli,
 					      parse_ctx->tlli, 0);
-			gbproxy_validate_tlli(&tlli_info->sgsn_tlli,
+			gbproxy_validate_tlli(&link_info->sgsn_tlli,
 					      sgsn_tlli, 0);
-			gbproxy_touch_tlli_info(peer, tlli_info, now);
+			gbproxy_touch_link_info(peer, link_info, now);
 		}
-	} else if (tlli_info) {
-		gbproxy_touch_tlli_info(peer, tlli_info, now);
+	} else if (link_info) {
+		gbproxy_touch_link_info(peer, link_info, now);
 	}
 
-	if (parse_ctx->imsi && tlli_info && tlli_info->imsi_len == 0)
-		gbproxy_assign_imsi(peer, tlli_info, parse_ctx);
+	if (parse_ctx->imsi && link_info && link_info->imsi_len == 0)
+		gbproxy_assign_imsi(peer, link_info, parse_ctx);
 
-	return tlli_info;
+	return link_info;
 }
 
-struct gbproxy_tlli_info *gbproxy_update_tlli_state_dl(
+struct gbproxy_link_info *gbproxy_update_link_state_dl(
 	struct gbproxy_peer *peer,
 	time_t now,
 	struct gprs_gb_parse_context *parse_ctx)
 {
-	struct gbproxy_tlli_info *tlli_info = NULL;
+	struct gbproxy_link_info *link_info = NULL;
 
 	if (parse_ctx->tlli_enc)
-		tlli_info = gbproxy_tlli_info_by_sgsn_tlli(
+		link_info = gbproxy_link_info_by_sgsn_tlli(
 			peer, parse_ctx->tlli, parse_ctx->peer_nsei);
 
-	if (parse_ctx->tlli_enc && parse_ctx->new_ptmsi_enc && tlli_info) {
+	if (parse_ctx->tlli_enc && parse_ctx->new_ptmsi_enc && link_info) {
 		/* A new P-TMSI has been signalled in the message,
 		 * register new TLLI */
 		uint32_t new_sgsn_ptmsi;
@@ -540,7 +540,7 @@
 			LOGP(DGPRS, LOGL_ERROR,
 			     "Failed to parse new TLLI/PTMSI (current is %08x)\n",
 			     parse_ctx->tlli);
-			return tlli_info;
+			return link_info;
 		}
 		new_bss_ptmsi = gbproxy_make_bss_ptmsi(peer, new_sgsn_ptmsi);
 
@@ -548,12 +548,12 @@
 		     "Got new PTMSI %08x from SGSN, using %08x for BSS\n",
 		     new_sgsn_ptmsi, new_bss_ptmsi);
 		/* Setup PTMSIs */
-		tlli_info->sgsn_tlli.ptmsi = new_sgsn_ptmsi;
-		tlli_info->tlli.ptmsi = new_bss_ptmsi;
-	} else if (parse_ctx->tlli_enc && parse_ctx->new_ptmsi_enc && !tlli_info &&
+		link_info->sgsn_tlli.ptmsi = new_sgsn_ptmsi;
+		link_info->tlli.ptmsi = new_bss_ptmsi;
+	} else if (parse_ctx->tlli_enc && parse_ctx->new_ptmsi_enc && !link_info &&
 		   !peer->cfg->patch_ptmsi) {
 		/* A new P-TMSI has been signalled in the message with an unknown
-		 * TLLI, create a new tlli_info */
+		 * TLLI, create a new link_info */
 		/* TODO: Add a test case for this branch */
 		uint32_t new_ptmsi;
 		if (!gprs_parse_mi_tmsi(parse_ctx->new_ptmsi_enc, GSM48_TMSI_LEN,
@@ -561,35 +561,35 @@
 			LOGP(DGPRS, LOGL_ERROR,
 			     "Failed to parse new PTMSI (TLLI is %08x)\n",
 			     parse_ctx->tlli);
-			return tlli_info;
+			return link_info;
 		}
 
 		LOGP(DGPRS, LOGL_INFO,
 		     "Adding TLLI %08x to list (SGSN, new P-TMSI is %08x)\n",
 		     parse_ctx->tlli, new_ptmsi);
 
-		tlli_info = gbproxy_tlli_info_alloc(peer);
-		tlli_info->sgsn_tlli.current = parse_ctx->tlli;;
-		tlli_info->tlli.current = parse_ctx->tlli;;
-		tlli_info->sgsn_tlli.ptmsi = new_ptmsi;
-		tlli_info->tlli.ptmsi = new_ptmsi;
-		gbproxy_attach_tlli_info(peer, now, tlli_info);
-	} else if (parse_ctx->tlli_enc && parse_ctx->llc && !tlli_info &&
+		link_info = gbproxy_link_info_alloc(peer);
+		link_info->sgsn_tlli.current = parse_ctx->tlli;;
+		link_info->tlli.current = parse_ctx->tlli;;
+		link_info->sgsn_tlli.ptmsi = new_ptmsi;
+		link_info->tlli.ptmsi = new_ptmsi;
+		gbproxy_attach_link_info(peer, now, link_info);
+	} else if (parse_ctx->tlli_enc && parse_ctx->llc && !link_info &&
 		   !peer->cfg->patch_ptmsi) {
-		/* Unknown SGSN TLLI, create a new tlli_info */
+		/* Unknown SGSN TLLI, create a new link_info */
 		uint32_t new_ptmsi;
-		tlli_info = gbproxy_tlli_info_alloc(peer);
+		link_info = gbproxy_link_info_alloc(peer);
 		LOGP(DGPRS, LOGL_INFO, "Adding TLLI %08x to list (SGSN)\n",
 		     parse_ctx->tlli);
 
-		gbproxy_attach_tlli_info(peer, now, tlli_info);
+		gbproxy_attach_link_info(peer, now, link_info);
 
 		/* Setup TLLIs */
-		tlli_info->sgsn_tlli.current = parse_ctx->tlli;
-		tlli_info->tlli.current = parse_ctx->tlli;
+		link_info->sgsn_tlli.current = parse_ctx->tlli;
+		link_info->tlli.current = parse_ctx->tlli;
 
 		if (!parse_ctx->new_ptmsi_enc)
-			return tlli_info;
+			return link_info;
 		/* A new P-TMSI has been signalled in the message */
 
 		if (!gprs_parse_mi_tmsi(parse_ctx->new_ptmsi_enc,
@@ -597,57 +597,57 @@
 			LOGP(DGPRS, LOGL_ERROR,
 			     "Failed to parse new PTMSI (TLLI is %08x)\n",
 			     parse_ctx->tlli);
-			return tlli_info;
+			return link_info;
 		}
 		LOGP(DGPRS, LOGL_INFO,
 		     "Assigning new P-TMSI %08x\n", new_ptmsi);
 		/* Setup P-TMSIs */
-		tlli_info->sgsn_tlli.ptmsi = new_ptmsi;
-		tlli_info->tlli.ptmsi = new_ptmsi;
-	} else if (parse_ctx->tlli_enc && parse_ctx->llc && tlli_info) {
+		link_info->sgsn_tlli.ptmsi = new_ptmsi;
+		link_info->tlli.ptmsi = new_ptmsi;
+	} else if (parse_ctx->tlli_enc && parse_ctx->llc && link_info) {
 		uint32_t bss_tlli = gbproxy_map_tlli(parse_ctx->tlli,
-						     tlli_info, 1);
-		gbproxy_validate_tlli(&tlli_info->sgsn_tlli, parse_ctx->tlli, 1);
-		gbproxy_validate_tlli(&tlli_info->tlli, bss_tlli, 1);
-		gbproxy_touch_tlli_info(peer, tlli_info, now);
-	} else if (tlli_info) {
-		gbproxy_touch_tlli_info(peer, tlli_info, now);
+						     link_info, 1);
+		gbproxy_validate_tlli(&link_info->sgsn_tlli, parse_ctx->tlli, 1);
+		gbproxy_validate_tlli(&link_info->tlli, bss_tlli, 1);
+		gbproxy_touch_link_info(peer, link_info, now);
+	} else if (link_info) {
+		gbproxy_touch_link_info(peer, link_info, now);
 	}
 
-	if (parse_ctx->imsi && tlli_info && tlli_info->imsi_len == 0)
-		gbproxy_assign_imsi(peer, tlli_info, parse_ctx);
+	if (parse_ctx->imsi && link_info && link_info->imsi_len == 0)
+		gbproxy_assign_imsi(peer, link_info, parse_ctx);
 
-	return tlli_info;
+	return link_info;
 }
 
-void gbproxy_update_tlli_state_after(
+void gbproxy_update_link_state_after(
 	struct gbproxy_peer *peer,
-	struct gbproxy_tlli_info *tlli_info,
+	struct gbproxy_link_info *link_info,
 	time_t now,
 	struct gprs_gb_parse_context *parse_ctx)
 {
-	if (parse_ctx->invalidate_tlli && tlli_info) {
+	if (parse_ctx->invalidate_tlli && link_info) {
 		int keep_info =
-			peer->cfg->keep_tlli_infos == GBPROX_KEEP_ALWAYS ||
-			(peer->cfg->keep_tlli_infos == GBPROX_KEEP_REATTACH &&
+			peer->cfg->keep_link_infos == GBPROX_KEEP_ALWAYS ||
+			(peer->cfg->keep_link_infos == GBPROX_KEEP_REATTACH &&
 			 parse_ctx->await_reattach) ||
-			(peer->cfg->keep_tlli_infos == GBPROX_KEEP_IDENTIFIED &&
-			 tlli_info->imsi_len > 0);
+			(peer->cfg->keep_link_infos == GBPROX_KEEP_IDENTIFIED &&
+			 link_info->imsi_len > 0);
 		if (keep_info) {
 			LOGP(DGPRS, LOGL_INFO, "Unregistering TLLI %08x\n",
-			     tlli_info->tlli.current);
-			gbproxy_unregister_tlli_info(peer, tlli_info);
+			     link_info->tlli.current);
+			gbproxy_unregister_link_info(peer, link_info);
 		} else {
 			LOGP(DGPRS, LOGL_INFO, "Removing TLLI %08x from list\n",
-			     tlli_info->tlli.current);
-			gbproxy_delete_tlli_info(peer, tlli_info);
+			     link_info->tlli.current);
+			gbproxy_delete_link_info(peer, link_info);
 		}
 	} else if (parse_ctx->to_bss && parse_ctx->tlli_enc &&
-		   parse_ctx->new_ptmsi_enc && tlli_info) {
+		   parse_ctx->new_ptmsi_enc && link_info) {
 		/* A new PTMSI has been signaled in the message,
 		 * register new TLLI */
-		uint32_t new_sgsn_ptmsi = tlli_info->sgsn_tlli.ptmsi;
-		uint32_t new_bss_ptmsi = tlli_info->tlli.ptmsi;
+		uint32_t new_sgsn_ptmsi = link_info->sgsn_tlli.ptmsi;
+		uint32_t new_bss_ptmsi = link_info->tlli.ptmsi;
 		uint32_t new_sgsn_tlli;
 		uint32_t new_bss_tlli = 0;
 
@@ -658,14 +658,14 @@
 		     "Assigning new TLLI %08x to SGSN, %08x to BSS\n",
 		     new_sgsn_tlli, new_bss_tlli);
 
-		gbproxy_reassign_tlli(&tlli_info->sgsn_tlli,
+		gbproxy_reassign_tlli(&link_info->sgsn_tlli,
 				      peer, new_sgsn_tlli);
-		gbproxy_reassign_tlli(&tlli_info->tlli,
+		gbproxy_reassign_tlli(&link_info->tlli,
 				      peer, new_bss_tlli);
-		gbproxy_remove_matching_tlli_infos(peer, tlli_info);
+		gbproxy_remove_matching_link_infos(peer, link_info);
 	}
 
-	gbproxy_remove_stale_tlli_infos(peer, now);
+	gbproxy_remove_stale_link_infos(peer, now);
 }