diff --git a/src/Makefile b/src/Makefile
new file mode 100644
index 0000000..d7c597e
--- /dev/null
+++ b/src/Makefile
@@ -0,0 +1,16 @@
+LDFLAGS += -losmocore -losmogsm -losmoabis -lsqlite3 -ltalloc
+CFLAGS += -g -Wall
+
+OBJS = auc.o db.o db_auc.o logging.o
+
+db_test: db_test.o rand_fake.o $(OBJS)
+	$(CC) $(LDFLAGS) -o $@ $^
+
+hlr: hlr.o gsup_server.o rand_urandom.o $(OBJS)
+	$(CC) $(LDFLAGS) -o $@ $^
+
+%.o: %.c
+	$(CC) $(CFLAGS) -o $@ -c $^
+
+clean:
+	rm -f *.o db_test
diff --git a/src/auc.c b/src/auc.c
new file mode 100644
index 0000000..8ceafad
--- /dev/null
+++ b/src/auc.c
@@ -0,0 +1,94 @@
+/* (C) 2015 by Harald Welte <laforge@gnumonks.org>
+ *
+ * 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 <string.h>
+
+#include <osmocom/core/utils.h>
+#include <osmocom/crypt/auth.h>
+
+#include "logging.h"
+#include "rand.h"
+
+/* compute given number of vectors using either aud2g or aud2g or a combination
+ * of both.  Handles re-synchrnization if rand_auts and auts are set */
+int auc_compute_vectors(struct osmo_auth_vector *vec, unsigned int num_vec,
+			struct osmo_sub_auth_data *aud2g,
+			struct osmo_sub_auth_data *aud3g,
+			const uint8_t *rand_auts, const uint8_t *auts)
+{
+	unsigned int i;
+	uint8_t rand[16];
+	int rc;
+
+	if (aud2g->algo == OSMO_AUTH_ALG_NONE)
+		aud2g = NULL;
+	if (aud3g->algo == OSMO_AUTH_ALG_NONE)
+		aud3g = NULL;
+
+	if (!aud2g && !aud3g)
+		return -1;
+
+	/* compute quintuples */
+	for (i = 0; i < num_vec; i++) {
+		rc = rand_get(rand, sizeof(rand));
+		if (rc != sizeof(rand)) {
+			LOGP(DAUC, LOGL_ERROR, "Unable to read %zu random "
+			     "bytes: rc=%d\n", sizeof(rand), rc);
+			goto out;
+		}
+
+		if (aud2g && !aud3g) {
+			/* 2G only case: output directly to vec */
+			rc = osmo_auth_gen_vec(vec+i, aud2g, rand);
+			if (rc < 0) {
+				LOGP(DAUC, LOGL_ERROR, "Error in 2G vector "
+				     "generation: %d\n", rc);
+				goto out;
+			}
+		} else if (aud3g) {
+			/* 3G or 3G + 2G case */
+			if (rand_auts && auts)
+				rc = osmo_auth_gen_vec_auts(vec+i, aud3g,
+							    rand_auts,
+							    auts, rand);
+			else
+				rc = osmo_auth_gen_vec(vec+i, aud3g, rand);
+			if (rc < 0) {
+				LOGP(DAUC, LOGL_ERROR, "Error in 3G vector "
+				     "generation: %d\n", rc);
+				goto out;
+			}
+		}
+		if (aud2g && aud3g) {
+			/* separate 2G + 3G case: patch 2G into 3G */
+			struct osmo_auth_vector vtmp;
+			rc = osmo_auth_gen_vec(&vtmp, aud2g, rand);
+			if (rc < 0) {
+				LOGP(DAUC, LOGL_ERROR, "Error in 2G vector "
+				     "generation: %d\n", rc);
+				goto out;
+			}
+			memcpy(&vec[i].kc, vtmp.kc, sizeof(vec[i].kc));
+			memcpy(&vec[i].sres, vtmp.sres, sizeof(vec[i].sres));
+			vec[i].auth_types |= OSMO_AUTH_TYPE_GSM;
+		}
+	}
+out:
+	return i;
+}
diff --git a/src/auc.h b/src/auc.h
new file mode 100644
index 0000000..f5b6765
--- /dev/null
+++ b/src/auc.h
@@ -0,0 +1,8 @@
+#pragma once
+
+#include <osmocom/crypt/auth.h>
+
+int auc_compute_vectors(struct osmo_auth_vector *vec, unsigned int num_vec,
+			struct osmo_sub_auth_data *aud2g,
+			struct osmo_sub_auth_data *aud3g,
+			const uint8_t *rand_auts, const uint8_t *auts);
diff --git a/src/db.c b/src/db.c
new file mode 100644
index 0000000..b4fadca
--- /dev/null
+++ b/src/db.c
@@ -0,0 +1,121 @@
+/* (C) 2015 by Harald Welte <laforge@gnumonks.org>
+ *
+ * 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/core/utils.h>
+
+#include <sqlite3.h>
+
+#include "logging.h"
+#include "db.h"
+
+static const char *stmt_sql[] = {
+	[SEL_BY_IMSI] = "SELECT * FROM subscriber WHERE imsi = ?",
+	[UPD_BY_IMSI] = "UPDATE subscriber SET vlr_number = ? WHERE imsi = ?",
+	[AUC_BY_IMSI] = "SELECT id, algo_id_2g, ki, algo_id_3g, k, op, opc, sqn FROM subscriber LEFT JOIN auc_2g ON auc_2g.subscriber_id = subscriber.id LEFT JOIN auc_3g ON auc_3g.subscriber_id = subscriber.id WHERE imsi = ?",
+	[AUC_UPD_SQN] = "UPDATE auc_3g SET sqn = ? WHERE subscriber_id = ?",
+};
+
+static void sql3_error_log_cb(void *arg, int err_code, const char *msg)
+{
+	LOGP(DDB, LOGL_ERROR, "(%d) %s\n", err_code, msg);
+}
+
+static void sql3_sql_log_cb(void *arg, sqlite3 *s3, const char *stmt, int type)
+{
+	switch (type) {
+	case 0:
+		LOGP(DDB, LOGL_DEBUG, "Opened database\n");
+		break;
+	case 1:
+		LOGP(DDB, LOGL_DEBUG, stmt);
+		break;
+	case 2:
+		LOGP(DDB, LOGL_DEBUG, "Closed database\n");
+		break;
+	default:
+		LOGP(DDB, LOGL_DEBUG, "Unknown %d\n", type);
+		break;
+	}
+}
+
+void db_close(struct db_context *dbc)
+{
+	unsigned int i;
+
+	for (i = 0; i < ARRAY_SIZE(dbc->stmt); i++) {
+		/* it is ok to call finalize on NULL */
+		sqlite3_finalize(dbc->stmt[i]);
+	}
+	sqlite3_close(dbc->db);
+	talloc_free(dbc);
+}
+
+struct db_context *db_open(void *ctx, const char *fname)
+{
+	struct db_context *dbc = talloc_zero(ctx, struct db_context);
+	unsigned int i;
+	int rc;
+
+	LOGP(DDB, LOGL_INFO, "Compiled against SQLite3 lib version %s\n", SQLITE_VERSION);
+	LOGP(DDB, LOGL_INFO, "Running with SQLite3 lib version %s\n", sqlite3_libversion());
+
+	dbc->fname = talloc_strdup(dbc, fname);
+
+	for (i = 0; i < 0xfffff; i++) {
+		const char *o = sqlite3_compileoption_get(i);
+		if (!o)
+			break;
+		LOGP(DDB, LOGL_DEBUG, "SQlite3 compiled with '%s'\n", o);
+	}
+
+	rc = sqlite3_config(SQLITE_CONFIG_LOG, sql3_error_log_cb, NULL);
+	if (rc != SQLITE_OK)
+		LOGP(DDB, LOGL_NOTICE, "Unable to set SQlite3 error log callback\n");
+
+	rc = sqlite3_config(SQLITE_CONFIG_SQLLOG, sql3_sql_log_cb, NULL);
+	if (rc != SQLITE_OK)
+		LOGP(DDB, LOGL_NOTICE, "Unable to set SQlite3 SQL statement log callback\n");
+
+	rc = sqlite3_open(dbc->fname, &dbc->db);
+	if (rc != SQLITE_OK) {
+		LOGP(DDB, LOGL_ERROR, "Unable to open DB; rc = %d\n", rc);
+		talloc_free(dbc);
+		return NULL;
+	}
+
+	/* enable extended result codes */
+	rc = sqlite3_extended_result_codes(dbc->db, 1);
+	if (rc != SQLITE_OK)
+		LOGP(DDB, LOGL_ERROR, "Unable to enable SQlite3 extended result codes\n");
+
+	/* prepare all SQL statements */
+	for (i = 0; i < ARRAY_SIZE(dbc->stmt); i++) {
+		rc = sqlite3_prepare_v2(dbc->db, stmt_sql[i], -1,
+					&dbc->stmt[i], NULL);
+		if (rc != SQLITE_OK) {
+			LOGP(DDB, LOGL_ERROR, "Unable to prepare SQL statement '%s'\n", stmt_sql[i]);
+			goto out_free;
+		}
+	}
+
+	return dbc;
+out_free:
+	db_close(dbc);
+	return NULL;
+}
diff --git a/src/db.h b/src/db.h
new file mode 100644
index 0000000..f0545a4
--- /dev/null
+++ b/src/db.h
@@ -0,0 +1,35 @@
+#pragma once
+
+#include <sqlite3.h>
+
+enum stmt_idx {
+	SEL_BY_IMSI	= 0,
+	UPD_BY_IMSI	= 1,
+	AUC_BY_IMSI	= 2,
+	AUC_UPD_SQN	= 3,
+	_NUM_STMT
+};
+
+struct db_context {
+	char *fname;
+	sqlite3 *db;
+	sqlite3_stmt *stmt[_NUM_STMT];
+};
+
+void db_close(struct db_context *dbc);
+struct db_context *db_open(void *ctx, const char *fname);
+
+#include <osmocom/crypt/auth.h>
+
+/* obtain the authentication data for a given imsi */
+int db_get_auth_data(struct db_context *dbc, const char *imsi,
+		     struct osmo_sub_auth_data *aud2g,
+		     struct osmo_sub_auth_data *aud3g,
+		     uint64_t *suscr_id);
+
+int db_update_sqn(struct db_context *dbc, uint64_t id,
+		      uint64_t new_sqn);
+
+int db_get_auc(struct db_context *dbc, const char *imsi,
+	    struct osmo_auth_vector *vec, unsigned int num_vec,
+	    const uint8_t *rand_auts, const uint8_t *auts);
diff --git a/src/db_auc.c b/src/db_auc.c
new file mode 100644
index 0000000..fa5f3e5
--- /dev/null
+++ b/src/db_auc.c
@@ -0,0 +1,208 @@
+/* (C) 2015 by Harald Welte <laforge@gnumonks.org>
+ *
+ * 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 <string.h>
+
+#include <osmocom/core/utils.h>
+#include <osmocom/crypt/auth.h>
+
+#include <sqlite3.h>
+
+#include "logging.h"
+#include "db.h"
+#include "auc.h"
+#include "rand.h"
+
+#define LOGAUC(imsi, level, fmt, args ...)	LOGP(DAUC, level, "%s: " fmt, imsi, ## args)
+
+/* update the SQN for a given subscriber ID */
+int db_update_sqn(struct db_context *dbc, uint64_t id,
+		      uint64_t new_sqn)
+{
+	sqlite3_stmt *stmt = dbc->stmt[AUC_UPD_SQN];
+	int rc;
+
+	/* bind new SQN and subscriber ID */
+	rc = sqlite3_bind_int64(stmt, 1, new_sqn);
+	if (rc != SQLITE_OK) {
+		LOGP(DAUC, LOGL_ERROR, "Error binding SQN: %d\n", rc);
+		return -1;
+	}
+
+	rc = sqlite3_bind_int64(stmt, 2, id);
+	if (rc != SQLITE_OK) {
+		LOGP(DAUC, LOGL_ERROR, "Error binding Subscrber ID: %d\n", rc);
+		return -1;
+	}
+
+	/* execute the statement */
+	rc = sqlite3_step(stmt);
+	if (rc != SQLITE_DONE) {
+		LOGP(DAUC, LOGL_ERROR, "Error updating SQN: %d\n", rc);
+		return -2;
+	}
+
+	/* remove bindings and reset statement to be re-executed */
+	rc = sqlite3_clear_bindings(stmt);
+	if (rc != SQLITE_OK) {
+		LOGP(DAUC, LOGL_ERROR, "Error clerearing bindings: %d\n", rc);
+	}
+	rc = sqlite3_reset(stmt);
+	if (rc != SQLITE_OK) {
+		LOGP(DAUC, LOGL_ERROR, "Error in sqlite3_reset: %d\n", rc);
+	}
+
+	return 0;
+}
+
+/* obtain the authentication data for a given imsi */
+int db_get_auth_data(struct db_context *dbc, const char *imsi,
+		     struct osmo_sub_auth_data *aud2g,
+		     struct osmo_sub_auth_data *aud3g,
+		     uint64_t *subscr_id)
+{
+	sqlite3_stmt *stmt = dbc->stmt[AUC_BY_IMSI];
+	int rc;
+
+	memset(aud2g, 0, sizeof(*aud2g));
+	memset(aud3g, 0, sizeof(*aud3g));
+
+	/* bind the IMSI value */
+	rc = sqlite3_bind_text(stmt, 1, imsi, -1,
+				SQLITE_STATIC);
+	if (rc != SQLITE_OK) {
+		LOGAUC(imsi, LOGL_ERROR, "Error binding IMSI: %d\n", rc);
+	}
+
+	/* execute the statement */
+	rc = sqlite3_step(stmt);
+	if (rc != SQLITE_ROW) {
+		LOGAUC(imsi, LOGL_ERROR, "Error executing SQL: %d\n", rc);
+		goto out;
+	}
+
+	/* as an optimization, we retrieve the subscriber ID, to ensure we can
+	 * update the SQN later without having to go back via a JOIN with the
+	 * subscriber table. */
+	if (subscr_id)
+		*subscr_id = sqlite3_column_int64(stmt, 0);
+
+	for (int i = 0; i < 10; i++)
+		LOGAUC(imsi, LOGL_DEBUG, "col_type(%d)=%d\n", i,
+				sqlite3_column_type(stmt, i));
+
+	/* obtain result values using sqlite3_column_*() */
+	if (sqlite3_column_type(stmt, 1) == SQLITE_INTEGER) {
+		/* we do have some 2G authentication data */
+		const uint8_t *ki;
+
+		aud2g->algo = sqlite3_column_int(stmt, 1);
+		ki = sqlite3_column_text(stmt, 2);
+#if 0
+		if (sqlite3_column_bytes(stmt, 2) != sizeof(aud2g->u.gsm.ki)) {
+			LOGAUC(imsi, LOGL_ERROR, "Error reading Ki: %d\n", rc);
+			goto end_2g;
+		}
+#endif
+		memcpy(&aud2g->u.gsm.ki, ki, sizeof(aud2g->u.gsm.ki));
+		aud2g->type = OSMO_AUTH_TYPE_GSM;
+	} else
+		LOGAUC(imsi, LOGL_DEBUG, "No 2G Auth Data\n");
+//end_2g:
+	if (sqlite3_column_type(stmt, 3) == SQLITE_INTEGER) {
+		/* we do have some 3G authentication data */
+		const uint8_t *k, *op, *opc;
+
+		aud3g->algo = sqlite3_column_int(stmt, 3);
+		k = sqlite3_column_text(stmt, 4);
+		if (!k) {
+			LOGAUC(imsi, LOGL_ERROR, "Error reading K: %d\n", rc);
+			goto out;
+		}
+		memcpy(&aud3g->u.umts.k, k, sizeof(aud3g->u.umts.k));
+		/* UMTS Subscribers can have either OP or OPC */
+		op = sqlite3_column_text(stmt, 5);
+		if (!op) {
+			opc = sqlite3_column_text(stmt, 6);
+			if (!opc) {
+				LOGAUC(imsi, LOGL_ERROR, "Error reading OPC: %d\n", rc);
+				goto out;
+			}
+			memcpy(&aud3g->u.umts.opc, opc, sizeof(aud3g->u.umts.opc));
+			aud3g->u.umts.opc_is_op = 0;
+		} else {
+			memcpy(&aud3g->u.umts.opc, op, sizeof(aud3g->u.umts.opc));
+			aud3g->u.umts.opc_is_op = 1;
+		}
+		aud3g->u.umts.sqn = sqlite3_column_int64(stmt, 7);
+		/* FIXME: amf? */
+		aud3g->type = OSMO_AUTH_TYPE_UMTS;
+	} else
+		LOGAUC(imsi, LOGL_DEBUG, "No 3G Auth Data\n");
+out:
+	/* remove bindings and reset statement to be re-executed */
+	rc = sqlite3_clear_bindings(stmt);
+	if (rc != SQLITE_OK) {
+		LOGAUC(imsi, LOGL_ERROR, "Error in sqlite3_clear_bindings(): %d\n", rc);
+	}
+	rc = sqlite3_reset(stmt);
+	if (rc != SQLITE_OK) {
+		LOGAUC(imsi, LOGL_ERROR, "Error in sqlite3_reset(): %d\n", rc);
+	}
+
+	if (aud2g->type == 0 && aud3g->type == 0)
+		return -1;
+
+	return 0;
+}
+
+int db_get_auc(struct db_context *dbc, const char *imsi,
+	    struct osmo_auth_vector *vec, unsigned int num_vec,
+	    const uint8_t *rand_auts, const uint8_t *auts)
+{
+	struct osmo_sub_auth_data aud2g, aud3g;
+	uint64_t subscr_id;
+	int rc;
+
+	rc = db_get_auth_data(dbc, imsi, &aud2g, &aud3g, &subscr_id);
+	if (rc < 0)
+		return rc;
+
+	LOGAUC(imsi, LOGL_INFO, "Calling to generate %u vectors\n", num_vec);
+	rc = auc_compute_vectors(vec, num_vec, &aud2g, &aud3g, rand_auts, auts);
+	if (rc < 0)
+		num_vec = 0;
+	else
+		num_vec = rc;
+	LOGAUC(imsi, LOGL_INFO, "Generated %u vectors\n", num_vec);
+
+	/* Update SQN in database, as needed */
+	if (aud3g.algo) {
+		LOGAUC(imsi, LOGL_DEBUG, "Updating SQN in DB\n");
+		rc = db_update_sqn(dbc, subscr_id, aud3g.u.umts.sqn);
+		/* don't tell caller we generated any triplets in case of
+		 * update error */
+		if (rc < 0) {
+			LOGAUC(imsi, LOGL_ERROR, "Error updating SQN: %d\n", rc);
+			num_vec = 0;
+		}
+	}
+
+	return num_vec;
+}
diff --git a/src/db_test.c b/src/db_test.c
new file mode 100644
index 0000000..75fcb62
--- /dev/null
+++ b/src/db_test.c
@@ -0,0 +1,84 @@
+#include <string.h>
+
+#include <osmocom/core/utils.h>
+#include <osmocom/core/application.h>
+
+#include "db.h"
+#include "rand.h"
+#include "logging.h"
+
+static struct db_context *g_dbc;
+
+static int test(const char *imsi)
+{
+	struct osmo_auth_vector vec[3];
+	int rc, i;
+
+	/* initialize all vectors with a known token pattern */
+	memset(vec, 0x55, sizeof(vec));
+	for (i = 0; i < ARRAY_SIZE(vec); i++)
+		vec[i].res_len = 0;
+
+	rc = db_get_auc(g_dbc, imsi, vec, ARRAY_SIZE(vec), NULL, NULL);
+	if (rc <= 0) {
+		LOGP(DMAIN, LOGL_ERROR, "Cannot obtain auth tuples for '%s'\n", imsi);
+		return rc;
+	}
+	LOGP(DMAIN, LOGL_INFO, "Obtained %u tuples for subscriber IMSI %s\n",
+		rc, imsi);
+
+	for (i = 0; i < rc; i++) {
+		struct osmo_auth_vector *v = vec + i;
+		LOGP(DMAIN, LOGL_DEBUG, "Tuple %u, auth_types=0x%x\n", i, v->auth_types);
+		LOGP(DMAIN, LOGL_DEBUG, "RAND=%s\n", osmo_hexdump_nospc(v->rand, sizeof(v->rand)));
+		LOGP(DMAIN, LOGL_DEBUG, "AUTN=%s\n", osmo_hexdump_nospc(v->autn, sizeof(v->autn)));
+		LOGP(DMAIN, LOGL_DEBUG, "CK=%s\n", osmo_hexdump_nospc(v->ck, sizeof(v->ck)));
+		LOGP(DMAIN, LOGL_DEBUG, "IK=%s\n", osmo_hexdump_nospc(v->ik, sizeof(v->ik)));
+		LOGP(DMAIN, LOGL_DEBUG, "RES=%s\n", osmo_hexdump_nospc(v->res, v->res_len));
+		LOGP(DMAIN, LOGL_DEBUG, "Kc=%s\n", osmo_hexdump_nospc(v->kc, sizeof(v->kc)));
+		LOGP(DMAIN, LOGL_DEBUG, "SRES=%s\n", osmo_hexdump_nospc(v->sres, sizeof(v->sres)));
+	}
+
+	return rc;
+}
+
+int main(int argc, char **argv)
+{
+	int rc;
+
+	rc = osmo_init_logging(&hlr_log_info);
+	if (rc < 0) {
+		fprintf(stderr, "Error initializing logging\n");
+		exit(1);
+	}
+	LOGP(DMAIN, LOGL_NOTICE, "hlr starting\n");
+
+	rc = rand_init();
+	if (rc < 0) {
+		LOGP(DMAIN, LOGL_ERROR, "Error initializing random source\n");
+		exit(1);
+	}
+
+	g_dbc = db_open(NULL, "hlr.db");
+	if (!g_dbc) {
+		LOGP(DMAIN, LOGL_ERROR, "Error opening database\n");
+		exit(1);
+	}
+
+	/* non-existing subscriber */
+	rc = test("901990123456789");
+	/* 2G only AUC data (COMP128v1 / MILENAGE) */
+	rc = test("901990000000001");
+	/* 2G + 3G AUC data (COMP128v1 / MILENAGE) */
+	rc = test("901990000000002");
+	/* 3G AUC data (MILENAGE) */
+	rc = test("901990000000003");
+
+	LOGP(DMAIN, LOGL_NOTICE, "Exiting\n");
+
+	db_close(g_dbc);
+
+	log_fini();
+
+	exit(0);
+}
diff --git a/src/gsup_server.c b/src/gsup_server.c
new file mode 100644
index 0000000..41a03f4
--- /dev/null
+++ b/src/gsup_server.c
@@ -0,0 +1,204 @@
+#include <errno.h>
+
+#include <osmocom/core/msgb.h>
+#include <osmocom/core/logging.h>
+#include <osmocom/core/linuxlist.h>
+#include <osmocom/abis/ipa.h>
+#include <osmocom/abis/ipaccess.h>
+
+#include "gsup_server.h"
+
+static void osmo_gsup_server_send(struct osmo_gsup_conn *conn,
+			     int proto_ext, struct msgb *msg_tx)
+{
+	ipa_prepend_header_ext(msg_tx, proto_ext);
+	ipa_msg_push_header(msg_tx, IPAC_PROTO_OSMO);
+	ipa_server_conn_send(conn->conn, msg_tx);
+}
+
+int osmo_gsup_conn_send(struct osmo_gsup_conn *conn, struct msgb *msg)
+{
+	if (!conn) {
+		msgb_free(msg);
+		return -ENOTCONN;
+	}
+
+	osmo_gsup_server_send(conn, IPAC_PROTO_EXT_GSUP, msg);
+
+	return 0;
+}
+
+static int osmo_gsup_conn_oap_handle(struct osmo_gsup_conn *conn,
+				struct msgb *msg_rx)
+{
+	int rc;
+	struct msgb *msg_tx;
+#if 0
+	rc = oap_handle(&conn->oap_state, msg_rx, &msg_tx);
+	msgb_free(msg_rx);
+	if (rc < 0)
+		return rc;
+
+	if (msg_tx)
+		osmo_gsup_conn_send(conn, IPAC_PROTO_EXT_OAP, msg_tx);
+#endif
+	return 0;
+}
+
+
+/* Data from a given client has arrived over the socket */
+static int osmo_gsup_server_read_cb(struct ipa_server_conn *conn,
+			       struct msgb *msg)
+{
+	struct ipaccess_head *hh = (struct ipaccess_head *) msg->data;
+	struct ipaccess_head_ext *he = (struct ipaccess_head_ext *) msgb_l2(msg);
+	struct osmo_gsup_conn *clnt = (struct osmo_gsup_conn *)conn->data;
+	int rc;
+	static struct ipaccess_unit ipa_dev = {
+		.unit_name = "HLR",
+		/* FIXME */
+	};
+
+	msg->l2h = &hh->data[0];
+
+	/* FIXME: not BTS for server side? */
+#if 0
+	rc = ipaccess_bts_handle_ccm(conn, &ipa_dev, msg);
+
+	if (rc < 0) {
+		LOGP(DLGSUP, LOGL_NOTICE,
+		     "GSUP received an invalid IPA/CCM message from %s:%d\n",
+		     conn->addr, conn->port);
+		/* Link has been closed */
+		clnt->is_connected = 0;
+		msgb_free(msg);
+		return -1;
+	}
+
+	if (rc == 1) {
+		uint8_t msg_type = *(msg->l2h);
+		/* CCM message */
+		if (msg_type == IPAC_MSGT_PONG) {
+			LOGP(DLGSUP, LOGL_DEBUG, "GSUP receiving PONG\n");
+			clnt->got_ipa_pong = 1;
+		}
+
+		msgb_free(msg);
+		return 0;
+	}
+#endif
+
+	if (hh->proto != IPAC_PROTO_OSMO)
+		goto invalid;
+
+	if (!he || msgb_l2len(msg) < sizeof(*he))
+		goto invalid;
+
+	msg->l2h = &he->data[0];
+
+	if (he->proto == IPAC_PROTO_EXT_GSUP) {
+		OSMO_ASSERT(clnt->server->read_cb != NULL);
+		clnt->server->read_cb(clnt, msg);
+		/* expecting read_cb() to free msg */
+	} else if (he->proto == IPAC_PROTO_EXT_OAP) {
+		return osmo_gsup_conn_oap_handle(clnt, msg);
+		/* osmo_gsup_client_oap_handle frees msg */
+	} else
+		goto invalid;
+
+	return 0;
+
+invalid:
+	LOGP(DLGSUP, LOGL_NOTICE,
+	     "GSUP received an invalid IPA message from %s:%d, size = %d\n",
+	     conn->addr, conn->port, msgb_length(msg));
+	msgb_free(msg);
+	return -1;
+
+}
+
+static int osmo_gsup_server_closed_cb(struct ipa_server_conn *conn)
+{
+	struct osmo_gsup_conn *clnt = (struct osmo_gsup_conn *)conn->data;
+
+	LOGP(DLGSUP, LOGL_INFO, "Lost GSUP client %s:%d\n",
+		conn->addr, conn->port);
+
+	llist_del(&clnt->list);
+
+	return 0;
+}
+
+/* a client has connected to the server socket and we have accept()ed it */
+static int osmo_gsup_server_accept_cb(struct ipa_server_link *link, int fd)
+{
+	struct osmo_gsup_conn *conn;
+	struct osmo_gsup_server *gsups =
+		(struct osmo_gsup_server *) link->data;
+
+	conn = talloc_zero(link->data, struct osmo_gsup_conn);
+	OSMO_ASSERT(conn);
+
+	conn->conn = ipa_server_conn_create(conn, link, fd,
+					   osmo_gsup_server_read_cb,
+					   osmo_gsup_server_closed_cb, conn);
+	OSMO_ASSERT(conn->conn);
+
+	/* link data structure with server structure */
+	conn->server = gsups;
+	llist_add_tail(&conn->list, &gsups->clients);
+
+	LOGP(DLGSUP, LOGL_INFO, "New GSUP client %s:%d\n",
+		conn->conn->addr, conn->conn->port);
+#if 0
+	rc = oap_init(&gsups->oap_config, &conn->oap_state);
+	if (rc != 0)
+		goto failed;
+failed:
+#endif
+	return 0;
+}
+
+struct osmo_gsup_server *
+osmo_gsup_server_create(void *ctx, const char *ip_addr,
+			uint16_t tcp_port,
+			osmo_gsup_read_cb_t read_cb)
+{
+	struct osmo_gsup_server *gsups;
+	int rc;
+
+	gsups = talloc_zero(ctx, struct osmo_gsup_server);
+	OSMO_ASSERT(gsups);
+
+	INIT_LLIST_HEAD(&gsups->clients);
+
+	gsups->link = ipa_server_link_create(gsups,
+					/* no e1inp */ NULL,
+					ip_addr, tcp_port,
+					osmo_gsup_server_accept_cb,
+					gsups);
+	if (!gsups->link)
+		goto failed;
+
+	gsups->read_cb = read_cb;
+
+	rc = ipa_server_link_open(gsups->link);
+	if (rc < 0)
+		goto failed;
+
+	return gsups;
+
+failed:
+	osmo_gsup_server_destroy(gsups);
+	return NULL;
+}
+
+void osmo_gsup_server_destroy(struct osmo_gsup_server *gsups)
+{
+	if (gsups->link) {
+		ipa_server_link_close(gsups->link);
+		ipa_server_link_destroy(gsups->link);
+		gsups->link = NULL;
+	}
+	talloc_free(gsups);
+}
diff --git a/src/gsup_server.h b/src/gsup_server.h
new file mode 100644
index 0000000..390bf2e
--- /dev/null
+++ b/src/gsup_server.h
@@ -0,0 +1,40 @@
+#pragma once
+
+#include <osmocom/core/linuxlist.h>
+#include <osmocom/core/msgb.h>
+#include <osmocom/abis/ipa.h>
+#include <osmocom/abis/ipaccess.h>
+
+struct osmo_gsup_conn;
+
+/* Expects message in msg->l2h */
+typedef int (*osmo_gsup_read_cb_t)(struct osmo_gsup_conn *conn, struct msgb *msg);
+
+struct osmo_gsup_server {
+	/* list of osmo_gsup_conn */
+	struct llist_head clients;
+
+	struct ipa_server_link *link;
+	osmo_gsup_read_cb_t read_cb;
+};
+
+
+/* a single connection to a given client (SGSN, MSC) */
+struct osmo_gsup_conn {
+	struct llist_head list;
+
+	struct osmo_gsup_server *server;
+	struct ipa_server_conn *conn;
+	//struct oap_state oap_state;
+};
+
+
+int osmo_gsup_conn_send(struct osmo_gsup_conn *conn, struct msgb *msg);
+
+struct osmo_gsup_server *osmo_gsup_server_create(void *ctx,
+					const char *ip_addr,
+					uint16_t tcp_port,
+					osmo_gsup_read_cb_t read_cb);
+
+void osmo_gsup_server_destroy(struct osmo_gsup_server *gsups);
+
diff --git a/src/hlr.c b/src/hlr.c
new file mode 100644
index 0000000..be0e96e
--- /dev/null
+++ b/src/hlr.c
@@ -0,0 +1,109 @@
+#include <osmocom/core/msgb.h>
+#include <osmocom/core/logging.h>
+#include <osmocom/core/application.h>
+#include <osmocom/gsm/gsup.h>
+
+#include "db.h"
+#include "logging.h"
+#include "gsup_server.h"
+#include "rand.h"
+
+static struct db_context *g_dbc;
+
+/* process an incoming SAI request */
+static int rx_send_auth_info(struct osmo_gsup_conn *conn,
+			     const struct osmo_gsup_message *gsup)
+{
+	struct osmo_gsup_message gsup_out;
+	struct msgb *msg_out;
+	int rc;
+
+	/* initialize return message structure */
+	memset(&gsup_out, 0, sizeof(gsup_out));
+	gsup_out.message_type = OSMO_GSUP_MSGT_SEND_AUTH_INFO_RESULT;
+	memcpy(&gsup_out.imsi, &gsup->imsi, sizeof(gsup_out.imsi));
+
+	rc = db_get_auc(g_dbc, gsup->imsi, gsup_out.auth_vectors,
+			ARRAY_SIZE(gsup_out.auth_vectors),
+			NULL /* gsup->rand_auts */, gsup->auts);
+	if (rc <= 0) {
+		gsup_out.message_type = OSMO_GSUP_MSGT_SEND_AUTH_INFO_ERROR;
+	}
+
+	msg_out = msgb_alloc(1024, "GSUP response");
+	osmo_gsup_encode(msg_out, &gsup_out);
+	return osmo_gsup_conn_send(conn, msg_out);
+}
+
+static int read_cb(struct osmo_gsup_conn *conn, struct msgb *msg)
+{
+	static struct osmo_gsup_message gsup;
+	int rc;
+
+	rc = osmo_gsup_decode(msgb_l3(msg), msgb_l3len(msg), &gsup);
+	if (rc < 0) {
+		LOGP(DMAIN, LOGL_ERROR, "error in GSUP decode: %d\n", rc);
+		return rc;
+	}
+
+	switch (gsup.message_type) {
+	/* requests sent to us */
+	case OSMO_GSUP_MSGT_SEND_AUTH_INFO_REQUEST:
+		rx_send_auth_info(conn, &gsup);
+		break;
+	case OSMO_GSUP_MSGT_UPDATE_LOCATION_REQUEST:
+		break;
+	/* responses to requests sent by us */
+	case OSMO_GSUP_MSGT_INSERT_DATA_ERROR:
+		break;
+	case OSMO_GSUP_MSGT_INSERT_DATA_RESULT:
+		break;
+	default:
+		LOGP(DMAIN, LOGL_DEBUG, "Unhandled GSUP message type %u\n",
+			gsup.message_type);
+		break;
+	}
+	return 0;
+}
+
+
+int main(int argc, char **argv)
+{
+	struct osmo_gsup_server *gs;
+	int rc;
+
+	rc = osmo_init_logging(&hlr_log_info);
+	if (rc < 0) {
+		fprintf(stderr, "Error initializing logging\n");
+		exit(1);
+	}
+	LOGP(DMAIN, LOGL_NOTICE, "hlr starting\n");
+
+	rc = rand_init();
+	if (rc < 0) {
+		LOGP(DMAIN, LOGL_FATAL, "Error initializing random source\n");
+		exit(1);
+	}
+
+	g_dbc = db_open(NULL, "hlr.db");
+	if (!g_dbc) {
+		LOGP(DMAIN, LOGL_FATAL, "Error opening database\n");
+		exit(1);
+	}
+
+	gs = osmo_gsup_server_create(NULL, NULL, 2222, read_cb);
+	if (!gs) {
+		LOGP(DMAIN, LOGL_FATAL, "Error starting GSUP server\n");
+		exit(1);
+	}
+
+	while (1) {
+		osmo_select_main(0);
+	}
+
+	db_close(g_dbc);
+
+	log_fini();
+
+	exit(0);
+}
diff --git a/src/logging.c b/src/logging.c
new file mode 100644
index 0000000..54c8900
--- /dev/null
+++ b/src/logging.c
@@ -0,0 +1,33 @@
+#include <osmocom/core/utils.h>
+#include "logging.h"
+
+const struct log_info_cat hlr_log_info_cat[] = {
+	[DMAIN] = {
+		.name = "DMAIN",
+		.description = "Main Program",
+		.enabled = 1, .loglevel = LOGL_DEBUG,
+	},
+	[DDB] = {
+		.name = "DDB",
+		.description = "Database Layer",
+		.color = "\033[1;31m",
+		.enabled = 1, .loglevel = LOGL_DEBUG,
+	},
+	[DLGSUP] = {
+		.name = "DLGSUP",
+		.description = "GSUP Protocol",
+		.color = "\033[1;32m",
+		.enabled = 1, .loglevel = LOGL_INFO,
+	},
+	[DAUC] = {
+		.name = "DAUC",
+		.description = "Authentication Center",
+		.color = "\033[1;33m",
+		.enabled = 1, .loglevel = LOGL_DEBUG,
+	},
+};
+
+const struct log_info hlr_log_info = {
+	.cat = hlr_log_info_cat,
+	.num_cat = ARRAY_SIZE(hlr_log_info_cat),
+};
diff --git a/src/logging.h b/src/logging.h
new file mode 100644
index 0000000..fdaf5d1
--- /dev/null
+++ b/src/logging.h
@@ -0,0 +1,12 @@
+#pragma once
+
+#include <osmocom/core/logging.h>
+
+enum {
+	DMAIN,
+	DDB,
+	DGSUP,
+	DAUC,
+};
+
+extern const struct log_info hlr_log_info;
diff --git a/src/rand.h b/src/rand.h
new file mode 100644
index 0000000..9c5aedf
--- /dev/null
+++ b/src/rand.h
@@ -0,0 +1,7 @@
+#pragma once
+
+#include <stdint.h>
+
+int rand_init(void);
+
+int rand_get(uint8_t *rand, unsigned int len);
diff --git a/src/rand_fake.c b/src/rand_fake.c
new file mode 100644
index 0000000..ad0cc68
--- /dev/null
+++ b/src/rand_fake.c
@@ -0,0 +1,52 @@
+/* (C) 2012 by Harald Welte <laforge@gnumonks.org>
+ *
+ * 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 <stdio.h>
+#include <string.h>
+#include <fcntl.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <sys/stat.h>
+
+static uint8_t ctr = 0;
+
+static void print_msg(void)
+{
+	static int printed = 0;
+	if (!printed) {
+		fprintf(stderr, "Using fake random generator for deterministic "
+			"test results. NEVER USE THIS IN PRODUCTION\n");
+		printed = 1;
+	}
+}
+
+int rand_init(void)
+{
+	print_msg();
+	return 0;
+}
+
+int rand_get(uint8_t *rand, unsigned int len)
+{
+	print_msg();
+	memset(rand, ctr, len);
+	ctr++;
+	return len;
+}
diff --git a/src/rand_urandom.c b/src/rand_urandom.c
new file mode 100644
index 0000000..68243ca
--- /dev/null
+++ b/src/rand_urandom.c
@@ -0,0 +1,38 @@
+/* (C) 2012 by Harald Welte <laforge@gnumonks.org>
+ *
+ * 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 <stdio.h>
+#include <fcntl.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <sys/stat.h>
+
+static int rand_fd = -1;
+int rand_init(void)
+{
+	rand_fd = open("/dev/urandom", O_RDONLY);
+
+	return rand_fd;
+}
+
+int rand_get(uint8_t *rand, unsigned int len)
+{
+	return read(rand_fd, rand, len);
+}