int main(int argc, char **argv)
{
struct esme esme;
char *host = "localhost";
int port = 0;
int rc;
memset(&esme, 0, sizeof(esme));
osmo_init_logging(&log_info);
snprintf((char *) esme.system_id, sizeof(esme.system_id), "mirror");
snprintf((char *) esme.password, sizeof(esme.password), "mirror");
esme.smpp_version = 0x34;
if (argc >= 2)
host = argv[1];
if (argc >= 3)
port = atoi(argv[2]);
rc = smpp_esme_init(&esme, host, port);
if (rc < 0)
exit(1);
while (1) {
osmo_select_main(0);
}
exit(0);
}
int main(int argc, char **argv)
{
osmo_init_logging(&log_info);
test_auep();
return 0;
}
int bts_log_init(const char *category_mask)
{
osmo_init_logging(&bts_log_info);
if (category_mask)
log_parse_category_mask(osmo_stderr_target, category_mask);
return 0;
}
int main(int argc, char **argv)
{
struct nat_rewrite *trie;
osmo_init_logging(&log_info);
printf("Testing the trie\n");
trie = nat_rewrite_parse(NULL, "prefixes.csv");
OSMO_ASSERT(trie);
/* verify that it has been parsed */
OSMO_ASSERT(trie->prefixes == 17);
printf("Dumping the internal trie\n");
nat_rewrite_dump(trie);
/* now do the matching... */
OSMO_ASSERT(!nat_rewrite_lookup(trie, ""));
OSMO_ASSERT(!nat_rewrite_lookup(trie, "2"));
OSMO_ASSERT(strcmp(nat_rewrite_lookup(trie, "1")->rewrite, "1") == 0);
OSMO_ASSERT(strcmp(nat_rewrite_lookup(trie, "12")->rewrite, "2") == 0);
OSMO_ASSERT(strcmp(nat_rewrite_lookup(trie, "123")->rewrite, "3") == 0);
OSMO_ASSERT(strcmp(nat_rewrite_lookup(trie, "1234")->rewrite, "4") == 0);
OSMO_ASSERT(strcmp(nat_rewrite_lookup(trie, "12345")->rewrite, "5") == 0);
OSMO_ASSERT(strcmp(nat_rewrite_lookup(trie, "123456")->rewrite, "6") == 0);
OSMO_ASSERT(strcmp(nat_rewrite_lookup(trie, "1234567")->rewrite, "7") == 0);
OSMO_ASSERT(strcmp(nat_rewrite_lookup(trie, "12345678")->rewrite, "8") == 0);
OSMO_ASSERT(strcmp(nat_rewrite_lookup(trie, "123456789")->rewrite, "9") == 0);
OSMO_ASSERT(strcmp(nat_rewrite_lookup(trie, "1234567890")->rewrite, "10") == 0);
OSMO_ASSERT(strcmp(nat_rewrite_lookup(trie, "13")->rewrite, "11") == 0);
OSMO_ASSERT(strcmp(nat_rewrite_lookup(trie, "14")->rewrite, "12") == 0);
OSMO_ASSERT(strcmp(nat_rewrite_lookup(trie, "15")->rewrite, "13") == 0);
OSMO_ASSERT(strcmp(nat_rewrite_lookup(trie, "16")->rewrite, "14") == 0);
OSMO_ASSERT(strcmp(nat_rewrite_lookup(trie, "823455")->rewrite, "15") == 0);
OSMO_ASSERT(strcmp(nat_rewrite_lookup(trie, "82")->rewrite, "16") == 0);
OSMO_ASSERT(strcmp(nat_rewrite_lookup(trie, "+49123445")->rewrite, "17") == 0);
/* match a prefix */
OSMO_ASSERT(strcmp(nat_rewrite_lookup(trie, "121")->rewrite, "2") == 0);
OSMO_ASSERT(strcmp(nat_rewrite_lookup(trie, "1292323")->rewrite, "2") == 0);
OSMO_ASSERT(strcmp(nat_rewrite_lookup(trie, "12345678901")->rewrite, "10") == 0);
OSMO_ASSERT(strcmp(nat_rewrite_lookup(trie, "160")->rewrite, "14") == 0);
OSMO_ASSERT(strcmp(nat_rewrite_lookup(trie, "12345678901123452123123")->rewrite, "10") == 0);
/* invalid input */
OSMO_ASSERT(!nat_rewrite_lookup(trie, "12abc"));
talloc_free(trie);
trie = nat_rewrite_parse(NULL, "does_not_exist.csv");
OSMO_ASSERT(!trie);
printf("Done with the tests.\n");
return 0;
}
int main(int argc, char **argv)
{
osmo_init_logging(&log_info);
test_messages();
printf("Done\n");
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
osmo_init_logging(&info);
test_oap_api();
printf("Done\n");
return 0;
}
int main(int argc, char **argv)
{
osmo_init_logging(&info);
test_lapdm_polling();
printf("Success.\n");
return 0;
}
int main()
{
printf("Testing subscriber database code.\n");
osmo_init_logging(&log_info);
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(NULL, alice_imsi);
db_sync_subscriber(alice);
alice_db = db_get_subscriber(NULL, GSM_SUBSCRIBER_IMSI, alice->imsi);
COMPARE(alice, alice_db);
SUBSCR_PUT(alice_db);
SUBSCR_PUT(alice);
alice_imsi = "3693245423445";
alice = db_create_subscriber(NULL, alice_imsi);
db_subscriber_assoc_imei(alice, "1234567890");
db_subscriber_alloc_tmsi(alice);
alice->lac=42;
db_sync_subscriber(alice);
alice_db = db_get_subscriber(NULL, GSM_SUBSCRIBER_IMSI, alice_imsi);
COMPARE(alice, alice_db);
SUBSCR_PUT(alice);
SUBSCR_PUT(alice_db);
alice_imsi = "9993245423445";
alice = db_create_subscriber(NULL, alice_imsi);
db_subscriber_alloc_tmsi(alice);
alice->lac=42;
db_sync_subscriber(alice);
db_subscriber_assoc_imei(alice, "1234567890");
db_subscriber_assoc_imei(alice, "6543560920");
alice_db = db_get_subscriber(NULL, GSM_SUBSCRIBER_IMSI, alice_imsi);
COMPARE(alice, alice_db);
SUBSCR_PUT(alice);
SUBSCR_PUT(alice_db);
db_fini();
printf("Done\n");
return 0;
}
int main(int argc, char **argv)
{
osmo_init_logging(&log_info);
test_simple_sw_config();
test_simple_sw_short();
test_dual_sw_config();
test_sw_selection();
return EXIT_SUCCESS;
}
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;
}
int main(void)
{
osmo_init_logging(&log_info);
log_set_log_level(osmo_stderr_target, LOGL_INFO);
test_error();
test_auth_not_avail();
test_auth_then_ciph1();
test_auth_then_ciph2();
test_auth_reuse();
test_auth_reuse_key_seq_mismatch();
return 0;
}
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;
}
int main(int argc, char *argv[])
{
int teip;
tall_test = talloc_named_const(NULL, 1, "lapd_test");
osmo_init_logging(&lapd_test_log_info);
log_set_log_level(osmo_stderr_target, LOGL_NOTICE);
/*
* initialize datagram server.
*/
conn = osmo_dgram_create(tall_test);
if (conn == NULL) {
fprintf(stderr, "cannot create client\n");
exit(EXIT_FAILURE);
}
osmo_dgram_set_local_addr(conn, "127.0.0.1");
osmo_dgram_set_local_port(conn, 10001);
osmo_dgram_set_remote_addr(conn, "127.0.0.1");
osmo_dgram_set_remote_port(conn, 10000);
osmo_dgram_set_read_cb(conn, read_cb);
lapd = lapd_instance_alloc(1, lapd_tx_cb, conn, lapd_rx_cb, conn,
&lapd_profile_sat);
if (lapd == NULL) {
LOGP(DLAPDTEST, LOGL_ERROR, "cannot allocate instance\n");
exit(EXIT_FAILURE);
}
teip = lapd_tei_alloc(lapd, tei);
if (teip == 0) {
LOGP(DLAPDTEST, LOGL_ERROR, "cannot assign TEI\n");
exit(EXIT_FAILURE);
}
if (osmo_dgram_open(conn) < 0) {
fprintf(stderr, "cannot open client\n");
exit(EXIT_FAILURE);
}
LOGP(DLAPDTEST, LOGL_NOTICE, "Entering main loop\n");
while(1) {
osmo_select_main(0);
}
}
int main(int argc, char **argv)
{
struct smsc *smsc = talloc_zero(NULL, struct smsc);
int rc;
osmo_init_logging(&log_info);
strcpy(smsc->system_id, "OpenBSC");
rc = smpp_smsc_init(smsc, 6080);
if (rc < 0)
exit(1);
while (1) {
osmo_select_main(0);
}
}
int main(int argc, char **argv)
{
tall_pcu_ctx = talloc_named_const(NULL, 1, "moiji-mobile Emu-PCU context");
if (!tall_pcu_ctx)
abort();
msgb_set_talloc_ctx(tall_pcu_ctx);
osmo_init_logging(&gprs_log_info);
vty_init(&pcu_vty_info);
pcu_vty_init(&gprs_log_info);
current_test = 0;
init_main_bts();
create_and_connect_bssgp(bts_main_data(), INADDR_LOOPBACK, 23000);
for (;;)
osmo_select_main(0);
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
struct sockaddr_in bss_peer= {0};
osmo_init_logging(&info);
log_set_use_color(osmo_stderr_target, 0);
log_set_print_filename(osmo_stderr_target, 0);
bssgp_nsi = gprs_ns_instantiate(gprs_ns_callback, NULL);
bss_peer.sin_family = AF_INET;
bss_peer.sin_port = htons(32000);
bss_peer.sin_addr.s_addr = htonl(0x7f0000ff);
gprs_ns_nsip_connect(bssgp_nsi, &bss_peer, BSS_NSEI, BSS_NSEI+1);
printf("===== BSSGP test START\n");
test_bssgp_suspend_resume();
printf("===== BSSGP test END\n\n");
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
struct gsm_network dummy_network;
struct sockaddr_in addr;
int on = 1, rc;
tall_bsc_ctx = talloc_named_const(NULL, 1, "mgcp-callagent");
osmo_init_ignore_signals();
osmo_init_logging(&log_info);
cfg = mgcp_config_alloc();
if (!cfg)
return -1;
#ifdef BUILD_MGCP_TRANSCODING
cfg->setup_rtp_processing_cb = &mgcp_transcoding_setup;
cfg->rtp_processing_cb = &mgcp_transcoding_process_rtp;
cfg->get_net_downlink_format_cb = &mgcp_transcoding_net_downlink_format;
#endif
vty_info.copyright = openbsc_copyright;
vty_init(&vty_info);
logging_vty_add_cmds(&log_info);
mgcp_vty_init();
handle_options(argc, argv);
rc = mgcp_parse_config(config_file, cfg, MGCP_BSC);
if (rc < 0)
return rc;
rc = telnet_init(tall_bsc_ctx, &dummy_network, OSMO_VTY_PORT_BSC_MGCP);
if (rc < 0)
return rc;
/* set some callbacks */
cfg->reset_cb = mgcp_rsip_cb;
/* we need to bind a socket */
if (rc == 0) {
cfg->gw_fd.bfd.when = BSC_FD_READ;
cfg->gw_fd.bfd.cb = read_call_agent;
cfg->gw_fd.bfd.fd = socket(AF_INET, SOCK_DGRAM, 0);
if (cfg->gw_fd.bfd.fd < 0) {
perror("Gateway failed to listen");
return -1;
}
setsockopt(cfg->gw_fd.bfd.fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(cfg->source_port);
inet_aton(cfg->source_addr, &addr.sin_addr);
if (bind(cfg->gw_fd.bfd.fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
perror("Gateway failed to bind");
return -1;
}
cfg->gw_fd.bfd.data = msgb_alloc(4096, "mgcp-msg");
if (!cfg->gw_fd.bfd.data) {
fprintf(stderr, "Gateway memory error.\n");
return -1;
}
if (cfg->call_agent_addr) {
addr.sin_port = htons(2727);
inet_aton(cfg->call_agent_addr, &addr.sin_addr);
if (connect(cfg->gw_fd.bfd.fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
LOGP(DMGCP, LOGL_ERROR, "Failed to connect to: '%s'. errno: %d\n",
cfg->call_agent_addr, errno);
close(cfg->gw_fd.bfd.fd);
cfg->gw_fd.bfd.fd = -1;
return -1;
}
}
if (osmo_fd_register(&cfg->gw_fd.bfd) != 0) {
LOGP(DMGCP, LOGL_FATAL, "Failed to register the fd\n");
return -1;
}
LOGP(DMGCP, LOGL_NOTICE, "Configured for MGCP.\n");
}
/* initialisation */
srand(time(NULL));
if (daemonize) {
rc = osmo_daemonize();
if (rc < 0) {
perror("Error during daemonize");
exit(1);
}
}
/* main loop */
while (1) {
osmo_select_main(0);
}
return 0;
}
int main(int argc, char *argv[])
{
struct sched_param param;
struct gprs_rlcmac_bts *bts;
int rc;
tall_pcu_ctx = talloc_named_const(NULL, 1, "Osmo-PCU context");
if (!tall_pcu_ctx)
return -ENOMEM;
bv_tall_ctx = tall_pcu_ctx;
bts = bts_main_data();
bts->fc_interval = 1;
bts->initial_cs_dl = bts->initial_cs_ul = 1;
bts->cs1 = 1;
bts->t3142 = 20;
bts->t3169 = 5;
bts->t3191 = 5;
bts->t3193_msec = 100;
bts->t3195 = 5;
bts->n3101 = 10;
bts->n3103 = 4;
bts->n3105 = 8;
bts->alpha = 0; /* a = 0.0 */
msgb_set_talloc_ctx(tall_pcu_ctx);
osmo_init_logging(&gprs_log_info);
vty_init(&pcu_vty_info);
pcu_vty_init(&gprs_log_info);
handle_options(argc, argv);
if ((!!spoof_mcc) + (!!spoof_mnc) == 1) {
fprintf(stderr, "--mcc and --mnc must be specified "
"together.\n");
exit(0);
}
rc = vty_read_config_file(config_file, NULL);
if (rc < 0 && config_given) {
fprintf(stderr, "Failed to parse the config file: '%s'\n",
config_file);
exit(1);
}
if (rc < 0)
fprintf(stderr, "No config file: '%s' Using default config.\n",
config_file);
rc = telnet_init(tall_pcu_ctx, NULL, 4240);
if (rc < 0) {
fprintf(stderr, "Error initializing telnet\n");
exit(1);
}
if (!bts->alloc_algorithm)
bts->alloc_algorithm = alloc_algorithm_b;
rc = pcu_l1if_open();
if (rc < 0)
return rc;
signal(SIGINT, sighandler);
signal(SIGHUP, sighandler);
signal(SIGTERM, sighandler);
signal(SIGPIPE, sighandler);
signal(SIGABRT, sighandler);
signal(SIGUSR1, sighandler);
signal(SIGUSR2, sighandler);
/* enable realtime priority for us */
if (rt_prio != -1) {
memset(¶m, 0, sizeof(param));
param.sched_priority = rt_prio;
rc = sched_setscheduler(getpid(), SCHED_RR, ¶m);
if (rc != 0) {
fprintf(stderr, "Setting SCHED_RR priority(%d) failed: %s\n",
param.sched_priority, strerror(errno));
exit(1);
}
}
while (!quit) {
osmo_gsm_timers_check();
osmo_gsm_timers_prepare();
osmo_gsm_timers_update();
osmo_select_main(0);
}
telnet_exit();
pcu_l1if_close();
bts->bts->timing_advance()->flush();
talloc_report_full(tall_pcu_ctx, stderr);
talloc_free(tall_pcu_ctx);
return 0;
}
int main(int argc, char **argv)
{
int rc;
struct cmdline_cfg _ccfg;
struct cmdline_cfg *ccfg = &_ccfg;
memset(ccfg, '\0', sizeof(*ccfg));
ccfg->config_file = "./gtphub.conf";
ccfg->restart_counter_file = "./gtphub_restart_count";
struct gtphub_cfg _cfg;
struct gtphub_cfg *cfg = &_cfg;
memset(cfg, '\0', sizeof(*cfg));
struct gtphub _hub;
struct gtphub *hub = &_hub;
osmo_gtphub_ctx = talloc_named_const(NULL, 0, "osmo_gtphub");
msgb_talloc_ctx_init(osmo_gtphub_ctx, 0);
signal(SIGINT, &signal_handler);
signal(SIGABRT, &signal_handler);
signal(SIGUSR1, &signal_handler);
signal(SIGUSR2, &signal_handler);
osmo_init_ignore_signals();
osmo_init_logging(>phub_log_info);
vty_info.copyright = gtphub_copyright;
vty_init(&vty_info);
logging_vty_add_cmds(>phub_log_info);
gtphub_vty_init(hub, cfg);
rate_ctr_init(osmo_gtphub_ctx);
handle_options(ccfg, argc, argv);
rc = gtphub_cfg_read(cfg, ccfg->config_file);
if (rc < 0) {
LOGP(DGTPHUB, LOGL_FATAL, "Cannot parse config file '%s'\n",
ccfg->config_file);
exit(2);
}
/* start telnet after reading config for vty_get_bind_addr() */
rc = telnet_init_dynif(osmo_gtphub_ctx, 0, vty_get_bind_addr(),
OSMO_VTY_PORT_GTPHUB);
if (rc < 0)
exit(1);
if (gtphub_start(hub, cfg,
next_restart_count(ccfg->restart_counter_file))
!= 0)
return -1;
log_cfg(cfg);
if (ccfg->daemonize) {
rc = osmo_daemonize();
if (rc < 0) {
LOGP(DGTPHUB, LOGL_FATAL, "Error during daemonize");
exit(1);
}
}
while (1) {
rc = osmo_select_main(0);
if (rc < 0)
exit(3);
}
/* not reached */
exit(0);
}
int main(int argc, char *argv[])
{
struct gprs_rlcmac_bts *bts;
int rc;
tall_pcu_ctx = talloc_named_const(NULL, 1, "Osmo-PCU context");
if (!tall_pcu_ctx)
return -ENOMEM;
bv_tall_ctx = tall_pcu_ctx;
bts = gprs_rlcmac_bts = talloc_zero(tall_pcu_ctx,
struct gprs_rlcmac_bts);
if (!gprs_rlcmac_bts)
return -ENOMEM;
bts->fc_interval = 1;
bts->initial_cs_dl = bts->initial_cs_ul = 1;
bts->cs1 = 1;
bts->t3142 = 20;
bts->t3169 = 5;
bts->t3191 = 5;
bts->t3193_msec = 100;
bts->t3195 = 5;
bts->n3101 = 10;
bts->n3103 = 4;
bts->n3105 = 8;
bts->alpha = 0; /* a = 0.0 */
msgb_set_talloc_ctx(tall_pcu_ctx);
osmo_init_logging(&gprs_log_info);
vty_init(&pcu_vty_info);
pcu_vty_init(&gprs_log_info);
handle_options(argc, argv);
if ((!!spoof_mcc) + (!!spoof_mnc) == 1) {
fprintf(stderr, "--mcc and --mnc must be specified "
"together.\n");
exit(0);
}
rc = vty_read_config_file(config_file, NULL);
if (rc < 0 && config_given) {
fprintf(stderr, "Failed to parse the config file: '%s'\n",
config_file);
exit(1);
}
if (rc < 0)
fprintf(stderr, "No config file: '%s' Using default config.\n",
config_file);
rc = telnet_init(tall_pcu_ctx, NULL, 4240);
if (rc < 0) {
fprintf(stderr, "Error initializing telnet\n");
exit(1);
}
if (!bts->alloc_algorithm)
bts->alloc_algorithm = alloc_algorithm_b;
rc = pcu_l1if_open();
if (rc < 0)
return rc;
signal(SIGINT, sighandler);
signal(SIGHUP, sighandler);
signal(SIGTERM, sighandler);
signal(SIGPIPE, sighandler);
signal(SIGABRT, sighandler);
signal(SIGUSR1, sighandler);
signal(SIGUSR2, sighandler);
while (!quit) {
osmo_gsm_timers_check();
osmo_gsm_timers_prepare();
osmo_gsm_timers_update();
osmo_select_main(0);
#ifdef DEBUG_DIAGRAM
gettimeofday(&diagram_time, NULL);
#endif
}
telnet_exit();
pcu_l1if_close();
talloc_free(gprs_rlcmac_bts);
talloc_report_full(tall_pcu_ctx, stderr);
talloc_free(tall_pcu_ctx);
return 0;
}
int main(int argc, char **argv)
{
struct gsm_network dummy_network;
int rc;
tall_bsc_ctx = talloc_named_const(NULL, 0, "osmo_sgsn");
tall_msgb_ctx = talloc_named_const(tall_bsc_ctx, 0, "msgb");
signal(SIGINT, &signal_handler);
signal(SIGABRT, &signal_handler);
signal(SIGUSR1, &signal_handler);
signal(SIGUSR2, &signal_handler);
osmo_init_ignore_signals();
osmo_init_logging(&gprs_log_info);
vty_info.copyright = openbsc_copyright;
vty_init(&vty_info);
logging_vty_add_cmds(&gprs_log_info);
sgsn_vty_init();
handle_options(argc, argv);
rate_ctr_init(tall_bsc_ctx);
rc = telnet_init(tall_bsc_ctx, &dummy_network, 4245);
if (rc < 0)
exit(1);
gprs_ns_set_log_ss(DNS);
bssgp_set_log_ss(DBSSGP);
sgsn_nsi = gprs_ns_instantiate(&sgsn_ns_cb, tall_bsc_ctx);
if (!sgsn_nsi) {
LOGP(DGPRS, LOGL_ERROR, "Unable to instantiate NS\n");
exit(1);
}
bssgp_nsi = sgsn_inst.cfg.nsi = sgsn_nsi;
gprs_llc_init("/usr/local/lib/osmocom/crypt/");
gprs_ns_vty_init(bssgp_nsi);
bssgp_vty_init();
gprs_llc_vty_init();
gprs_sndcp_vty_init();
/* FIXME: register signal handler for SS_L_NS */
rc = sgsn_parse_config(sgsn_inst.config_file, &sgsn_inst.cfg);
if (rc < 0) {
LOGP(DGPRS, LOGL_FATAL, "Cannot parse config file\n");
exit(2);
}
rc = sgsn_gtp_init(&sgsn_inst);
if (rc) {
LOGP(DGPRS, LOGL_FATAL, "Cannot bind/listen on GTP socket\n");
exit(2);
}
rc = gprs_ns_nsip_listen(sgsn_nsi);
if (rc < 0) {
LOGP(DGPRS, LOGL_FATAL, "Cannot bind/listen on NSIP socket\n");
exit(2);
}
rc = gprs_ns_frgre_listen(sgsn_nsi);
if (rc < 0) {
LOGP(DGPRS, LOGL_FATAL, "Cannot bind/listen GRE "
"socket. Do you have CAP_NET_RAW?\n");
exit(2);
}
if (daemonize) {
rc = osmo_daemonize();
if (rc < 0) {
perror("Error during daemonize");
exit(1);
}
}
while (1) {
rc = osmo_select_main(0);
if (rc < 0)
exit(3);
}
/* not reached */
exit(0);
}
int main(int argc, char **argv)
{
struct osmo_msc_data *data;
int rc;
tall_bsc_ctx = talloc_named_const(NULL, 1, "openbsc");
osmo_init_logging(&log_info);
bts_init();
e1inp_init();
/* enable filters */
/* This needs to precede handle_options() */
vty_info.copyright = openbsc_copyright;
vty_init(&vty_info);
bsc_vty_init(&log_info);
/* parse options */
handle_options(argc, argv);
/* seed the PRNG */
srand(time(NULL));
/* initialize SCCP */
sccp_set_log_area(DSCCP);
rc = bsc_bootstrap_network(NULL, config_file);
if (rc < 0) {
fprintf(stderr, "Bootstrapping the network failed. exiting.\n");
exit(1);
}
bsc_api_init(bsc_gsmnet, osmo_bsc_api());
data = bsc_gsmnet->msc_data;
if (rf_ctl)
bsc_replace_string(data, &data->rf_ctrl_name, rf_ctl);
if (data->rf_ctrl_name) {
data->rf_ctl = osmo_bsc_rf_create(data->rf_ctrl_name,
bsc_gsmnet);
if (!data->rf_ctl) {
fprintf(stderr, "Failed to create the RF service.\n");
exit(1);
}
}
if (osmo_bsc_msc_init(bsc_gsmnet) != 0) {
LOGP(DNAT, LOGL_ERROR, "Failed to start up. Exiting.\n");
exit(1);
}
if (osmo_bsc_sccp_init(bsc_gsmnet) != 0) {
LOGP(DNM, LOGL_ERROR, "Failed to register SCCP.\n");
exit(1);
}
if (osmo_bsc_audio_init(bsc_gsmnet) != 0) {
LOGP(DMSC, LOGL_ERROR, "Failed to register audio support.\n");
exit(1);
}
signal(SIGINT, &signal_handler);
signal(SIGABRT, &signal_handler);
signal(SIGUSR1, &signal_handler);
signal(SIGUSR2, &signal_handler);
osmo_init_ignore_signals();
if (daemonize) {
rc = osmo_daemonize();
if (rc < 0) {
perror("Error during daemonize");
exit(1);
}
}
while (1) {
osmo_select_main(0);
}
return 0;
}
static void test_bssgp_flow_control_bvc(void)
{
struct bssgp_bvc_ctx bctx = {
.nsei = 0x1234,
.bvci = 0x5678,
};
const uint8_t tag = 42;
const uint32_t bmax = 0x1022 * 100;
const uint32_t rate = 0xc040 / 8 * 100;
const uint32_t bmax_ms = bmax / 2;
const uint32_t rate_ms = rate / 2;
uint8_t ratio = 0x78;
uint32_t qdelay = 0x1144 * 10;
int rc;
static uint8_t expected_simple_msg[] = {
0x26,
0x1e, 0x81, 0x2a, /* tag */
0x05, 0x82, 0x10, 0x22, /* Bmax */
0x03, 0x82, 0xc0, 0x40, /* R */
0x01, 0x82, 0x08, 0x11, /* Bmax_MS */
0x1c, 0x82, 0x60, 0x20, /* R_MS */
};
static uint8_t expected_ext_msg[] = {
0x26,
0x1e, 0x81, 0x2a, /* tag */
0x05, 0x82, 0x10, 0x22, /* Bmax */
0x03, 0x82, 0xc0, 0x40, /* R */
0x01, 0x82, 0x08, 0x11, /* Bmax_MS */
0x1c, 0x82, 0x60, 0x20, /* R_MS */
0x3c, 0x81, 0x78, /* ratio */
0x06, 0x82, 0x11, 0x44, /* Qdelay */
};
printf("----- %s START\n", __func__);
rc = bssgp_tx_fc_bvc(&bctx, tag, bmax, rate, bmax_ms, rate_ms,
NULL, NULL);
OSMO_ASSERT(rc >= 0);
OSMO_ASSERT(last_ns_tx_msg != NULL);
printf("Got message: %s\n", msgb_hexdump(last_ns_tx_msg));
OSMO_ASSERT(msgb_length(last_ns_tx_msg) == sizeof(expected_simple_msg));
OSMO_ASSERT(0 == memcmp(msgb_data(last_ns_tx_msg),
expected_simple_msg, sizeof(expected_simple_msg)));
rc = bssgp_tx_fc_bvc(&bctx, tag, bmax, rate, bmax_ms, rate_ms,
&ratio, &qdelay);
OSMO_ASSERT(rc >= 0);
OSMO_ASSERT(last_ns_tx_msg != NULL);
printf("Got message: %s\n", msgb_hexdump(last_ns_tx_msg));
OSMO_ASSERT(msgb_length(last_ns_tx_msg) == sizeof(expected_ext_msg));
OSMO_ASSERT(0 == memcmp(msgb_data(last_ns_tx_msg),
expected_ext_msg, sizeof(expected_ext_msg)));
msgb_free(last_ns_tx_msg);
last_ns_tx_msg = NULL;
printf("----- %s END\n", __func__);
}
static struct log_info info = {};
int main(int argc, char **argv)
{
struct sockaddr_in bss_peer= {0};
osmo_init_logging(&info);
log_set_use_color(osmo_stderr_target, 0);
log_set_print_filename(osmo_stderr_target, 0);
bssgp_nsi = gprs_ns_instantiate(gprs_ns_callback, NULL);
bss_peer.sin_family = AF_INET;
bss_peer.sin_port = htons(32000);
bss_peer.sin_addr.s_addr = htonl(0x7f0000ff);
gprs_ns_nsip_connect(bssgp_nsi, &bss_peer, BSS_NSEI, BSS_NSEI+1);
printf("===== BSSGP test START\n");
test_bssgp_suspend_resume();
test_bssgp_status();
test_bssgp_bad_reset();
test_bssgp_flow_control_bvc();
printf("===== BSSGP test END\n\n");
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
struct gsm_network dummy_network;
int rc;
tall_bsc_ctx = talloc_named_const(NULL, 0, "nsip_proxy");
tall_msgb_ctx = talloc_named_const(tall_bsc_ctx, 0, "msgb");
signal(SIGINT, &signal_handler);
signal(SIGABRT, &signal_handler);
signal(SIGUSR1, &signal_handler);
signal(SIGUSR2, &signal_handler);
osmo_init_ignore_signals();
osmo_init_logging(&gprs_log_info);
vty_info.copyright = openbsc_copyright;
vty_init(&vty_info);
logging_vty_add_cmds(&gprs_log_info);
gbproxy_vty_init();
handle_options(argc, argv);
rate_ctr_init(tall_bsc_ctx);
rc = telnet_init(tall_bsc_ctx, &dummy_network, 4246);
if (rc < 0)
exit(1);
bssgp_nsi = gprs_ns_instantiate(&proxy_ns_cb, tall_bsc_ctx);
if (!bssgp_nsi) {
LOGP(DGPRS, LOGL_ERROR, "Unable to instantiate NS\n");
exit(1);
}
gbcfg.nsi = bssgp_nsi;
gprs_ns_vty_init(bssgp_nsi);
gprs_ns_set_log_ss(DNS);
bssgp_set_log_ss(DBSSGP);
osmo_signal_register_handler(SS_L_NS, &gbprox_signal, NULL);
rc = gbproxy_parse_config(config_file, &gbcfg);
if (rc < 0) {
LOGP(DGPRS, LOGL_FATAL, "Cannot parse config file\n");
exit(2);
}
if (!gprs_nsvc_by_nsei(gbcfg.nsi, gbcfg.nsip_sgsn_nsei)) {
LOGP(DGPRS, LOGL_FATAL, "You cannot proxy to NSEI %u "
"without creating that NSEI before\n",
gbcfg.nsip_sgsn_nsei);
exit(2);
}
rc = gprs_ns_nsip_listen(bssgp_nsi);
if (rc < 0) {
LOGP(DGPRS, LOGL_FATAL, "Cannot bind/listen on NSIP socket\n");
exit(2);
}
rc = gprs_ns_frgre_listen(bssgp_nsi);
if (rc < 0) {
LOGP(DGPRS, LOGL_FATAL, "Cannot bind/listen GRE "
"socket. Do you have CAP_NET_RAW?\n");
exit(2);
}
if (daemonize) {
rc = osmo_daemonize();
if (rc < 0) {
perror("Error during daemonize");
exit(1);
}
}
/* Reset all the persistent NS-VCs that we've read from the config */
gbprox_reset_persistent_nsvcs(bssgp_nsi);
while (1) {
rc = osmo_select_main(0);
if (rc < 0)
exit(3);
}
exit(0);
}
int main(int argc, char **argv)
{
uint32_t bucket_size_max = 100; /* octets */
uint32_t bucket_leak_rate = 100; /* octets / second */
uint32_t max_queue_depth = 5; /* messages */
uint32_t pdu_length = 10; /* octets */
uint32_t pdu_count = 20; /* messages */
int c;
static const struct option long_options[] = {
{ "bucket-size-max", 1, 0, 's' },
{ "bucket-leak-rate", 1, 0, 'r' },
{ "max-queue-depth", 1, 0, 'd' },
{ "pdu-length", 1, 0, 'l' },
{ "pdu-count", 1, 0, 'c' },
{ "help", 0, 0, 'h' },
{ 0, 0, 0, 0 }
};
osmo_init_logging(&info);
log_set_use_color(osmo_stderr_target, 0);
log_set_print_filename(osmo_stderr_target, 0);
while ((c = getopt_long(argc, argv, "s:r:d:l:c:",
long_options, NULL)) != -1) {
switch (c) {
case 's':
bucket_size_max = atoi(optarg);
break;
case 'r':
bucket_leak_rate = atoi(optarg);
break;
case 'd':
max_queue_depth = atoi(optarg);
break;
case 'l':
pdu_length = atoi(optarg);
break;
case 'c':
pdu_count = atoi(optarg);
break;
case 'h':
help();
exit(EXIT_SUCCESS);
break;
default:
exit(EXIT_FAILURE);
}
}
/* bucket leak rate less than 100 not supported! */
if (bucket_leak_rate < 100) {
fprintf(stderr, "Bucket leak rate < 100 not supported!\n");
exit(EXIT_FAILURE);
}
printf("===== BSSGP flow-control test START\n");
printf("size-max=%u oct, leak-rate=%u oct/s, "
"queue-len=%u msgs, pdu_len=%u oct, pdu_cnt=%u\n\n", bucket_size_max,
bucket_leak_rate, max_queue_depth, pdu_length, pdu_count);
test_fc(bucket_size_max, bucket_leak_rate, max_queue_depth,
pdu_length, pdu_count);
printf("===== BSSGP flow-control test END\n\n");
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
struct ctrl_handle *ctrl;
struct gsm_network dummy_network;
int rc;
tall_bsc_ctx = talloc_named_const(NULL, 0, "osmo_sgsn");
tall_msgb_ctx = talloc_named_const(tall_bsc_ctx, 0, "msgb");
signal(SIGINT, &signal_handler);
signal(SIGABRT, &signal_handler);
signal(SIGUSR1, &signal_handler);
signal(SIGUSR2, &signal_handler);
osmo_init_ignore_signals();
osmo_init_logging(&gprs_log_info);
vty_info.copyright = openbsc_copyright;
vty_init(&vty_info);
logging_vty_add_cmds(&gprs_log_info);
sgsn_vty_init();
handle_options(argc, argv);
rate_ctr_init(tall_bsc_ctx);
rc = telnet_init(tall_bsc_ctx, &dummy_network, OSMO_VTY_PORT_SGSN);
if (rc < 0)
exit(1);
ctrl = sgsn_controlif_setup(NULL, OSMO_CTRL_PORT_SGSN);
if (!ctrl) {
LOGP(DGPRS, LOGL_ERROR, "Failed to create CTRL interface.\n");
exit(1);
}
if (sgsn_ctrl_cmds_install() != 0) {
LOGP(DGPRS, LOGL_ERROR, "Failed to install CTRL commands.\n");
exit(1);
}
gprs_ns_set_log_ss(DNS);
bssgp_set_log_ss(DBSSGP);
sgsn_nsi = gprs_ns_instantiate(&sgsn_ns_cb, tall_bsc_ctx);
if (!sgsn_nsi) {
LOGP(DGPRS, LOGL_ERROR, "Unable to instantiate NS\n");
exit(1);
}
bssgp_nsi = sgsn_inst.cfg.nsi = sgsn_nsi;
gprs_llc_init("/usr/local/lib/osmocom/crypt/");
sgsn_inst_init();
gprs_ns_vty_init(bssgp_nsi);
bssgp_vty_init();
gprs_llc_vty_init();
gprs_sndcp_vty_init();
sgsn_auth_init();
sgsn_cdr_init(&sgsn_inst);
/* FIXME: register signal handler for SS_L_NS */
rc = sgsn_parse_config(sgsn_inst.config_file, &sgsn_inst.cfg);
if (rc < 0) {
LOGP(DGPRS, LOGL_FATAL, "Cannot parse config file\n");
exit(2);
}
rc = sgsn_gtp_init(&sgsn_inst);
if (rc) {
LOGP(DGPRS, LOGL_FATAL, "Cannot bind/listen on GTP socket\n");
exit(2);
}
rc = gprs_subscr_init(&sgsn_inst);
if (rc < 0) {
LOGP(DGPRS, LOGL_FATAL, "Cannot set up subscriber management\n");
exit(2);
}
rc = gprs_ns_nsip_listen(sgsn_nsi);
if (rc < 0) {
LOGP(DGPRS, LOGL_FATAL, "Cannot bind/listen on NSIP socket\n");
exit(2);
}
rc = gprs_ns_frgre_listen(sgsn_nsi);
if (rc < 0) {
LOGP(DGPRS, LOGL_FATAL, "Cannot bind/listen GRE "
"socket. Do you have CAP_NET_RAW?\n");
exit(2);
}
if (sgsn->cfg.dynamic_lookup) {
if (sgsn_ares_init(sgsn) != 0) {
LOGP(DGPRS, LOGL_FATAL,
"Failed to initialize c-ares(%d)\n", rc);
exit(4);
}
}
if (daemonize) {
rc = osmo_daemonize();
if (rc < 0) {
perror("Error during daemonize");
exit(1);
}
}
while (1) {
rc = osmo_select_main(0);
if (rc < 0)
exit(3);
}
/* not reached */
exit(0);
}
