X-Git-Url: http://git.eversberg.eu/gitweb.cgi?p=lcr.git;a=blobdiff_plain;f=gsm.cpp;h=ec33695853bde95ef0dd88d585b283fa05c3c048;hp=d6109c9e230223bf606c38edff33ec4fe9022466;hb=034d3a91404addedc1c7a3494862c79532b0b878;hpb=0f805e041a900551a8c3cf9a75a78c2b34e1977c diff --git a/gsm.cpp b/gsm.cpp index d6109c9..ec33695 100644 --- a/gsm.cpp +++ b/gsm.cpp @@ -4,71 +4,117 @@ ** ** **---------------------------------------------------------------------------** ** Copyright: Andreas Eversberg ** +** MNCC-Interface: Harald Welte ** ** ** ** mISDN gsm ** ** ** \*****************************************************************************/ #include "main.h" +#include "mncc.h" #ifndef _GNU_SOURCE #define _GNU_SOURCE #endif extern "C" { -#include - -#include -#include -#include -#include -#include -#include -#include -struct gsm_network *bsc_gsmnet = 0; -extern int ipacc_rtp_direct; -extern int bsc_bootstrap_network(int (*mmc_rev)(struct gsm_network *, int, void *), - const char *cfg_file); -extern int bsc_shutdown_net(struct gsm_network *net); -void talloc_ctx_init(void); -void on_dso_load_token(void); -void on_dso_load_rrlp(void); -void on_dso_load_ho_dec(void); -int bts_model_unknown_init(void); -int bts_model_bs11_init(void); -int bts_model_nanobts_init(void); -static struct log_target *stderr_target; - -/* timer to store statistics */ -#define DB_SYNC_INTERVAL 60, 0 -static struct timer_list db_sync_timer; - #include "gsm_audio.h" - } -#include - -struct lcr_gsm *gsm = NULL; - -static unsigned int new_callref = 1; - -/* timer handling */ -static int _db_store_counter(struct counter *counter, void *data) +#include + +#define SOCKET_RETRY_TIMER 5 + +//struct lcr_gsm *gsm = NULL; + +int new_callref = 1; + +/* names of MNCC-SAP */ +static const struct _value_string { + int msg_type; + const char *name; +} mncc_names[] = { + { 0, "New call ref" }, + { 1, "Codec negotiation" }, + { MNCC_SETUP_REQ, "MNCC_SETUP_REQ" }, + { MNCC_SETUP_IND, "MNCC_SETUP_IND" }, + { MNCC_SETUP_RSP, "MNCC_SETUP_RSP" }, + { MNCC_SETUP_CNF, "MNCC_SETUP_CNF" }, + { MNCC_SETUP_COMPL_REQ, "MNCC_SETUP_COMPL_REQ" }, + { MNCC_SETUP_COMPL_IND, "MNCC_SETUP_COMPL_IND" }, + { MNCC_CALL_CONF_IND, "MNCC_CALL_CONF_IND" }, + { MNCC_CALL_PROC_REQ, "MNCC_CALL_PROC_REQ" }, + { MNCC_PROGRESS_REQ, "MNCC_PROGRESS_REQ" }, + { MNCC_ALERT_REQ, "MNCC_ALERT_REQ" }, + { MNCC_ALERT_IND, "MNCC_ALERT_IND" }, + { MNCC_NOTIFY_REQ, "MNCC_NOTIFY_REQ" }, + { MNCC_NOTIFY_IND, "MNCC_NOTIFY_IND" }, + { MNCC_DISC_REQ, "MNCC_DISC_REQ" }, + { MNCC_DISC_IND, "MNCC_DISC_IND" }, + { MNCC_REL_REQ, "MNCC_REL_REQ" }, + { MNCC_REL_IND, "MNCC_REL_IND" }, + { MNCC_REL_CNF, "MNCC_REL_CNF" }, + { MNCC_FACILITY_REQ, "MNCC_FACILITY_REQ" }, + { MNCC_FACILITY_IND, "MNCC_FACILITY_IND" }, + { MNCC_START_DTMF_IND, "MNCC_START_DTMF_IND" }, + { MNCC_START_DTMF_RSP, "MNCC_START_DTMF_RSP" }, + { MNCC_START_DTMF_REJ, "MNCC_START_DTMF_REJ" }, + { MNCC_STOP_DTMF_IND, "MNCC_STOP_DTMF_IND" }, + { MNCC_STOP_DTMF_RSP, "MNCC_STOP_DTMF_RSP" }, + { MNCC_MODIFY_REQ, "MNCC_MODIFY_REQ" }, + { MNCC_MODIFY_IND, "MNCC_MODIFY_IND" }, + { MNCC_MODIFY_RSP, "MNCC_MODIFY_RSP" }, + { MNCC_MODIFY_CNF, "MNCC_MODIFY_CNF" }, + { MNCC_MODIFY_REJ, "MNCC_MODIFY_REJ" }, + { MNCC_HOLD_IND, "MNCC_HOLD_IND" }, + { MNCC_HOLD_CNF, "MNCC_HOLD_CNF" }, + { MNCC_HOLD_REJ, "MNCC_HOLD_REJ" }, + { MNCC_RETRIEVE_IND, "MNCC_RETRIEVE_IND" }, + { MNCC_RETRIEVE_CNF, "MNCC_RETRIEVE_CNF" }, + { MNCC_RETRIEVE_REJ, "MNCC_RETRIEVE_REJ" }, + { MNCC_USERINFO_REQ, "MNCC_USERINFO_REQ" }, + { MNCC_USERINFO_IND, "MNCC_USERINFO_IND" }, + { MNCC_REJ_REQ, "MNCC_REJ_REQ" }, + { MNCC_REJ_IND, "MNCC_REJ_IND" }, + { MNCC_PROGRESS_IND, "MNCC_PROGRESS_IND" }, + { MNCC_CALL_PROC_IND, "MNCC_CALL_PROC_IND" }, + { MNCC_CALL_CONF_REQ, "MNCC_CALL_CONF_REQ" }, + { MNCC_START_DTMF_REQ, "MNCC_START_DTMF_REQ" }, + { MNCC_STOP_DTMF_REQ, "MNCC_STOP_DTMF_REQ" }, + { MNCC_HOLD_REQ, "MNCC_HOLD_REQ " }, + { MNCC_RETRIEVE_REQ, "MNCC_RETRIEVE_REQ" }, + + { MNCC_LCHAN_MODIFY, "MNCC_LCHAN_MODIFY" }, + + { MNCC_BRIDGE, "MNCC_BRIDGE" }, + { MNCC_FRAME_RECV, "MNCC_FRAME_RECV" }, + { MNCC_FRAME_DROP, "MNCC_FRAME_DROP" }, + { MNCC_RTP_CREATE, "MNCC_RTP_CREATE" }, + { MNCC_RTP_CONNECT, "MNCC_RTP_CONNECT" }, + { MNCC_RTP_FREE, "MNCC_RTP_FREE" }, + + { 0, NULL } +}; + +const char *mncc_name(int value) { - return db_store_counter(counter); -} + int i = 0; + static char ukn[32]; -static void db_sync_timer_cb(void *data) -{ - /* store counters to database and re-schedule */ - counters_for_each(_db_store_counter, NULL); - bsc_schedule_timer(&db_sync_timer, DB_SYNC_INTERVAL); + while (mncc_names[i].name) { + if (mncc_names[i].msg_type == value) + return mncc_names[i].name; + i++; + } + SPRINT(ukn, "unknown(0x%x)", value); + return ukn; } +static int mncc_send(struct lcr_gsm *lcr_gsm, int msg_type, void *data); + /* * create and send mncc message */ -static struct gsm_mncc *create_mncc(int msg_type, unsigned int callref) +struct gsm_mncc *create_mncc(int msg_type, unsigned int callref) { struct gsm_mncc *mncc; @@ -77,42 +123,120 @@ static struct gsm_mncc *create_mncc(int msg_type, unsigned int callref) mncc->callref = callref; return (mncc); } -static int send_and_free_mncc(struct gsm_network *net, unsigned int msg_type, void *data) +int send_and_free_mncc(struct lcr_gsm *lcr_gsm, unsigned int msg_type, void *data) { - int ret; + int ret = 0; - ret = mncc_send(net, msg_type, data); + if (lcr_gsm) { + ret = mncc_send(lcr_gsm, msg_type, data); + } free(data); return ret; } +void Pgsm::send_mncc_rtp_connect(void) +{ + struct gsm_mncc_rtp *nrtp; + + nrtp = (struct gsm_mncc_rtp *) create_mncc(MNCC_RTP_CONNECT, p_g_callref); + nrtp->ip = p_g_rtp_ip_remote; + nrtp->port = p_g_rtp_port_remote; + switch (p_g_media_type) { + case MEDIA_TYPE_GSM: + nrtp->payload_msg_type = GSM_TCHF_FRAME; + break; + case MEDIA_TYPE_GSM_EFR: + nrtp->payload_msg_type = GSM_TCHF_FRAME_EFR; + break; + case MEDIA_TYPE_AMR: + nrtp->payload_msg_type = GSM_TCH_FRAME_AMR; + break; + case MEDIA_TYPE_GSM_HR: + nrtp->payload_msg_type = GSM_TCHH_FRAME; + break; + } + nrtp->payload_type = p_g_payload_type; + PDEBUG(DEBUG_GSM, "sending MNCC RTP connect with payload_msg_type=%x, payload_type=%d\n", nrtp->payload_msg_type, nrtp->payload_type); + send_and_free_mncc(p_g_lcr_gsm, nrtp->msg_type, nrtp); +} + static int delete_event(struct lcr_work *work, void *instance, int index); /* * constructor */ -Pgsm::Pgsm(int type, struct mISDNport *mISDNport, char *portname, struct port_settings *settings, int channel, int exclusive, int mode) : PmISDN(type, mISDNport, portname, settings, channel, exclusive, mode) +Pgsm::Pgsm(int type, char *portname, struct port_settings *settings, struct interface *interface) : Port(type, portname, settings, interface) { - p_callerinfo.itype = (mISDNport->ifport->interface->extension)?INFO_ITYPE_ISDN_EXTENSION:INFO_ITYPE_ISDN; - memset(&p_m_g_delete, 0, sizeof(p_m_g_delete)); - add_work(&p_m_g_delete, delete_event, this, 0); - p_m_g_callref = 0; - p_m_g_mode = 0; - p_m_g_gsm_b_sock = -1; - p_m_g_gsm_b_index = -1; - p_m_g_gsm_b_active = 0; - p_m_g_notify_pending = NULL; - p_m_g_decoder = gsm_audio_create(); - p_m_g_encoder = gsm_audio_create(); - if (!p_m_g_encoder || !p_m_g_decoder) { - PERROR("Failed to create GSM audio codec instance\n"); - trigger_work(&p_m_g_delete); +#ifdef WITH_GSMHR + signed short homing[160]; + int i; +#endif + + p_g_tones = 0; + if (interface->is_tones == IS_YES) + p_g_tones = 1; + p_g_earlyb = 0; + if (interface->is_earlyb == IS_YES) + p_g_earlyb = 1; + p_g_rtp_bridge = 0; + if (interface->rtp_bridge) + p_g_rtp_bridge = 1; + p_g_rtp_payloads = 0; + memset(&p_g_samples, 0, sizeof(p_g_samples)); + p_callerinfo.itype = (interface->extension)?INFO_ITYPE_ISDN_EXTENSION:INFO_ITYPE_ISDN; + memset(&p_g_delete, 0, sizeof(p_g_delete)); + add_work(&p_g_delete, delete_event, this, 0); + p_g_lcr_gsm = NULL; + p_g_callref = 0; + p_g_mode = 0; + p_g_gsm_b_sock = -1; + p_g_gsm_b_index = -1; + p_g_gsm_b_active = 0; + p_g_notify_pending = NULL; + p_g_setup_pending = NULL; + p_g_connect_pending = NULL; + p_g_fr_decoder = NULL; + p_g_fr_encoder = NULL; + p_g_hr_decoder = NULL; + p_g_hr_encoder = NULL; + p_g_amr_decoder = NULL; + p_g_amr_encoder = NULL; + p_g_amr_cmr = 0; + p_g_amr_cmr_valid = 0; +#ifdef WITH_GSMFR + p_g_fr_decoder = gsm_fr_create(); + p_g_fr_encoder = gsm_fr_create(); + if (!p_g_fr_encoder || !p_g_fr_decoder) { + PERROR("Failed to create GSM FR codec instance\n"); + trigger_work(&p_g_delete); } - p_m_g_rxpos = 0; - p_m_g_tch_connected = 0; +#endif +#ifdef WITH_GSMHR + p_g_hr_decoder = gsm_hr_create(); + p_g_hr_encoder = gsm_hr_create(); + if (!p_g_hr_encoder || !p_g_hr_decoder) { + PERROR("Failed to create GSM HR codec instance\n"); + trigger_work(&p_g_delete); + } + /* Homing */ + for (i = 0; i < 160; i++) + homing[i] = 0x0008; + gsm_hr_encode(p_g_hr_encoder, homing, NULL); +#endif +#ifdef WITH_GSMAMR + p_g_amr_decoder = gsm_amr_create(); + p_g_amr_encoder = gsm_amr_create(); + if (!p_g_amr_encoder || !p_g_amr_decoder) { + PERROR("Failed to create GSM AMR codec instance\n"); + trigger_work(&p_g_delete); + } +#endif + p_g_rxpos = 0; + p_g_tch_connected = 0; + p_g_media_type = 0; - PDEBUG(DEBUG_GSM, "Created new mISDNPort(%s).\n", portname); + PDEBUG(DEBUG_GSM, "Created new GSMPort(%s).\n", portname); } /* @@ -122,188 +246,312 @@ Pgsm::~Pgsm() { PDEBUG(DEBUG_GSM, "Destroyed GSM process(%s).\n", p_name); - del_work(&p_m_g_delete); + del_work(&p_g_delete); /* remove queued message */ - if (p_m_g_notify_pending) - message_free(p_m_g_notify_pending); - - /* close audio transfer socket */ - if (p_m_g_gsm_b_sock > -1) - bchannel_close(); - + if (p_g_notify_pending) + message_free(p_g_notify_pending); + if (p_g_setup_pending) + message_free(p_g_setup_pending); + if (p_g_connect_pending) + message_free(p_g_connect_pending); + +//#ifdef WITH_GSMFR /* close codec */ - if (p_m_g_encoder) - gsm_audio_destroy(p_m_g_encoder); - if (p_m_g_decoder) - gsm_audio_destroy(p_m_g_decoder); + if (p_g_fr_encoder) + gsm_fr_destroy(p_g_fr_encoder); + if (p_g_fr_decoder) + gsm_fr_destroy(p_g_fr_decoder); +//#endif +#ifdef WITH_GSMHR + if (p_g_hr_encoder) + gsm_hr_destroy(p_g_hr_encoder); + if (p_g_hr_decoder) + gsm_hr_destroy(p_g_hr_decoder); +#endif +#ifdef WITH_GSMAMR + /* close codec */ + if (p_g_amr_encoder) + gsm_amr_destroy(p_g_amr_encoder); + if (p_g_amr_decoder) + gsm_amr_destroy(p_g_amr_decoder); +#endif } -/* close bsc side bchannel */ -void Pgsm::bchannel_close(void) +/* receive encoded frame from gsm */ +void Pgsm::frame_receive(void *arg) { - if (p_m_g_gsm_b_sock > -1) { - unregister_fd(&p_m_g_gsm_b_fd); - close(p_m_g_gsm_b_sock); + struct gsm_data_frame *frame = (struct gsm_data_frame *)arg; + unsigned char data[160]; + int i, cmr; + + if (!p_g_fr_decoder) + return; + + switch (frame->msg_type) { + case GSM_TCHF_FRAME: + if (p_g_media_type != MEDIA_TYPE_GSM) { + PERROR("FR frame, but current media type mismatches.\n"); + return; + } + if (!p_g_fr_decoder) { + PERROR("FR frame, but decoder not created.\n"); + return; + } + if ((frame->data[0]>>4) != 0xd) { + PDEBUG(DEBUG_GSM, "received GSM frame with wrong magig 0x%x\n", frame->data[0]>>4); + goto bfi; + } +#ifdef WITH_GSMFR + /* decode */ + gsm_fr_decode(p_g_fr_decoder, frame->data, p_g_samples); + for (i = 0; i < 160; i++) { + data[i] = audio_s16_to_law[p_g_samples[i] & 0xffff]; + } +#endif + break; + case GSM_TCHH_FRAME: + if (p_g_media_type != MEDIA_TYPE_GSM_HR) { + PERROR("HR frame, but current media type mismatches.\n"); + return; + } + if (!p_g_hr_decoder) { + PERROR("HR frame, but decoder not created.\n"); + return; + } + if ((frame->data[0]>>4) != 0x0) + goto bfi; +#ifdef WITH_GSMHR + /* decode */ + if (gsm_hr_decode(p_g_hr_decoder, frame->data, p_g_samples)) + goto bfi; + for (i = 0; i < 160; i++) { + data[i] = audio_s16_to_law[p_g_samples[i] & 0xffff]; + } +#endif + break; + case GSM_TCHF_FRAME_EFR: + if (p_g_media_type != MEDIA_TYPE_GSM_EFR) { + PERROR("EFR frame, but current media type mismatches.\n"); + return; + } + if (!p_g_amr_decoder) { + PERROR("EFR frame, but decoder not created.\n"); + return; + } + if ((frame->data[0]>>4) != 0xc) + goto bfi; +#ifdef WITH_GSMAMR + /* decode */ + gsm_efr_decode(p_g_amr_decoder, frame->data, p_g_samples); + for (i = 0; i < 160; i++) { + data[i] = audio_s16_to_law[p_g_samples[i] & 0xffff]; + } +#endif + break; + case GSM_TCH_FRAME_AMR: + if (p_g_media_type != MEDIA_TYPE_AMR) { + PERROR("AMR frame, but current media type mismatches.\n"); + return; + } + if (!p_g_amr_decoder) { + PERROR("AMR frame, but decoder not created.\n"); + return; + } + cmr = (frame->data[1] >> 4); + if (cmr <= 7) { + p_g_amr_cmr = cmr; + p_g_amr_cmr_valid = 1; + } + if (!(frame->data[2] & 0x04)) + goto bfi; +#ifdef WITH_GSMAMR + /* decode (skip length byte in front) */ + gsm_amr_decode(p_g_amr_decoder, frame->data + 1, p_g_samples); + for (i = 0; i < 160; i++) { + data[i] = audio_s16_to_law[p_g_samples[i] & 0xffff]; + } +#endif + break; + case GSM_BAD_FRAME: + default: +bfi: + if (p_echotest) { + /* beep on bad frame */ + for (i = 0; i < 160; i++) { + if ((i & 3) > 2) + p_g_samples[i] = 15000; + else + p_g_samples[i] = -15000; + data[i] = audio_s16_to_law[p_g_samples[i] & 0xffff]; + } + } else { + /* repeat on bad frame */ + for (i = 0; i < 160; i++) { + p_g_samples[i] = (p_g_samples[i] * 14) >> 4; + data[i] = audio_s16_to_law[p_g_samples[i] & 0xffff]; + } + } } - p_m_g_gsm_b_sock = -1; - p_m_g_gsm_b_index = -1; - p_m_g_gsm_b_active = 0; -} -static int b_handler(struct lcr_fd *fd, unsigned int what, void *instance, int index); + /* record data */ + if (p_record) + record(data, 160, 0); // from down + if (p_tap) + tap(data, 160, 0); // from down + + /* local echo */ + if (p_echotest) + bridge_rx(data, 160); -/* open bsc side bchannel */ -int Pgsm::bchannel_open(int index) + /* send to remote*/ + bridge_tx(data, 160); +} + +/* send traffic to gsm */ +int Pgsm::bridge_rx(unsigned char *data, int len) { int ret; - struct sockaddr_mISDN addr; - struct mISDNhead act; - if (p_m_g_gsm_b_sock > -1) { - PERROR("Socket already created for index %d\n", index); - return(-EIO); - } - - /* open socket */ - ret = p_m_g_gsm_b_sock = socket(PF_ISDN, SOCK_DGRAM, ISDN_P_B_RAW); - if (ret < 0) { - PERROR("Failed to open bchannel-socket for index %d\n", index); - bchannel_close(); - return(ret); - } - memset(&p_m_g_gsm_b_fd, 0, sizeof(p_m_g_gsm_b_fd)); - p_m_g_gsm_b_fd.fd = p_m_g_gsm_b_sock; - register_fd(&p_m_g_gsm_b_fd, LCR_FD_READ, b_handler, this, 0); - - - /* bind socket to bchannel */ - addr.family = AF_ISDN; - addr.dev = gsm->gsm_port; - addr.channel = index+1+(index>15); - ret = bind(p_m_g_gsm_b_sock, (struct sockaddr *)&addr, sizeof(addr)); - if (ret < 0) { - PERROR("Failed to bind bchannel-socket for index %d\n", index); - bchannel_close(); - return(ret); - } - /* activate bchannel */ - PDEBUG(DEBUG_GSM, "Activating GSM side channel index %i.\n", index); - act.prim = PH_ACTIVATE_REQ; - act.id = 0; - ret = sendto(p_m_g_gsm_b_sock, &act, MISDN_HEADER_LEN, 0, NULL, 0); - if (ret < 0) { - PERROR("Failed to activate index %d\n", index); - bchannel_close(); - return(ret); - } + if ((ret = Port::bridge_rx(data, len))) + return ret; - p_m_g_gsm_b_index = index; + if (p_tone_name[0]) + return -EINVAL; - return(0); + return audio_send(data, len); } -/* receive from bchannel */ -void Pgsm::bchannel_receive(struct mISDNhead *hh, unsigned char *data, int len) +int Pgsm::audio_send(unsigned char *data, int len) { unsigned char frame[33]; + int ret; + + /* record data */ + if (p_record) + record(data, len, 1); // from up + if (p_tap) + tap(data, len, 1); // from up /* encoder init failed */ - if (!p_m_g_encoder) - return; + if (!p_g_fr_encoder) + return -EINVAL; /* (currently) not connected, so don't flood tch! */ - if (!p_m_g_tch_connected) - return; + if (!p_g_tch_connected) + return -EINVAL; /* write to rx buffer */ while(len--) { - p_m_g_rxdata[p_m_g_rxpos++] = audio_law_to_s32[*data++]; - if (p_m_g_rxpos == 160) { - p_m_g_rxpos = 0; - + p_g_rxdata[p_g_rxpos++] = audio_law_to_s32[*data++]; + if (p_g_rxpos != 160) + continue; + p_g_rxpos = 0; + + switch (p_g_media_type) { + case MEDIA_TYPE_GSM: + if (!p_g_fr_encoder) { + PERROR("FR frame, but encoder not created.\n"); + break; + } +#ifdef WITH_GSMFR + /* encode data */ + gsm_fr_encode(p_g_fr_encoder, p_g_rxdata, frame); + frame_send(frame, 33, GSM_TCHF_FRAME); +#endif + break; + case MEDIA_TYPE_GSM_HR: + if (!p_g_hr_encoder) { + PERROR("HR frame, but encoder not created.\n"); + break; + } +#ifdef WITH_GSMHR /* encode data */ - gsm_audio_encode(p_m_g_encoder, p_m_g_rxdata, frame); - frame_send(frame); + gsm_hr_encode(p_g_hr_encoder, p_g_rxdata, frame); + frame_send(frame, 15, GSM_TCHH_FRAME); +#endif + break; + case MEDIA_TYPE_GSM_EFR: + if (!p_g_amr_encoder) { + PERROR("EFR frame, but encoder not created.\n"); + break; + } +#ifdef WITH_GSMAMR + /* encode data */ + gsm_efr_encode(p_g_amr_encoder, p_g_rxdata, frame); + frame_send(frame, 31, GSM_TCHF_FRAME_EFR); +#endif + break; + case MEDIA_TYPE_AMR: + if (!p_g_amr_encoder) { + PERROR("AMR frame, but encoder not created.\n"); + break; + } + if (!p_g_amr_cmr_valid) { + PDEBUG(DEBUG_GSM, "no valid CMR yet.\n"); + break; + } +#ifdef WITH_GSMAMR + /* encode data (prefix a length byte) */ + ret = gsm_amr_encode(p_g_amr_encoder, p_g_rxdata, frame + 1, p_g_amr_cmr); + frame[0] = ret; + frame_send(frame, ret + 1, GSM_TCH_FRAME_AMR); +#endif + break; } } -} - -/* transmit to bchannel */ -void Pgsm::bchannel_send(unsigned int prim, unsigned int id, unsigned char *data, int len) -{ - unsigned char buf[MISDN_HEADER_LEN+len]; - struct mISDNhead *hh = (struct mISDNhead *)buf; - int ret; - - if (!p_m_g_gsm_b_active) - return; - /* make and send frame */ - hh->prim = PH_DATA_REQ; - hh->id = 0; - memcpy(buf+MISDN_HEADER_LEN, data, len); - ret = sendto(p_m_g_gsm_b_sock, buf, MISDN_HEADER_LEN+len, 0, NULL, 0); - if (ret <= 0) - PERROR("Failed to send to socket index %d\n", p_m_g_gsm_b_index); + return 0; } -void Pgsm::frame_send(void *_frame) +void Pgsm::frame_send(void *_frame, int len, int msg_type) { - unsigned char buffer[sizeof(struct gsm_data_frame) + 33]; + unsigned char buffer[sizeof(struct gsm_data_frame) + len]; struct gsm_data_frame *frame = (struct gsm_data_frame *)buffer; - frame->msg_type = GSM_TCHF_FRAME; - frame->callref = p_m_g_callref; - memcpy(frame->data, _frame, 33); - mncc_send((struct gsm_network *)gsm->network, frame->msg_type, frame); -} - + frame->msg_type = msg_type; + frame->callref = p_g_callref; + memcpy(frame->data, _frame, len); -void Pgsm::frame_receive(void *_frame) -{ - struct gsm_data_frame *frame = (struct gsm_data_frame *)_frame; - signed short samples[160]; - unsigned char data[160]; - int i; - - if (!p_m_g_decoder) - return; - - if ((frame->data[0]>>4) != 0xd) - PERROR("received GSM frame with wrong magig 0x%x\n", frame->data[0]>>4); - - /* decode */ - gsm_audio_decode(p_m_g_decoder, frame->data, samples); - for (i = 0; i < 160; i++) { - data[i] = audio_s16_to_law[samples[i] & 0xffff]; + if (p_g_lcr_gsm) { + mncc_send(p_g_lcr_gsm, frame->msg_type, frame); } - - /* send */ - bchannel_send(PH_DATA_REQ, 0, data, 160); } - /* * create trace - **/ -static void gsm_trace_header(struct mISDNport *mISDNport, class PmISDN *port, unsigned int msg_type, int direction) + */ +void gsm_trace_header(const char *interface_name, class Pgsm *port, unsigned int msg_type, int direction) { char msgtext[64]; + struct interface *interface = interface_first; + + interface = getinterfacebyname(interface_name); + if (!interface) + return; /* select message and primitive text */ - SCPY(msgtext, get_mncc_name(msg_type)); + SCPY(msgtext, mncc_name(msg_type)); /* add direction */ - if (direction == DIRECTION_OUT) - SCAT(msgtext, " MSC->BSC"); - else - SCAT(msgtext, " MSC<-BSC"); + if (port) { + switch(port->p_type) { + case PORT_TYPE_GSM_BS_OUT: + case PORT_TYPE_GSM_BS_IN: + SCAT(msgtext, " LCR<->BSC"); + break; + case PORT_TYPE_GSM_MS_OUT: + case PORT_TYPE_GSM_MS_IN: + SCAT(msgtext, " LCR<->MS"); + break; + } + } else + SCAT(msgtext, " ----"); /* init trace with given values */ - start_trace(mISDNport?mISDNport->portnum:-1, - mISDNport?(mISDNport->ifport?mISDNport->ifport->interface:NULL):NULL, + start_trace(-1, + interface, port?numberrize_callerinfo(port->p_callerinfo.id, port->p_callerinfo.ntype, options.national, options.international):NULL, port?port->p_dialinginfo.id:NULL, direction, @@ -312,326 +560,70 @@ static void gsm_trace_header(struct mISDNport *mISDNport, class PmISDN *port, un msgtext); } - - -/* select bchannel */ -int Pgsm::hunt_bchannel(void) +/* modify lchan to given payload type */ +void Pgsm::modify_lchan(int media_type) { - int channel; - int i; - - chan_trace_header(p_m_mISDNport, this, "CHANNEL SELECTION (setup)", DIRECTION_NONE); - add_trace("channel", "reserved", "%d", p_m_mISDNport->b_reserved); - if (p_m_mISDNport->b_reserved >= p_m_mISDNport->b_num) { // of out chan.. - add_trace("conclusion", NULL, "all channels are reserved"); - end_trace(); - return(-34); // no channel - } - /* find channel */ - i = 0; - channel = 0; - while(i < p_m_mISDNport->b_num) { - if (p_m_mISDNport->b_port[i] == NULL) { - channel = i+1+(i>=15); - break; - } - i++; - } - if (!channel) { - add_trace("conclusion", NULL, "no channel available"); - end_trace(); - return(-6); // channel unacceptable - } - add_trace("conclusion", NULL, "channel available"); - add_trace("connect", "channel", "%d", channel); - end_trace(); - return(channel); -} - - -/* - * handles all indications - */ -/* SETUP INDICATION */ -void Pgsm::setup_ind(unsigned int msg_type, unsigned int callref, struct gsm_mncc *mncc) -{ - int ret; - class Endpoint *epoint; - struct lcr_msg *message; - int channel; - struct gsm_mncc *mode, *proceeding, *frame; - - /* emergency shutdown */ - printf("%d %d\n", mncc->emergency, !gsm->conf.noemergshut); - if (mncc->emergency && !gsm->conf.noemergshut) { - start_trace(p_m_mISDNport->portnum, - p_m_mISDNport->ifport->interface, - NULL, - NULL, - DIRECTION_NONE, - CATEGORY_CH, - 0, - "EMERGENCY SHUTDOWN (due to received emergency call)"); - end_trace(); - quit = 1; - } - /* process given callref */ - l1l2l3_trace_header(p_m_mISDNport, this, L3_NEW_L3ID_IND, DIRECTION_IN); - add_trace("callref", "new", "0x%x", callref); - if (p_m_g_callref) { - /* release in case the ID is already in use */ - add_trace("error", NULL, "callref already in use"); - end_trace(); - mncc = create_mncc(MNCC_REJ_REQ, callref); - gsm_trace_header(p_m_mISDNport, this, MNCC_REJ_REQ, DIRECTION_OUT); - mncc->fields |= MNCC_F_CAUSE; - mncc->cause.coding = 3; - mncc->cause.location = 1; - mncc->cause.value = 47; - add_trace("cause", "coding", "%d", mncc->cause.coding); - add_trace("cause", "location", "%d", mncc->cause.location); - add_trace("cause", "value", "%d", mncc->cause.value); - add_trace("reason", NULL, "callref already in use"); - end_trace(); - send_and_free_mncc((struct gsm_network *)gsm->network, mncc->msg_type, mncc); - new_state(PORT_STATE_RELEASE); - trigger_work(&p_m_g_delete); - return; - } - p_m_g_callref = callref; - end_trace(); + struct gsm_mncc *mode; - /* if blocked, release call with MT_RELEASE_COMPLETE */ - if (p_m_mISDNport->ifport->block) { - mncc = create_mncc(MNCC_REJ_REQ, p_m_g_callref); - gsm_trace_header(p_m_mISDNport, this, MNCC_REJ_REQ, DIRECTION_OUT); - mncc->fields |= MNCC_F_CAUSE; - mncc->cause.coding = 3; - mncc->cause.location = 1; - mncc->cause.value = 27; - add_trace("cause", "coding", "%d", mncc->cause.coding); - add_trace("cause", "location", "%d", mncc->cause.location); - add_trace("cause", "value", "%d", mncc->cause.value); - add_trace("reason", NULL, "port is blocked"); - end_trace(); - send_and_free_mncc((struct gsm_network *)gsm->network, mncc->msg_type, mncc); - new_state(PORT_STATE_RELEASE); - trigger_work(&p_m_g_delete); + /* already modified to that media type */ + if (p_g_media_type == media_type) return; - } - /* caller info */ - if (mncc->clir.inv) - p_callerinfo.present = INFO_PRESENT_RESTRICTED; - else - p_callerinfo.present = INFO_PRESENT_ALLOWED; - if (mncc->calling.number[0]) - SCPY(p_callerinfo.id, mncc->calling.number); - else - p_callerinfo.present = INFO_PRESENT_NOTAVAIL; - SCPY(p_callerinfo.imsi, mncc->imsi); - p_callerinfo.screen = INFO_SCREEN_NETWORK; - p_callerinfo.ntype = INFO_NTYPE_UNKNOWN; - p_callerinfo.isdn_port = p_m_portnum; - SCPY(p_callerinfo.interface, p_m_mISDNport->ifport->interface->name); - - /* dialing information */ - SCAT(p_dialinginfo.id, mncc->called.number); - switch (mncc->called.type) { - case 0x1: - p_dialinginfo.ntype = INFO_NTYPE_INTERNATIONAL; - break; - case 0x2: - p_dialinginfo.ntype = INFO_NTYPE_NATIONAL; - break; - case 0x4: - p_dialinginfo.ntype = INFO_NTYPE_SUBSCRIBER; + p_g_media_type = media_type; + gsm_trace_header(p_interface_name, this, MNCC_LCHAN_MODIFY, DIRECTION_OUT); + mode = create_mncc(MNCC_LCHAN_MODIFY, p_g_callref); + switch (media_type) { + case MEDIA_TYPE_GSM_EFR: + add_trace("speech", "version", "EFR given"); + mode->lchan_mode = 0x21; /* GSM V2 */ break; - default: - p_dialinginfo.ntype = INFO_NTYPE_UNKNOWN; + case MEDIA_TYPE_AMR: + add_trace("speech", "version", "AMR given"); + mode->lchan_mode = 0x41; /* GSM V3 */ break; + default: + add_trace("speech", "version", "Full/Half Rate given"); + mode->lchan_mode = 0x01; /* GSM V1 */ } - if (mncc->emergency) { - SCPY(p_dialinginfo.id, "emergency"); - } - p_dialinginfo.sending_complete = 1; - - /* bearer capability */ - // todo - p_capainfo.bearer_capa = INFO_BC_SPEECH; - p_capainfo.bearer_info1 = (options.law=='a')?3:2; - p_capainfo.bearer_mode = INFO_BMODE_CIRCUIT; - p_capainfo.source_mode = B_MODE_TRANSPARENT; - p_m_g_mode = p_capainfo.source_mode; - - /* useruser */ - - /* hunt channel */ - ret = channel = hunt_bchannel(); - if (ret < 0) - goto no_channel; - - /* open channel */ - ret = seize_bchannel(channel, 1); - if (ret < 0) { - no_channel: - mncc = create_mncc(MNCC_REJ_REQ, p_m_g_callref); - gsm_trace_header(p_m_mISDNport, this, MNCC_REJ_REQ, DIRECTION_OUT); - mncc->fields |= MNCC_F_CAUSE; - mncc->cause.coding = 3; - mncc->cause.location = 1; - mncc->cause.value = 34; - add_trace("cause", "coding", "%d", mncc->cause.coding); - add_trace("cause", "location", "%d", mncc->cause.location); - add_trace("cause", "value", "%d", mncc->cause.value); - add_trace("reason", NULL, "no channel"); - end_trace(); - send_and_free_mncc((struct gsm_network *)gsm->network, mncc->msg_type, mncc); - new_state(PORT_STATE_RELEASE); - trigger_work(&p_m_g_delete); - return; - } - bchannel_event(p_m_mISDNport, p_m_b_index, B_EVENT_USE); - if (bchannel_open(p_m_b_index)) - goto no_channel; - - /* what infos did we got ... */ - gsm_trace_header(p_m_mISDNport, this, msg_type, DIRECTION_IN); - if (p_callerinfo.id[0]) - add_trace("calling", "number", "%s", p_callerinfo.id); - else - SPRINT(p_callerinfo.id, "imsi-%s", p_callerinfo.imsi); - add_trace("calling", "imsi", "%s", p_callerinfo.imsi); - add_trace("dialing", "number", "%s", p_dialinginfo.id); - end_trace(); - - /* create endpoint */ - if (p_epointlist) - FATAL("Incoming call but already got an endpoint.\n"); - if (!(epoint = new Endpoint(p_serial, 0))) - FATAL("No memory for Endpoint instance\n"); - if (!(epoint->ep_app = new DEFAULT_ENDPOINT_APP(epoint, 0))) //incoming - FATAL("No memory for Endpoint Application instance\n"); - epointlist_new(epoint->ep_serial); - - /* modify lchan to GSM codec V1 */ - gsm_trace_header(p_m_mISDNport, this, MNCC_LCHAN_MODIFY, DIRECTION_OUT); - mode = create_mncc(MNCC_LCHAN_MODIFY, p_m_g_callref); - mode->lchan_mode = 0x01; /* GSM V1 */ + mode->lchan_type = 0x02; /* FIXME: unused */ add_trace("mode", NULL, "0x%02x", mode->lchan_mode); end_trace(); - send_and_free_mncc((struct gsm_network *)gsm->network, mode->msg_type, mode); - - /* send call proceeding */ - gsm_trace_header(p_m_mISDNport, this, MNCC_CALL_PROC_REQ, DIRECTION_OUT); - proceeding = create_mncc(MNCC_CALL_PROC_REQ, p_m_g_callref); - if (p_m_mISDNport->tones) { - proceeding->fields |= MNCC_F_PROGRESS; - proceeding->progress.coding = 3; /* GSM */ - proceeding->progress.location = 1; - proceeding->progress.descr = 8; - add_trace("progress", "coding", "%d", proceeding->progress.coding); - add_trace("progress", "location", "%d", proceeding->progress.location); - add_trace("progress", "descr", "%d", proceeding->progress.descr); - } - end_trace(); - send_and_free_mncc((struct gsm_network *)gsm->network, proceeding->msg_type, proceeding); - - new_state(PORT_STATE_IN_PROCEEDING); - - if (p_m_mISDNport->tones && !p_m_g_tch_connected) { /* only if ... */ - gsm_trace_header(p_m_mISDNport, this, MNCC_FRAME_RECV, DIRECTION_OUT); - end_trace(); - frame = create_mncc(MNCC_FRAME_RECV, p_m_g_callref); - send_and_free_mncc((struct gsm_network *)gsm->network, frame->msg_type, frame); - p_m_g_tch_connected = 1; - } - - /* send setup message to endpoit */ - message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_SETUP); - message->param.setup.isdn_port = p_m_portnum; - message->param.setup.port_type = p_type; -// message->param.setup.dtmf = 0; - memcpy(&message->param.setup.dialinginfo, &p_dialinginfo, sizeof(struct dialing_info)); - memcpy(&message->param.setup.callerinfo, &p_callerinfo, sizeof(struct caller_info)); - memcpy(&message->param.setup.capainfo, &p_capainfo, sizeof(struct capa_info)); - SCPY((char *)message->param.setup.useruser.data, (char *)mncc->useruser.info); - message->param.setup.useruser.len = strlen(mncc->useruser.info); - message->param.setup.useruser.protocol = mncc->useruser.proto; - message_put(message); + send_and_free_mncc(p_g_lcr_gsm, mode->msg_type, mode); } -/* DTMF INDICATION */ -void Pgsm::start_dtmf_ind(unsigned int msg_type, unsigned int callref, struct gsm_mncc *mncc) +/* CALL PROCEEDING INDICATION (from network) */ +void Pgsm::call_proc_ind(unsigned int msg_type, unsigned int callref, struct gsm_mncc *mncc) { struct lcr_msg *message; - struct gsm_mncc *resp; - - gsm_trace_header(p_m_mISDNport, this, msg_type, DIRECTION_IN); - add_trace("keypad", NULL, "%c", mncc->keypad); - end_trace(); - SPRINT(p_dialinginfo.id, "%c", mncc->keypad); - p_dialinginfo.ntype = INFO_NTYPE_UNKNOWN; + struct gsm_mncc *frame; - /* send resp */ - gsm_trace_header(p_m_mISDNport, this, MNCC_START_DTMF_RSP, DIRECTION_OUT); - add_trace("keypad", NULL, "%c", mncc->keypad); + gsm_trace_header(p_interface_name, this, msg_type, DIRECTION_IN); end_trace(); - resp = create_mncc(MNCC_START_DTMF_RSP, p_m_g_callref); - resp->keypad = mncc->keypad; - send_and_free_mncc((struct gsm_network *)gsm->network, resp->msg_type, resp); - /* send dialing information */ - message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_INFORMATION); - memcpy(&message->param.information, &p_dialinginfo, sizeof(struct dialing_info)); + message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_PROCEEDING); message_put(message); -} -void Pgsm::stop_dtmf_ind(unsigned int msg_type, unsigned int callref, struct gsm_mncc *mncc) -{ - struct gsm_mncc *resp; - - gsm_trace_header(p_m_mISDNport, this, msg_type, DIRECTION_IN); - add_trace("keypad", NULL, "%c", mncc->keypad); - end_trace(); - /* send resp */ - gsm_trace_header(p_m_mISDNport, this, MNCC_STOP_DTMF_RSP, DIRECTION_OUT); - add_trace("keypad", NULL, "%c", mncc->keypad); - end_trace(); - resp = create_mncc(MNCC_STOP_DTMF_RSP, p_m_g_callref); - resp->keypad = mncc->keypad; - send_and_free_mncc((struct gsm_network *)gsm->network, resp->msg_type, resp); -} - -/* PROCEEDING INDICATION */ -void Pgsm::call_conf_ind(unsigned int msg_type, unsigned int callref, struct gsm_mncc *mncc) -{ - struct gsm_mncc *mode; + new_state(PORT_STATE_OUT_PROCEEDING); - gsm_trace_header(p_m_mISDNport, this, msg_type, DIRECTION_IN); - if (mncc->fields & MNCC_F_CAUSE) { - add_trace("cause", "coding", "%d", mncc->cause.coding); - add_trace("cause", "location", "%", mncc->cause.location); - add_trace("cause", "value", "%", mncc->cause.value); + if (p_g_earlyb && !p_g_tch_connected) { /* only if ... */ + gsm_trace_header(p_interface_name, this, MNCC_FRAME_RECV, DIRECTION_OUT); + end_trace(); + frame = create_mncc(MNCC_FRAME_RECV, p_g_callref); + send_and_free_mncc(p_g_lcr_gsm, frame->msg_type, frame); + p_g_tch_connected = 1; } - end_trace(); - - /* modify lchan to GSM codec V1 */ - gsm_trace_header(p_m_mISDNport, this, MNCC_LCHAN_MODIFY, DIRECTION_OUT); - mode = create_mncc(MNCC_LCHAN_MODIFY, p_m_g_callref); - mode->lchan_mode = 0x01; /* GSM V1 */ - add_trace("mode", NULL, "0x%02x", mode->lchan_mode); - end_trace(); - send_and_free_mncc((struct gsm_network *)gsm->network, mode->msg_type, mode); + /* modify to GSM FR (this is GSM user side only, so there is FR supported only) */ + modify_lchan(MEDIA_TYPE_GSM); } /* ALERTING INDICATION */ void Pgsm::alert_ind(unsigned int msg_type, unsigned int callref, struct gsm_mncc *mncc) { struct lcr_msg *message; + struct gsm_mncc *frame; - gsm_trace_header(p_m_mISDNport, this, msg_type, DIRECTION_IN); + gsm_trace_header(p_interface_name, this, msg_type, DIRECTION_IN); end_trace(); message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_ALERTING); @@ -639,6 +631,18 @@ void Pgsm::alert_ind(unsigned int msg_type, unsigned int callref, struct gsm_mnc new_state(PORT_STATE_OUT_ALERTING); + if (p_g_earlyb && !p_g_tch_connected) { /* only if ... */ + gsm_trace_header(p_interface_name, this, MNCC_FRAME_RECV, DIRECTION_OUT); + end_trace(); + frame = create_mncc(MNCC_FRAME_RECV, p_g_callref); + send_and_free_mncc(p_g_lcr_gsm, frame->msg_type, frame); + p_g_tch_connected = 1; + } + + /* modify to GSM FR, if not already */ + if (!p_g_media_type) { + modify_lchan(MEDIA_TYPE_GSM); + } } /* CONNECT INDICATION */ @@ -652,10 +656,9 @@ void Pgsm::setup_cnf(unsigned int msg_type, unsigned int callref, struct gsm_mnc p_connectinfo.present = INFO_PRESENT_ALLOWED; p_connectinfo.screen = INFO_SCREEN_NETWORK; p_connectinfo.ntype = INFO_NTYPE_UNKNOWN; - p_connectinfo.isdn_port = p_m_portnum; - SCPY(p_connectinfo.interface, p_m_mISDNport->ifport->interface->name); + SCPY(p_connectinfo.interface, p_interface_name); - gsm_trace_header(p_m_mISDNport, this, msg_type, DIRECTION_IN); + gsm_trace_header(p_interface_name, this, msg_type, DIRECTION_IN); if (p_connectinfo.id[0]) add_trace("connect", "number", "%s", p_connectinfo.id); else if (mncc->imsi[0]) @@ -665,24 +668,53 @@ void Pgsm::setup_cnf(unsigned int msg_type, unsigned int callref, struct gsm_mnc end_trace(); /* send resp */ - gsm_trace_header(p_m_mISDNport, this, MNCC_SETUP_COMPL_REQ, DIRECTION_OUT); - resp = create_mncc(MNCC_SETUP_COMPL_REQ, p_m_g_callref); + gsm_trace_header(p_interface_name, this, MNCC_SETUP_COMPL_REQ, DIRECTION_OUT); + resp = create_mncc(MNCC_SETUP_COMPL_REQ, p_g_callref); end_trace(); - send_and_free_mncc((struct gsm_network *)gsm->network, resp->msg_type, resp); - - message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_CONNECT); - memcpy(&message->param.connectinfo, &p_connectinfo, sizeof(struct connect_info)); - message_put(message); + send_and_free_mncc(p_g_lcr_gsm, resp->msg_type, resp); new_state(PORT_STATE_CONNECT); - if (!p_m_g_tch_connected) { /* only if ... */ - gsm_trace_header(p_m_mISDNport, this, MNCC_FRAME_RECV, DIRECTION_OUT); + if (!p_g_tch_connected) { /* only if ... */ + gsm_trace_header(p_interface_name, this, MNCC_FRAME_RECV, DIRECTION_OUT); end_trace(); - frame = create_mncc(MNCC_FRAME_RECV, p_m_g_callref); - send_and_free_mncc((struct gsm_network *)gsm->network, frame->msg_type, frame); - p_m_g_tch_connected = 1; + frame = create_mncc(MNCC_FRAME_RECV, p_g_callref); + send_and_free_mncc(p_g_lcr_gsm, frame->msg_type, frame); + p_g_tch_connected = 1; } + + message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_CONNECT); + memcpy(&message->param.connectinfo, &p_connectinfo, sizeof(struct connect_info)); + + /* if we have a bridge, but not yet modified, the phone accepts out requested payload. + * we force the first in list */ + if (p_g_rtp_bridge) { + if (!p_g_media_type) { + /* modify to first given type */ + modify_lchan(p_g_rtp_media_types[0]); + /* also set payload type */ + p_g_payload_type = p_g_rtp_payload_types[0]; + } + message->param.connectinfo.rtpinfo.media_types[0] = p_g_media_type; + message->param.connectinfo.rtpinfo.payload_types[0] = p_g_payload_type; + message->param.connectinfo.rtpinfo.payloads = 1; + } else { + /* modify to GSM FR, if not already + * for network side, this should have been already happened */ + if (!p_g_media_type) + modify_lchan(MEDIA_TYPE_GSM); + } + + + if (p_g_rtp_bridge) { + struct gsm_mncc_rtp *rtp; + + PDEBUG(DEBUG_GSM, "Request RTP peer info, before forwarding connect msg\n"); + p_g_connect_pending = message; + rtp = (struct gsm_mncc_rtp *) create_mncc(MNCC_RTP_CREATE, p_g_callref); + send_and_free_mncc(p_g_lcr_gsm, rtp->msg_type, rtp); + } else + message_put(message); } /* CONNECT ACK INDICATION */ @@ -690,17 +722,22 @@ void Pgsm::setup_compl_ind(unsigned int msg_type, unsigned int callref, struct g { struct gsm_mncc *frame; - gsm_trace_header(p_m_mISDNport, this, msg_type, DIRECTION_IN); + gsm_trace_header(p_interface_name, this, msg_type, DIRECTION_IN); end_trace(); new_state(PORT_STATE_CONNECT); - if (!p_m_g_tch_connected) { /* only if ... */ - gsm_trace_header(p_m_mISDNport, this, MNCC_FRAME_RECV, DIRECTION_OUT); + if (!p_g_tch_connected) { /* only if ... */ + gsm_trace_header(p_interface_name, this, MNCC_FRAME_RECV, DIRECTION_OUT); end_trace(); - frame = create_mncc(MNCC_FRAME_RECV, p_m_g_callref); - send_and_free_mncc((struct gsm_network *)gsm->network, frame->msg_type, frame); - p_m_g_tch_connected = 1; + frame = create_mncc(MNCC_FRAME_RECV, p_g_callref); + send_and_free_mncc(p_g_lcr_gsm, frame->msg_type, frame); + p_g_tch_connected = 1; + } + + /* modify to GSM FR, if not already */ + if (!p_g_media_type) { + modify_lchan(MEDIA_TYPE_GSM); } } @@ -711,7 +748,7 @@ void Pgsm::disc_ind(unsigned int msg_type, unsigned int callref, struct gsm_mncc int cause = 16, location = 0; struct gsm_mncc *resp; - gsm_trace_header(p_m_mISDNport, this, msg_type, DIRECTION_IN); + gsm_trace_header(p_interface_name, this, msg_type, DIRECTION_IN); if (mncc->fields & MNCC_F_CAUSE) { location = mncc->cause.location; cause = mncc->cause.value; @@ -722,8 +759,8 @@ void Pgsm::disc_ind(unsigned int msg_type, unsigned int callref, struct gsm_mncc end_trace(); /* send release */ - resp = create_mncc(MNCC_REL_REQ, p_m_g_callref); - gsm_trace_header(p_m_mISDNport, this, MNCC_REL_REQ, DIRECTION_OUT); + resp = create_mncc(MNCC_REL_REQ, p_g_callref); + gsm_trace_header(p_interface_name, this, MNCC_REL_REQ, DIRECTION_OUT); #if 0 resp->fields |= MNCC_F_CAUSE; resp->cause.coding = 3; @@ -731,463 +768,65 @@ void Pgsm::disc_ind(unsigned int msg_type, unsigned int callref, struct gsm_mncc resp->cause.value = cause; add_trace("cause", "coding", "%d", resp->cause.coding); add_trace("cause", "location", "%d", resp->cause.location); - add_trace("cause", "value", "%d", resp->cause.value); -#endif - end_trace(); - send_and_free_mncc((struct gsm_network *)gsm->network, resp->msg_type, resp); - - /* sending release to endpoint */ - while(p_epointlist) { - message = message_create(p_serial, p_epointlist->epoint_id, PORT_TO_EPOINT, MESSAGE_RELEASE); - message->param.disconnectinfo.cause = cause; - message->param.disconnectinfo.location = location; - message_put(message); - /* remove epoint */ - free_epointlist(p_epointlist); - } - new_state(PORT_STATE_RELEASE); - trigger_work(&p_m_g_delete); -} - -/* CC_RELEASE INDICATION */ -void Pgsm::rel_ind(unsigned int msg_type, unsigned int callref, struct gsm_mncc *mncc) -{ - int location = 0, cause = 16; - struct lcr_msg *message; - - gsm_trace_header(p_m_mISDNport, this, msg_type, DIRECTION_IN); - if (mncc->fields & MNCC_F_CAUSE) { - location = mncc->cause.location; - cause = mncc->cause.value; - add_trace("cause", "coding", "%d", mncc->cause.coding); - add_trace("cause", "location", "%d", mncc->cause.location); - add_trace("cause", "value", "%d", mncc->cause.value); - } - end_trace(); - - /* sending release to endpoint */ - while(p_epointlist) { - message = message_create(p_serial, p_epointlist->epoint_id, PORT_TO_EPOINT, MESSAGE_RELEASE); - message->param.disconnectinfo.cause = cause; - message->param.disconnectinfo.location = location; - message_put(message); - /* remove epoint */ - free_epointlist(p_epointlist); - } - new_state(PORT_STATE_RELEASE); - trigger_work(&p_m_g_delete); -} - -/* NOTIFY INDICATION */ -void Pgsm::notify_ind(unsigned int msg_type, unsigned int callref, struct gsm_mncc *mncc) -{ - struct lcr_msg *message; - - gsm_trace_header(p_m_mISDNport, this, msg_type, DIRECTION_IN); - add_trace("notify", NULL, "%d", mncc->notify); - end_trace(); - - message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_NOTIFY); - message->param.notifyinfo.notify = mncc->notify; - message_put(message); -} - - -/* HOLD INDICATION */ -void Pgsm::hold_ind(unsigned int msg_type, unsigned int callref, struct gsm_mncc *mncc) -{ - struct lcr_msg *message; - struct gsm_mncc *resp, *frame; - - gsm_trace_header(p_m_mISDNport, this, msg_type, DIRECTION_IN); - end_trace(); - - /* notify the hold of call */ - message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_NOTIFY); - message->param.notifyinfo.notify = INFO_NOTIFY_REMOTE_HOLD; - message->param.notifyinfo.local = 1; /* call is held by supplementary service */ - message_put(message); - - /* acknowledge hold */ - gsm_trace_header(p_m_mISDNport, this, MNCC_HOLD_CNF, DIRECTION_OUT); - end_trace(); - resp = create_mncc(MNCC_HOLD_CNF, p_m_g_callref); - send_and_free_mncc((struct gsm_network *)gsm->network, resp->msg_type, resp); - - /* disable audio */ - if (p_m_g_tch_connected) { /* it should be true */ - gsm_trace_header(p_m_mISDNport, this, MNCC_FRAME_DROP, DIRECTION_OUT); - end_trace(); - frame = create_mncc(MNCC_FRAME_DROP, p_m_g_callref); - send_and_free_mncc((struct gsm_network *)gsm->network, frame->msg_type, frame); - p_m_g_tch_connected = 0; - } -} - - -/* RETRIEVE INDICATION */ -void Pgsm::retr_ind(unsigned int msg_type, unsigned int callref, struct gsm_mncc *mncc) -{ - struct lcr_msg *message; - struct gsm_mncc *resp, *frame; - - gsm_trace_header(p_m_mISDNport, this, msg_type, DIRECTION_IN); - end_trace(); - - /* notify the retrieve of call */ - message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_NOTIFY); - message->param.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL; - message->param.notifyinfo.local = 1; /* call is retrieved by supplementary service */ - message_put(message); - - /* acknowledge retr */ - gsm_trace_header(p_m_mISDNport, this, MNCC_RETRIEVE_CNF, DIRECTION_OUT); - end_trace(); - resp = create_mncc(MNCC_RETRIEVE_CNF, p_m_g_callref); - send_and_free_mncc((struct gsm_network *)gsm->network, resp->msg_type, resp); - - /* enable audio */ - if (!p_m_g_tch_connected) { /* it should be true */ - gsm_trace_header(p_m_mISDNport, this, MNCC_FRAME_RECV, DIRECTION_OUT); - end_trace(); - frame = create_mncc(MNCC_FRAME_RECV, p_m_g_callref); - send_and_free_mncc((struct gsm_network *)gsm->network, frame->msg_type, frame); - p_m_g_tch_connected = 1; - } -} - -/* - * BSC sends message to port - */ -static int message_bsc(struct gsm_network *net, int msg_type, void *arg) -{ - struct gsm_mncc *mncc = (struct gsm_mncc *)arg; - unsigned int callref = mncc->callref; - class Port *port; - class Pgsm *pgsm = NULL; - char name[64]; - struct mISDNport *mISDNport; - - /* Special messages */ - switch(msg_type) { - } - - /* find callref */ - callref = mncc->callref; - port = port_first; - while(port) { - if ((port->p_type & PORT_CLASS_mISDN_MASK) == PORT_CLASS_mISDN_GSM) { - pgsm = (class Pgsm *)port; - if (pgsm->p_m_g_callref == callref) { - break; - } - } - port = port->next; - } - - if (msg_type == GSM_TCHF_FRAME) { - if (port) - pgsm->frame_receive((struct gsm_trau_frame *)arg); - return 0; - } - - if (!port) { - if (msg_type != MNCC_SETUP_IND) - return(0); - /* find gsm port */ - mISDNport = mISDNport_first; - while(mISDNport) { - if (mISDNport->gsm) - break; - mISDNport = mISDNport->next; - } - if (!mISDNport) { - struct gsm_mncc *rej; - - rej = create_mncc(MNCC_REJ_REQ, callref); - rej->fields |= MNCC_F_CAUSE; - rej->cause.coding = 3; - rej->cause.location = 1; - rej->cause.value = 27; - gsm_trace_header(NULL, NULL, MNCC_REJ_REQ, DIRECTION_OUT); - add_trace("cause", "coding", "%d", rej->cause.coding); - add_trace("cause", "location", "%d", rej->cause.location); - add_trace("cause", "value", "%d", rej->cause.value); - end_trace(); - send_and_free_mncc((struct gsm_network *)gsm->network, rej->msg_type, rej); - return 0; - } - /* creating port object, transparent until setup with hdlc */ - SPRINT(name, "%s-%d-in", mISDNport->ifport->interface->name, mISDNport->portnum); - if (!(pgsm = new Pgsm(PORT_TYPE_GSM_IN, mISDNport, name, NULL, 0, 0, B_MODE_TRANSPARENT))) - - FATAL("Cannot create Port instance.\n"); - } - - switch(msg_type) { - case MNCC_SETUP_IND: - pgsm->setup_ind(msg_type, callref, mncc); - break; - - case MNCC_START_DTMF_IND: - pgsm->start_dtmf_ind(msg_type, callref, mncc); - break; - - case MNCC_STOP_DTMF_IND: - pgsm->stop_dtmf_ind(msg_type, callref, mncc); - break; - - case MNCC_CALL_CONF_IND: - pgsm->call_conf_ind(msg_type, callref, mncc); - break; - - case MNCC_ALERT_IND: - pgsm->alert_ind(msg_type, callref, mncc); - break; - - case MNCC_SETUP_CNF: - pgsm->setup_cnf(msg_type, callref, mncc); - break; - - case MNCC_SETUP_COMPL_IND: - pgsm->setup_compl_ind(msg_type, callref, mncc); - break; - - case MNCC_DISC_IND: - pgsm->disc_ind(msg_type, callref, mncc); - break; - - case MNCC_REL_IND: - case MNCC_REL_CNF: - case MNCC_REJ_IND: - pgsm->rel_ind(msg_type, callref, mncc); - break; - - case MNCC_NOTIFY_IND: - pgsm->notify_ind(msg_type, callref, mncc); - break; - - case MNCC_HOLD_IND: - pgsm->hold_ind(msg_type, callref, mncc); - break; - - case MNCC_RETRIEVE_IND: - pgsm->retr_ind(msg_type, callref, mncc); - break; + add_trace("cause", "value", "%d", resp->cause.value); +#endif + end_trace(); + send_and_free_mncc(p_g_lcr_gsm, resp->msg_type, resp); - default: - PDEBUG(DEBUG_GSM, "Pgsm(%s) gsm port with (caller id %s) received unhandled nessage: 0x%x\n", pgsm->p_name, pgsm->p_callerinfo.id, msg_type); + /* sending release to endpoint */ + while(p_epointlist) { + message = message_create(p_serial, p_epointlist->epoint_id, PORT_TO_EPOINT, MESSAGE_RELEASE); + message->param.disconnectinfo.cause = cause; + message->param.disconnectinfo.location = location; + message_put(message); + /* remove epoint */ + free_epointlist(p_epointlist); } - return(0); + new_state(PORT_STATE_RELEASE); + trigger_work(&p_g_delete); } -/* MESSAGE_SETUP */ -void Pgsm::message_setup(unsigned int epoint_id, int message_id, union parameter *param) +/* CC_RELEASE INDICATION */ +void Pgsm::rel_ind(unsigned int msg_type, unsigned int callref, struct gsm_mncc *mncc) { + int location = 0, cause = 16; struct lcr_msg *message; - int ret; - struct epoint_list *epointlist; - struct gsm_mncc *mncc; - int channel; - - /* copy setup infos to port */ - memcpy(&p_callerinfo, ¶m->setup.callerinfo, sizeof(p_callerinfo)); - memcpy(&p_dialinginfo, ¶m->setup.dialinginfo, sizeof(p_dialinginfo)); - memcpy(&p_capainfo, ¶m->setup.capainfo, sizeof(p_capainfo)); - memcpy(&p_redirinfo, ¶m->setup.redirinfo, sizeof(p_redirinfo)); - - /* no number */ - if (!p_dialinginfo.id[0]) { - gsm_trace_header(p_m_mISDNport, this, MNCC_SETUP_REQ, DIRECTION_OUT); - add_trace("failure", NULL, "No dialed subscriber given."); - end_trace(); - message = message_create(p_serial, epoint_id, PORT_TO_EPOINT, MESSAGE_RELEASE); - message->param.disconnectinfo.cause = 28; - message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL; - message_put(message); - new_state(PORT_STATE_RELEASE); - trigger_work(&p_m_g_delete); - return; - } - - /* release if port is blocked */ - if (p_m_mISDNport->ifport->block) { - gsm_trace_header(p_m_mISDNport, this, MNCC_SETUP_REQ, DIRECTION_OUT); - add_trace("failure", NULL, "Port blocked."); - end_trace(); - message = message_create(p_serial, epoint_id, PORT_TO_EPOINT, MESSAGE_RELEASE); - message->param.disconnectinfo.cause = 27; // temp. unavail. - message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL; - message_put(message); - new_state(PORT_STATE_RELEASE); - trigger_work(&p_m_g_delete); - return; - } - - /* hunt channel */ - ret = channel = hunt_bchannel(); - if (ret < 0) - goto no_channel; - /* open channel */ - ret = seize_bchannel(channel, 1); - if (ret < 0) { - no_channel: - gsm_trace_header(p_m_mISDNport, this, MNCC_SETUP_REQ, DIRECTION_OUT); - add_trace("failure", NULL, "No internal audio channel available."); - end_trace(); - message = message_create(p_serial, epoint_id, PORT_TO_EPOINT, MESSAGE_RELEASE); - message->param.disconnectinfo.cause = 34; - message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL; - message_put(message); - new_state(PORT_STATE_RELEASE); - trigger_work(&p_m_g_delete); - return; - } - bchannel_event(p_m_mISDNport, p_m_b_index, B_EVENT_USE); - if (bchannel_open(p_m_b_index)) - goto no_channel; - -// SCPY(&p_m_tones_dir, param->setup.ext.tones_dir); - /* screen outgoing caller id */ - do_screen(1, p_callerinfo.id, sizeof(p_callerinfo.id), &p_callerinfo.ntype, &p_callerinfo.present, p_m_mISDNport->ifport->interface); - /* attach only if not already */ - epointlist = p_epointlist; - while(epointlist) { - if (epointlist->epoint_id == epoint_id) - break; - epointlist = epointlist->next; + gsm_trace_header(p_interface_name, this, msg_type, DIRECTION_IN); + if (mncc->fields & MNCC_F_CAUSE) { + location = mncc->cause.location; + cause = mncc->cause.value; + add_trace("cause", "coding", "%d", mncc->cause.coding); + add_trace("cause", "location", "%d", mncc->cause.location); + add_trace("cause", "value", "%d", mncc->cause.value); } - if (!epointlist) - epointlist_new(epoint_id); - - /* creating l3id */ - l1l2l3_trace_header(p_m_mISDNport, this, L3_NEW_L3ID_REQ, DIRECTION_OUT); - p_m_g_callref = new_callref++; - add_trace("callref", "new", "0x%x", p_m_g_callref); end_trace(); - gsm_trace_header(p_m_mISDNport, this, MNCC_SETUP_REQ, DIRECTION_OUT); - mncc = create_mncc(MNCC_SETUP_REQ, p_m_g_callref); - /* caller information */ - mncc->fields |= MNCC_F_CALLING; - mncc->calling.plan = 1; - switch (p_callerinfo.ntype) { - case INFO_NTYPE_UNKNOWN: - mncc->calling.type = 0x0; - break; - case INFO_NTYPE_INTERNATIONAL: - mncc->calling.type = 0x1; - break; - case INFO_NTYPE_NATIONAL: - mncc->calling.type = 0x2; - break; - case INFO_NTYPE_SUBSCRIBER: - mncc->calling.type = 0x4; - break; - default: /* INFO_NTYPE_NOTPRESENT */ - mncc->fields &= ~MNCC_F_CALLING; - break; - } - switch (p_callerinfo.screen) { - case INFO_SCREEN_USER: - mncc->calling.screen = 0; - break; - default: /* INFO_SCREEN_NETWORK */ - mncc->calling.screen = 3; - break; - } - switch (p_callerinfo.present) { - case INFO_PRESENT_ALLOWED: - mncc->calling.present = 0; - break; - case INFO_PRESENT_RESTRICTED: - mncc->calling.present = 1; - break; - default: /* INFO_PRESENT_NOTAVAIL */ - mncc->calling.present = 2; - break; - } - if (mncc->fields & MNCC_F_CALLING) { - SCPY(mncc->calling.number, p_callerinfo.id); - add_trace("calling", "type", "%d", mncc->calling.type); - add_trace("calling", "plan", "%d", mncc->calling.plan); - add_trace("calling", "present", "%d", mncc->calling.present); - add_trace("calling", "screen", "%d", mncc->calling.screen); - add_trace("calling", "number", "%s", mncc->calling.number); - } - /* dialing information */ - mncc->fields |= MNCC_F_CALLED; - if (!strncmp(p_dialinginfo.id, "imsi-", 5)) { - SCPY(mncc->imsi, p_dialinginfo.id+5); - add_trace("dialing", "imsi", "%s", mncc->imsi); - } else { - SCPY(mncc->called.number, p_dialinginfo.id); - add_trace("dialing", "number", "%s", mncc->called.number); + /* sending release to endpoint */ + while(p_epointlist) { + message = message_create(p_serial, p_epointlist->epoint_id, PORT_TO_EPOINT, MESSAGE_RELEASE); + message->param.disconnectinfo.cause = cause; + message->param.disconnectinfo.location = location; + message_put(message); + /* remove epoint */ + free_epointlist(p_epointlist); } - - /* sending user-user */ + new_state(PORT_STATE_RELEASE); + trigger_work(&p_g_delete); +} - /* redirecting number */ - mncc->fields |= MNCC_F_REDIRECTING; - mncc->redirecting.plan = 1; - switch (p_redirinfo.ntype) { - case INFO_NTYPE_UNKNOWN: - mncc->redirecting.type = 0x0; - break; - case INFO_NTYPE_INTERNATIONAL: - mncc->redirecting.type = 0x1; - break; - case INFO_NTYPE_NATIONAL: - mncc->redirecting.type = 0x2; - break; - case INFO_NTYPE_SUBSCRIBER: - mncc->redirecting.type = 0x4; - break; - default: /* INFO_NTYPE_NOTPRESENT */ - mncc->fields &= ~MNCC_F_REDIRECTING; - break; - } - switch (p_redirinfo.screen) { - case INFO_SCREEN_USER: - mncc->redirecting.screen = 0; - break; - default: /* INFO_SCREE_NETWORK */ - mncc->redirecting.screen = 3; - break; - } - switch (p_redirinfo.present) { - case INFO_PRESENT_ALLOWED: - mncc->redirecting.present = 0; - break; - case INFO_PRESENT_RESTRICTED: - mncc->redirecting.present = 1; - break; - default: /* INFO_PRESENT_NOTAVAIL */ - mncc->redirecting.present = 2; - break; - } - /* sending redirecting number only in ntmode */ - if (mncc->fields & MNCC_F_REDIRECTING) { - SCPY(mncc->redirecting.number, p_redirinfo.id); - add_trace("redir", "type", "%d", mncc->redirecting.type); - add_trace("redir", "plan", "%d", mncc->redirecting.plan); - add_trace("redir", "present", "%d", mncc->redirecting.present); - add_trace("redir", "screen", "%d", mncc->redirecting.screen); - add_trace("redir", "number", "%s", mncc->redirecting.number); - } - /* bearer capability */ - //todo +/* NOTIFY INDICATION */ +void Pgsm::notify_ind(unsigned int msg_type, unsigned int callref, struct gsm_mncc *mncc) +{ + struct lcr_msg *message; + gsm_trace_header(p_interface_name, this, msg_type, DIRECTION_IN); + add_trace("notify", NULL, "%d", mncc->notify); end_trace(); - send_and_free_mncc((struct gsm_network *)gsm->network, mncc->msg_type, mncc); - - new_state(PORT_STATE_OUT_SETUP); - message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_PROCEEDING); + message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_NOTIFY); + message->param.notifyinfo.notify = mncc->notify; message_put(message); - - new_state(PORT_STATE_OUT_PROCEEDING); } /* MESSAGE_NOTIFY */ @@ -1201,31 +840,92 @@ void Pgsm::message_notify(unsigned int epoint_id, int message_id, union paramete notify = param->notifyinfo.notify & 0x7f; if (p_state!=PORT_STATE_CONNECT /*&& p_state!=PORT_STATE_IN_PROCEEDING*/ && p_state!=PORT_STATE_IN_ALERTING) { /* queue notification */ - if (p_m_g_notify_pending) - message_free(p_m_g_notify_pending); - p_m_g_notify_pending = message_create(ACTIVE_EPOINT(p_epointlist), p_serial, EPOINT_TO_PORT, message_id); - memcpy(&p_m_g_notify_pending->param, param, sizeof(union parameter)); + if (p_g_notify_pending) + message_free(p_g_notify_pending); + p_g_notify_pending = message_create(ACTIVE_EPOINT(p_epointlist), p_serial, EPOINT_TO_PORT, message_id); + memcpy(&p_g_notify_pending->param, param, sizeof(union parameter)); } else { /* sending notification */ - gsm_trace_header(p_m_mISDNport, this, MNCC_NOTIFY_REQ, DIRECTION_OUT); + gsm_trace_header(p_interface_name, this, MNCC_NOTIFY_REQ, DIRECTION_OUT); add_trace("notify", NULL, "%d", notify); end_trace(); - mncc = create_mncc(MNCC_NOTIFY_REQ, p_m_g_callref); + mncc = create_mncc(MNCC_NOTIFY_REQ, p_g_callref); mncc->notify = notify; - send_and_free_mncc((struct gsm_network *)gsm->network, mncc->msg_type, mncc); + send_and_free_mncc(p_g_lcr_gsm, mncc->msg_type, mncc); } } } +/* RTP create indication */ +void Pgsm::rtp_create_ind(unsigned int msg_type, unsigned int callref, struct gsm_mncc *mncc) +{ + struct gsm_mncc_rtp *rtp = (struct gsm_mncc_rtp *) mncc; + + /* send queued setup, as we received remote RTP info */ + if (p_g_setup_pending) { + struct lcr_msg *message; + + message = p_g_setup_pending; + PDEBUG(DEBUG_GSM, "Got RTP peer info (%08x,%d) forwarding setup\n", rtp->ip, rtp->port); + message->param.setup.rtpinfo.ip = rtp->ip; + message->param.setup.rtpinfo.port = rtp->port; + message_put(message); + p_g_setup_pending = NULL; + } + if (p_g_connect_pending) { + PDEBUG(DEBUG_GSM, "Got RTP peer info (%08x,%d) connecting RTP... \n", rtp->ip, rtp->port); + send_mncc_rtp_connect(); + } +} + +/* RTP connect indication */ +void Pgsm::rtp_connect_ind(unsigned int msg_type, unsigned int callref, struct gsm_mncc *mncc) +{ + struct lcr_msg *message; + struct gsm_mncc_rtp *rtp = (struct gsm_mncc_rtp *) mncc; + + if (p_g_connect_pending) { + message = p_g_connect_pending; + PDEBUG(DEBUG_GSM, "Got RTP peer info (%08x,%d) forwarding connect\n", rtp->ip, rtp->port); + message->param.connectinfo.rtpinfo.ip = rtp->ip; + message->param.connectinfo.rtpinfo.port = rtp->port; + message_put(message); + p_g_connect_pending = NULL; + } +} + +/* MESSAGE_PROGRESS */ +void Pgsm::message_progress(unsigned int epoint_id, int message_id, union parameter *param) +{ + if (param->progressinfo.progress == 8) { + PDEBUG(DEBUG_GSM, "Remote provides tones for us\n"); + p_g_tones = 1; + } + + if (param->progressinfo.rtpinfo.port) { + PDEBUG(DEBUG_GSM, "PROGRESS with RTP peer info, sent to BSC (%08x,%d) with media %d, pt %d\n", param->progressinfo.rtpinfo.ip, param->progressinfo.rtpinfo.port, param->progressinfo.rtpinfo.media_types[0], param->progressinfo.rtpinfo.payload_types[0]); + + /* modify channel to givne type, also sets media type */ + modify_lchan(param->progressinfo.rtpinfo.media_types[0]); + + /* connect RTP */ + p_g_rtp_ip_remote = param->progressinfo.rtpinfo.ip; + p_g_rtp_port_remote = param->progressinfo.rtpinfo.port; + /* p_g_media_type is already set by modify_lchan() */ + p_g_payload_type = param->progressinfo.rtpinfo.payload_types[0]; + send_mncc_rtp_connect(); + } +} + /* MESSAGE_ALERTING */ void Pgsm::message_alerting(unsigned int epoint_id, int message_id, union parameter *param) { struct gsm_mncc *mncc; /* send alert */ - gsm_trace_header(p_m_mISDNport, this, MNCC_ALERT_REQ, DIRECTION_OUT); - mncc = create_mncc(MNCC_ALERT_REQ, p_m_g_callref); - if (p_m_mISDNport->tones) { + gsm_trace_header(p_interface_name, this, MNCC_ALERT_REQ, DIRECTION_OUT); + mncc = create_mncc(MNCC_ALERT_REQ, p_g_callref); + if (p_g_tones) { mncc->fields |= MNCC_F_PROGRESS; mncc->progress.coding = 3; /* GSM */ mncc->progress.location = 1; @@ -1235,16 +935,21 @@ void Pgsm::message_alerting(unsigned int epoint_id, int message_id, union parame add_trace("progress", "descr", "%d", mncc->progress.descr); } end_trace(); - send_and_free_mncc((struct gsm_network *)gsm->network, mncc->msg_type, mncc); + send_and_free_mncc(p_g_lcr_gsm, mncc->msg_type, mncc); new_state(PORT_STATE_IN_ALERTING); - if (p_m_mISDNport->tones && !p_m_g_tch_connected) { /* only if ... */ - gsm_trace_header(p_m_mISDNport, this, MNCC_FRAME_RECV, DIRECTION_OUT); + if (p_g_tones && !p_g_tch_connected) { /* only if ... */ + gsm_trace_header(p_interface_name, this, MNCC_FRAME_RECV, DIRECTION_OUT); end_trace(); - mncc = create_mncc(MNCC_FRAME_RECV, p_m_g_callref); - send_and_free_mncc((struct gsm_network *)gsm->network, mncc->msg_type, mncc); - p_m_g_tch_connected = 1; + mncc = create_mncc(MNCC_FRAME_RECV, p_g_callref); + send_and_free_mncc(p_g_lcr_gsm, mncc->msg_type, mncc); + p_g_tch_connected = 1; + } + + /* modify to GSM FR, if not already */ + if (!p_g_media_type) { + modify_lchan(MEDIA_TYPE_GSM); } } @@ -1256,11 +961,11 @@ void Pgsm::message_connect(unsigned int epoint_id, int message_id, union paramet /* copy connected information */ memcpy(&p_connectinfo, ¶m->connectinfo, sizeof(p_connectinfo)); /* screen outgoing caller id */ - do_screen(1, p_connectinfo.id, sizeof(p_connectinfo.id), &p_connectinfo.ntype, &p_connectinfo.present, p_m_mISDNport->ifport->interface); + do_screen(1, p_connectinfo.id, sizeof(p_connectinfo.id), &p_connectinfo.ntype, &p_connectinfo.present, p_interface_name); /* send connect */ - mncc = create_mncc(MNCC_SETUP_RSP, p_m_g_callref); - gsm_trace_header(p_m_mISDNport, this, MNCC_SETUP_RSP, DIRECTION_OUT); + mncc = create_mncc(MNCC_SETUP_RSP, p_g_callref); + gsm_trace_header(p_interface_name, this, MNCC_SETUP_RSP, DIRECTION_OUT); /* caller information */ mncc->fields |= MNCC_F_CONNECTED; mncc->connected.plan = 1; @@ -1309,9 +1014,23 @@ void Pgsm::message_connect(unsigned int epoint_id, int message_id, union paramet add_trace("connected", "number", "%s", mncc->connected.number); } end_trace(); - send_and_free_mncc((struct gsm_network *)gsm->network, mncc->msg_type, mncc); + send_and_free_mncc(p_g_lcr_gsm, mncc->msg_type, mncc); new_state(PORT_STATE_CONNECT_WAITING); + + if (param->connectinfo.rtpinfo.port) { + PDEBUG(DEBUG_GSM, "CONNECT with RTP peer info, sent to BSC (%08x,%d)\n", param->connectinfo.rtpinfo.ip, param->connectinfo.rtpinfo.port); + + /* modify channel to givne type, also sets media type */ + modify_lchan(param->connectinfo.rtpinfo.media_types[0]); + + /* connect RTP */ + p_g_rtp_ip_remote = param->connectinfo.rtpinfo.ip; + p_g_rtp_port_remote = param->connectinfo.rtpinfo.port; + /* p_g_media_type is already set by modify_lchan() */ + p_g_payload_type = param->connectinfo.rtpinfo.payload_types[0]; + send_mncc_rtp_connect(); + } } /* MESSAGE_DISCONNECT */ @@ -1320,9 +1039,9 @@ void Pgsm::message_disconnect(unsigned int epoint_id, int message_id, union para struct gsm_mncc *mncc; /* send disconnect */ - mncc = create_mncc(MNCC_DISC_REQ, p_m_g_callref); - gsm_trace_header(p_m_mISDNport, this, MNCC_DISC_REQ, DIRECTION_OUT); - if (p_m_mISDNport->tones) { + mncc = create_mncc(MNCC_DISC_REQ, p_g_callref); + gsm_trace_header(p_interface_name, this, MNCC_DISC_REQ, DIRECTION_OUT); + if (p_g_tones) { mncc->fields |= MNCC_F_PROGRESS; mncc->progress.coding = 3; /* GSM */ mncc->progress.location = 1; @@ -1339,16 +1058,16 @@ void Pgsm::message_disconnect(unsigned int epoint_id, int message_id, union para add_trace("cause", "location", "%d", mncc->cause.location); add_trace("cause", "value", "%d", mncc->cause.value); end_trace(); - send_and_free_mncc((struct gsm_network *)gsm->network, mncc->msg_type, mncc); + send_and_free_mncc(p_g_lcr_gsm, mncc->msg_type, mncc); new_state(PORT_STATE_OUT_DISCONNECT); - if (p_m_mISDNport->tones && !p_m_g_tch_connected) { /* only if ... */ - gsm_trace_header(p_m_mISDNport, this, MNCC_FRAME_RECV, DIRECTION_OUT); + if (p_g_tones && !p_g_tch_connected) { /* only if ... */ + gsm_trace_header(p_interface_name, this, MNCC_FRAME_RECV, DIRECTION_OUT); end_trace(); - mncc = create_mncc(MNCC_FRAME_RECV, p_m_g_callref); - send_and_free_mncc((struct gsm_network *)gsm->network, mncc->msg_type, mncc); - p_m_g_tch_connected = 1; + mncc = create_mncc(MNCC_FRAME_RECV, p_g_callref); + send_and_free_mncc(p_g_lcr_gsm, mncc->msg_type, mncc); + p_g_tch_connected = 1; } } @@ -1359,8 +1078,8 @@ void Pgsm::message_release(unsigned int epoint_id, int message_id, union paramet struct gsm_mncc *mncc; /* send release */ - mncc = create_mncc(MNCC_REL_REQ, p_m_g_callref); - gsm_trace_header(p_m_mISDNport, this, MNCC_REL_REQ, DIRECTION_OUT); + mncc = create_mncc(MNCC_REL_REQ, p_g_callref); + gsm_trace_header(p_interface_name, this, MNCC_REL_REQ, DIRECTION_OUT); mncc->fields |= MNCC_F_CAUSE; mncc->cause.coding = 3; mncc->cause.location = param->disconnectinfo.location; @@ -1369,30 +1088,26 @@ void Pgsm::message_release(unsigned int epoint_id, int message_id, union paramet add_trace("cause", "location", "%d", mncc->cause.location); add_trace("cause", "value", "%d", mncc->cause.value); end_trace(); - send_and_free_mncc((struct gsm_network *)gsm->network, mncc->msg_type, mncc); + send_and_free_mncc(p_g_lcr_gsm, mncc->msg_type, mncc); new_state(PORT_STATE_RELEASE); - trigger_work(&p_m_g_delete); + trigger_work(&p_g_delete); return; } - /* * endpoint sends messages to the port */ int Pgsm::message_epoint(unsigned int epoint_id, int message_id, union parameter *param) { - if (PmISDN::message_epoint(epoint_id, message_id, param)) - return(1); + int ret = 0; - switch(message_id) { - case MESSAGE_SETUP: /* dial-out command received from epoint */ - if (p_state!=PORT_STATE_IDLE) - break; - message_setup(epoint_id, message_id, param); - break; + if (Port::message_epoint(epoint_id, message_id, param)) + return 1; + switch(message_id) { case MESSAGE_NOTIFY: /* display and notifications */ + ret = 1; message_notify(epoint_id, message_id, param); break; @@ -1401,34 +1116,43 @@ int Pgsm::message_epoint(unsigned int epoint_id, int message_id, union parameter // break; case MESSAGE_PROCEEDING: /* message not handles */ + ret = 1; + break; + + case MESSAGE_PROGRESS: + ret = 1; + message_progress(epoint_id, message_id, param); break; case MESSAGE_ALERTING: /* call of endpoint is ringing */ + ret = 1; if (p_state!=PORT_STATE_IN_PROCEEDING) break; message_alerting(epoint_id, message_id, param); - if (p_m_g_notify_pending) { + if (p_g_notify_pending) { /* send pending notify message during connect */ - message_notify(ACTIVE_EPOINT(p_epointlist), p_m_g_notify_pending->type, &p_m_g_notify_pending->param); - message_free(p_m_g_notify_pending); - p_m_g_notify_pending = NULL; + message_notify(ACTIVE_EPOINT(p_epointlist), p_g_notify_pending->type, &p_g_notify_pending->param); + message_free(p_g_notify_pending); + p_g_notify_pending = NULL; } break; case MESSAGE_CONNECT: /* call of endpoint is connected */ + ret = 1; if (p_state!=PORT_STATE_IN_PROCEEDING && p_state!=PORT_STATE_IN_ALERTING) break; message_connect(epoint_id, message_id, param); - if (p_m_g_notify_pending) { + if (p_g_notify_pending) { /* send pending notify message during connect */ - message_notify(ACTIVE_EPOINT(p_epointlist), p_m_g_notify_pending->type, &p_m_g_notify_pending->param); - message_free(p_m_g_notify_pending); - p_m_g_notify_pending = NULL; + message_notify(ACTIVE_EPOINT(p_epointlist), p_g_notify_pending->type, &p_g_notify_pending->param); + message_free(p_g_notify_pending); + p_g_notify_pending = NULL; } break; case MESSAGE_DISCONNECT: /* call has been disconnected */ + ret = 1; if (p_state!=PORT_STATE_IN_PROCEEDING && p_state!=PORT_STATE_IN_ALERTING && p_state!=PORT_STATE_OUT_SETUP @@ -1442,19 +1166,17 @@ int Pgsm::message_epoint(unsigned int epoint_id, int message_id, union parameter break; case MESSAGE_RELEASE: /* release isdn port */ + ret = 1; if (p_state==PORT_STATE_RELEASE) break; message_release(epoint_id, message_id, param); break; - default: - PDEBUG(DEBUG_GSM, "Pgsm(%s) gsm port with (caller id %s) received unhandled nessage: %d\n", p_name, p_callerinfo.id, message_id); } - return(1); + return ret; } - /* deletes only if l3id is release, otherwhise it will be triggered then */ static int delete_event(struct lcr_work *work, void *instance, int index) { @@ -1465,251 +1187,264 @@ static int delete_event(struct lcr_work *work, void *instance, int index) return 0; } -/* - * handler of bchannel events - */ -static int b_handler(struct lcr_fd *fd, unsigned int what, void *instance, int index) +int gsm_exit(int rc) { - class Pgsm *gsmport = (class Pgsm *)instance; - int ret; - unsigned char buffer[2048+MISDN_HEADER_LEN]; - struct mISDNhead *hh = (struct mISDNhead *)buffer; - - /* handle message from bchannel */ - if (gsmport->p_m_g_gsm_b_sock > -1) { - ret = recv(gsmport->p_m_g_gsm_b_sock, buffer, sizeof(buffer), 0); - if (ret >= (int)MISDN_HEADER_LEN) { - switch(hh->prim) { - /* we don't care about confirms, we use rx data to sync tx */ - case PH_DATA_CNF: - break; - /* we receive audio data, we respond to it AND we send tones */ - case PH_DATA_IND: - gsmport->bchannel_receive(hh, buffer+MISDN_HEADER_LEN, ret-MISDN_HEADER_LEN); - break; - case PH_ACTIVATE_IND: - gsmport->p_m_g_gsm_b_active = 1; - break; - case PH_DEACTIVATE_IND: - gsmport->p_m_g_gsm_b_active = 0; - break; - } - } else { - if (ret < 0 && errno != EWOULDBLOCK) - PERROR("Read from GSM port, index %d failed with return code %d\n", ret); - } - } - - return 0; + return(rc); } -static void gsm_sock_close(void) +int gsm_init(void) { - if (gsm->gsm_sock > -1) - close(gsm->gsm_sock); - gsm->gsm_sock = -1; + /* seed the PRNG */ + srand(time(NULL)); + + return 0; } -static int gsm_sock_open(char *portname) +/* + * MNCC interface + */ + +static int mncc_q_enqueue(struct lcr_gsm *lcr_gsm, struct gsm_mncc *mncc, unsigned int len) { - int ret; - int cnt; - unsigned long on = 1; - struct sockaddr_mISDN addr; - struct mISDN_devinfo devinfo; - int pri, bri; - - /* check port counts */ - ret = ioctl(mISDNsocket, IMGETCOUNT, &cnt); - if (ret < 0) { - fprintf(stderr, "Cannot get number of mISDN devices. (ioctl IMGETCOUNT failed ret=%d)\n", ret); - return(ret); - } + struct mncc_q_entry *qe; - if (cnt <= 0) { - PERROR_RUNTIME("Found no card. Please be sure to load card drivers.\n"); - return -EIO; - } - gsm->gsm_port = mISDN_getportbyname(mISDNsocket, cnt, portname); - if (gsm->gsm_port < 0) { - PERROR_RUNTIME("Port name '%s' not found, did you load loopback interface for GSM?.\n", portname); - return gsm->gsm_port; - } - /* get protocol */ - bri = pri = 0; - devinfo.id = gsm->gsm_port; - ret = ioctl(mISDNsocket, IMGETDEVINFO, &devinfo); - if (ret < 0) { - PERROR_RUNTIME("Cannot get device information for port %d. (ioctl IMGETDEVINFO failed ret=%d)\n", gsm->gsm_port, ret); - return ret; - } - if (devinfo.Dprotocols & (1 << ISDN_P_TE_S0)) { - bri = 1; - } - if (devinfo.Dprotocols & (1 << ISDN_P_TE_E1)) { - pri = 1; - } - if (!pri && !pri) { - PERROR_RUNTIME("GSM port %d does not support TE PRI or TE BRI.\n", gsm->gsm_port); - } - /* open socket */ - if ((gsm->gsm_sock = socket(PF_ISDN, SOCK_DGRAM, (pri)?ISDN_P_TE_E1:ISDN_P_TE_S0)) < 0) { - PERROR_RUNTIME("GSM port %d failed to open socket.\n", gsm->gsm_port); - gsm_sock_close(); - return gsm->gsm_sock; - } - /* set nonblocking io */ - if ((ret = ioctl(gsm->gsm_sock, FIONBIO, &on)) < 0) { - PERROR_RUNTIME("GSM port %d failed to set socket into nonblocking io.\n", gsm->gsm_port); - gsm_sock_close(); - return ret; - } - /* bind socket to dchannel */ - memset(&addr, 0, sizeof(addr)); - addr.family = AF_ISDN; - addr.dev = gsm->gsm_port; - addr.channel = 0; - if ((ret = bind(gsm->gsm_sock, (struct sockaddr *)&addr, sizeof(addr))) < 0) { - PERROR_RUNTIME("GSM port %d failed to bind socket. (name = %s errno=%d)\n", gsm->gsm_port, portname, errno); - gsm_sock_close(); - return (ret); + qe = (struct mncc_q_entry *) MALLOC(sizeof(*qe)+sizeof(*mncc)+len); + if (!qe) + return -ENOMEM; + + qe->next = NULL; + qe->len = len; + memcpy(qe->data, mncc, len); + + /* in case of empty list ... */ + if (!lcr_gsm->mncc_q_hd && !lcr_gsm->mncc_q_tail) { + /* the list head and tail both point to the new qe */ + lcr_gsm->mncc_q_hd = lcr_gsm->mncc_q_tail = qe; + } else { + /* append to tail of list */ + lcr_gsm->mncc_q_tail->next = qe; + lcr_gsm->mncc_q_tail = qe; } + lcr_gsm->mncc_lfd.when |= LCR_FD_WRITE; + return 0; } +static struct mncc_q_entry *mncc_q_dequeue(struct lcr_gsm *lcr_gsm) +{ + struct mncc_q_entry *qe = lcr_gsm->mncc_q_hd; + if (!qe) + return NULL; + + /* dequeue the successfully sent message */ + lcr_gsm->mncc_q_hd = qe->next; + if (!qe) + return NULL; + if (qe == lcr_gsm->mncc_q_tail) + lcr_gsm->mncc_q_tail = NULL; + + return qe; +} -int gsm_exit(int rc) +/* routine called by LCR code if it wants to send a message to OpenBSC */ +static int mncc_send(struct lcr_gsm *lcr_gsm, int msg_type, void *data) { - /* free gsm instance */ - if (gsm) { - if (gsm->gsm_sock > -1) - gsm_sock_close(); - /* shutdown network */ - if (gsm->network) - bsc_shutdown_net((struct gsm_network *)gsm->network); - /* free network */ -// if (gsm->network) { -// free((struct gsm_network *)gsm->network); /* TBD */ -// } - free(gsm); - gsm = NULL; - } + int len = 0; - return(rc); + /* FIXME: the caller should provide this */ + switch (msg_type) { + case GSM_TCHF_FRAME: + len = sizeof(struct gsm_data_frame) + 33; + break; + default: + len = sizeof(struct gsm_mncc); + break; + } + + return mncc_q_enqueue(lcr_gsm, (struct gsm_mncc *)data, len); } -int gsm_init(void) +/* close MNCC socket */ +static int mncc_fd_close(struct lcr_gsm *lcr_gsm, struct lcr_fd *lfd) { - char hlr[128], cfg[128], filename[128]; - mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH; - int pcapfd, rc; - char conf_error[128] = ""; - + class Port *port; + class Pgsm *pgsm = NULL; + struct lcr_msg *message; - log_init(&log_info); - tall_bsc_ctx = talloc_named_const(NULL, 1, "openbsc"); - talloc_ctx_init(); - on_dso_load_token(); - on_dso_load_rrlp(); - on_dso_load_ho_dec(); - stderr_target = log_target_create_stderr(); - log_add_target(stderr_target); + PERROR("Lost MNCC socket, retrying in %u seconds\n", SOCKET_RETRY_TIMER); + close(lfd->fd); + unregister_fd(lfd); + lfd->fd = -1; - bts_model_unknown_init(); - bts_model_bs11_init(); - bts_model_nanobts_init(); + /* free all the calls that were running through the MNCC interface */ + port = port_first; + while(port) { + if ((port->p_type & PORT_CLASS_mISDN_MASK) == PORT_CLASS_GSM) { + pgsm = (class Pgsm *)port; + if (pgsm->p_g_lcr_gsm == lcr_gsm) { + message = message_create(pgsm->p_serial, ACTIVE_EPOINT(pgsm->p_epointlist), PORT_TO_EPOINT, MESSAGE_RELEASE); + message->param.disconnectinfo.cause = 27; // temp. unavail. + message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL; + message_put(message); + pgsm->new_state(PORT_STATE_RELEASE); + trigger_work(&pgsm->p_g_delete); + } + } + port = port->next; + } - /* enable filters */ - log_set_all_filter(stderr_target, 1); + /* flush the queue */ + while (mncc_q_dequeue(lcr_gsm)) + ; - /* seed the PRNG */ - srand(time(NULL)); + /* start the re-connect timer */ + schedule_timer(&lcr_gsm->socket_retry, SOCKET_RETRY_TIMER, 0); - /* create gsm instance */ - gsm = (struct lcr_gsm *)MALLOC(sizeof(struct lcr_gsm)); - gsm->gsm_sock = -1; + return 0; +} - /* parse options */ - if (!gsm_conf(&gsm->conf, conf_error)) { - PERROR("%s", conf_error); - return gsm_exit(-EINVAL); +/* write to OpenBSC via MNCC socket */ +static int mncc_fd_write(struct lcr_fd *lfd, void *inst, int idx) +{ + struct lcr_gsm *lcr_gsm = (struct lcr_gsm *) inst; + struct mncc_q_entry *qe, *qe2; + int rc; + + while (1) { + qe = lcr_gsm->mncc_q_hd; + if (!qe) { + lfd->when &= ~LCR_FD_WRITE; + break; + } + rc = write(lfd->fd, qe->data, qe->len); + if (rc == 0) + return mncc_fd_close(lcr_gsm, lfd); + if (rc < 0) + return rc; + if (rc < (int)qe->len) + return -1; + /* dequeue the successfully sent message */ + qe2 = mncc_q_dequeue(lcr_gsm); + assert(qe == qe2); + free(qe); } + return 0; +} + +/* read from OpenBSC via MNCC socket */ +static int mncc_fd_read(struct lcr_fd *lfd, void *inst, int idx) +{ + struct lcr_gsm *lcr_gsm = (struct lcr_gsm *) inst; + int rc; + static char buf[sizeof(struct gsm_mncc)+1024]; + struct gsm_mncc *mncc_prim = (struct gsm_mncc *) buf; + struct gsm_mncc_hello *hello = (struct gsm_mncc_hello *) buf; + + memset(buf, 0, sizeof(buf)); + rc = recv(lfd->fd, buf, sizeof(buf), 0); + if (rc == 0) + return mncc_fd_close(lcr_gsm, lfd); + if (rc < 0) + return rc; + + /* TODO: size check? */ + switch (mncc_prim->msg_type) { + case MNCC_SOCKET_HELLO: + if (hello->version != MNCC_SOCK_VERSION) { + PERROR("MNCC version different. BSC version is %u\n", hello->version); + mncc_fd_close(lcr_gsm, lfd); + return 0; + } + if (hello->mncc_size != sizeof(struct gsm_mncc)) { + PERROR("MNCC gsm_mncc size differs: %u %u\n", + hello->mncc_size, sizeof(struct gsm_mncc)); + mncc_fd_close(lcr_gsm, lfd); + return 0; + } + if (hello->data_frame_size != sizeof(struct gsm_data_frame)) { + PERROR("MNCC gsm_mncc size differs: %u %u\n", + hello->data_frame_size, sizeof(struct gsm_data_frame)); + mncc_fd_close(lcr_gsm, lfd); + return 0; + } - /* set debug */ - if (gsm->conf.debug[0]) - log_parse_category_mask(stderr_target, gsm->conf.debug); - - /* open pcap file */ - if (gsm->conf.pcapfile[0]) { - if (gsm->conf.pcapfile[0] == '/') - SCPY(filename, gsm->conf.pcapfile); - else - SPRINT(filename, "%s/%s", CONFIG_DATA, gsm->conf.pcapfile); - pcapfd = open(filename, O_WRONLY|O_TRUNC|O_CREAT, mode); - if (pcapfd < 0) { - PERROR("Failed to open file for pcap\n"); - return gsm_exit(-1); +#define CHECK_OFFSET(hello, field, lcr_gsm, lfd) \ + if (hello->field ##_offset != __builtin_offsetof(struct gsm_mncc, field)) { \ + PERROR("MNCC gsm_mncc offset of %s is %u %u\n", \ + #field, hello->field ##_offset, \ + __builtin_offsetof(struct gsm_mncc, field)); \ + mncc_fd_close(lcr_gsm, lfd); \ + return 0; \ } - e1_set_pcap_fd(pcapfd); - } - /* use RTP proxy for audio streaming */ - ipacc_rtp_direct = 0; - - /* init database */ - if (gsm->conf.hlr[0] == '/') - SCPY(hlr, gsm->conf.hlr); - else - SPRINT(hlr, "%s/%s", CONFIG_DATA, gsm->conf.hlr); - if (db_init(hlr)) { - PERROR("GSM DB: Failed to init database '%s'. Please check the option settings.\n", hlr); - return gsm_exit(-1); - } - printf("DB: Database initialized.\n"); - if (db_prepare()) { - PERROR("GSM DB: Failed to prepare database.\n"); - return gsm_exit(-1); - } - printf("DB: Database prepared.\n"); - - /* setup the timer */ - db_sync_timer.cb = db_sync_timer_cb; - db_sync_timer.data = NULL; - bsc_schedule_timer(&db_sync_timer, DB_SYNC_INTERVAL); - - /* bootstrap network */ - if (gsm->conf.openbsc_cfg[0] == '/') - SCPY(cfg, gsm->conf.openbsc_cfg); - else - SPRINT(cfg, "%s/%s", CONFIG_DATA, gsm->conf.openbsc_cfg); - rc = bsc_bootstrap_network(&message_bsc, cfg); - if (rc < 0) { - PERROR("Failed to bootstrap GSM network.\n"); - return gsm_exit(-1); + CHECK_OFFSET(hello, called, lcr_gsm, lfd); + CHECK_OFFSET(hello, signal, lcr_gsm, lfd); + CHECK_OFFSET(hello, emergency, lcr_gsm, lfd); + CHECK_OFFSET(hello, lchan_type, lcr_gsm, lfd); +#undef CHECK_OFFSET + + break; } - gsm->network = bsc_gsmnet; - /* open gsm loop interface */ - if (gsm_sock_open(gsm->conf.interface_bsc)) { - return gsm_exit(-1); + /* Hand the MNCC message into LCR */ + switch (lcr_gsm->type) { +#ifdef WITH_GSM_BS + case LCR_GSM_TYPE_NETWORK: + return message_bsc(lcr_gsm, mncc_prim->msg_type, mncc_prim); +#endif +#ifdef WITH_GSM_MS + case LCR_GSM_TYPE_MS: + return message_ms(lcr_gsm, mncc_prim->msg_type, mncc_prim); +#endif + default: + return 0; } +} - return 0; +/* file descriptor callback if we can read or write form MNCC socket */ +static int mncc_fd_cb(struct lcr_fd *lfd, unsigned int what, void *inst, int idx) +{ + int rc = 0; + + if (what & LCR_FD_READ) + rc = mncc_fd_read(lfd, inst, idx); + if (rc < 0) + return rc; + + if (what & LCR_FD_WRITE) + rc = mncc_fd_write(lfd, inst, idx); + + return rc; } -/* - * handles bsc select function within LCR's main loop - */ -int handle_gsm(void) +int mncc_socket_retry_cb(struct lcr_timer *timer, void *inst, int index) { - int ret1, ret2; + struct lcr_gsm *lcr_gsm = (struct lcr_gsm *) inst; + int fd, rc; + + lcr_gsm->mncc_lfd.fd = -1; + + fd = socket(PF_UNIX, SOCK_SEQPACKET, 0); + if (fd < 0) { + PERROR("Cannot create SEQPACKET socket, giving up!\n"); + return fd; + } + + rc = connect(fd, (struct sockaddr *) &lcr_gsm->sun, + sizeof(lcr_gsm->sun)); + if (rc < 0) { + PERROR("Could not connect to MNCC socket %s, " + "retrying in %u seconds\n", lcr_gsm->sun.sun_path, + SOCKET_RETRY_TIMER); + close(fd); + schedule_timer(&lcr_gsm->socket_retry, SOCKET_RETRY_TIMER, 0); + } else { + PDEBUG(DEBUG_GSM, "Connected to MNCC socket %s!\n", lcr_gsm->sun.sun_path); + lcr_gsm->mncc_lfd.fd = fd; + register_fd(&lcr_gsm->mncc_lfd, LCR_FD_READ, &mncc_fd_cb, lcr_gsm, 0); + } - ret1 = bsc_upqueue((struct gsm_network *)gsm->network); - log_reset_context(); - ret2 = bsc_select_main(1); /* polling */ - if (ret1 || ret2) - return 1; return 0; }