cellular-infrastructure
/
osmo-hlr
mirror of https://gerrit.osmocom.org/osmo-hlr
8
0
Fork 0
Code Issues Releases Wiki Activity

initial import of osmo-gsup-hlr code so far

changes/03/1403/1
Harald Welte 2016-04-28 07:18:49 +02:00
commit e72cf55347
18 changed files with 1145 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.gitignore vendored Normal file
View File

@ -0,0 +1,4 @@
*.o
*.db
src/hlr
src/db_test

67
sql/hlr.sql Normal file
View File

@ -0,0 +1,67 @@
--modelled roughly after TS 23.008 version 13.3.0
CREATE TABLE subscriber (
id INTEGER PRIMARY KEY,
-- Chapter 2.1.1.1
imsi VARCHAR(15) NOT NULL,
-- Chapter 2.1.2
msisdn VARCHAR(15),
-- Chapter 2.2.3: Most recent / current IMEI
imeisv VARCHAR,
-- Chapter 2.4.5
vlr_number VARCHAR(15),
-- Chapter 2.4.6
hlr_number VARCHAR(15),
-- Chapter 2.4.8.1
sgsn_number VARCHAR(15),
-- Chapter 2.13.10
sgsn_address VARCHAR,
-- Chapter 2.4.8.2
ggsn_number VARCHAR(15),
-- Chapter 2.4.9.2
gmlc_number VARCHAR(15),
-- Chapter 2.4.23
smsc_number VARCHAR(15),
-- Chapter 2.4.24
periodic_lu_tmr INTEGER,
-- Chapter 2.13.115
periodic_rau_tau_tmr INTEGER,
-- Chapter 2.1.1.2: network access mode
nam_cs BOOLEAN NOT NULL DEFAULT TRUE,
nam_ps BOOLEAN NOT NULL DEFAULT TRUE,
-- Chapter 2.1.8
lmsi INTEGER,
-- Chapter 2.7.5
ms_purged_cs BOOLEAN NOT NULL DEFAULT FALSE,
-- Chapter 2.7.6
ms_purged_ps BOOLEAN NOT NULL DEFAULT FALSE
);
CREATE TABLE subscriber_apn (
subscriber_id INTEGER, -- subscriber.id
apn VARCHAR(256) NOT NULL
);
-- Chapter 2.1.3
CREATE TABLE subscriber_multi_msisdn (
subscriber_id INTEGER, -- subscriber.id
msisdn VARCHAR(15) NOT NULL
);
CREATE TABLE auc_2g (
subscriber_id INTEGER PRIMARY KEY, -- subscriber.id
algo_id_2g INTEGER NOT NULL,
ki VARCHAR NOT NULL
);
CREATE TABLE auc_3g (
subscriber_id INTEGER PRIMARY KEY, -- subscrbier.id
algo_id_3g INTEGER NOT NULL,
k INTEGER NOT NULL,
op VARCHAR,
opc VARCHAR,
sqn INTEGER
);
-- SELECT 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 = ?

13
sql/hlr_data.sql Normal file
View File

@ -0,0 +1,13 @@
-- 2G only subscriber
INSERT INTO subscriber (id, imsi) VALUES (1, '901990000000001');
INSERT INTO auc_2g (subscriber_id, algo_id_2g, ki) VALUES (1, 1, '000102030405060708090a0b0c0d0e0f');
-- 3G only subscriber
INSERT INTO subscriber (id, imsi) VALUES (2, '901990000000002');
INSERT INTO auc_3g (subscriber_id, algo_id_3g, k, op, sqn) VALUES (2, 5, '000102030405060708090a0b0c0d0e0f', '101112131415161718191a1b1c1d1e1f', 0);
-- 2G + 3G subscriber
INSERT INTO subscriber (id, imsi) VALUES (3, '901990000000003');
INSERT INTO auc_2g (subscriber_id, algo_id_2g, ki) VALUES (3, 1, '000102030405060708090a0b0c0d0e0f');
INSERT INTO auc_3g (subscriber_id, algo_id_3g, k, op, sqn) VALUES (3, 5, '000102030405060708090a0b0c0d0e0f', '101112131415161718191a1b1c1d1e1f', 0);

16
src/Makefile Normal file
View File

@ -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

94
src/auc.c Normal file
View File

@ -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;
}

8
src/auc.h Normal file
View File

@ -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);

121
src/db.c Normal file
View File

@ -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;
}

35
src/db.h Normal file
View File

@ -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);

208
src/db_auc.c Normal file
View File

@ -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;
}

84
src/db_test.c Normal file
View File

@ -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);
}

204
src/gsup_server.c Normal file
View File

@ -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);
}

40
src/gsup_server.h Normal file
View File

@ -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);

109
src/hlr.c Normal file
View File

@ -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);
}

33
src/logging.c Normal file
View File

@ -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),
};

12
src/logging.h Normal file
View File

@ -0,0 +1,12 @@
#pragma once
#include <osmocom/core/logging.h>
enum {
DMAIN,
DDB,
DGSUP,
DAUC,
};
extern const struct log_info hlr_log_info;

7
src/rand.h Normal file
View File

@ -0,0 +1,7 @@
#pragma once
#include <stdint.h>
int rand_init(void);
int rand_get(uint8_t *rand, unsigned int len);

52
src/rand_fake.c Normal file
View File

@ -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;
}

38
src/rand_urandom.c Normal file
View File

@ -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);
}