osmo-gbproxy/src/gb_proxy_peer.c

/* Gb proxy peer handling */

/* (C) 2010 by Harald Welte <laforge@gnumonks.org>
 * (C) 2010-2013 by On-Waves
 * (C) 2013 by Holger Hans Peter Freyther
 * All Rights Reserved
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#include <osmocom/sgsn/gb_proxy.h>

#include <osmocom/sgsn/debug.h>

#include <osmocom/gprs/protocol/gsm_08_18.h>
#include <osmocom/core/logging.h>
#include <osmocom/core/rate_ctr.h>
#include <osmocom/core/stats.h>
#include <osmocom/core/talloc.h>
#include <osmocom/gsm/tlv.h>

#include <string.h>

extern void *tall_sgsn_ctx;

static const struct rate_ctr_desc bvc_ctr_description[] = {
	{ "blocked",	   "BVC Block                       " },
	{ "unblocked",	   "BVC Unblock                     " },
	{ "dropped",	   "BVC blocked, dropped packet     " },
	{ "inv-nsei",	   "NSEI mismatch                   " },
	{ "tx-err",	   "NS Transmission error           " },
};

osmo_static_assert(ARRAY_SIZE(bvc_ctr_description) == GBPROX_PEER_CTR_LAST, everything_described);

static const struct rate_ctr_group_desc bvc_ctrg_desc = {
	.group_name_prefix = "gbproxy:peer",
	.group_description = "GBProxy Peer Statistics",
	.num_ctr = ARRAY_SIZE(bvc_ctr_description),
	.ctr_desc = bvc_ctr_description,
	.class_id = OSMO_STATS_CLASS_PEER,
};


/* Find the gbproxy_bvc by its BVCI. There can only be one match */
struct gbproxy_bvc *gbproxy_bvc_by_bvci(struct gbproxy_config *cfg, uint16_t bvci)
{
	struct gbproxy_nse *nse;
	int i;

	hash_for_each(cfg->bss_nses, i, nse, list) {
		struct gbproxy_bvc *bvc;
		hash_for_each_possible(nse->bvcs, bvc, list, bvci) {
			if (bvc->bvci == bvci)
				return bvc;
		}
	}
	return NULL;
}

/* Find the gbproxy_bvc by its NSEI */
/* FIXME: Only returns the first bvc, but we could have multiple on this nsei */
struct gbproxy_bvc *gbproxy_bvc_by_nsei(struct gbproxy_config *cfg,
					  uint16_t nsei)
{
	struct gbproxy_nse *nse = gbproxy_nse_by_nsei(cfg, nsei);
	struct gbproxy_bvc *bvc;
	int i;

	if (!nse || hash_empty(nse->bvcs))
		return NULL;

	/* return the first entry we find */
	hash_for_each(nse->bvcs, i, bvc, list)
		return bvc;

	return NULL;
}

/* look-up a bvc by its Routeing Area Identification (RAI) */
/* FIXME: this doesn't make sense, as RA can span multiple bvcs! */
struct gbproxy_bvc *gbproxy_bvc_by_rai(struct gbproxy_config *cfg,
					 const uint8_t *ra)
{
	struct gbproxy_nse *nse;
	int i, j;

	hash_for_each(cfg->bss_nses, i, nse, list) {
		struct gbproxy_bvc *bvc;
		hash_for_each(nse->bvcs, j, bvc, list) {
			if (!memcmp(bvc->ra, ra, 6))
				return bvc;
		}
	}

	return NULL;
}

struct gbproxy_bvc *gbproxy_bvc_alloc(struct gbproxy_nse *nse, uint16_t bvci)
{
	struct gbproxy_bvc *bvc;
	OSMO_ASSERT(nse);
	struct gbproxy_config *cfg = nse->cfg;
	OSMO_ASSERT(cfg);

	bvc = talloc_zero(tall_sgsn_ctx, struct gbproxy_bvc);
	if (!bvc)
		return NULL;

	bvc->bvci = bvci;
	bvc->ctrg = rate_ctr_group_alloc(bvc, &bvc_ctrg_desc, bvci);
	if (!bvc->ctrg) {
		talloc_free(bvc);
		return NULL;
	}
	bvc->nse = nse;

	hash_add(nse->bvcs, &bvc->list, bvc->bvci);

	return bvc;
}

void gbproxy_bvc_free(struct gbproxy_bvc *bvc)
{
	if (!bvc)
		return;

	hash_del(&bvc->list);

	rate_ctr_group_free(bvc->ctrg);
	bvc->ctrg = NULL;

	talloc_free(bvc);
}

void gbproxy_bvc_move(struct gbproxy_bvc *bvc, struct gbproxy_nse *nse)
{
	hash_del(&bvc->list);
	hash_add(nse->bvcs, &bvc->list, bvc->bvci);
	bvc->nse = nse;
}

/*! remove bvcs (BVCs) on NSE specified by NSEI.
 *  \param[in] cfg proxy in which we operate
 *  \param[in] nsei NS entity in which we should clean up
 *  \param[in] bvci if 0: remove all BVCs; if != 0: BVCI of the single BVC to clean up */
int gbproxy_cleanup_bvcs(struct gbproxy_config *cfg, uint16_t nsei, uint16_t bvci)
{
	int i, j, counter = 0;
	struct gbproxy_nse *nse;
	struct hlist_node *ntmp;
	OSMO_ASSERT(cfg);

	hash_for_each_safe(cfg->bss_nses, i, ntmp, nse, list) {
		struct gbproxy_bvc *bvc;
		struct hlist_node *btmp;
		if (nse->nsei != nsei)
			continue;
		hash_for_each_safe(nse->bvcs, j, btmp, bvc, list) {
			if (bvci && bvc->bvci != bvci)
				continue;

			gbproxy_bvc_free(bvc);
			counter += 1;
		}
	}

	return counter;
}

struct gbproxy_nse *gbproxy_nse_alloc(struct gbproxy_config *cfg, uint16_t nsei)
{
	struct gbproxy_nse *nse;
	OSMO_ASSERT(cfg);

	nse = talloc_zero(tall_sgsn_ctx, struct gbproxy_nse);
	if (!nse)
		return NULL;

	nse->nsei = nsei;
	nse->cfg = cfg;

	hash_add(cfg->bss_nses, &nse->list, nsei);

	hash_init(nse->bvcs);

	return nse;
}

void gbproxy_nse_free(struct gbproxy_nse *nse)
{
	struct gbproxy_bvc *bvc;
	struct hlist_node *tmp;
	int i;

	if (!nse)
		return;

	hash_del(&nse->list);

	hash_for_each_safe(nse->bvcs, i, tmp, bvc, list)
		gbproxy_bvc_free(bvc);

	talloc_free(nse);
}

struct gbproxy_nse *gbproxy_nse_by_nsei(struct gbproxy_config *cfg, uint16_t nsei)
{
	struct gbproxy_nse *nse;
	OSMO_ASSERT(cfg);

	hash_for_each_possible(cfg->bss_nses, nse, list, nsei) {
		if (nse->nsei == nsei)
			return nse;
	}

	return NULL;
}

struct gbproxy_nse *gbproxy_nse_by_nsei_or_new(struct gbproxy_config *cfg, uint16_t nsei)
{
	struct gbproxy_nse *nse;
	OSMO_ASSERT(cfg);

	nse = gbproxy_nse_by_nsei(cfg, nsei);
	if (!nse)
		nse = gbproxy_nse_alloc(cfg, nsei);

	return nse;
}