int main(int argc, char **argv)
{
char *host = "localhost";
int i, rc;
openlog("gpsdate", LOG_PERROR, LOG_CRON);
if (argc > 1)
host = argv[1];
for (i = 1; i <= NUM_RETRIES; i++) {
printf("Attempt #%d to connect to gpsd at %s...\n", i, host);
rc = gps_open(host, DEFAULT_GPSD_PORT, &gpsdata);
if (!rc)
break;
sleep(RETRY_SLEEP);
}
if (rc) {
syslog(LOG_ERR, "no gpsd running or network error: %d, %s\n",
errno, gps_errstr(errno));
closelog();
exit(EXIT_FAILURE);
}
osmo_daemonize();
gps_stream(&gpsdata, WATCH_ENABLE|WATCH_JSON, NULL);
/* We run in an endless loop. The only reasonable way to exit is after
* a correct GPS timestamp has been received in callback() */
while (1)
gps_mainloop(&gpsdata, INT_MAX, callback);
gps_close(&gpsdata);
closelog();
exit(EXIT_SUCCESS);
}
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)
{
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);
}
}
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;
}
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)
{
char *host = "localhost";
char *port = DEFAULT_GPSD_PORT;
int num_retries = NUM_RETRIES;
int retry_sleep = RETRY_SLEEP;
int i, rc;
enum state state;
openlog("gps-wd", LOG_PERROR, LOG_CRON);
while (1) {
int option_index = 0, c;
static struct option long_options[] = {
{"num-retries", 1, 0, 'n'},
{"retry-sleep", 1, 0, 's'},
{"no-detach", 0, 0, 'd'},
{"timeout", 1, 0, 't'},
{"service-name", 1, 0, 'r'},
{0,0,0,0}
};
c = getopt_long(argc, argv, "n:s:dt:r:",
long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 'n':
num_retries = atoi(optarg);
break;
case 's':
retry_sleep = atoi(optarg);
break;
case 'd':
no_detach = 1;
break;
case 't':
timeout = atoi(optarg);
break;
case 'r':
service_name = optarg;
break;
}
}
if (optind < argc)
host = argv[optind++];
if (optind < argc)
port = argv[optind++];
syslog(LOG_INFO, "starting gps-wd for %s:%s (timeout %ds, service %s)",
host, port, timeout, service_name);
/* attempt up to NUM_RETRIES times to connect to gpsd while we are
* still running in foreground. The idea is that we will block the
* boot process (init scripts) until we have a connection */
for (i = 1; i <= num_retries; i++) {
printf("Attempt #%d to connect to gpsd at %s...\n", i, host);
rc = attempt_reconnect(host, port, &gpsdata);
if (rc >= 0)
break;
sleep(retry_sleep);
}
if (rc < 0) {
syslog(LOG_ERR, "no gpsd running or network error: %d, %s\n",
errno, gps_errstr(errno));
closelog();
exit(EXIT_FAILURE);
}
state = S_CONNECTED;
if (!no_detach)
osmo_daemonize();
signal(SIGALRM, alarm_hdlr);
/* We run in an endless loop. The only reasonable way to exit is after
* a correct GPS timestamp has been received in callback() */
while (1) {
switch (state) {
case S_CONNECTED:
alarm(timeout);
rc = my_gps_mainloop(&gpsdata, INT_MAX, callback);
if (rc < 1) {
syslog(LOG_ERR, "connection to gpsd was "
"closed: %d, reconnecting\n", rc);
gps_close(&gpsdata);
alarm(0);
state = S_RECONNECT;
}
break;
case S_RECONNECT:
rc = attempt_reconnect(host, port, &gpsdata);
if (rc < 0)
sleep(RETRY_SLEEP);
else
state = S_CONNECTED;
break;
}
}
gps_close(&gpsdata);
closelog();
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);
}
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 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 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);
}