int main(int argc, char **argv)
{
struct l1fwd_hdl *l1fh;
struct femtol1_hdl *fl1h;
int rc, i;
printf("sizeof(GsmL1_Prim_t) = %zu\n", sizeof(GsmL1_Prim_t));
printf("sizeof(SuperFemto_Prim_t) = %zu\n", sizeof(SuperFemto_Prim_t));
bts_log_init(NULL);
/* allocate new femtol1_handle */
fl1h = talloc_zero(NULL, struct femtol1_hdl);
INIT_LLIST_HEAD(&fl1h->wlc_list);
/* open the actual hardware transport */
for (i = 0; i < ARRAY_SIZE(fl1h->write_q); i++) {
rc = l1if_transport_open(i, fl1h);
if (rc < 0)
exit(1);
}
/* create our fwd handle */
l1fh = talloc_zero(NULL, struct l1fwd_hdl);
l1fh->fl1h = fl1h;
fl1h->priv = l1fh;
/* Open UDP */
for (i = 0; i < ARRAY_SIZE(l1fh->udp_wq); i++) {
struct osmo_wqueue *wq = &l1fh->udp_wq[i];
osmo_wqueue_init(wq, 10);
wq->write_cb = udp_write_cb;
wq->read_cb = udp_read_cb;
wq->bfd.when |= BSC_FD_READ;
wq->bfd.data = l1fh;
wq->bfd.priv_nr = i;
rc = osmo_sock_init_ofd(&wq->bfd, AF_UNSPEC, SOCK_DGRAM,
IPPROTO_UDP, NULL, fwd_udp_ports[i],
OSMO_SOCK_F_BIND);
if (rc < 0) {
perror("sock_init");
exit(1);
}
}
while (1) {
rc = osmo_select_main(0);
if (rc < 0) {
perror("select");
exit(1);
}
}
exit(0);
}
int l1if_transport_open(int q, struct femtol1_hdl *hdl)
{
int rc;
/* Step 1: Open all msg_queue file descriptors */
struct osmo_fd *read_ofd = &hdl->read_ofd[q];
struct osmo_wqueue *wq = &hdl->write_q[q];
struct osmo_fd *write_ofd = &hdl->write_q[q].bfd;
rc = open(rd_devnames[q], O_RDONLY);
if (rc < 0) {
LOGP(DL1IF, LOGL_FATAL, "unable to open msg_queue: %s\n",
strerror(errno));
return rc;
}
read_ofd->fd = rc;
read_ofd->priv_nr = q;
read_ofd->data = hdl;
read_ofd->cb = l1if_fd_cb;
read_ofd->when = BSC_FD_READ;
rc = osmo_fd_register(read_ofd);
if (rc < 0) {
close(read_ofd->fd);
read_ofd->fd = -1;
return rc;
}
rc = open(wr_devnames[q], O_WRONLY);
if (rc < 0) {
LOGP(DL1IF, LOGL_FATAL, "unable to open msg_queue: %s\n",
strerror(errno));
goto out_read;
}
osmo_wqueue_init(wq, 10);
wq->write_cb = l1fd_write_cb;
write_ofd->fd = rc;
write_ofd->priv_nr = q;
write_ofd->data = hdl;
write_ofd->when = BSC_FD_WRITE;
rc = osmo_fd_register(write_ofd);
if (rc < 0) {
close(write_ofd->fd);
write_ofd->fd = -1;
goto out_read;
}
return 0;
out_read:
close(hdl->read_ofd[q].fd);
osmo_fd_unregister(&hdl->read_ofd[q]);
return rc;
}
static void test_wqueue_limit(void)
{
struct msgb *msg;
struct osmo_wqueue wqueue;
int rc;
osmo_wqueue_init(&wqueue, 0);
OSMO_ASSERT(wqueue.max_length == 0);
OSMO_ASSERT(wqueue.current_length == 0);
OSMO_ASSERT(wqueue.read_cb == NULL);
OSMO_ASSERT(wqueue.write_cb == NULL);
OSMO_ASSERT(wqueue.except_cb == NULL);
/* try to add and fail */
msg = msgb_alloc(4096, "msg1");
rc = osmo_wqueue_enqueue(&wqueue, msg);
OSMO_ASSERT(rc < 0);
/* add one and fail on the second */
wqueue.max_length = 1;
rc = osmo_wqueue_enqueue(&wqueue, msg);
OSMO_ASSERT(rc == 0);
OSMO_ASSERT(wqueue.current_length == 1);
msg = msgb_alloc(4096, "msg2");
rc = osmo_wqueue_enqueue(&wqueue, msg);
OSMO_ASSERT(rc < 0);
/* add one more */
wqueue.max_length = 2;
rc = osmo_wqueue_enqueue(&wqueue, msg);
OSMO_ASSERT(rc == 0);
OSMO_ASSERT(wqueue.current_length == 2);
/* release everything */
osmo_wqueue_clear(&wqueue);
OSMO_ASSERT(wqueue.current_length == 0);
OSMO_ASSERT(wqueue.max_length == 2);
/* Add two, fail on the third, free it and the queue */
msg = msgb_alloc(4096, "msg3");
rc = osmo_wqueue_enqueue(&wqueue, msg);
OSMO_ASSERT(rc == 0);
OSMO_ASSERT(wqueue.current_length == 1);
msg = msgb_alloc(4096, "msg4");
rc = osmo_wqueue_enqueue(&wqueue, msg);
OSMO_ASSERT(rc == 0);
OSMO_ASSERT(wqueue.current_length == 2);
msg = msgb_alloc(4096, "msg5");
rc = osmo_wqueue_enqueue(&wqueue, msg);
OSMO_ASSERT(rc < 0);
OSMO_ASSERT(wqueue.current_length == 2);
msgb_free(msg);
osmo_wqueue_clear(&wqueue);
}
struct bsc_msc_connection *bsc_msc_create(void *ctx, struct llist_head *dests)
{
struct bsc_msc_connection *con;
con = talloc_zero(NULL, struct bsc_msc_connection);
if (!con) {
LOGP(DMSC, LOGL_FATAL, "Failed to create the MSC connection.\n");
return NULL;
}
con->dests = dests;
con->write_queue.bfd.fd = -1;
con->name = "";
osmo_wqueue_init(&con->write_queue, 100);
return con;
}
static int ussd_listen_cb(struct osmo_fd *bfd, unsigned int what)
{
struct bsc_nat_ussd_con *conn;
struct bsc_nat *nat;
struct sockaddr_in sa;
socklen_t sa_len = sizeof(sa);
int fd;
if (!(what & BSC_FD_READ))
return 0;
fd = accept(bfd->fd, (struct sockaddr *) &sa, &sa_len);
if (fd < 0) {
perror("accept");
return fd;
}
nat = (struct bsc_nat *) bfd->data;
osmo_counter_inc(nat->stats.ussd.reconn);
conn = bsc_nat_ussd_alloc(nat);
if (!conn) {
LOGP(DNAT, LOGL_ERROR, "Failed to allocate USSD con struct.\n");
close(fd);
return -1;
}
osmo_wqueue_init(&conn->queue, 10);
conn->queue.bfd.data = conn;
conn->queue.bfd.fd = fd;
conn->queue.bfd.when = BSC_FD_READ;
conn->queue.read_cb = ussd_read_cb;
conn->queue.write_cb = bsc_write_cb;
if (osmo_fd_register(&conn->queue.bfd) < 0) {
LOGP(DNAT, LOGL_ERROR, "Failed to register USSD fd.\n");
bsc_nat_ussd_destroy(conn);
return -1;
}
LOGP(DNAT, LOGL_NOTICE, "USSD Connection on %d with IP: %s\n",
fd, inet_ntoa(sa.sin_addr));
/* do authentication */
ussd_start_auth(conn);
return 0;
}
int meas_feed_cfg_set(const char *dst_host, uint16_t dst_port)
{
int rc;
int already_initialized = 0;
if (g_mfs.wqueue.bfd.fd)
already_initialized = 1;
if (already_initialized &&
!strcmp(dst_host, g_mfs.dst_host) &&
dst_port == g_mfs.dst_port)
return 0;
if (!already_initialized) {
osmo_wqueue_init(&g_mfs.wqueue, 10);
g_mfs.wqueue.write_cb = feed_write_cb;
g_mfs.wqueue.read_cb = feed_read_cb;
osmo_signal_register_handler(SS_LCHAN, meas_feed_sig_cb, NULL);
}
if (already_initialized) {
osmo_wqueue_clear(&g_mfs.wqueue);
osmo_fd_unregister(&g_mfs.wqueue.bfd);
close(g_mfs.wqueue.bfd.fd);
/* don't set to zero, as that would mean 'not yet initialized' */
g_mfs.wqueue.bfd.fd = -1;
}
rc = osmo_sock_init_ofd(&g_mfs.wqueue.bfd, AF_UNSPEC, SOCK_DGRAM,
IPPROTO_UDP, dst_host, dst_port,
OSMO_SOCK_F_CONNECT);
if (rc < 0)
return rc;
g_mfs.wqueue.bfd.when &= ~BSC_FD_READ;
if (g_mfs.dst_host)
talloc_free(g_mfs.dst_host);
g_mfs.dst_host = talloc_strdup(NULL, dst_host);
g_mfs.dst_port = dst_port;
return 0;
}
static int smpp_esme_init(struct esme *esme, const char *host, uint16_t port)
{
int rc;
if (port == 0)
port = 2775;
esme->own_seq_nr = rand();
esme_inc_seq_nr(esme);
osmo_wqueue_init(&esme->wqueue, 10);
esme->wqueue.bfd.data = esme;
esme->wqueue.read_cb = esme_read_cb;
esme->wqueue.write_cb = esme_write_cb;
rc = osmo_sock_init_ofd(&esme->wqueue.bfd, AF_UNSPEC, SOCK_STREAM,
IPPROTO_TCP, host, port, OSMO_SOCK_F_CONNECT);
if (rc < 0)
return rc;
return bind_transceiver(esme);
}
/*! \brief Open GSMTAP source socket, connect and register osmo_fd
* \param[in] host host name or IP address in string format
* \param[in] port UDP port number in host byte order
* \param[in] ofd_wq_mode Register \ref osmo_wqueue (1) or not (0)
*
* Open GSMTAP source (sending) socket, connect it to host/port,
* allocate 'struct gsmtap_inst' and optionally osmo_fd/osmo_wqueue
* registration. This means it is like \ref gsmtap_init2 but integrated
* with libosmocore \ref select */
struct gsmtap_inst *gsmtap_source_init(const char *host, uint16_t port,
int ofd_wq_mode)
{
struct gsmtap_inst *gti;
int fd;
fd = gsmtap_source_init_fd(host, port);
if (fd < 0)
return NULL;
gti = talloc_zero(NULL, struct gsmtap_inst);
gti->ofd_wq_mode = ofd_wq_mode;
gti->wq.bfd.fd = fd;
gti->sink_ofd.fd = -1;
if (ofd_wq_mode) {
osmo_wqueue_init(>i->wq, 64);
gti->wq.write_cb = &gsmtap_wq_w_cb;
osmo_fd_register(>i->wq.bfd);
}
return gti;
}
int main(int argc, char **argv)
{
struct l1fwd_hdl *l1fh;
struct femtol1_hdl *fl1h;
int rc, i;
printf("sizeof(GsmL1_Prim_t) = %zu\n", sizeof(GsmL1_Prim_t));
printf("sizeof(SuperFemto_Prim_t) = %zu\n", sizeof(SuperFemto_Prim_t));
bts_log_init(NULL);
/*
* hack and prevent that two l1fwd-proxy/sysmobts run at the same
* time. This is done by binding to the same VTY port.
*/
rc = osmo_sock_init(AF_UNSPEC, SOCK_STREAM, IPPROTO_TCP,
"127.0.0.1", 4241, OSMO_SOCK_F_BIND);
if (rc < 0) {
fprintf(stderr, "Failed to bind to the BTS VTY port.\n");
return EXIT_FAILURE;
}
/* allocate new femtol1_handle */
fl1h = talloc_zero(NULL, struct femtol1_hdl);
INIT_LLIST_HEAD(&fl1h->wlc_list);
/* open the actual hardware transport */
for (i = 0; i < ARRAY_SIZE(fl1h->write_q); i++) {
rc = l1if_transport_open(i, fl1h);
if (rc < 0)
exit(1);
}
/* create our fwd handle */
l1fh = talloc_zero(NULL, struct l1fwd_hdl);
l1fh->fl1h = fl1h;
fl1h->priv = l1fh;
/* Open UDP */
for (i = 0; i < ARRAY_SIZE(l1fh->udp_wq); i++) {
struct osmo_wqueue *wq = &l1fh->udp_wq[i];
osmo_wqueue_init(wq, 10);
wq->write_cb = udp_write_cb;
wq->read_cb = udp_read_cb;
wq->bfd.when |= BSC_FD_READ;
wq->bfd.data = l1fh;
wq->bfd.priv_nr = i;
rc = osmo_sock_init_ofd(&wq->bfd, AF_UNSPEC, SOCK_DGRAM,
IPPROTO_UDP, NULL, fwd_udp_ports[i],
OSMO_SOCK_F_BIND);
if (rc < 0) {
perror("sock_init");
exit(1);
}
}
while (1) {
rc = osmo_select_main(0);
if (rc < 0) {
perror("select");
exit(1);
}
}
exit(0);
}
