static void test_dual_sw_config(void)
{
struct abis_nm_sw_descr descr[2];
int rc;
rc = abis_nm_parse_sw_config(dual_config, ARRAY_SIZE(dual_config),
&descr[0], ARRAY_SIZE(descr));
if (rc != 2) {
printf("FAILED to parse the File Id/File version\n");
abort();
}
if (descr[0].len != 13) {
printf("WRONG SIZE0: %d\n", descr[0].len);
abort();
}
if (descr[1].len != 13) {
printf("WRONG SIZE1: %d\n", descr[1].len);
abort();
}
printf("Start: %u len: %zu\n", descr[0].start - dual_config, descr[0].len);
printf("file_id: %s\n", osmo_hexdump(descr[0].file_id, descr[0].file_id_len));
printf("file_ver: %s\n", osmo_hexdump(descr[0].file_ver, descr[0].file_ver_len));
printf("Start: %u len: %zu\n", descr[1].start - dual_config, descr[1].len);
printf("file_id: %s\n", osmo_hexdump(descr[1].file_id, descr[1].file_id_len));
printf("file_ver: %s\n", osmo_hexdump(descr[1].file_ver, descr[1].file_ver_len));
}
static void test_mi_functionality(void)
{
const char *imsi_odd = "987654321098763";
const char *imsi_even = "9876543210987654";
const uint32_t tmsi = 0xfabeacd0;
uint8_t mi[128];
unsigned int mi_len;
char mi_parsed[GSM48_MI_SIZE];
printf("Testing parsing and generating TMSI/IMSI\n");
/* tmsi code */
mi_len = gsm48_generate_mid_from_tmsi(mi, tmsi);
gsm48_mi_to_string(mi_parsed, sizeof(mi_parsed), mi + 2, mi_len - 2);
COMPARE((uint32_t)strtoul(mi_parsed, NULL, 10), ==, tmsi);
/* imsi code */
mi_len = gsm48_generate_mid_from_imsi(mi, imsi_odd);
gsm48_mi_to_string(mi_parsed, sizeof(mi_parsed), mi + 2, mi_len -2);
printf("hex: %s\n", osmo_hexdump(mi, mi_len));
COMPARE_STR(mi_parsed, imsi_odd);
mi_len = gsm48_generate_mid_from_imsi(mi, imsi_even);
gsm48_mi_to_string(mi_parsed, sizeof(mi_parsed), mi + 2, mi_len -2);
printf("hex: %s\n", osmo_hexdump(mi, mi_len));
COMPARE_STR(mi_parsed, imsi_even);
}
static void subscr_dump_full_vty(struct vty *vty, struct gsm_subscriber *subscr, int pending)
{
int rc;
struct gsm_auth_info ainfo;
struct gsm_auth_tuple atuple;
char expire_time[200];
vty_out(vty, " ID: %llu, Authorized: %d%s", subscr->id,
subscr->authorized, VTY_NEWLINE);
if (subscr->name)
vty_out(vty, " Name: '%s'%s", subscr->name, VTY_NEWLINE);
if (subscr->extension)
vty_out(vty, " Extension: %s%s", subscr->extension,
VTY_NEWLINE);
vty_out(vty, " LAC: %d/0x%x%s",
subscr->lac, subscr->lac, VTY_NEWLINE);
vty_out(vty, " IMSI: %s%s", subscr->imsi, VTY_NEWLINE);
if (subscr->tmsi != GSM_RESERVED_TMSI)
vty_out(vty, " TMSI: %08X%s", subscr->tmsi,
VTY_NEWLINE);
rc = db_get_authinfo_for_subscr(&ainfo, subscr);
if (!rc) {
vty_out(vty, " A3A8 algorithm id: %d%s",
ainfo.auth_algo, VTY_NEWLINE);
vty_out(vty, " A3A8 Ki: %s%s",
osmo_hexdump(ainfo.a3a8_ki, ainfo.a3a8_ki_len),
VTY_NEWLINE);
}
rc = db_get_lastauthtuple_for_subscr(&atuple, subscr);
if (!rc) {
vty_out(vty, " A3A8 last tuple (used %d times):%s",
atuple.use_count, VTY_NEWLINE);
vty_out(vty, " seq # : %d%s",
atuple.key_seq, VTY_NEWLINE);
vty_out(vty, " RAND : %s%s",
osmo_hexdump(atuple.rand, sizeof(atuple.rand)),
VTY_NEWLINE);
vty_out(vty, " SRES : %s%s",
osmo_hexdump(atuple.sres, sizeof(atuple.sres)),
VTY_NEWLINE);
vty_out(vty, " Kc : %s%s",
osmo_hexdump(atuple.kc, sizeof(atuple.kc)),
VTY_NEWLINE);
}
/* print the expiration time of a subscriber */
strftime(expire_time, sizeof(expire_time),
"%a, %d %b %Y %T %z", localtime(&subscr->expire_lu));
expire_time[sizeof(expire_time) - 1] = '\0';
vty_out(vty, " Expiration Time: %s%s", expire_time, VTY_NEWLINE);
if (pending)
vty_out(vty, " Pending: %d%s",
subscr_pending_requests(subscr), VTY_NEWLINE);
vty_out(vty, " Use count: %u%s", subscr->use_count, VTY_NEWLINE);
}
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 int test_bearer_cap()
{
struct gsm_mncc_bearer_cap bc;
int i, rc;
for (i = 0; i < ARRAY_SIZE(bcap_tests); i++) {
struct msgb *msg = msgb_alloc(100, "test");
int lv_len;
memset(&bc, 0, sizeof(bc));
/* test decoding */
rc = gsm48_decode_bearer_cap(&bc, bcap_tests[i].lv);
if (rc < 0) {
fprintf(stderr, "Error decoding %s\n",
bcap_tests[i].name);
return rc;
}
if (memcmp(&bc, bcap_tests[i].bc, sizeof(bc))) {
fprintf(stderr, "Incorrect decoded result of %s:\n",
bcap_tests[i].name);
fprintf(stderr, " should: %s\n",
osmo_hexdump((uint8_t *) bcap_tests[i].bc, sizeof(bc)));
fprintf(stderr, " is: %s\n",
osmo_hexdump((uint8_t *) &bc, sizeof(bc)));
return -1;
}
/* also test re-encode? */
rc = gsm48_encode_bearer_cap(msg, 1, &bc);
if (rc < 0) {
fprintf(stderr, "Error encoding %s\n",
bcap_tests[i].name);
return rc;
}
lv_len = bcap_tests[i].lv[0]+1;
if (memcmp(msg->data, bcap_tests[i].lv, lv_len)) {
fprintf(stderr, "Incorrect encoded result of %s:\n",
bcap_tests[i].name);
fprintf(stderr, " should: %s\n",
osmo_hexdump(bcap_tests[i].lv, lv_len));
fprintf(stderr, " is: %s\n",
osmo_hexdump(msg->data, msg->len));
return -1;
}
printf("Test `%s' passed\n", bcap_tests[i].name);
msgb_free(msg);
}
return 0;
}
static inline void check_ra(const struct gprs_ra_id *raid)
{
struct gsm48_ra_id ra;
struct gprs_ra_id raid0 = {
.mnc = 0,
.mcc = 0,
.lac = 0,
.rac = 0,
};
gsm48_encode_ra(&ra, raid);
printf("Constructed RA:\n");
gsm48_parse_ra(&raid0, (const uint8_t *)&ra);
dump_ra(raid);
printf("MCC+MNC in BCD: %s\n", osmo_hexdump(ra.digits, sizeof(ra.digits)));
dump_ra(&raid0);
printf("RA test...");
if (raid->mnc != raid0.mnc || raid->mcc != raid0.mcc || raid->lac != raid0.lac || raid->rac != raid0.rac
|| (raid->mnc_3_digits || raid->mnc > 99) != raid0.mnc_3_digits)
printf("FAIL\n");
else
printf("passed\n");
}
static inline void check_lai(const struct gprs_ra_id *raid)
{
int rc;
struct gsm48_loc_area_id lai = {};
struct gprs_ra_id decoded = {};
struct gprs_ra_id _laid = *raid;
struct gprs_ra_id *laid = &_laid;
laid->rac = 0;
printf("- gsm48_generate_lai() from "); dump_ra(laid);
gsm48_generate_lai(&lai, laid->mcc, laid->mnc, laid->lac);
printf(" Encoded %s\n", osmo_hexdump((unsigned char*)&lai, sizeof(lai)));
rc = gsm48_decode_lai(&lai, &decoded.mcc, &decoded.mnc, &decoded.lac);
if (rc) {
printf(" gsm48_decode_lai() returned %d --> FAIL\n", rc);
return;
}
printf(" gsm48_decode_lai() gives "); dump_ra(&decoded);
if (decoded.mcc == laid->mcc
&& decoded.mnc == laid->mnc
&& decoded.lac == laid->lac)
printf(" passed\n");
else
printf(" FAIL\n");
}
static int dtap_rcvmsg(struct osmo_bsc_sccp_con *conn,
struct msgb *msg, unsigned int length)
{
struct dtap_header *header;
struct msgb *gsm48;
uint8_t *data;
int rc, dtap_rc;
LOGP(DMSC, LOGL_DEBUG, "Rx MSC DTAP: %s\n",
osmo_hexdump(msg->l3h, length));
if (!conn->conn) {
LOGP(DMSC, LOGL_ERROR, "No subscriber connection available\n");
return -1;
}
header = (struct dtap_header *) msg->l3h;
if (sizeof(*header) >= length) {
LOGP(DMSC, LOGL_ERROR, "The DTAP header does not fit. Wanted: %zu got: %u\n", sizeof(*header), length);
LOGP(DMSC, LOGL_ERROR, "hex: %s\n", osmo_hexdump(msg->l3h, length));
return -1;
}
if (header->length > length - sizeof(*header)) {
LOGP(DMSC, LOGL_ERROR, "The DTAP l4 information does not fit: header: %u length: %u\n", header->length, length);
LOGP(DMSC, LOGL_ERROR, "hex: %s\n", osmo_hexdump(msg->l3h, length));
return -1;
}
LOGP(DMSC, LOGL_INFO, "Rx MSC DTAP, SAPI: %u CHAN: %u\n", header->link_id & 0x07, header->link_id & 0xC0);
/* forward the data */
gsm48 = gsm48_msgb_alloc();
if (!gsm48) {
LOGP(DMSC, LOGL_ERROR, "Allocation of the message failed.\n");
return -1;
}
gsm48->l3h = gsm48->data;
data = msgb_put(gsm48, length - sizeof(*header));
memcpy(data, msg->l3h + sizeof(*header), length - sizeof(*header));
/* pass it to the filter for extra actions */
rc = bsc_scan_msc_msg(conn->conn, gsm48);
dtap_rc = gsm0808_submit_dtap(conn->conn, gsm48, header->link_id, 1);
if (rc == BSS_SEND_USSD)
bsc_send_welcome_ussd(conn->conn);
return dtap_rc;
}
static void test_data(void)
{
struct m2ua_msg_part *part;
struct m2ua_msg *m2u = m2ua_from_msg(ARRAY_SIZE(data), data);
struct msgb *msg = m2ua_to_msg(m2u);
printf("Testing parsing of data.\n");
if (msg->len != ARRAY_SIZE(data)) {
printf("Got %d wanted %d\n", msg->len, ARRAY_SIZE(data));
FAIL("Wrong size");
}
if (memcmp(msg->data, data, msg->len) != 0) {
printf("Got '%s'\n", osmo_hexdump(msg->data, msg->len));
FAIL("Wrong memory");
}
part = m2ua_msg_find_tag(m2u, 0x300);
if (!part)
FAIL("Could not find part");
if (part->len != 22) {
printf("Got the length %d\n", part->len);
FAIL("Part is not of length 22\n");
}
m2ua_msg_free(m2u);
msgb_free(msg);
}
int bsc_handle_udt(struct osmo_msc_data *msc,
struct msgb *msgb, unsigned int length)
{
struct bssmap_header *bs;
LOGP(DMSC, LOGL_DEBUG, "Rx MSC UDT: %s\n",
osmo_hexdump(msgb->l3h, length));
if (length < sizeof(*bs)) {
LOGP(DMSC, LOGL_ERROR, "The header is too short.\n");
return -1;
}
bs = (struct bssmap_header *) msgb->l3h;
if (bs->length < length - sizeof(*bs))
return -1;
switch (bs->type) {
case BSSAP_MSG_BSS_MANAGEMENT:
msgb->l4h = &msgb->l3h[sizeof(*bs)];
bssmap_rcvmsg_udt(msc, msgb, length - sizeof(*bs));
break;
default:
LOGP(DMSC, LOGL_NOTICE, "Unimplemented msg type: %s\n",
gsm0808_bssmap_name(bs->type));
}
return 0;
}
static int ranap_rx_dt(struct hnb_context *hnb, ANY_t *in)
{
RANAP_DirectTransferIEs_t ies;
int sapi = 0;
int rc;
rc = ranap_decode_directtransferies(&ies, in);
if (rc < 0)
return rc;
if (ies.presenceMask & DIRECTTRANSFERIES_RANAP_SAPI_PRESENT)
sapi = ies.sapi;
if (ies.presenceMask & DIRECTTRANSFERIES_RANAP_LAI_PRESENT) {
/* FIXME: Update LAI associated with UE */
}
if (ies.presenceMask & DIRECTTRANSFERIES_RANAP_RAC_PRESENT) {
/* FIXME: Update RAC associated with UE */
}
DEBUGP(DRANAP, "DirectTransfer: %s\n",
osmo_hexdump(ies.nas_pdu.buf, ies.nas_pdu.size));
/* FIXME: hand NAS PDU into MSC */
}
static int try_cbch(struct osmocom_ms *ms, struct gsm48_sysinfo *s)
{
if (!s->si1 || !s->si4)
return 0;
if (!s->chan_nr) {
LOGP(DRR, LOGL_INFO, "no CBCH chan_nr found\n");
return 0;
}
if (s->h) {
LOGP(DRR, LOGL_INFO, "chan_nr = 0x%02x TSC = %d MAIO = %d "
"HSN = %d hseq (%d): %s\n",
s->chan_nr, s->tsc, s->maio, s->hsn,
s->hopp_len,
osmo_hexdump((unsigned char *) s->hopping, s->hopp_len * 2));
return l1ctl_tx_dm_est_req_h1(ms,
s->maio, s->hsn, s->hopping, s->hopp_len,
s->chan_nr, s->tsc,
GSM48_CMODE_SIGN, 0);
} else {
LOGP(DRR, LOGL_INFO, "chan_nr = 0x%02x TSC = %d ARFCN = %d\n",
s->chan_nr, s->tsc, s->arfcn);
return l1ctl_tx_dm_est_req_h0(ms, s->arfcn,
s->chan_nr, s->tsc, GSM48_CMODE_SIGN, 0);
}
}
/* write to a B channel TS */
static int handle_tsX_write(struct osmo_fd *bfd, int len)
{
struct e1inp_line *line = bfd->data;
unsigned int ts_nr = bfd->priv_nr;
struct e1inp_ts *e1i_ts = &line->ts[ts_nr-1];
struct mISDNhead *hh;
uint8_t tx_buf[len + sizeof(*hh)];
struct subch_mux *mx = &e1i_ts->trau.mux;
int ret;
hh = (struct mISDNhead *) tx_buf;
hh->prim = PH_DATA_REQ;
hh->id = 0;
subchan_mux_out(mx, tx_buf+sizeof(*hh), len);
DEBUGP(DLMIB, "BCHAN TX: %s\n",
osmo_hexdump(tx_buf+sizeof(*hh), len));
ret = send(bfd->fd, tx_buf, sizeof(*hh) + len, 0);
if (ret < sizeof(*hh) + len)
DEBUGP(DLMIB, "send returns %d instead of %zu\n", ret,
sizeof(*hh) + len);
return ret;
}
static void test_asp_up(void)
{
struct m2ua_msg_part *part;
struct m2ua_msg *m2u = m2ua_from_msg(ARRAY_SIZE(asp_up), asp_up);
struct msgb *msg = m2ua_to_msg(m2u);
const uint8_t res[] = { 0xac, 0x10, 0x01, 0x51 };
printf("Testing ASP UP parsing.\n");
if (msg->len != ARRAY_SIZE(asp_up)) {
printf("Got %d wanted %d\n", msg->len, ARRAY_SIZE(asp_up));
FAIL("Wrong size");
}
if (memcmp(msg->data, asp_up, msg->len) != 0) {
printf("Got '%s'\n", osmo_hexdump(msg->data, msg->len));
FAIL("Wrong memory");
}
part = m2ua_msg_find_tag(m2u, 0x11);
if (!part)
FAIL("Could not find part");
if (part->len != 4)
FAIL("Part is not of length four\n");
if (memcmp(part->dat, res, 4) != 0)
FAIL("Wrong result for the tag\n");
m2ua_msg_free(m2u);
msgb_free(msg);
}
static void replay_mainloop(FILE* dump_usb_file)
{
unsigned int msg_count, byte_count = 0;
char buf[16*265];
int xfer_len=0;
int rc=0;
int nitems=0;
printf("Entering main replay loop\n");
apdu_split_reset(as);
while (1) {
nitems = fread(&xfer_len,sizeof(xfer_len),1,dump_usb_file);
if(nitems!=1) {
return;
}
printf("xfer_len:%d\n",xfer_len);
if (xfer_len > 0) {
nitems = fread(buf,1,xfer_len,dump_usb_file);
if(nitems!=xfer_len) {
return;
}
printf("URB: %s\n", osmo_hexdump(buf, rc));
process_usb_msg(buf, xfer_len);
msg_count++;
byte_count += xfer_len;
}
}
}
static inline void check_lai2(const struct gprs_ra_id *raid)
{
struct gsm48_loc_area_id lai = {};
struct osmo_location_area_id decoded = {};
struct osmo_location_area_id laid = {
.plmn = {
.mcc = raid->mcc,
.mnc = raid->mnc,
.mnc_3_digits = raid->mnc_3_digits,
},
.lac = raid->lac,
};
printf("- gsm48_generate_lai2() from "); dump_lai(&laid);
gsm48_generate_lai2(&lai, &laid);
printf(" Encoded %s\n", osmo_hexdump((unsigned char*)&lai, sizeof(lai)));
gsm48_decode_lai2(&lai, &decoded);
printf(" gsm48_decode_lai2() gives "); dump_lai(&decoded);
if (decoded.plmn.mcc == laid.plmn.mcc
&& decoded.plmn.mnc == laid.plmn.mnc
&& decoded.lac == laid.lac
&& decoded.plmn.mnc_3_digits == (laid.plmn.mnc_3_digits || laid.plmn.mnc > 99))
printf(" passed\n");
else
printf(" FAIL\n");
}
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__);
}
/* override */
int gprs_ns_callback(enum gprs_ns_evt event, struct gprs_nsvc *nsvc,
struct msgb *msg, uint16_t bvci)
{
fprintf(stderr, "CALLBACK, event %d, msg length %td, bvci 0x%04x\n%s\n\n",
event, msgb_bssgp_len(msg), bvci,
osmo_hexdump(msgb_bssgph(msg), msgb_bssgp_len(msg)));
return 0;
}
/**
* @brief Handler for received L1CTL_SIM_REQ from L23.
*
* -- sim request --
*
* @param [in] msg the received message.
*
* Forward and a sim request to the SIM APDU.
*
* Note: Not needed for virtual layer. Please configure layer23 application to use test-sim implementation.
* In this case layer1 wont need to handle sim logic.
* ms <x>
* --------
* sim test
* test-sim
* imsi <xxxxxxxxxxxxxxx>
* ki comp128 <xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx>
* --------
*/
void l1ctl_rx_sim_req(struct l1_model_ms *ms, struct msgb *msg)
{
uint16_t len = msg->len - sizeof(struct l1ctl_hdr);
uint8_t *data = msg->data + sizeof(struct l1ctl_hdr);
LOGPMS(DL1C, LOGL_ERROR, ms, "Rx SIM Request (length: %u, data: %s): UNSUPPORTED\n",
len, osmo_hexdump(data, sizeof(data)));
}
/*! \brief Return a (static) buffer containing a hexdump of the msg
* \param[in] msg message buffer
* \returns a pointer to a static char array
*/
const char *msgb_hexdump(const struct msgb *msg)
{
static char buf[4100];
int buf_offs = 0;
int nchars;
const unsigned char *start = msg->data;
const unsigned char *lxhs[4];
int i;
lxhs[0] = msg->l1h;
lxhs[1] = msg->l2h;
lxhs[2] = msg->l3h;
lxhs[3] = msg->l4h;
for (i = 0; i < ARRAY_SIZE(lxhs); i++) {
if (!lxhs[i])
continue;
if (lxhs[i] < msg->data)
goto out_of_range;
if (lxhs[i] > msg->tail)
goto out_of_range;
nchars = snprintf(buf + buf_offs, sizeof(buf) - buf_offs,
"%s[L%d]> ",
osmo_hexdump(start, lxhs[i] - start),
i+1);
if (nchars < 0 || nchars + buf_offs >= sizeof(buf))
return "ERROR";
buf_offs += nchars;
start = lxhs[i];
}
nchars = snprintf(buf + buf_offs, sizeof(buf) - buf_offs,
"%s", osmo_hexdump(start, msg->tail - start));
if (nchars < 0 || nchars + buf_offs >= sizeof(buf))
return "ERROR";
return buf;
out_of_range:
nchars = snprintf(buf, sizeof(buf) - buf_offs,
"!!! L%d out of range", i+1);
return buf;
}
int mtp_handle_pcap(struct mtp_link *link, int dir, const uint8_t *data, int len)
{
if (link->pcap_fd >= 0)
mtp_pcap_write_msu(link->pcap_fd, data, len);
if (link->set->pcap_fd >= 0)
mtp_pcap_write_msu(link->set->pcap_fd, data, len);
/* This might be too expensive? */
LOGP(DPCAP, LOGL_DEBUG, "Packet: %s\n", osmo_hexdump(data, len));
return 0;
}
static void test_mid_from_imsi(void)
{
char *imsi = "901700000004620";
uint8_t buf[10], len;
printf("Simple IMSI encoding test....");
len = gsm48_generate_mid_from_imsi(buf, imsi);
printf("passed: [%u] %s\n", len, osmo_hexdump(buf, len));
}
static void test_7bit_ussd(const char *text, const char *encoded_hex, const char *appended_after_decode)
{
uint8_t coded[256];
char decoded[256];
int octets_written;
int buffer_size;
int nchars;
printf("original = %s\n", osmo_hexdump((uint8_t *)text, strlen(text)));
gsm_7bit_encode_n_ussd(coded, sizeof(coded), text, &octets_written);
printf("encoded = %s\n", osmo_hexdump(coded, octets_written));
OSMO_ASSERT(strcmp(encoded_hex, osmo_hexdump_nospc(coded, octets_written)) == 0);
gsm_7bit_decode_n_ussd(decoded, sizeof(decoded), coded, octets_written * 8 / 7);
octets_written = strlen(decoded);
printf("decoded = %s\n\n", osmo_hexdump((uint8_t *)decoded, octets_written));
OSMO_ASSERT(strncmp(text, decoded, strlen(text)) == 0);
OSMO_ASSERT(strcmp(appended_after_decode, decoded + strlen(text)) == 0);
/* check buffer limiting */
memset(decoded, 0xaa, sizeof(decoded));
for (buffer_size = 1; buffer_size < sizeof(decoded) - 1; ++buffer_size)
{
nchars = gsm_7bit_decode_n_ussd(decoded, buffer_size, coded, octets_written * 8 / 7);
OSMO_ASSERT(nchars <= buffer_size);
OSMO_ASSERT(decoded[buffer_size] == (char)0xaa);
OSMO_ASSERT(decoded[nchars] == '\0');
}
memset(coded, 0xaa, sizeof(coded));
for (buffer_size = 0; buffer_size < sizeof(coded) - 1; ++buffer_size)
{
gsm_7bit_encode_n_ussd(coded, buffer_size, text, &octets_written);
OSMO_ASSERT(octets_written <= buffer_size);
OSMO_ASSERT(coded[buffer_size] == 0xaa);
}
}
static void test_sw_selection(void)
{
struct abis_nm_sw_descr descr[8], tmp;
int rc, pos;
rc = abis_nm_parse_sw_config(load_config, ARRAY_SIZE(load_config),
&descr[0], ARRAY_SIZE(descr));
if (rc != 2) {
printf("FAILED to parse the File Id/File version\n");
abort();
}
printf("Start: %u len: %zu\n", descr[0].start - load_config, descr[0].len);
printf("file_id: %s\n", osmo_hexdump(descr[0].file_id, descr[0].file_id_len));
printf("file_ver: %s\n", osmo_hexdump(descr[0].file_ver, descr[0].file_ver_len));
printf("Start: %u len: %zu\n", descr[1].start - load_config, descr[1].len);
printf("file_id: %s\n", osmo_hexdump(descr[1].file_id, descr[1].file_id_len));
printf("file_ver: %s\n", osmo_hexdump(descr[1].file_ver, descr[1].file_ver_len));
/* start */
pos = abis_nm_select_newest_sw(descr, rc);
if (pos != 1) {
printf("Selected the wrong version: %d\n", pos);
abort();
}
printf("SELECTED: %d\n", pos);
/* shuffle */
tmp = descr[0];
descr[0] = descr[1];
descr[1] = tmp;
pos = abis_nm_select_newest_sw(descr, rc);
if (pos != 0) {
printf("Selected the wrong version: %d\n", pos);
abort();
}
printf("SELECTED: %d\n", pos);
}
static int dump_fcp_template(struct tlv_parsed *tp)
{
int i;
for (i = 0; i < ARRAY_SIZE(tp->lv); i++) {
if (TLVP_PRESENT(tp, i))
printf("Tag 0x%02x (%s): %s\n", i,
get_value_string(ts102221_fcp_vals, i),
osmo_hexdump(TLVP_VAL(tp, i), TLVP_LEN(tp, i)));
}
return 0;
}
static int ussd_read_cb(struct osmo_fd *bfd)
{
struct bsc_nat_ussd_con *conn = bfd->data;
struct msgb *msg = NULL;
struct ipaccess_head *hh;
int ret;
ret = ipa_msg_recv_buffered(bfd->fd, &msg, &conn->pending_msg);
if (ret <= 0) {
if (ret == -EAGAIN)
return 0;
LOGP(DNAT, LOGL_ERROR, "USSD Connection was lost.\n");
bsc_nat_ussd_destroy(conn);
return -1;
}
LOGP(DNAT, LOGL_NOTICE, "MSG from USSD: %s proto: %d\n",
osmo_hexdump(msg->data, msg->len), msg->l2h[0]);
hh = (struct ipaccess_head *) msg->data;
if (hh->proto == IPAC_PROTO_IPACCESS) {
if (msg->l2h[0] == IPAC_MSGT_ID_RESP) {
struct tlv_parsed tvp;
int ret;
ret = ipa_ccm_idtag_parse(&tvp,
(unsigned char *) msg->l2h + 2,
msgb_l2len(msg) - 2);
if (ret < 0) {
LOGP(DNAT, LOGL_ERROR, "ignoring IPA response "
"message with malformed TLVs\n");
msgb_free(msg);
return ret;
}
if (TLVP_PRESENT(&tvp, IPAC_IDTAG_UNITNAME))
ussd_auth_con(&tvp, conn);
} else if (msg->l2h[0] == IPAC_MSGT_PING) {
LOGP(DNAT, LOGL_DEBUG, "Got USSD ping request.\n");
ussd_pong(conn);
} else {
LOGP(DNAT, LOGL_NOTICE, "Got unknown IPACCESS message 0x%02x.\n", msg->l2h[0]);
}
msgb_free(msg);
} else if (hh->proto == IPAC_PROTO_SCCP) {
forward_sccp(conn->nat, msg);
} else {
msgb_free(msg);
}
return 0;
}
static int __handle_ts1_write(struct osmo_fd *bfd, struct e1inp_line *line)
{
unsigned int ts_nr = bfd->priv_nr;
struct e1inp_ts *e1i_ts = &line->ts[ts_nr-1];
struct e1inp_sign_link *sign_link;
struct msgb *msg;
int ret;
bfd->when &= ~BSC_FD_WRITE;
/* get the next msg for this timeslot */
msg = e1inp_tx_ts(e1i_ts, &sign_link);
if (!msg) {
/* no message after tx delay timer */
return 0;
}
switch (sign_link->type) {
case E1INP_SIGN_OML:
#ifdef HSL_SR_1_0
/* HSL uses 0x81 for FOM for some reason */
if (msg->data[0] == ABIS_OM_MDISC_FOM)
msg->data[0] = ABIS_OM_MDISC_FOM | 0x01;
#endif
break;
case E1INP_SIGN_RSL:
break;
default:
msgb_free(msg);
bfd->when |= BSC_FD_WRITE; /* come back for more msg */
return -EINVAL;
}
msg->l2h = msg->data;
ipaccess_prepend_header(msg, sign_link->tei);
DEBUGP(DLMI, "TX %u: %s\n", ts_nr, osmo_hexdump(msg->l2h, msgb_l2len(msg)));
ret = send(bfd->fd, msg->data, msg->len, 0);
msgb_free(msg);
/* set tx delay timer for next event */
e1i_ts->sign.tx_timer.cb = timeout_ts1_write;
e1i_ts->sign.tx_timer.data = e1i_ts;
/* Reducing this might break the nanoBTS 900 init. */
osmo_timer_schedule(&e1i_ts->sign.tx_timer, 0, e1i_ts->sign.delay);
return ret;
}
void lapd_rx_cb(struct osmo_dlsap_prim *dp, uint8_t tei, uint8_t sapi,
void *rx_cbdata)
{
struct msgb *msg = dp->oph.msg;
switch (dp->oph.primitive) {
case PRIM_DL_EST:
DEBUGP(DLAPDTEST, "DL_EST: sapi(%d) tei(%d)\n", sapi, tei);
break;
case PRIM_DL_REL:
DEBUGP(DLAPDTEST, "DL_REL: sapi(%d) tei(%d)\n", sapi, tei);
break;
case PRIM_DL_DATA:
case PRIM_DL_UNIT_DATA:
if (dp->oph.operation == PRIM_OP_INDICATION) {
struct msgb *nmsg;
char *ptr;
int x;
msg->l2h = msg->l3h;
DEBUGP(DLAPDTEST, "RX: %s sapi=%d tei=%d\n",
osmo_hexdump(msgb_l2(msg), msgb_l2len(msg)),
sapi, tei);
LOGP(DLAPDTEST, LOGL_DEBUG, "forwarding message\n");
nmsg = msgb_alloc(1024, "LAPD/test");
if (nmsg == NULL) {
LOGP(DLAPDTEST, LOGL_ERROR, "cannot alloc msg\n");
return;
}
ptr = (char *)msgb_put(nmsg, sizeof(int));
x = *((int *)msg->data);
memcpy(ptr, &x, sizeof(int));
/* send the message back to client over LAPD */
lapd_transmit(lapd, tei, sapi, msg);
return;
}
break;
case PRIM_MDL_ERROR:
DEBUGP(DLMI, "MDL_EERROR: cause(%d)\n", dp->u.error_ind.cause);
break;
default:
printf("ERROR: unknown prim\n");
break;
}
}
static int
_use_comp128_v1(struct gsm_auth_info *ainfo, struct gsm_auth_tuple *atuple)
{
if (ainfo->a3a8_ki_len != A38_COMP128_KEY_LEN) {
LOGP(DMM, LOGL_ERROR, "Invalid COMP128v1 key (len=%d) %s\n",
ainfo->a3a8_ki_len,
osmo_hexdump(ainfo->a3a8_ki, ainfo->a3a8_ki_len));
return -1;
}
comp128(ainfo->a3a8_ki, atuple->vec.rand, atuple->vec.sres, atuple->vec.kc);
return 0;
}
int BTS::add_paging(uint8_t chan_needed, uint8_t *identity_lv)
{
uint8_t l, trx, ts, any_tbf = 0;
struct gprs_rlcmac_tbf *tbf;
LListHead<gprs_rlcmac_tbf> *pos;
uint8_t slot_mask[8];
int8_t first_ts; /* must be signed */
LListHead<gprs_rlcmac_tbf> *tbfs_lists[] = {
&m_ul_tbfs,
&m_dl_tbfs,
NULL
};
LOGP(DRLCMAC, LOGL_INFO, "Add RR paging: chan-needed=%d MI=%s\n",
chan_needed, osmo_hexdump(identity_lv + 1, identity_lv[0]));
/* collect slots to page
* Mark slots for every TBF, but only mark one of it.
* Mark only the first slot found.
* Don't mark, if TBF uses a different slot that is already marked. */
memset(slot_mask, 0, sizeof(slot_mask));
for (l = 0; tbfs_lists[l]; l++) {
llist_for_each(pos, tbfs_lists[l]) {
tbf = pos->entry();
first_ts = -1;
for (ts = 0; ts < 8; ts++) {
if (tbf->pdch[ts]) {
/* remember the first slot found */
if (first_ts < 0)
first_ts = ts;
/* break, if we already marked a slot */
if ((slot_mask[tbf->trx->trx_no] & (1 << ts)))
break;
}
}
/* mark first slot found, if none is marked already */
if (ts == 8 && first_ts >= 0) {
LOGPTBF(tbf, LOGL_DEBUG, "uses "
"TRX=%d TS=%d, so we mark\n",
tbf->trx->trx_no, first_ts);
slot_mask[tbf->trx->trx_no] |= (1 << first_ts);
} else
LOGPTBF(tbf, LOGL_DEBUG, "uses "
"already marked TRX=%d TS=%d\n",
tbf->trx->trx_no, ts);
}
}
static char *auth_tuple_str(struct gsm_auth_tuple *atuple)
{
static char buf[256];
char *pos = buf;
int len = sizeof(buf);
int l;
#define print2buf(FMT, args...) do {\
l = snprintf(pos, len, FMT, ## args); \
pos += l;\
len -= l;\
} while (0)
print2buf("gsm_auth_tuple {\n");
print2buf(" .use_count = %d\n", atuple->use_count);
print2buf(" .key_seq = %d\n", atuple->key_seq);
print2buf(" .rand = %s\n", osmo_hexdump(atuple->vec.rand, sizeof(atuple->vec.rand)));
print2buf(" .sres = %s\n", osmo_hexdump(atuple->vec.sres, sizeof(atuple->vec.sres)));
print2buf(" .kc = %s\n", osmo_hexdump(atuple->vec.kc, sizeof(atuple->vec.kc)));
print2buf("}\n");
#undef print2buf
return buf;
}