static bool test_unref_reparent(void)
{
void *root, *p1, *p2, *c1;
printf("test: unref_reparent\n# UNREFERENCE AFTER PARENT FREED\n");
root = talloc_named_const(NULL, 0, "root");
p1 = talloc_named_const(root, 1, "orig parent");
p2 = talloc_named_const(root, 1, "parent by reference");
c1 = talloc_named_const(p1, 1, "child");
talloc_reference(p2, c1);
CHECK_PARENT("unref_reparent", c1, p1);
talloc_free(p1);
CHECK_PARENT("unref_reparent", c1, p2);
talloc_unlink(p2, c1);
CHECK_SIZE("unref_reparent", root, 1);
talloc_free(p2);
talloc_free(root);
printf("success: unref_reparent\n");
return true;
}
/*
test references
*/
static bool test_ref3(void)
{
void *root, *p1, *p2, *ref, *r1;
printf("test: ref3 [\nPARENT REFERENCE FREE\n]\n");
root = talloc_named_const(NULL, 0, "root");
p1 = talloc_named_const(root, 1, "p1");
p2 = talloc_named_const(root, 1, "p2");
r1 = talloc_named_const(p1, 1, "r1");
ref = talloc_reference(p2, r1);
talloc_report_full(root, stderr);
CHECK_BLOCKS("ref3", p1, 2);
CHECK_BLOCKS("ref3", p2, 2);
CHECK_BLOCKS("ref3", r1, 1);
fprintf(stderr, "Freeing p1\n");
talloc_free(p1);
talloc_report_full(root, stderr);
CHECK_BLOCKS("ref3", p2, 2);
CHECK_BLOCKS("ref3", r1, 1);
fprintf(stderr, "Freeing p2\n");
talloc_free(p2);
talloc_report_full(root, stderr);
CHECK_SIZE("ref3", root, 0);
talloc_free(root);
printf("success: ref3\n");
return true;
}
/*
create a directory, returning a handle to it
*/
NTSTATUS create_directory_handle(struct smbcli_tree *tree, const char *dname, int *fnum)
{
NTSTATUS status;
union smb_open io;
TALLOC_CTX *mem_ctx;
mem_ctx = talloc_named_const(tree, 0, "create_directory_handle");
io.generic.level = RAW_OPEN_NTCREATEX;
io.ntcreatex.in.root_fid.fnum = 0;
io.ntcreatex.in.flags = 0;
io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE | NTCREATEX_SHARE_ACCESS_DELETE;
io.ntcreatex.in.alloc_size = 0;
io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
io.ntcreatex.in.security_flags = 0;
io.ntcreatex.in.fname = dname;
status = smb_raw_open(tree, mem_ctx, &io);
talloc_free(mem_ctx);
if (NT_STATUS_IS_OK(status)) {
*fnum = io.ntcreatex.out.file.fnum;
}
return status;
}
NTSTATUS srv_fssa_start(struct messaging_context *msg_ctx)
{
NTSTATUS status;
fss_global.mem_ctx = talloc_named_const(NULL, 0,
"parent fss rpc server ctx");
if (fss_global.mem_ctx == NULL) {
return NT_STATUS_NO_MEMORY;
}
fss_global.db_path = lock_path(FSS_DB_NAME);
if (fss_global.db_path == NULL) {
talloc_free(fss_global.mem_ctx);
return NT_STATUS_NO_MEMORY;
}
fss_global.min_vers = FSRVP_RPC_VERSION_1;
fss_global.max_vers = FSRVP_RPC_VERSION_1;
/*
* The server MUST populate the GlobalShadowCopySetTable with the
* ShadowCopySet entries read from the configuration store.
*/
if (lp_parm_bool(GLOBAL_SECTION_SNUM, "fss", "prune stale", false)) {
fss_prune_stale(msg_ctx, fss_global.db_path);
}
become_root();
status = fss_state_retrieve(fss_global.mem_ctx, &fss_global.sc_sets,
&fss_global.sc_sets_count,
fss_global.db_path);
unbecome_root();
if (!NT_STATUS_IS_OK(status)) {
DEBUG(1, ("failed to retrieve fss server state: %s\n",
nt_errstr(status)));
}
return NT_STATUS_OK;
}
/* e must make sure to initialize logging before the BTS static
* constructors are executed below, as those call libosmocore APIs that
* require logging already to be initialized. */
__attribute__((constructor)) static void early_init(void)
{
if (!tall_pcu_ctx) {
tall_pcu_ctx = talloc_named_const(NULL, 1, "Osmo-PCU context");
osmo_init_logging2(tall_pcu_ctx, &gprs_log_info);
}
}
int main(int argc, char **argv)
{
void *ctx = talloc_named_const(NULL, 0, "gprs_test");
osmo_init_logging2(ctx, &info);
test_gsm_03_03_apn();
printf("Done.\n");
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
void *tall_msgb_ctx;
tall_bts_ctx = talloc_named_const(NULL, 1, "OsmoBTS context");
tall_msgb_ctx = talloc_named_const(tall_bts_ctx, 1, "msgb");
msgb_set_talloc_ctx(tall_msgb_ctx);
bts_log_init(NULL);
bts = gsm_bts_alloc(tall_bts_ctx);
if (bts_init(bts) < 0) {
fprintf(stderr, "unable to open bts\n");
exit(1);
}
btsb = bts_role_bts(bts);
test_cipher_parsing();
printf("Success\n");
return 0;
}
static bool test_unref_reparent(const struct torture_context *ctx)
{
void *root, *p1, *p2, *c1;
bool ret = false;
root = talloc_named_const(ctx, 0, "root");
if (!root)
goto out;
p1 = talloc_named_const(root, 1, "orig parent");
if (!p1)
goto out;
p2 = talloc_named_const(root, 1, "parent by reference");
if (!p2)
goto out;
c1 = talloc_named_const(p1, 1, "child");
if (!c1)
goto out;
if (!talloc_reference(p2, c1))
goto out;
CHECK_PARENT("unref_reparent", c1, p1);
talloc_free(p1);
CHECK_PARENT("unref_reparent", c1, p2);
talloc_unlink(p2, c1);
CHECK_SIZE("unref_reparent", root, 1);
talloc_free(p2);
ret = true;
out:
talloc_free(root);
return ret;
}
/*
test references
*/
static bool test_ref1(void)
{
void *root, *p1, *p2, *ref, *r1;
printf("test: ref1\n# SINGLE REFERENCE FREE\n");
root = talloc_named_const(NULL, 0, "root");
p1 = talloc_named_const(root, 1, "p1");
p2 = talloc_named_const(p1, 1, "p2");
talloc_named_const(p1, 1, "x1");
talloc_named_const(p1, 2, "x2");
talloc_named_const(p1, 3, "x3");
r1 = talloc_named_const(root, 1, "r1");
ref = talloc_reference(r1, p2);
talloc_report_full(root, stderr);
CHECK_BLOCKS("ref1", p1, 5);
CHECK_BLOCKS("ref1", p2, 1);
CHECK_BLOCKS("ref1", ref, 1);
CHECK_BLOCKS("ref1", r1, 2);
fprintf(stderr, "Freeing p2\n");
talloc_unlink(r1, p2);
talloc_report_full(root, stderr);
CHECK_BLOCKS("ref1", p1, 5);
CHECK_BLOCKS("ref1", p2, 1);
CHECK_BLOCKS("ref1", r1, 1);
fprintf(stderr, "Freeing p1\n");
talloc_free(p1);
talloc_report_full(root, stderr);
CHECK_BLOCKS("ref1", r1, 1);
fprintf(stderr, "Freeing r1\n");
talloc_free(r1);
talloc_report_full(NULL, stderr);
fprintf(stderr, "Testing NULL\n");
if (talloc_reference(root, NULL)) {
return false;
}
CHECK_BLOCKS("ref1", root, 1);
CHECK_SIZE("ref1", root, 0);
talloc_free(root);
printf("success: ref1\n");
return true;
}
/*
test references
*/
static bool test_ref2(void)
{
void *root, *p1, *p2, *ref, *r1;
printf("test: ref2\n# DOUBLE REFERENCE FREE\n");
root = talloc_named_const(NULL, 0, "root");
p1 = talloc_named_const(root, 1, "p1");
talloc_named_const(p1, 1, "x1");
talloc_named_const(p1, 1, "x2");
talloc_named_const(p1, 1, "x3");
p2 = talloc_named_const(p1, 1, "p2");
r1 = talloc_named_const(root, 1, "r1");
ref = talloc_reference(r1, p2);
talloc_report_full(root, stderr);
CHECK_BLOCKS("ref2", p1, 5);
CHECK_BLOCKS("ref2", p2, 1);
CHECK_BLOCKS("ref2", r1, 2);
fprintf(stderr, "Freeing ref\n");
talloc_unlink(r1, ref);
talloc_report_full(root, stderr);
CHECK_BLOCKS("ref2", p1, 5);
CHECK_BLOCKS("ref2", p2, 1);
CHECK_BLOCKS("ref2", r1, 1);
fprintf(stderr, "Freeing p2\n");
talloc_free(p2);
talloc_report_full(root, stderr);
CHECK_BLOCKS("ref2", p1, 4);
CHECK_BLOCKS("ref2", r1, 1);
fprintf(stderr, "Freeing p1\n");
talloc_free(p1);
talloc_report_full(root, stderr);
CHECK_BLOCKS("ref2", r1, 1);
fprintf(stderr, "Freeing r1\n");
talloc_free(r1);
talloc_report_full(root, stderr);
CHECK_SIZE("ref2", root, 0);
talloc_free(root);
printf("success: ref2\n");
return true;
}
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)
{
void *ctx = talloc_named_const(NULL, 0, "oap_client_test");
msgb_talloc_ctx_init(ctx, 0);
osmo_init_logging2(ctx, &info);
OSMO_ASSERT(osmo_stderr_target);
log_set_use_color(osmo_stderr_target, 0);
log_set_print_timestamp(osmo_stderr_target, 0);
log_set_print_filename(osmo_stderr_target, 0);
log_set_print_category(osmo_stderr_target, 1);
log_parse_category_mask(osmo_stderr_target, "DLOAP,1");
test_oap_api();
printf("Done\n");
return 0;
}
/*! \brief Initialize telnet based VTY interface
* \param[in] tall_ctx \ref talloc context
* \param[in] priv private data to be passed to callback
* \param[in] port UDP port number
*/
int telnet_init(void *tall_ctx, void *priv, int port)
{
struct sockaddr_in sock_addr;
int fd, rc, on = 1;
tall_telnet_ctx = talloc_named_const(tall_ctx, 1,
"telnet_connection");
/* FIXME: use new socket.c code of libosmocore */
fd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
if (fd < 0) {
LOGP(0, LOGL_ERROR, "Telnet interface socket creation failed\n");
return fd;
}
setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
memset(&sock_addr, 0, sizeof(sock_addr));
sock_addr.sin_family = AF_INET;
sock_addr.sin_port = htons(port);
sock_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
rc = bind(fd, (struct sockaddr*)&sock_addr, sizeof(sock_addr));
if (rc < 0) {
LOGP(0, LOGL_ERROR, "Telnet interface failed to bind\n");
close(fd);
return rc;
}
rc = listen(fd, 0);
if (rc < 0) {
LOGP(0, LOGL_ERROR, "Telnet interface failed to listen\n");
close(fd);
return rc;
}
server_socket.data = priv;
server_socket.fd = fd;
osmo_fd_register(&server_socket);
return 0;
}
/*
sees what IOCTLs are supported
*/
bool torture_ioctl_test(struct torture_context *tctx,
struct smbcli_state *cli)
{
uint16_t device, function;
int fnum;
const char *fname = "\\ioctl.dat";
NTSTATUS status;
union smb_ioctl parms;
TALLOC_CTX *mem_ctx;
mem_ctx = talloc_named_const(tctx, 0, "ioctl_test");
smbcli_unlink(cli->tree, fname);
fnum = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
if (fnum == -1) {
torture_comment(tctx, "open of %s failed (%s)\n", fname, smbcli_errstr(cli->tree));
return false;
}
parms.ioctl.level = RAW_IOCTL_IOCTL;
parms.ioctl.in.file.fnum = fnum;
parms.ioctl.in.request = IOCTL_QUERY_JOB_INFO;
status = smb_raw_ioctl(cli->tree, mem_ctx, &parms);
torture_comment(tctx, "ioctl job info: %s\n", smbcli_errstr(cli->tree));
for (device=0;device<0x100;device++) {
torture_comment(tctx, "testing device=0x%x\n", device);
for (function=0;function<0x100;function++) {
parms.ioctl.in.request = (device << 16) | function;
status = smb_raw_ioctl(cli->tree, mem_ctx, &parms);
if (NT_STATUS_IS_OK(status)) {
torture_comment(tctx, "ioctl device=0x%x function=0x%x OK : %d bytes\n",
device, function, (int)parms.ioctl.out.blob.length);
}
}
}
return true;
}
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;
}
/*
test references
*/
static bool test_unlink1(void)
{
void *root, *p1, *p2, *ref, *r1;
printf("test: unlink\n# UNLINK\n");
root = talloc_named_const(NULL, 0, "root");
p1 = talloc_named_const(root, 1, "p1");
talloc_named_const(p1, 1, "x1");
talloc_named_const(p1, 1, "x2");
talloc_named_const(p1, 1, "x3");
p2 = talloc_named_const(p1, 1, "p2");
r1 = talloc_named_const(p1, 1, "r1");
ref = talloc_reference(r1, p2);
talloc_report_full(root, stderr);
CHECK_BLOCKS("unlink", p1, 7);
CHECK_BLOCKS("unlink", p2, 1);
CHECK_BLOCKS("unlink", ref, 1);
CHECK_BLOCKS("unlink", r1, 2);
fprintf(stderr, "Unreferencing r1\n");
talloc_unlink(r1, p2);
talloc_report_full(root, stderr);
CHECK_BLOCKS("unlink", p1, 6);
CHECK_BLOCKS("unlink", p2, 1);
CHECK_BLOCKS("unlink", r1, 1);
fprintf(stderr, "Freeing p1\n");
talloc_free(p1);
talloc_report_full(root, stderr);
CHECK_SIZE("unlink", root, 0);
talloc_free(root);
printf("success: unlink\n");
return true;
}
int main(int argc, char** argv)
{
tall_bts_ctx = talloc_named_const(NULL, 1, "softBTS");
handle_options(argc, argv);
set_globals();
bts_core_set_rlimits();
daemonize();
/* Initialize */
srand(time(NULL));
telnet_init(TELNET_PORT);
socket_init(&oml.addr, &oml.socket, BSC_OML_PORT);
socket_init(&rsl.addr, &rsl.socket, BSC_RSL_PORT);
trx_socket_init(TRX_PORT);
while(1){
socket_select_main(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);
}
/*
miscellaneous tests to try to get a higher test coverage percentage
*/
static bool test_misc(void)
{
void *root, *p1;
char *p2;
double *d;
const char *name;
printf("test: misc\n# MISCELLANEOUS\n");
root = talloc_new(NULL);
p1 = talloc_size(root, 0x7fffffff);
torture_assert("misc", !p1, "failed: large talloc allowed\n");
p1 = talloc_strdup(root, "foo");
talloc_increase_ref_count(p1);
talloc_increase_ref_count(p1);
talloc_increase_ref_count(p1);
CHECK_BLOCKS("misc", p1, 1);
CHECK_BLOCKS("misc", root, 2);
talloc_unlink(NULL, p1);
CHECK_BLOCKS("misc", p1, 1);
CHECK_BLOCKS("misc", root, 2);
talloc_unlink(NULL, p1);
CHECK_BLOCKS("misc", p1, 1);
CHECK_BLOCKS("misc", root, 2);
p2 = talloc_strdup(p1, "foo");
torture_assert("misc", talloc_unlink(root, p2) == -1,
"failed: talloc_unlink() of non-reference context should return -1\n");
torture_assert("misc", talloc_unlink(p1, p2) == 0,
"failed: talloc_unlink() of parent should succeed\n");
talloc_unlink(NULL, p1);
CHECK_BLOCKS("misc", p1, 1);
CHECK_BLOCKS("misc", root, 2);
name = talloc_set_name(p1, "my name is %s", "foo");
torture_assert_str_equal("misc", talloc_get_name(p1), "my name is foo",
"failed: wrong name after talloc_set_name(my name is foo)");
torture_assert_str_equal("misc", talloc_get_name(p1), name,
"failed: wrong name after talloc_set_name(my name is foo)");
CHECK_BLOCKS("misc", p1, 2);
CHECK_BLOCKS("misc", root, 3);
talloc_set_name_const(p1, NULL);
torture_assert_str_equal ("misc", talloc_get_name(p1), "UNNAMED",
"failed: wrong name after talloc_set_name(NULL)");
CHECK_BLOCKS("misc", p1, 2);
CHECK_BLOCKS("misc", root, 3);
torture_assert("misc", talloc_free(NULL) == -1,
"talloc_free(NULL) should give -1\n");
talloc_set_destructor(p1, fail_destructor);
torture_assert("misc", talloc_free(p1) == -1,
"Failed destructor should cause talloc_free to fail\n");
talloc_set_destructor(p1, NULL);
talloc_report(root, stderr);
p2 = (char *)talloc_zero_size(p1, 20);
torture_assert("misc", p2[19] == 0, "Failed to give zero memory\n");
talloc_free(p2);
torture_assert("misc", talloc_strdup(root, NULL) == NULL,
"failed: strdup on NULL should give NULL\n");
p2 = talloc_strndup(p1, "foo", 2);
torture_assert("misc", strcmp("fo", p2) == 0,
"strndup doesn't work\n");
p2 = talloc_asprintf_append_buffer(p2, "o%c", 'd');
torture_assert("misc", strcmp("food", p2) == 0,
"talloc_asprintf_append_buffer doesn't work\n");
CHECK_BLOCKS("misc", p2, 1);
CHECK_BLOCKS("misc", p1, 3);
p2 = talloc_asprintf_append_buffer(NULL, "hello %s", "world");
torture_assert("misc", strcmp("hello world", p2) == 0,
"talloc_asprintf_append_buffer doesn't work\n");
CHECK_BLOCKS("misc", p2, 1);
CHECK_BLOCKS("misc", p1, 3);
talloc_free(p2);
d = talloc_array(p1, double, 0x20000000);
torture_assert("misc", !d, "failed: integer overflow not detected\n");
d = talloc_realloc(p1, d, double, 0x20000000);
torture_assert("misc", !d, "failed: integer overflow not detected\n");
talloc_free(p1);
CHECK_BLOCKS("misc", root, 1);
p1 = talloc_named(root, 100, "%d bytes", 100);
CHECK_BLOCKS("misc", p1, 2);
CHECK_BLOCKS("misc", root, 3);
talloc_unlink(root, p1);
p1 = talloc_init("%d bytes", 200);
p2 = talloc_asprintf(p1, "my test '%s'", "string");
torture_assert_str_equal("misc", p2, "my test 'string'",
"failed: talloc_asprintf(\"my test '%%s'\", \"string\") gave: \"%s\"");
CHECK_BLOCKS("misc", p1, 3);
CHECK_SIZE("misc", p2, 17);
CHECK_BLOCKS("misc", root, 1);
talloc_unlink(NULL, p1);
p1 = talloc_named_const(root, 10, "p1");
p2 = (char *)talloc_named_const(root, 20, "p2");
(void)talloc_reference(p1, p2);
talloc_report_full(root, stderr);
talloc_unlink(root, p2);
talloc_report_full(root, stderr);
CHECK_BLOCKS("misc", p2, 1);
CHECK_BLOCKS("misc", p1, 2);
CHECK_BLOCKS("misc", root, 3);
talloc_unlink(p1, p2);
talloc_unlink(root, p1);
p1 = talloc_named_const(root, 10, "p1");
p2 = (char *)talloc_named_const(root, 20, "p2");
(void)talloc_reference(NULL, p2);
talloc_report_full(root, stderr);
talloc_unlink(root, p2);
talloc_report_full(root, stderr);
CHECK_BLOCKS("misc", p2, 1);
CHECK_BLOCKS("misc", p1, 1);
CHECK_BLOCKS("misc", root, 2);
talloc_unlink(NULL, p2);
talloc_unlink(root, p1);
/* Test that talloc_unlink is a no-op */
torture_assert("misc", talloc_unlink(root, NULL) == -1,
"failed: talloc_unlink(root, NULL) == -1\n");
talloc_report(root, stderr);
talloc_report(NULL, stderr);
CHECK_SIZE("misc", root, 0);
talloc_free(root);
CHECK_SIZE("misc", NULL, 0);
talloc_enable_null_tracking_no_autofree();
talloc_enable_leak_report();
talloc_enable_leak_report_full();
printf("success: misc\n");
return true;
}
int main(int argc, char **argv)
{
int quit = 0;
int rc;
char const * home;
size_t len;
const char osmocomcfg[] = ".osmocom/bb/mobile.cfg";
char *config_file = NULL;
printf("%s\n", openbsc_copyright);
srand(time(NULL));
INIT_LLIST_HEAD(&ms_list);
log_init(&log_info, NULL);
stderr_target = log_target_create_stderr();
log_add_target(stderr_target);
log_set_all_filter(stderr_target, 1);
l23_ctx = talloc_named_const(NULL, 1, "layer2 context");
msgb_set_talloc_ctx(l23_ctx);
handle_options(argc, argv);
if (!debug_set)
log_parse_category_mask(stderr_target, debug_default);
log_set_log_level(stderr_target, LOGL_DEBUG);
if (gsmtap_ip) {
gsmtap_inst = gsmtap_source_init(gsmtap_ip, GSMTAP_UDP_PORT, 1);
if (!gsmtap_inst) {
fprintf(stderr, "Failed during gsmtap_init()\n");
exit(1);
}
gsmtap_source_add_sink(gsmtap_inst);
}
home = getenv("HOME");
if (home != NULL) {
len = strlen(home) + 1 + sizeof(osmocomcfg);
config_file = talloc_size(l23_ctx, len);
if (config_file != NULL)
snprintf(config_file, len, "%s/%s", home, osmocomcfg);
}
/* save the config file directory name */
config_dir = talloc_strdup(l23_ctx, config_file);
config_dir = dirname(config_dir);
if (use_mncc_sock)
rc = l23_app_init(mncc_recv_socket, config_file, vty_port);
else
rc = l23_app_init(NULL, config_file, vty_port);
if (rc)
exit(rc);
signal(SIGINT, sighandler);
signal(SIGHUP, sighandler);
signal(SIGTERM, sighandler);
signal(SIGPIPE, sighandler);
signal(SIGABRT, sighandler);
signal(SIGUSR1, sighandler);
signal(SIGUSR2, sighandler);
if (daemonize) {
printf("Running as daemon\n");
rc = osmo_daemonize();
if (rc)
fprintf(stderr, "Failed to run as daemon\n");
}
while (1) {
l23_app_work(&quit);
if (quit && llist_empty(&ms_list))
break;
osmo_select_main(0);
}
l23_app_exit();
talloc_free(config_file);
talloc_free(config_dir);
talloc_report_full(l23_ctx, stderr);
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)
{
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);
}
int bts_main(int argc, char **argv)
{
struct gsm_bts_role_bts *btsb;
struct gsm_bts_trx *trx;
struct e1inp_line *line;
void *tall_msgb_ctx;
int rc, i;
printf("((*))\n |\n / \\ OsmoBTS\n");
tall_bts_ctx = talloc_named_const(NULL, 1, "OsmoBTS context");
tall_msgb_ctx = talloc_pool(tall_bts_ctx, 100*1024);
msgb_set_talloc_ctx(tall_msgb_ctx);
bts_log_init(NULL);
handle_options(argc, argv);
bts = gsm_bts_alloc(tall_bts_ctx);
if (!bts) {
fprintf(stderr, "Failed to create BTS structure\n");
exit(1);
}
for (i = 1; i < trx_num; i++) {
trx = gsm_bts_trx_alloc(bts);
if (!trx) {
fprintf(stderr, "Failed to create TRX structure\n");
exit(1);
}
}
vty_init(&bts_vty_info);
e1inp_vty_init();
bts_vty_init(bts, &bts_log_info);
/* enable realtime priority for us */
if (rt_prio != -1) {
struct sched_param param;
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);
}
}
if (gsmtap_ip) {
gsmtap = gsmtap_source_init(gsmtap_ip, GSMTAP_UDP_PORT, 1);
if (!gsmtap) {
fprintf(stderr, "Failed during gsmtap_init()\n");
exit(1);
}
gsmtap_source_add_sink(gsmtap);
}
if (bts_init(bts) < 0) {
fprintf(stderr, "unable to open bts\n");
exit(1);
}
abis_init(bts);
rc = vty_read_config_file(config_file, NULL);
if (rc < 0) {
fprintf(stderr, "Failed to parse the config file: '%s'\n",
config_file);
exit(1);
}
write_pid_file("osmo-bts");
bts_controlif_setup(bts);
rc = telnet_init(tall_bts_ctx, NULL, OSMO_VTY_PORT_BTS);
if (rc < 0) {
fprintf(stderr, "Error initializing telnet\n");
exit(1);
}
if (pcu_sock_init()) {
fprintf(stderr, "PCU L1 socket failed\n");
exit(1);
}
signal(SIGINT, &signal_handler);
//signal(SIGABRT, &signal_handler);
signal(SIGUSR1, &signal_handler);
signal(SIGUSR2, &signal_handler);
osmo_init_ignore_signals();
btsb = bts_role_bts(bts);
if (!btsb->bsc_oml_host) {
fprintf(stderr, "Cannot start BTS without knowing BSC OML IP\n");
exit(1);
}
line = abis_open(bts, btsb->bsc_oml_host, "sysmoBTS");
if (!line) {
fprintf(stderr, "unable to connect to BSC\n");
exit(2);
}
if (daemonize) {
rc = osmo_daemonize();
if (rc < 0) {
perror("Error during daemonize");
exit(1);
}
}
while (quit < 2) {
log_reset_context();
osmo_select_main(0);
}
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
int rc;
struct ctrl_connection *ccon;
tall_mgr_ctx = talloc_named_const(NULL, 1, "bts manager");
msgb_talloc_ctx_init(tall_mgr_ctx, 0);
srand(time(NULL));
osmo_init_logging2(tall_mgr_ctx, &mgr_log_info);
if (classify_bts() != 0)
exit(2);
osmo_init_ignore_signals();
signal(SIGINT, &signal_handler);
signal(SIGTERM, &signal_handler);
signal(SIGUSR1, &signal_handler);
signal(SIGUSR2, &signal_handler);
rc = parse_options(argc, argv);
if (rc < 0)
exit(2);
sysmobts_mgr_vty_init();
logging_vty_add_cmds(&mgr_log_info);
rc = sysmobts_mgr_parse_config(&manager);
if (rc < 0) {
LOGP(DFIND, LOGL_FATAL, "Cannot parse config file\n");
exit(1);
}
rc = telnet_init(tall_mgr_ctx, NULL, OSMO_VTY_PORT_BTSMGR);
if (rc < 0) {
fprintf(stderr, "Error initializing telnet\n");
exit(1);
}
/* start temperature check timer */
temp_timer.cb = check_temp_timer_cb;
check_temp_timer_cb(NULL);
/* start operational hours timer */
hours_timer.cb = hours_timer_cb;
hours_timer_cb(NULL);
/* start uc temperature check timer */
sbts2050_uc_initialize();
/* handle broadcast messages for ipaccess-find */
if (sysmobts_mgr_nl_init() != 0)
exit(3);
/* Initialize the temperature control */
ccon = osmo_ctrl_conn_alloc(tall_mgr_ctx, NULL);
rc = -1;
if (ccon) {
ccon->write_queue.bfd.data = ccon;
rc = osmo_sock_init_ofd(&ccon->write_queue.bfd, AF_INET,
SOCK_STREAM, IPPROTO_TCP,
"localhost", OSMO_CTRL_PORT_BTS,
OSMO_SOCK_F_CONNECT);
}
if (rc < 0)
LOGP(DLCTRL, LOGL_ERROR, "Can't connect to CTRL @ localhost:%u\n",
OSMO_CTRL_PORT_BTS);
else
LOGP(DLCTRL, LOGL_NOTICE, "CTRL connected to locahost:%u\n",
OSMO_CTRL_PORT_BTS);
sysmobts_mgr_temp_init(&manager, ccon);
if (sysmobts_mgr_calib_init(&manager) != 0)
exit(3);
if (daemonize) {
rc = osmo_daemonize();
if (rc < 0) {
perror("Error during daemonize");
exit(1);
}
}
while (1) {
log_reset_context();
osmo_select_main(0);
}
}
void talloc_ctx_init(void)
{
tall_msgb_ctx = talloc_named_const(tall_bsc_ctx, 0, "msgb");
tall_fle_ctx = talloc_named_const(tall_bsc_ctx, 0,
"bs11_file_list_entry");
tall_locop_ctx = talloc_named_const(tall_bsc_ctx, 0, "loc_updating_oper");
tall_authciphop_ctx = talloc_named_const(tall_bsc_ctx, 0, "auth_ciph_oper");
tall_gsms_ctx = talloc_named_const(tall_bsc_ctx, 0, "sms");
tall_subscr_ctx = talloc_named_const(tall_bsc_ctx, 0, "subscriber");
tall_sub_req_ctx = talloc_named_const(tall_bsc_ctx, 0, "subscr_request");
tall_call_ctx = talloc_named_const(tall_bsc_ctx, 0, "gsm_call");
tall_paging_ctx = talloc_named_const(tall_bsc_ctx, 0, "paging_request");
tall_sigh_ctx = talloc_named_const(tall_bsc_ctx, 0, "signal_handler");
tall_tqe_ctx = talloc_named_const(tall_bsc_ctx, 0, "subch_txq_entry");
tall_trans_ctx = talloc_named_const(tall_bsc_ctx, 0, "transaction");
tall_map_ctx = talloc_named_const(tall_bsc_ctx, 0, "trau_map_entry");
tall_upq_ctx = talloc_named_const(tall_bsc_ctx, 0, "trau_upq_entry");
tall_ctr_ctx = talloc_named_const(tall_bsc_ctx, 0, "counter");
}
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);
}
const Object_Class* OBJECT_CLASS_PTR(Object)
{
static Object_Class the_class = {
.magic = CLASS_MAGIC,
.name = "Object",
.super = NULL,
.size = sizeof (Object),
.initializer = NULL,
.finalize = NULL,
};
static const Object the_default_object = { ._.isa = &the_class };
if (the_class.initializer == NULL) {
_ObjectClass_Lock();
the_class.initializer = &the_default_object;
_ObjectClass_Unlock();
}
return &the_class;
}
const Object_Class* OBJECT_BASE_CLASS_PTR(Object)
{
return OBJECT_CLASS_PTR(Object);
}
/*****************************************************************************
* _Object_check_alloc
*****************************************************************************/
static const char* const NAME_UNDER_CONSTRUCTION = "under construction";
Object*
_Object_check_alloc (void* talloc_context, const Object_Class* isa)
{
/*
* 1) check if we have a "real" context, or an object already
* allocated and under construction.
*/
if (talloc_get_name (talloc_context) == NAME_UNDER_CONSTRUCTION) {
return talloc_context; // ---------->
}
/*
* 2) Allocate a new object
*/
if (isa == NULL) {
Log_Print (LOG_ERROR, "Object CreateBase NULL isa class");
return NULL; // ---------->
}
Object* obj = talloc_named_const (talloc_context, isa->size,
NAME_UNDER_CONSTRUCTION);
if (obj == NULL) {
Log_Print (LOG_ERROR, "Object CreateBase Out of Memory");
return NULL; // ---------->
}
// Init fields to default values
if (isa->initializer)
memcpy (obj, isa->initializer, isa->size);
_OBJECT_SET_CLASS (obj, isa);
// Register destructor
talloc_set_destructor (obj, destroy);
return obj;
}
/*****************************************************************************
* Object_Create
*****************************************************************************/
Object*
Object_Create (void* parent_context, void* unused)
{
(void) unused;
Object* self = _Object_check_alloc (parent_context,
OBJECT_BASE_CLASS_PTR (Object));
// Finalize construction
if (self != NULL)
talloc_set_name_const (self, OBJECT_GET_CLASS_NAME (self));
return self;
}
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 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;
}
