int sgsn_gtp_init(struct sgsn_instance *sgi)
{
int rc;
struct gsn_t *gsn;
rc = gtp_new(&sgi->gsn, sgi->cfg.gtp_statedir,
&sgi->cfg.gtp_listenaddr.sin_addr, GTP_MODE_SGSN);
if (rc) {
LOGP(DGPRS, LOGL_ERROR, "Failed to create GTP: %d\n", rc);
return rc;
}
gsn = sgi->gsn;
sgi->gtp_fd0.fd = gsn->fd0;
sgi->gtp_fd0.priv_nr = 0;
sgi->gtp_fd0.data = sgi;
sgi->gtp_fd0.when = BSC_FD_READ;
sgi->gtp_fd0.cb = sgsn_gtp_fd_cb;
rc = osmo_fd_register(&sgi->gtp_fd0);
if (rc < 0)
return rc;
sgi->gtp_fd1c.fd = gsn->fd1c;
sgi->gtp_fd1c.priv_nr = 1;
sgi->gtp_fd1c.data = sgi;
sgi->gtp_fd1c.when = BSC_FD_READ;
sgi->gtp_fd1c.cb = sgsn_gtp_fd_cb;
rc = osmo_fd_register(&sgi->gtp_fd1c);
if (rc < 0) {
osmo_fd_unregister(&sgi->gtp_fd0);
return rc;
}
sgi->gtp_fd1u.fd = gsn->fd1u;
sgi->gtp_fd1u.priv_nr = 2;
sgi->gtp_fd1u.data = sgi;
sgi->gtp_fd1u.when = BSC_FD_READ;
sgi->gtp_fd1u.cb = sgsn_gtp_fd_cb;
rc = osmo_fd_register(&sgi->gtp_fd1u);
if (rc < 0) {
osmo_fd_unregister(&sgi->gtp_fd0);
osmo_fd_unregister(&sgi->gtp_fd1c);
return rc;
}
/* Start GTP re-transmission timer */
sgi->gtp_timer.cb = sgsn_gtp_tmr_cb;
sgi->gtp_timer.data = sgi;
sgsn_gtp_tmr_start(sgi);
/* Register callbackcs with libgtp */
gtp_set_cb_delete_context(gsn, cb_delete_context);
gtp_set_cb_conf(gsn, cb_conf);
gtp_set_cb_recovery(gsn, cb_recovery);
gtp_set_cb_data_ind(gsn, cb_data_ind);
gtp_set_cb_unsup_ind(gsn, cb_unsup_ind);
gtp_set_cb_extheader_ind(gsn, cb_extheader_ind);
return 0;
}
int l1if_transport_close(int q, struct femtol1_hdl *hdl)
{
struct osmo_fd *read_ofd = &hdl->read_ofd[q];
struct osmo_fd *write_ofd = &hdl->write_q[q].bfd;
osmo_fd_unregister(read_ofd);
close(read_ofd->fd);
read_ofd->fd = -1;
osmo_fd_unregister(write_ofd);
close(write_ofd->fd);
write_ofd->fd = -1;
return 0;
}
static int process_hsl_rsl(struct msgb *msg, struct e1inp_line *line,
struct osmo_fd *bfd)
{
char serno_buf[16];
uint8_t serno_len;
struct e1inp_sign_link *sign_link;
struct hsl_unit unit_data;
switch (msg->l2h[1]) {
case 0x80:
/*, contains Serial Number + SW version */
if (msg->l2h[2] != 0xc0)
break;
serno_len = msg->l2h[3];
if (serno_len > sizeof(serno_buf)-1)
serno_len = sizeof(serno_buf)-1;
memcpy(serno_buf, msg->l2h+4, serno_len);
serno_buf[serno_len] = '\0';
unit_data.serno = strtoul(serno_buf, NULL, 10);
if (!line->ops->sign_link_up) {
LOGP(DLINP, LOGL_ERROR,
"Unable to set signal link, closing socket.\n");
osmo_fd_unregister(bfd);
close(bfd->fd);
bfd->fd = -1;
return -EINVAL;
}
sign_link = line->ops->sign_link_up(&unit_data,
line, E1INP_SIGN_NONE);
if (sign_link == NULL) {
LOGP(DLINP, LOGL_ERROR,
"Unable to set signal link, closing socket.\n");
osmo_fd_unregister(bfd);
close(bfd->fd);
bfd->fd = -1;
return -EINVAL;
}
msgb_free(msg);
return 1; /* == we have taken over the msg */
case 0x82:
/* FIXME: do something with BSSGP, i.e. forward it over
* NSIP to OsmoSGSN */
msgb_free(msg);
return 1;
}
return 0;
}
int mgcp_free_rtp_port(struct mgcp_rtp_end *end)
{
if (end->rtp.fd != -1) {
close(end->rtp.fd);
end->rtp.fd = -1;
osmo_fd_unregister(&end->rtp);
}
if (end->rtcp.fd != -1) {
close(end->rtcp.fd);
end->rtcp.fd = -1;
osmo_fd_unregister(&end->rtcp);
}
return 0;
}
static int oml_router_accept_cb(struct osmo_fd *accept_fd, unsigned int what)
{
int fd;
struct osmo_fd *read_fd = (struct osmo_fd *) accept_fd->data;
/* Accept only one connection at a time. De-register it */
if (read_fd->fd > -1) {
LOGP(DL1C, LOGL_NOTICE,
"New OML router connection. Closing old one.\n");
close(read_fd->fd);
osmo_fd_unregister(read_fd);
read_fd->fd = -1;
}
fd = accept(accept_fd->fd, NULL, NULL);
if (fd < 0) {
LOGP(DL1C, LOGL_ERROR, "Failed to accept. errno: %s.\n",
strerror(errno));
return -1;
}
read_fd->fd = fd;
if (osmo_fd_register(read_fd) != 0) {
LOGP(DL1C, LOGL_ERROR, "Registering the read fd failed.\n");
close(fd);
read_fd->fd = -1;
return -1;
}
return 0;
}
/* close socket */
static void trx_udp_close(struct osmo_fd *ofd)
{
if (ofd->fd > 0) {
osmo_fd_unregister(ofd);
close(ofd->fd);
ofd->fd = -1;
}
}
void bsc_msc_lost(struct bsc_msc_connection *con)
{
osmo_wqueue_clear(&con->write_queue);
osmo_timer_del(&con->timeout_timer);
osmo_timer_del(&con->reconnect_timer);
if (con->write_queue.bfd.fd >= 0)
osmo_fd_unregister(&con->write_queue.bfd);
connection_loss(con);
}
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;
}
void ipa_client_conn_close(struct ipa_client_conn *link)
{
/* be safe against multiple calls */
if (link->ofd->fd != -1) {
osmo_fd_unregister(link->ofd);
close(link->ofd->fd);
link->ofd->fd = -1;
}
msgb_free(link->pending_msg);
link->pending_msg = NULL;
}
/* called in the case of a non blocking connect */
static int msc_connection_connect(struct osmo_fd *fd, unsigned int what)
{
int rc;
int val;
struct bsc_msc_connection *con;
struct osmo_wqueue *queue;
socklen_t len = sizeof(val);
queue = container_of(fd, struct osmo_wqueue, bfd);
con = container_of(queue, struct bsc_msc_connection, write_queue);
if ((what & BSC_FD_WRITE) == 0) {
LOGP(DMSC, LOGL_ERROR,
"MSC(%s) Callback but not writable.\n", con->name);
return -1;
}
/* From here on we will either be connected or reconnect */
osmo_timer_del(&con->timeout_timer);
/* check the socket state */
rc = getsockopt(fd->fd, SOL_SOCKET, SO_ERROR, &val, &len);
if (rc != 0) {
LOGP(DMSC, LOGL_ERROR,
"getsockopt for the MSC(%s) socket failed.\n", con->name);
goto error;
}
if (val != 0) {
LOGP(DMSC, LOGL_ERROR,
"Not connected to the MSC(%s): %d\n",
con->name, val);
goto error;
}
/* go to full operation */
fd->cb = osmo_wqueue_bfd_cb;
fd->when = BSC_FD_READ | BSC_FD_EXCEPT;
con->is_connected = 1;
LOGP(DMSC, LOGL_NOTICE,
"(Re)Connected to the MSC(%s).\n", con->name);
if (con->connected)
con->connected(con);
return 0;
error:
osmo_fd_unregister(fd);
connection_loss(con);
return -1;
}
static void hsl_drop(struct e1inp_line *line, struct osmo_fd *bfd)
{
line->ops->sign_link_down(line);
if (bfd->fd != -1) {
osmo_fd_unregister(bfd);
close(bfd->fd);
bfd->fd = -1;
}
/* put the virtual E1 line that we cloned for this socket, if
* it becomes unused, it gets released. */
e1inp_line_put(line);
}
static void bsc_nat_ussd_destroy(struct bsc_nat_ussd_con *con)
{
if (con->nat->ussd_con == con) {
bsc_close_ussd_connections(con->nat);
con->nat->ussd_con = NULL;
}
close(con->queue.bfd.fd);
osmo_fd_unregister(&con->queue.bfd);
osmo_timer_del(&con->auth_timeout);
osmo_wqueue_clear(&con->queue);
talloc_free(con);
}
void ipa_server_conn_destroy(struct ipa_server_conn *conn)
{
/* make the function re-entrant in case closed_cb() below somehow
* calls again into this destructor */
if (conn->ofd.fd == -1)
return;
close(conn->ofd.fd);
conn->ofd.fd = -1;
msgb_free(conn->pending_msg);
osmo_fd_unregister(&conn->ofd);
if (conn->closed_cb)
conn->closed_cb(conn);
talloc_free(conn);
}
static void esme_write_cb(struct osmo_fd *ofd, struct msgb *msg)
{
struct esme *esme = ofd->data;
int rc;
rc = write(ofd->fd, msgb_data(msg), msgb_length(msg));
if (rc == 0) {
osmo_fd_unregister(&esme->wqueue.bfd);
close(esme->wqueue.bfd.fd);
esme->wqueue.bfd.fd = -1;
exit(99);
} else if (rc < msgb_length(msg)) {
LOGP(DSMPP, LOGL_ERROR, "[%s] Short write\n", esme->system_id);
return;
}
}
/*! \brief close a telnet connection */
int telnet_close_client(struct osmo_fd *fd)
{
struct telnet_connection *conn = (struct telnet_connection*)fd->data;
close(fd->fd);
osmo_fd_unregister(fd);
if (conn->dbg) {
log_del_target(conn->dbg);
talloc_free(conn->dbg);
}
llist_del(&conn->entry);
talloc_free(conn);
return 0;
}
static int bind_rtp(struct mgcp_config *cfg, struct mgcp_rtp_end *rtp_end, int endpno)
{
if (mgcp_create_bind(cfg->source_addr, &rtp_end->rtp,
rtp_end->local_port) != 0) {
LOGP(DMGCP, LOGL_ERROR, "Failed to create RTP port: %s:%d on 0x%x\n",
cfg->source_addr, rtp_end->local_port, endpno);
goto cleanup0;
}
if (mgcp_create_bind(cfg->source_addr, &rtp_end->rtcp,
rtp_end->local_port + 1) != 0) {
LOGP(DMGCP, LOGL_ERROR, "Failed to create RTCP port: %s:%d on 0x%x\n",
cfg->source_addr, rtp_end->local_port + 1, endpno);
goto cleanup1;
}
set_ip_tos(rtp_end->rtp.fd, cfg->endp_dscp);
set_ip_tos(rtp_end->rtcp.fd, cfg->endp_dscp);
rtp_end->rtp.when = BSC_FD_READ;
if (osmo_fd_register(&rtp_end->rtp) != 0) {
LOGP(DMGCP, LOGL_ERROR, "Failed to register RTP port %d on 0x%x\n",
rtp_end->local_port, endpno);
goto cleanup2;
}
rtp_end->rtcp.when = BSC_FD_READ;
if (osmo_fd_register(&rtp_end->rtcp) != 0) {
LOGP(DMGCP, LOGL_ERROR, "Failed to register RTCP port %d on 0x%x\n",
rtp_end->local_port + 1, endpno);
goto cleanup3;
}
return 0;
cleanup3:
osmo_fd_unregister(&rtp_end->rtp);
cleanup2:
close(rtp_end->rtcp.fd);
rtp_end->rtcp.fd = -1;
cleanup1:
close(rtp_end->rtp.fd);
rtp_end->rtp.fd = -1;
cleanup0:
return -1;
}
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 oml_router_read_cb(struct osmo_fd *fd, unsigned int what)
{
struct msgb *msg;
int rc;
msg = oml_msgb_alloc();
if (!msg) {
LOGP(DL1C, LOGL_ERROR, "Failed to allocate oml msgb.\n");
return -1;
}
rc = recv(fd->fd, msg->tail, msg->data_len, 0);
if (rc <= 0) {
close(fd->fd);
osmo_fd_unregister(fd);
fd->fd = -1;
goto err;
}
msg->l1h = msgb_put(msg, rc);
rc = msg_verify_ipa_structure(msg);
if (rc < 0) {
LOGP(DL1C, LOGL_ERROR,
"OML Router: Invalid IPA message rc(%d)\n", rc);
goto err;
}
rc = msg_verify_oml_structure(msg);
if (rc < 0) {
LOGP(DL1C, LOGL_ERROR,
"OML Router: Invalid OML message rc(%d)\n", rc);
goto err;
}
/* todo dispatch message */
err:
msgb_free(msg);
return -1;
}
static void pcu_sock_close(struct pcu_sock_state *state, int lost)
{
struct osmo_fd *bfd = &state->conn_bfd;
struct gprs_rlcmac_bts *bts = bts_main_data();
uint8_t trx, ts;
LOGP(DL1IF, LOGL_NOTICE, "PCU socket has %s connection\n",
(lost) ? "LOST" : "closed");
close(bfd->fd);
bfd->fd = -1;
osmo_fd_unregister(bfd);
/* flush the queue */
while (!llist_empty(&state->upqueue)) {
struct msgb *msg = msgb_dequeue(&state->upqueue);
msgb_free(msg);
}
/* disable all slots, kick all TBFs */
for (trx = 0; trx < 8; trx++) {
#ifdef ENABLE_DIRECT_PHY
if (bts->trx[trx].fl1h) {
l1if_close_pdch(bts->trx[trx].fl1h);
bts->trx[trx].fl1h = NULL;
}
#endif
for (ts = 0; ts < 8; ts++)
bts->trx[trx].pdch[ts].disable();
/* FIXME: NOT ALL RESOURCES are freed in this case... inconsistent with the other code. Share the code with pcu_l1if.c
for the reset. */
gprs_rlcmac_tbf::free_all(&bts->trx[trx]);
}
gprs_bssgp_destroy();
exit(0);
}
void ipa_server_link_close(struct ipa_server_link *link)
{
osmo_fd_unregister(&link->ofd);
close(link->ofd.fd);
}
/* FIXME: merge with smpp_smsc.c */
static int esme_read_cb(struct osmo_fd *ofd)
{
struct esme *esme = ofd->data;
uint32_t len;
uint8_t *lenptr = (uint8_t *) &len;
uint8_t *cur;
struct msgb *msg;
int rdlen;
int rc;
switch (esme->read_state) {
case READ_ST_IN_LEN:
rdlen = sizeof(uint32_t) - esme->read_idx;
rc = read(ofd->fd, lenptr + esme->read_idx, rdlen);
if (rc < 0) {
LOGP(DSMPP, LOGL_ERROR, "[%s] read returned %d\n",
esme->system_id, rc);
} else if (rc == 0) {
goto dead_socket;
} else
esme->read_idx += rc;
if (esme->read_idx >= sizeof(uint32_t)) {
esme->read_len = ntohl(len);
msg = msgb_alloc(esme->read_len, "SMPP Rx");
if (!msg)
return -ENOMEM;
esme->read_msg = msg;
cur = msgb_put(msg, sizeof(uint32_t));
memcpy(cur, lenptr, sizeof(uint32_t));
esme->read_state = READ_ST_IN_MSG;
esme->read_idx = sizeof(uint32_t);
}
break;
case READ_ST_IN_MSG:
msg = esme->read_msg;
rdlen = esme->read_len - esme->read_idx;
rc = read(ofd->fd, msg->tail, OSMO_MIN(rdlen, msgb_tailroom(msg)));
if (rc < 0) {
LOGP(DSMPP, LOGL_ERROR, "[%s] read returned %d\n",
esme->system_id, rc);
} else if (rc == 0) {
goto dead_socket;
} else {
esme->read_idx += rc;
msgb_put(msg, rc);
}
if (esme->read_idx >= esme->read_len) {
rc = smpp_pdu_rx(esme, esme->read_msg);
esme->read_msg = NULL;
esme->read_idx = 0;
esme->read_len = 0;
esme->read_state = READ_ST_IN_LEN;
}
break;
}
return 0;
dead_socket:
msgb_free(esme->read_msg);
osmo_fd_unregister(&esme->wqueue.bfd);
close(esme->wqueue.bfd.fd);
esme->wqueue.bfd.fd = -1;
exit(2342);
return 0;
}
