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; }