gbproxy: Use the term 'link' instead of 'tlli'

Currently in many places where 'tlli' (Temporary Logical Link
Identifier) within identifiers is used, the logical link itself is
meant instead. For instance, the tlli_info contain information about
an LLC logical link including up to four individual TLLI.

To avoid confusion between these concepts, this patch replaces all
'tlli_info' by 'link_info' and a few 'tlli' by 'link'.

Sponsored-by: On-Waves ehf

1 files changed, 199 insertions, 199 deletions

diff --git a/openbsc/src/gprs/gb_proxy_tlli.c b/openbsc/src/gprs/gb_proxy_tlli.c
index 70f2bfb62..14ce7d86b 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 @@ int gbproxy_remove_stale_tlli_infos(struct gbproxy_peer *peer, time_t now)
 	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 @@ int gbproxy_remove_stale_tlli_infos(struct gbproxy_peer *peer, time_t now)
 		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 @@ void gbproxy_detach_tlli_info(
 		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 @@ void gbproxy_reassign_tlli(struct gbproxy_tlli_state *tlli_state,
 }
 
 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 @@ static void gbproxy_validate_tlli(struct gbproxy_tlli_state *tlli_state,
 	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 @@ static int gbproxy_tlli_match(const struct gbproxy_tlli_state *a,
 	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 @@ struct gbproxy_tlli_info *gbproxy_get_tlli_info_ul(
 			     "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 @@ struct gbproxy_tlli_info *gbproxy_update_tlli_state_dl(
 			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 @@ struct gbproxy_tlli_info *gbproxy_update_tlli_state_dl(
 		     "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 @@ struct gbproxy_tlli_info *gbproxy_update_tlli_state_dl(
 			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 @@ struct gbproxy_tlli_info *gbproxy_update_tlli_state_dl(
 			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 @@ void gbproxy_update_tlli_state_after(
 		     "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);
 }