/* Initalize data compression */
int gprs_sndcp_dcomp_init(const void *ctx, struct gprs_sndcp_comp *comp_entity,
const struct gprs_sndcp_comp_field *comp_field)
{
/* Note: This function is automatically called from
* gprs_sndcp_comp.c when a new data compression
* entity is created by gprs_sndcp.c */
OSMO_ASSERT(comp_entity);
OSMO_ASSERT(comp_field);
if (comp_entity->compclass == SNDCP_XID_DATA_COMPRESSION
&& comp_entity->algo == V42BIS) {
OSMO_ASSERT(comp_field->v42bis_params);
comp_entity->state =
v42bis_init(ctx, NULL, comp_field->v42bis_params->p0,
comp_field->v42bis_params->p1,
comp_field->v42bis_params->p2,
&tx_v42bis_frame_handler, NULL,
V42BIS_MAX_OUTPUT_LENGTH,
&rx_v42bis_data_handler, NULL,
V42BIS_MAX_OUTPUT_LENGTH);
LOGP(DSNDCP, LOGL_INFO,
"V.42bis data compression initalized.\n");
return 0;
}
/* Just in case someone tries to initalize an unknown or unsupported
* data compresson. Since everything is checked during the SNDCP
* negotiation process, this should never happen! */
OSMO_ASSERT(false);
}
int main(int argc, char **argv)
{
struct log_target *stderr_target;
log_init(&log_info, NULL);
stderr_target = log_target_create_stderr();
log_add_target(stderr_target);
log_set_all_filter(stderr_target, 1);
log_set_print_filename(stderr_target, 0);
log_parse_category_mask(stderr_target, "DRLL:DCC");
log_parse_category_mask(stderr_target, "DRLL");
DEBUGP(DCC, "You should not see this\n");
log_parse_category_mask(stderr_target, "DRLL:DCC");
DEBUGP(DRLL, "You should see this\n");
DEBUGP(DCC, "You should see this\n");
DEBUGP(DMM, "You should not see this\n");
OSMO_ASSERT(filter_called == 0);
log_set_all_filter(stderr_target, 0);
DEBUGP(DRLL, "You should not see this and filter is called\n");
OSMO_ASSERT(filter_called == 1);
return 0;
}
void test_replay_gprs_data(struct gprs_bssgp_pcu *pcu, struct msgb *msg, struct tlv_parsed *tp)
{
struct bssgp_ud_hdr *budh;
struct gprs_llc_hdr_parsed ph;
uint32_t tlli;
if (!TLVP_PRESENT(tp, BSSGP_IE_LLC_PDU))
return;
gprs_llc_hdr_parse(&ph, TLVP_VAL(tp, BSSGP_IE_LLC_PDU),
TLVP_LEN(tp, BSSGP_IE_LLC_PDU));
budh = (struct bssgp_ud_hdr *)msgb_bssgph(msg);
tlli = ntohl(budh->tlli);
/* all messages we should get, should be for a foreign tlli */
OSMO_ASSERT(gprs_tlli_type(tlli) == TLLI_FOREIGN);
printf("TLLI(0x%08x) is foreign!\n", tlli);
OSMO_ASSERT(ph.cmd == GPRS_LLC_UI);
OSMO_ASSERT(ph.sapi == 1);
OSMO_ASSERT(ph.seq_tx == next_wanted_nu++);
/* this test just wants to see messages... no further data is sent */
if (next_wanted_nu == 6) {
printf("GPRS attach with increasing N(U) done.\n");
gprs_test_success(pcu);
}
}
static void test_auth_reuse_key_seq_mismatch()
{
int auth_action;
struct gsm_auth_tuple atuple = {0};
struct gsm_subscriber subscr = {0};
int key_seq;
printf("\n* test_auth_reuse_key_seq_mismatch()\n");
/* Ki entry, auth tuple negotiated, valid+matching incoming key_seq */
test_auth_info = default_auth_info;
test_last_auth_tuple = default_auth_tuple;
test_last_auth_tuple.key_seq = 3;
key_seq = 4;
test_last_auth_tuple.use_count = 1;
test_get_authinfo_rc = 0;
test_get_lastauthtuple_rc = 0;
auth_action = auth_get_tuple_for_subscr_verbose(&atuple, &subscr,
key_seq);
OSMO_ASSERT(auth_action == AUTH_DO_AUTH_THEN_CIPH);
OSMO_ASSERT(auth_tuple_is(&atuple,
"gsm_auth_tuple {\n"
" .use_count = 1\n"
" .key_seq = 4\n"
" .rand = 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17 \n"
" .sres = a1 ab c6 90 \n"
" .kc = 0f 27 ed f3 ac 97 ac 00 \n"
"}\n"
));
}
static void test_sms_migrate(void)
{
struct gsm_subscriber *rcv_subscr;
struct gsm_sms *sms;
static const uint8_t user_data_1[] = {
0x41, 0xf1, 0xd8, 0x05, 0x22, 0x96, 0xcd, 0x2e,
0x90, 0xf1, 0xfd, 0x06, 0x00 };
static const uint8_t user_data_2[] = {
0x41, 0xf1, 0xd8, 0x05, 0x22, 0x96, 0xcd, 0x2e,
0xd0, 0xf1, 0xfd, 0x06, 0x00 };
rcv_subscr = db_get_subscriber(GSM_SUBSCRIBER_IMSI, "901010000001111");
rcv_subscr->group = &dummy_sgrp;
sms = db_sms_get(&dummy_net, 1);
OSMO_ASSERT(sms->id == 1);
OSMO_ASSERT(sms->receiver == rcv_subscr);
OSMO_ASSERT(strcmp(sms->text, "Abc. Def. Foo") == 0);
OSMO_ASSERT(sms->user_data_len == ARRAY_SIZE(user_data_1));
OSMO_ASSERT(memcmp(sms->user_data, user_data_1, ARRAY_SIZE(user_data_1)) == 0);
sms_free(sms);
sms = db_sms_get(&dummy_net, 2);
OSMO_ASSERT(sms->id == 2);
OSMO_ASSERT(sms->receiver == rcv_subscr);
OSMO_ASSERT(strcmp(sms->text, "Abc. Def. Goo") == 0);
OSMO_ASSERT(sms->user_data_len == ARRAY_SIZE(user_data_2));
OSMO_ASSERT(memcmp(sms->user_data, user_data_2, ARRAY_SIZE(user_data_2)) == 0);
sms_free(sms);
subscr_put(rcv_subscr);
}
static void test_fsm_tmr_cb(struct osmo_fsm_inst *fi)
{
OSMO_ASSERT(fi->T == 2342);
OSMO_ASSERT(fi->state == ST_TWO);
LOGP(DMAIN, LOGL_INFO, "Timer\n");
exit(0);
}
int main(int argc, char **argv)
{
struct ss_request req;
const int size = sizeof(ussd_request);
int i;
struct msgb *msg;
osmo_init_logging(&info);
memset(&req, 0, sizeof(req));
gsm0480_decode_ss_request((struct gsm48_hdr *) ussd_request, size, &req);
printf("Tested if it still works. Text was: %s\n", req.ussd_text);
memset(&req, 0, sizeof(req));
gsm0480_decode_ss_request((struct gsm48_hdr *) interrogate_ss, size, &req);
OSMO_ASSERT(strlen((char *) req.ussd_text) == 0);
OSMO_ASSERT(req.ss_code == 33);
printf("interrogateSS CFU text..'%s' code %d\n", req.ussd_text, req.ss_code);
printf("Testing parsing a USSD request and truncated versions\n");
for (i = size; i > sizeof(struct gsm48_hdr); --i) {
int rc = parse_ussd(&ussd_request[0], i);
printf("Result for %d is %d\n", rc, i);
}
printf("Mangling the container now\n");
for (i = size; i > sizeof(struct gsm48_hdr) + 2; --i) {
int rc = parse_mangle_ussd(&ussd_request[0], i);
printf("Result for %d is %d\n", rc, i);
}
printf("<CR> case test for 7 bit encode\n");
test_7bit_ussd("01234567", "b0986c46abd96e", "");
test_7bit_ussd("0123456", "b0986c46abd91a", "");
test_7bit_ussd("01234567\r", "b0986c46abd96e0d", "");
/* The appended \r is compliant to GSM 03.38 section 6.1.2.3.1: */
test_7bit_ussd("0123456\r", "b0986c46abd91a0d", "\r");
test_7bit_ussd("012345\r", "b0986c46ab351a", "");
printf("Checking GSM 04.80 USSD message generation.\n");
test_7bit_ussd("", "", "");
msg = gsm0480_create_unstructuredSS_Notify (0x00, "");
printf ("Created unstructuredSS_Notify (0x00): %s\n",
osmo_hexdump(msgb_data(msg), msgb_length(msg)));
msgb_free (msg);
test_7bit_ussd("forty-two", "e6b79c9e6fd1ef6f", "");
msg = gsm0480_create_unstructuredSS_Notify (0x42, "forty-two");
printf ("Created unstructuredSS_Notify (0x42): %s\n",
osmo_hexdump(msgb_data(msg), msgb_length(msg)));
msgb_free (msg);
return 0;
}
static void test_fsm_null(struct osmo_fsm_inst *fi, uint32_t event, void *data)
{
switch (event) {
case EV_A:
OSMO_ASSERT(data == (void *) 23);
osmo_fsm_inst_state_chg(fi, ST_ONE, 0, 0);
break;
default:
OSMO_ASSERT(0);
break;
}
}
static void test_fsm_one(struct osmo_fsm_inst *fi, uint32_t event, void *data)
{
switch (event) {
case EV_B:
OSMO_ASSERT(data == (void *) 42);
osmo_fsm_inst_state_chg(fi,ST_TWO, 1, 2342);
break;
default:
OSMO_ASSERT(0);
break;
}
}
static void test_auth_then_ciph1()
{
int auth_action;
struct gsm_auth_tuple atuple = {0};
struct gsm_subscriber subscr = {0};
int key_seq;
printf("\n* test_auth_then_ciph1()\n");
/* Ki entry, but no auth tuple negotiated yet */
test_auth_info = default_auth_info;
test_last_auth_tuple = default_auth_tuple;
test_get_authinfo_rc = 0;
test_get_lastauthtuple_rc = -ENOENT;
key_seq = 0;
auth_action = auth_get_tuple_for_subscr_verbose(&atuple, &subscr,
key_seq);
OSMO_ASSERT(auth_action == AUTH_DO_AUTH_THEN_CIPH);
OSMO_ASSERT(auth_tuple_is(&atuple,
"gsm_auth_tuple {\n"
" .use_count = 1\n"
" .key_seq = 0\n"
" .rand = 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17 \n"
" .sres = a1 ab c6 90 \n"
" .kc = 0f 27 ed f3 ac 97 ac 00 \n"
"}\n"
));
/* With a different last saved key_seq stored in the out-arg of
* db_get_lastauthtuple_for_subscr() by coincidence, expect absolutely
* the same as above. */
test_auth_info = default_auth_info;
test_last_auth_tuple = default_auth_tuple;
test_last_auth_tuple.key_seq = 3;
test_get_authinfo_rc = 0;
test_get_lastauthtuple_rc = -ENOENT;
key_seq = 0;
auth_action = auth_get_tuple_for_subscr_verbose(&atuple, &subscr,
key_seq);
OSMO_ASSERT(auth_action == AUTH_DO_AUTH_THEN_CIPH);
OSMO_ASSERT(auth_tuple_is(&atuple,
"gsm_auth_tuple {\n"
" .use_count = 1\n"
" .key_seq = 0\n"
" .rand = 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17 \n"
" .sres = a1 ab c6 90 \n"
" .kc = 0f 27 ed f3 ac 97 ac 00 \n"
"}\n"
));
}
static int foo(void)
{
struct osmo_fsm_inst *fi;
LOGP(DMAIN, LOGL_INFO, "Checking FSM allocation\n");
fi = osmo_fsm_inst_alloc(&fsm, g_ctx, NULL, LOGL_DEBUG, NULL);
OSMO_ASSERT(fi);
OSMO_ASSERT(fi->fsm == &fsm);
OSMO_ASSERT(!strncmp(osmo_fsm_inst_name(fi), fsm.name, strlen(fsm.name)));
OSMO_ASSERT(fi->state == ST_NULL);
OSMO_ASSERT(fi->log_level == LOGL_DEBUG);
/* Try invalid state transition */
osmo_fsm_inst_dispatch(fi, EV_B, (void *) 42);
OSMO_ASSERT(fi->state == ST_NULL);
/* Legitimate state transition */
osmo_fsm_inst_dispatch(fi, EV_A, (void *) 23);
OSMO_ASSERT(fi->state == ST_ONE);
/* Legitimate transition with timer */
fsm.timer_cb = test_fsm_tmr_cb;
osmo_fsm_inst_dispatch(fi, EV_B, (void *) 42);
OSMO_ASSERT(fi->state == ST_TWO);
return 0;
}
static void test_auth_then_ciph2()
{
int auth_action;
struct gsm_auth_tuple atuple = {0};
struct gsm_subscriber subscr = {0};
int key_seq;
printf("\n* test_auth_then_ciph2()\n");
/* Ki entry, auth tuple negotiated, but invalid incoming key_seq */
test_auth_info = default_auth_info;
test_last_auth_tuple = default_auth_tuple;
test_last_auth_tuple.key_seq = 2;
test_get_authinfo_rc = 0;
test_get_lastauthtuple_rc = 0;
key_seq = GSM_KEY_SEQ_INVAL;
auth_action = auth_get_tuple_for_subscr_verbose(&atuple, &subscr,
key_seq);
OSMO_ASSERT(auth_action == AUTH_DO_AUTH_THEN_CIPH);
OSMO_ASSERT(auth_tuple_is(&atuple,
"gsm_auth_tuple {\n"
" .use_count = 1\n"
" .key_seq = 3\n"
" .rand = 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17 \n"
" .sres = a1 ab c6 90 \n"
" .kc = 0f 27 ed f3 ac 97 ac 00 \n"
"}\n"
));
/* Change the last saved key_seq, expect last_auth_tuple.key_seq + 1 */
test_auth_info = default_auth_info;
test_last_auth_tuple = default_auth_tuple;
test_last_auth_tuple.key_seq = 3;
test_get_authinfo_rc = 0;
test_get_lastauthtuple_rc = 0;
key_seq = GSM_KEY_SEQ_INVAL;
auth_action = auth_get_tuple_for_subscr_verbose(&atuple, &subscr,
key_seq);
OSMO_ASSERT(auth_action == AUTH_DO_AUTH_THEN_CIPH);
OSMO_ASSERT(auth_tuple_is(&atuple,
"gsm_auth_tuple {\n"
" .use_count = 1\n"
" .key_seq = 4\n"
" .rand = 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17 \n"
" .sres = a1 ab c6 90 \n"
" .kc = 0f 27 ed f3 ac 97 ac 00 \n"
"}\n"
));
}
static void test_bssgp_suspend_resume(void)
{
const uint32_t tlli = 0xf0123456;
printf("----- %s START\n", __func__);
memset(&last_oph, 0, sizeof(last_oph));
send_bssgp_supend(BSSGP_PDUT_SUSPEND, tlli);
OSMO_ASSERT(last_oph.primitive == PRIM_BSSGP_GMM_SUSPEND);
send_bssgp_resume(BSSGP_PDUT_RESUME, tlli);
OSMO_ASSERT(last_oph.primitive == PRIM_BSSGP_GMM_RESUME);
printf("----- %s END\n", __func__);
}
/* Expand packet */
int gprs_sndcp_dcomp_expand(uint8_t *data, unsigned int len, uint8_t pcomp,
const struct llist_head *comp_entities)
{
int rc;
uint8_t pcomp_index = 0;
struct gprs_sndcp_comp *comp_entity;
OSMO_ASSERT(data);
OSMO_ASSERT(comp_entities);
LOGP(DSNDCP, LOGL_DEBUG,
"Data compression entity list: comp_entities=%p\n", comp_entities);
LOGP(DSNDCP, LOGL_DEBUG, "Data compression mode: dcomp=%d\n", pcomp);
/* Skip on pcomp=0 */
if (pcomp == 0) {
return len;
}
/* Find out which compression entity handles the data */
comp_entity = gprs_sndcp_comp_by_comp(comp_entities, pcomp);
/* Skip compression if no suitable compression entity can be found */
if (!comp_entity) {
return len;
}
/* Note: Only data compression entities may appear in
* data compression context */
OSMO_ASSERT(comp_entity->compclass == SNDCP_XID_DATA_COMPRESSION);
/* Note: Currently V42BIS is the only compression method we
* support, so the only allowed algorithm is V42BIS */
OSMO_ASSERT(comp_entity->algo == V42BIS);
/* Find pcomp_index */
pcomp_index = gprs_sndcp_comp_get_idx(comp_entity, pcomp);
/* Run decompression algo */
rc = v42bis_expand_unitdata(data, len, pcomp_index, comp_entity->state);
LOGP(DSNDCP, LOGL_DEBUG,
"Data expansion done, old length=%d, new length=%d, entity=%p\n",
len, rc, comp_entity);
return rc;
}
struct ipa_server_link *
ipa_server_link_create(void *ctx, struct e1inp_line *line,
const char *addr, uint16_t port,
int (*accept_cb)(struct ipa_server_link *link, int fd),
void *data)
{
struct ipa_server_link *ipa_link;
OSMO_ASSERT(accept_cb != NULL);
ipa_link = talloc_zero(ctx, struct ipa_server_link);
if (!ipa_link)
return NULL;
ipa_link->ofd.when |= BSC_FD_READ | BSC_FD_WRITE;
ipa_link->ofd.cb = ipa_server_fd_cb;
ipa_link->ofd.data = ipa_link;
if (addr)
ipa_link->addr = talloc_strdup(ipa_link, addr);
ipa_link->port = port;
ipa_link->accept_cb = accept_cb;
ipa_link->line = line;
ipa_link->data = data;
return ipa_link;
}
int oap_client_init(struct oap_client_config *config,
struct oap_client_state *state)
{
OSMO_ASSERT(state->state == OAP_UNINITIALIZED);
if (!config)
goto disable;
if (config->client_id == 0)
goto disable;
if (config->secret_k_present == 0) {
LOGP(DLOAP, LOGL_NOTICE, "OAP: client ID set, but secret K missing.\n");
goto disable;
}
if (config->secret_opc_present == 0) {
LOGP(DLOAP, LOGL_NOTICE, "OAP: client ID set, but secret OPC missing.\n");
goto disable;
}
state->client_id = config->client_id;
memcpy(state->secret_k, config->secret_k, sizeof(state->secret_k));
memcpy(state->secret_opc, config->secret_opc, sizeof(state->secret_opc));
state->state = OAP_INITIALIZED;
return 0;
disable:
state->state = OAP_DISABLED;
return 0;
}
struct msgb *oap_client_encoded(const struct osmo_oap_message *oap_msg)
{
struct msgb *msg = msgb_alloc_headroom(1000, 64, __func__);
OSMO_ASSERT(msg);
osmo_oap_encode(msg, oap_msg);
return msg;
}
uint8_t *encode_big_endian(uint64_t value, size_t data_len)
{
static uint8_t buf[sizeof(uint64_t)];
OSMO_ASSERT(data_len <= ARRAY_SIZE(buf));
osmo_store64be_ext(value, buf, data_len);
return buf;
}
/* Set the timestamp offset according to the packet duration. */
static int align_rtp_timestamp_offset(struct mgcp_endpoint *endp,
struct mgcp_rtp_state *state,
struct mgcp_rtp_end *rtp_end,
struct sockaddr_in *addr,
uint32_t timestamp)
{
int timestamp_error = 0;
int ptime = state->packet_duration;
/* Align according to: T + Toffs - Tlast = k * Tptime */
timestamp_error = compute_timestamp_aligment_error(
&state->out_stream, ptime,
timestamp + state->timestamp_offset);
if (timestamp_error) {
state->timestamp_offset += ptime - timestamp_error;
LOGP(DMGCP, LOGL_NOTICE,
"Corrected timestamp alignment error of %d on 0x%x SSRC: %u "
"new TS offset: %d, "
"from %s:%d in %d\n",
timestamp_error,
ENDPOINT_NUMBER(endp), state->in_stream.ssrc,
state->timestamp_offset, inet_ntoa(addr->sin_addr),
ntohs(addr->sin_port), endp->conn_mode);
}
OSMO_ASSERT(compute_timestamp_aligment_error(&state->out_stream, ptime,
timestamp + state->timestamp_offset) == 0);
return timestamp_error;
}
/* Simulate a real life situation: voice frames with a few dropouts */
void test_fr_concealment_realistic()
{
struct osmo_ecu_fr_state state;
uint8_t frame[GSM_FR_BYTES];
unsigned int frame_len;
int rc, i = 0;
while (fr_frames_hex[i] != NULL) {
/* Debug print */
printf("Frame No. %03i:\n", i);
/* Good or bad frame? */
frame_len = strlen(fr_frames_hex[i]) / 2;
if (frame_len == GSM_FR_BYTES) {
printf(" * input: %s\n", fr_frames_hex[i]);
osmo_hexparse(fr_frames_hex[i], frame, GSM_FR_BYTES);
osmo_ecu_fr_reset(&state, frame);
} else {
printf(" * input: (bad)\n");
memset(frame, 0x00, GSM_FR_BYTES);
rc = osmo_ecu_fr_conceal(&state, frame);
OSMO_ASSERT(rc == 0);
}
/* Print result */
printf(" * output: %s\n",
osmo_hexdump_nospc(frame, GSM_FR_BYTES));
/* Go to the next frame */
i++;
}
}
/**
* Start with a good voice frame and then simulate 20 consecutive bad frames,
* watching how the error concealment decreases the XMAXC parameters.
*/
void test_fr_concealment(void)
{
struct osmo_ecu_fr_state state;
uint8_t frame[GSM_FR_BYTES];
uint64_t xmaxc[4];
int i, rc;
int j = 0;
while (sample_frame_hex[j] != NULL) {
/* Parse frame from string to hex */
osmo_hexparse(sample_frame_hex[j], frame, GSM_FR_BYTES);
parse_xmaxc_frame(frame, xmaxc);
printf("Start with: %s, XMAXC: [%"PRIx64", %"PRIx64", %"PRIx64", %"PRIx64"]\n",
sample_frame_hex[j], xmaxc[0], xmaxc[1], xmaxc[2], xmaxc[3]);
/* Reset the ECU with the proposed known good frame */
osmo_ecu_fr_reset(&state, frame);
/* Now pretend that we do not receive any good frames anymore */
for (i = 0; i < 20; i++) {
rc = osmo_ecu_fr_conceal(&state, frame);
OSMO_ASSERT(rc == 0);
parse_xmaxc_frame(frame, xmaxc);
printf("conceal: %02i, result: %s XMAXC: [%"PRIx64", %"PRIx64", %"PRIx64", %"PRIx64"]\n",
i, osmo_hexdump_nospc(frame, GSM_FR_BYTES),
xmaxc[0], xmaxc[1], xmaxc[2], xmaxc[3]);
}
/* Go to the next frame */
j++;
}
}
static void test_bssgp_status(void)
{
uint16_t bvci;
printf("----- %s START\n", __func__);
send_bssgp_status(BSSGP_CAUSE_PROTO_ERR_UNSPEC, NULL);
OSMO_ASSERT(last_oph.primitive == PRIM_NM_STATUS);
/* Enforce prim != PRIM_NM_STATUS */
last_oph.primitive = PRIM_NM_LLC_DISCARDED;
bvci = 1234;
send_bssgp_status(BSSGP_CAUSE_UNKNOWN_BVCI, &bvci);
OSMO_ASSERT(last_oph.primitive == PRIM_NM_STATUS);
printf("----- %s END\n", __func__);
}
static struct mgcp_rtp_end *source_for_dest(struct mgcp_endpoint *endp,
struct mgcp_rtp_end *dst_end)
{
if (&endp->bts_end == dst_end)
return &endp->net_end;
else if (&endp->net_end == dst_end)
return &endp->bts_end;
OSMO_ASSERT(0);
}
struct msgb *bssgp_msgb_alloc(void)
{
struct msgb *msg = msgb_alloc_headroom(4096, 128, "BSSGP");
/* TODO: Add handling of msg == NULL to this function and to all callers */
OSMO_ASSERT(msg != NULL);
msgb_bssgph(msg) = msg->data;
return msg;
}
static void test_byte_ops()
{
struct bitvec bv;
const uint8_t *in = (const uint8_t *)"ABCDEFGHIJKLMNOPQRSTUVWXYZ";
uint8_t out[26 + 2];
uint8_t data[64];
int i;
int rc;
int in_size = strlen((const char *)in);
printf("=== start %s ===\n", __func__);
bv.data = data;
bv.data_len = sizeof(data);
for (i = 0; i < 32; i++) {
/* Write to bitvec */
memset(data, 0x00, sizeof(data));
bv.cur_bit = i;
rc = bitvec_set_uint(&bv, 0x7e, 8);
OSMO_ASSERT(rc >= 0);
rc = bitvec_set_bytes(&bv, in, in_size);
OSMO_ASSERT(rc >= 0);
rc = bitvec_set_uint(&bv, 0x7e, 8);
OSMO_ASSERT(rc >= 0);
printf("bitvec: %s\n", osmo_hexdump(bv.data, bv.data_len));
/* Read from bitvec */
memset(out, 0xff, sizeof(out));
bv.cur_bit = i;
rc = bitvec_get_uint(&bv, 8);
OSMO_ASSERT(rc == 0x7e);
rc = bitvec_get_bytes(&bv, out + 1, in_size);
OSMO_ASSERT(rc >= 0);
rc = bitvec_get_uint(&bv, 8);
OSMO_ASSERT(rc == 0x7e);
printf("out: %s\n", osmo_hexdump(out, sizeof(out)));
OSMO_ASSERT(out[0] == 0xff);
OSMO_ASSERT(out[in_size+1] == 0xff);
OSMO_ASSERT(memcmp(in, out + 1, in_size) == 0);
}
printf("=== end %s ===\n", __func__);
}
static int m3ua_rx_xfer(struct osmo_ss7_asp *asp, struct xua_msg *xua)
{
uint32_t rctx = xua_msg_get_u32(xua, M3UA_IEI_ROUTE_CTX);
struct m3ua_data_hdr *dh;
struct osmo_ss7_as *as;
LOGPASP(asp, DLM3UA, LOGL_DEBUG, "m3ua_rx_xfer\n");
if (xua->hdr.msg_type != M3UA_XFER_DATA) {
LOGPASP(asp, DLM3UA, LOGL_ERROR,
"%s(): unsupported message type: %s\n",
__func__,
get_value_string(m3ua_xfer_msgt_names, xua->hdr.msg_type));
return M3UA_ERR_UNSUPP_MSG_TYPE;
}
/* Use routing context IE to look up the AS for which the
* message was received. */
as = osmo_ss7_as_find_by_rctx(asp->inst, rctx);
if (!as) {
LOGPASP(asp, DLM3UA, LOGL_ERROR,
"%s(): invalid routing context: %u\n",
__func__, rctx);
return M3UA_ERR_INVAL_ROUT_CTX;
}
/* Verify that this ASP is part of the AS. */
if (!osmo_ss7_as_has_asp(as, asp)) {
LOGPASP(asp, DLM3UA, LOGL_ERROR,
"%s(): This Application Server Process is not part of the AS resolved by"
" routing context %u\n",
__func__, rctx);
return M3UA_ERR_NO_CONFGD_AS_FOR_ASP;
}
/* FIXME: check for AS state == ACTIVE */
/* store the MTP-level information in the xua_msg for use by
* higher layer protocols */
dh = data_hdr_from_m3ua(xua);
OSMO_ASSERT(dh);
m3ua_dh_to_xfer_param(&xua->mtp, dh);
LOGPASP(asp, DLM3UA, LOGL_DEBUG,
"%s(): M3UA data header: opc=%u=%s dpc=%u=%s\n",
__func__, xua->mtp.opc, osmo_ss7_pointcode_print(asp->inst, xua->mtp.opc),
xua->mtp.dpc, osmo_ss7_pointcode_print2(asp->inst, xua->mtp.dpc));
/* remove ROUTE_CTX as in the routing case we want to add a new
* routing context on the outbound side */
xua_msg_free_tag(xua, M3UA_IEI_ROUTE_CTX);
return m3ua_hmdc_rx_from_l2(asp->inst, xua);
/* xua will be freed by caller m3ua_rx_msg() */
}
/* transmit given xua_msg via given ASP */
static int m3ua_tx_xua_asp(struct osmo_ss7_asp *asp, struct xua_msg *xua)
{
struct msgb *msg = m3ua_to_msg(xua);
OSMO_ASSERT(asp->cfg.proto == OSMO_SS7_ASP_PROT_M3UA);
if (!msg)
return -1;
return osmo_ss7_asp_send(asp, msg);
}
static void parse_xmaxc_frame(uint8_t *frame, uint64_t xmaxc_res[4])
{
unsigned int field_index, len;
struct bitvec *frame_bitvec = bitvec_alloc(GSM_FR_BYTES, NULL);
OSMO_ASSERT(frame_bitvec);
len = bitvec_unpack(frame_bitvec, frame);
OSMO_ASSERT(len == GSM_FR_BYTES);
field_index = GSM610_RTP_XMAXC00;
xmaxc_res[0] = bitvec_read_field(frame_bitvec, &field_index, GSM610_XMAXC_LEN);
field_index = GSM610_RTP_XMAXC10;
xmaxc_res[1] = bitvec_read_field(frame_bitvec, &field_index, GSM610_XMAXC_LEN);
field_index = GSM610_RTP_XMAXC20;
xmaxc_res[2] = bitvec_read_field(frame_bitvec, &field_index, GSM610_XMAXC_LEN);
field_index = GSM610_RTP_XMAXC30;
xmaxc_res[3] = bitvec_read_field(frame_bitvec, &field_index, GSM610_XMAXC_LEN);
bitvec_free(frame_bitvec);
}
int main()
{
printf("Testing subscriber database code.\n");
osmo_init_logging(&log_info);
log_set_print_filename(osmo_stderr_target, 0);
dummy_net.subscr_group = &dummy_sgrp;
dummy_sgrp.net = &dummy_net;
if (db_init("hlr.sqlite3")) {
printf("DB: Failed to init database. Please check the option settings.\n");
return 1;
}
printf("DB: Database initialized.\n");
if (db_prepare()) {
printf("DB: Failed to prepare database.\n");
return 1;
}
printf("DB: Database prepared.\n");
struct gsm_subscriber *alice = NULL;
struct gsm_subscriber *alice_db;
char *alice_imsi = "3243245432345";
alice = db_create_subscriber(alice_imsi, GSM_MIN_EXTEN, GSM_MAX_EXTEN,
true);
db_sync_subscriber(alice);
alice_db = db_get_subscriber(GSM_SUBSCRIBER_IMSI, alice->imsi);
COMPARE(alice, alice_db);
SUBSCR_PUT(alice_db);
SUBSCR_PUT(alice);
test_subs("3693245423445", "1234567890", NULL, true);
test_subs("9993245423445", "1234567890", "6543560920", true);
test_subs("3123122223445", "1234567890", NULL, false);
test_subs("9123121223445", "1234567890", "6543560920", false);
/* create it again and see it fails */
alice = db_create_subscriber(alice_imsi, GSM_MIN_EXTEN, GSM_MAX_EXTEN,
true);
OSMO_ASSERT(!alice);
test_sms();
test_sms_migrate();
db_fini();
printf("Done\n");
return 0;
}
struct xua_msg *m3ua_xfer_from_data(const struct m3ua_data_hdr *data_hdr,
const uint8_t *data, unsigned int data_len)
{
struct xua_msg *xua = xua_msg_alloc();
struct xua_msg_part *data_part;
xua->hdr = XUA_HDR(M3UA_MSGC_XFER, M3UA_XFER_DATA);
/* Network Appearance: Optional */
/* Routing Context: Conditional */
/* Protocol Data: Mandatory */
data_part = talloc_zero(xua, struct xua_msg_part);
OSMO_ASSERT(data_part);
data_part->tag = M3UA_IEI_PROT_DATA;
data_part->len = sizeof(*data_hdr) + data_len;
data_part->dat = talloc_size(data_part, data_part->len);
OSMO_ASSERT(data_part->dat);
memcpy(data_part->dat, data_hdr, sizeof(*data_hdr));
memcpy(data_part->dat+sizeof(*data_hdr), data, data_len);
llist_add_tail(&data_part->entry, &xua->headers);
/* Correlation Id: Optional */
return xua;
}
