mgcp: Merge OpenBSC MGCP code and update the structure to match it
* Upstream has a separation of BTS and NET side for RTP ports and
can allocate them dynamically.
* Upstream has gained the concept of trunks. We will now have various
trunks to connect audio things.
* We will now be able to utilize multiple trunks and have the endpoints
used properly.
diff --git a/include/mgcp/mgcp.h b/include/mgcp/mgcp.h
index 71e45f3..675db0c 100644
--- a/include/mgcp/mgcp.h
+++ b/include/mgcp/mgcp.h
@@ -1,13 +1,13 @@
/* A Media Gateway Control Protocol Media Gateway: RFC 3435 */
/*
- * (C) 2009-2010 by Holger Hans Peter Freyther <zecke@selfish.org>
- * (C) 2009-2010 by On-Waves
+ * (C) 2009-2011 by Holger Hans Peter Freyther <zecke@selfish.org>
+ * (C) 2009-2011 by On-Waves
* All Rights Reserved
*
- * This program is free software: you can redistribute it and/or modify
+ * This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
+ * the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
@@ -23,11 +23,15 @@
#ifndef OPENBSC_MGCP_H
#define OPENBSC_MGCP_H
+#include "cellmgr_debug.h"
+
#include <osmocore/msgb.h>
+#include <osmocore/write_queue.h>
#include <arpa/inet.h>
#define RTP_PORT_DEFAULT 4000
+#define RTP_PORT_NET_DEFAULT 16000
/**
* Calculate the RTP audio port for the given multiplex
@@ -59,6 +63,7 @@
*/
struct mgcp_endpoint;
struct mgcp_config;
+struct mgcp_trunk_config;
#define MGCP_ENDP_CRCX 1
#define MGCP_ENDP_DLCX 2
@@ -74,51 +79,113 @@
#define MGCP_POLICY_REJECT 5
#define MGCP_POLICY_DEFER 6
-typedef int (*mgcp_realloc)(struct mgcp_config *cfg, int endpoint);
-typedef int (*mgcp_change)(struct mgcp_config *cfg, int endpoint, int state, int local_rtp);
-typedef int (*mgcp_policy)(struct mgcp_config *cfg, int endpoint, int state, const char *transactio_id);
+typedef int (*mgcp_realloc)(struct mgcp_trunk_config *cfg, int endpoint);
+typedef int (*mgcp_change)(struct mgcp_trunk_config *cfg, int endpoint, int state);
+typedef int (*mgcp_policy)(struct mgcp_trunk_config *cfg, int endpoint, int state, const char *transactio_id);
typedef int (*mgcp_reset)(struct mgcp_config *cfg);
+#define PORT_ALLOC_STATIC 0
+#define PORT_ALLOC_DYNAMIC 1
+
+/**
+ * This holds information on how to allocate ports
+ */
+struct mgcp_port_range {
+ int mode;
+
+ /* pre-allocated from a base? */
+ int base_port;
+
+ /* dynamically allocated */
+ int range_start;
+ int range_end;
+ int last_port;
+};
+
+struct mgcp_trunk_config {
+ struct llist_head entry;
+
+ struct mgcp_config *cfg;
+
+ int trunk_nr;
+ int trunk_type;
+
+ char *audio_name;
+ int audio_payload;
+ int audio_loop;
+
+ /* spec handling */
+ int force_realloc;
+
+ unsigned int number_endpoints;
+ struct mgcp_endpoint *endpoints;
+
+ /* Special MGW handling */
+ int target_trunk_start;
+ int trunk_base;
+ int endp_offset;
+ int vad_enabled;
+
+ int digital_inp_gain;
+ int digital_out_gain;
+ int upstr_agc_enbl;
+ int upstr_adp_rate;
+ int upstr_max_gain;
+ int upstr_target_lvl;
+ int dwnstr_agc_enbl;
+ int dwnstr_adp_rate;
+ int dwnstr_max_gain;
+ int dwnstr_target_lvl;
+};
+
struct mgcp_config {
int source_port;
char *local_ip;
char *source_addr;
- unsigned int number_endpoints;
char *bts_ip;
char *call_agent_addr;
struct in_addr bts_in;
- char *audio_name;
- int audio_payload;
- int audio_loop;
- int early_bind;
- int rtp_base_port;
+
+ /* transcoder handling */
+ char *transcoder_ip;
+ struct in_addr transcoder_in;
+ int transcoder_remote_base;
+
+ struct write_queue gw_fd;
+
+ struct mgcp_port_range bts_ports;
+ struct mgcp_port_range net_ports;
+ struct mgcp_port_range transcoder_ports;
int endp_dscp;
- char *forward_ip;
- int forward_port;
-
- /* spec handling */
- int force_realloc;
-
mgcp_change change_cb;
mgcp_policy policy_cb;
mgcp_reset reset_cb;
mgcp_realloc realloc_cb;
void *data;
- struct mgcp_endpoint *endpoints;
uint32_t last_call_id;
+
+ /* trunk handling */
+ struct mgcp_trunk_config trunk;
+ struct llist_head trunks;
+
+ /* only used for start with a static configuration */
+ int last_net_port;
+ int last_bts_port;
+
+ /* MGW handling */
+ int configure_trunks;
};
/* config management */
struct mgcp_config *mgcp_config_alloc(void);
int mgcp_parse_config(const char *config_file, struct mgcp_config *cfg);
int mgcp_vty_init(void);
-void mgcp_vty_set_config(struct mgcp_config *cfg);
-int mgcp_endpoints_allocate(struct mgcp_config *cfg);
-int mgcp_bind_rtp_port(struct mgcp_endpoint *endp, int rtp_port);
+int mgcp_endpoints_allocate(struct mgcp_trunk_config *cfg);
void mgcp_free_endp(struct mgcp_endpoint *endp);
+int mgcp_reset_transcoder(struct mgcp_config *cfg);
/*
* format helper functions
@@ -129,9 +196,18 @@
/* adc helper */
static inline int mgcp_timeslot_to_endpoint(int multiplex, int timeslot)
{
- if (timeslot == 0)
- timeslot = 1;
- return timeslot + (31 * multiplex);
+ if (timeslot == 0) {
+ LOGP(DMGCP, LOGL_ERROR, "Timeslot should not be 0\n");
+ timeslot = 255;
+ }
+
+ return timeslot + (32 * multiplex);
+}
+
+static inline void mgcp_endpoint_to_timeslot(int endpoint, int *multiplex, int *timeslot)
+{
+ *multiplex = endpoint / 32;
+ *timeslot = endpoint % 32;
}
diff --git a/include/mgcp/mgcp_internal.h b/include/mgcp/mgcp_internal.h
index b156aea..3197543 100644
--- a/include/mgcp/mgcp_internal.h
+++ b/include/mgcp/mgcp_internal.h
@@ -1,13 +1,13 @@
/* MGCP Private Data */
/*
- * (C) 2009-2010 by Holger Hans Peter Freyther <zecke@selfish.org>
- * (C) 2009-2010 by On-Waves
+ * (C) 2009-2011 by Holger Hans Peter Freyther <zecke@selfish.org>
+ * (C) 2009-2011 by On-Waves
* All Rights Reserved
*
- * This program is free software: you can redistribute it and/or modify
+ * This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
+ * the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
@@ -35,6 +35,11 @@
MGCP_CONN_LOOPBACK = 4,
};
+enum mgcp_trunk_type {
+ MGCP_TRUNK_VIRTUAL,
+ MGCP_TRUNK_E1,
+};
+
struct mgcp_rtp_state {
int initialized;
int patch;
@@ -48,47 +53,82 @@
int32_t timestamp_offset;
};
+struct mgcp_rtp_end {
+ /* statistics */
+ unsigned int packets;
+ struct in_addr addr;
+
+ /* in network byte order */
+ int rtp_port, rtcp_port;
+
+ int payload_type;
+
+ /*
+ * Each end has a socket...
+ */
+ struct bsc_fd rtp;
+ struct bsc_fd rtcp;
+
+ int local_port;
+ int local_alloc;
+};
+
+enum {
+ MGCP_TAP_BTS_IN,
+ MGCP_TAP_BTS_OUT,
+ MGCP_TAP_NET_IN,
+ MGCP_TAP_NET_OUT,
+
+ /* last element */
+ MGCP_TAP_COUNT
+};
+
+struct mgcp_rtp_tap {
+ int enabled;
+ struct sockaddr_in forward;
+};
+
struct mgcp_endpoint {
+ int allocated;
uint32_t ci;
char *callid;
char *local_options;
int conn_mode;
int orig_mode;
- int bts_payload_type;
- int net_payload_type;
-
- /* the local rtp port we are binding to */
- int rtp_port;
-
- /*
- * RTP mangling:
- * - we get RTP and RTCP to us and need to forward to the BTS
- * - we get RTP and RTCP from the BTS and forward to the network
- */
- struct bsc_fd local_rtp;
- struct bsc_fd local_rtcp;
-
- struct in_addr remote;
- struct in_addr bts;
-
- /* in network byte order */
- int net_rtp, net_rtcp;
- int bts_rtp, bts_rtcp;
-
/* backpointer */
struct mgcp_config *cfg;
+ struct mgcp_trunk_config *tcfg;
- /* statistics */
- unsigned int in_bts;
- unsigned int in_remote;
+ /* port status for bts/net */
+ struct mgcp_rtp_end bts_end;
+ struct mgcp_rtp_end net_end;
+
+ /*
+ * For transcoding we will send from the local_port
+ * of trans_bts and it will arrive at trans_net from
+ * where we will forward it to the network.
+ */
+ struct mgcp_rtp_end trans_bts;
+ struct mgcp_rtp_end trans_net;
+ int is_transcoded;
/* sequence bits */
struct mgcp_rtp_state net_state;
struct mgcp_rtp_state bts_state;
+
+ /* SSRC/seq/ts patching for loop */
+ int allow_patch;
+
+ /* tap for the endpoint */
+ struct mgcp_rtp_tap taps[MGCP_TAP_COUNT];
+
+ /* Special MGW handling */
+ unsigned int audio_port;
+ int block_processing;
};
-#define ENDPOINT_NUMBER(endp) abs(endp - endp->cfg->endpoints)
+#define ENDPOINT_NUMBER(endp) abs(endp - endp->tcfg->endpoints)
struct mgcp_msg_ptr {
unsigned int start;
@@ -99,5 +139,20 @@
struct mgcp_msg_ptr *ptr, int size,
const char **transaction_id, struct mgcp_endpoint **endp);
int mgcp_send_dummy(struct mgcp_endpoint *endp);
+int mgcp_bind_bts_rtp_port(struct mgcp_endpoint *endp, int rtp_port);
+int mgcp_bind_net_rtp_port(struct mgcp_endpoint *endp, int rtp_port);
+int mgcp_bind_trans_bts_rtp_port(struct mgcp_endpoint *enp, int rtp_port);
+int mgcp_bind_trans_net_rtp_port(struct mgcp_endpoint *enp, int rtp_port);
+int mgcp_free_rtp_port(struct mgcp_rtp_end *end);
+
+/* For transcoding we need to manage an in and an output that are connected */
+static inline int endp_back_channel(int endpoint)
+{
+ return endpoint + 60;
+}
+
+struct mgcp_trunk_config *mgcp_trunk_alloc(struct mgcp_config *cfg, int index);
+struct mgcp_trunk_config *mgcp_trunk_num(struct mgcp_config *cfg, int index);
+
#endif
diff --git a/include/mgcp_ss7.h b/include/mgcp_ss7.h
index ff0973b..45828e8 100644
--- a/include/mgcp_ss7.h
+++ b/include/mgcp_ss7.h
@@ -1,7 +1,7 @@
/* mgcp_ss7 helper coder */
/*
- * (C) 2010 by Holger Hans Peter Freyther <zecke@selfish.org>
- * (C) 2010 by On-Waves
+ * (C) 2010-2011 by Holger Hans Peter Freyther <zecke@selfish.org>
+ * (C) 2010-2011 by On-Waves
* All Rights Reserved
*
* This program is free software: you can redistribute it and/or modify
@@ -29,19 +29,11 @@
#include "thread.h"
-enum cellmgr_node {
- MGCP_NODE = _LAST_OSMOVTY_NODE + 1,
-};
-
-
-struct mgcp_ss7_endpoint;
struct mgcp_ss7 {
struct mgcp_config *cfg;
struct write_queue mgcp_fd;
struct msgb *mgcp_msg;
- struct mgcp_ss7_endpoint *mgw_end;
-
/* timer */
struct timer_list poll_timer;
@@ -54,19 +46,17 @@
MGCP_SS7_MUTE_STATUS,
MGCP_SS7_ALLOCATE,
MGCP_SS7_DELETE,
- MGCP_SS7_SHUTDOWN,
};
struct mgcp_ss7_cmd {
struct llist_head entry;
uint8_t type;
- uint32_t port;
+ struct mgcp_endpoint *endp;
uint32_t param;
};
-void mgcp_ss7_exec(struct mgcp_ss7 *mgcp, uint8_t type, uint32_t port, uint32_t param);
-
void mgcp_ss7_reset(struct mgcp_ss7 *mgcp);
-void mgcp_ss7_free(struct mgcp_ss7 *mgcp);
+
+void mgcp_mgw_vty_init();
#endif
diff --git a/include/ss7_vty.h b/include/ss7_vty.h
index 48dbb48..a0368bd 100644
--- a/include/ss7_vty.h
+++ b/include/ss7_vty.h
@@ -27,6 +27,7 @@
enum ss7_vty_node {
MGCP_NODE = _LAST_OSMOVTY_NODE + 1,
+ TRUNK_NODE,
CELLMGR_NODE,
SS7_NODE,
LINKSETS_NODE,
diff --git a/src/Makefile.am b/src/Makefile.am
index 4930e97..9670904 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -4,7 +4,7 @@
sbin_PROGRAMS = cellmgr_ng osmo_stp mgcp_mgw
-mgcp_mgw_SOURCES = mgcp_ss7.c thread.c debug.c \
+mgcp_mgw_SOURCES = mgcp_ss7.c mgcp_ss7_vty.c thread.c debug.c \
mgcp/mgcp_protocol.c mgcp/mgcp_network.c mgcp/mgcp_vty.c
mgcp_mgw_LDADD = $(LAFORGE_LIBS) $(NEXUSWARE_C7_LIBS) $(NEXUSWARE_UNIPORTE_LIBS) \
$(LIBOSMOVTY_LIBS) $(LIBOSMOCORE_LIBS) -lpthread
diff --git a/src/mgcp/mgcp_network.c b/src/mgcp/mgcp_network.c
index 18e450b..5bac1af 100644
--- a/src/mgcp/mgcp_network.c
+++ b/src/mgcp/mgcp_network.c
@@ -2,13 +2,13 @@
/* The protocol implementation */
/*
- * (C) 2009-2010 by Holger Hans Peter Freyther <zecke@selfish.org>
- * (C) 2009-2010 by On-Waves
+ * (C) 2009-2011 by Holger Hans Peter Freyther <zecke@selfish.org>
+ * (C) 2009-2011 by On-Waves
* All Rights Reserved
*
- * This program is free software: you can redistribute it and/or modify
+ * This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
+ * the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
@@ -24,23 +24,28 @@
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
-#include <endian.h>
#include <errno.h>
#include <sys/socket.h>
#include <arpa/inet.h>
+#include <osmocore/msgb.h>
+#include <osmocore/select.h>
+
#include <mgcp/mgcp.h>
#include <mgcp/mgcp_internal.h>
-#include <cellmgr_debug.h>
-
-#include <osmocore/msgb.h>
-#include <osmocore/talloc.h>
-#include <osmocore/select.h>
-
#warning "Make use of the rtp proxy code"
+/* attempt to determine byte order */
+#include <sys/types.h>
+#include <sys/param.h>
+#include <limits.h>
+
+#ifndef __BYTE_ORDER
+#error "__BYTE_ORDER should be defined by someone"
+#endif
+
/* according to rtp_proxy.c RFC 3550 */
struct rtp_hdr {
#if __BYTE_ORDER == __LITTLE_ENDIAN
@@ -91,11 +96,12 @@
{
static char buf[] = { DUMMY_LOAD };
- return udp_send(endp->local_rtp.fd, &endp->remote,
- endp->net_rtp, buf, 1);
+ return udp_send(endp->net_end.rtp.fd, &endp->net_end.addr,
+ endp->net_end.rtp_port, buf, 1);
}
-static void patch_and_count(struct mgcp_rtp_state *state, int payload, char *data, int len)
+static void patch_and_count(struct mgcp_endpoint *endp, struct mgcp_rtp_state *state,
+ int payload, struct sockaddr_in *addr, char *data, int len)
{
uint16_t seq;
uint32_t timestamp;
@@ -117,9 +123,11 @@
state->ssrc = rtp_hdr->ssrc;
state->seq_offset = (state->seq_no + 1) - seq;
state->timestamp_offset = state->last_timestamp - timestamp;
- state->patch = 1;
- LOGP(DMGCP, LOGL_NOTICE, "The SSRC changed... SSRC: %u offset: %d\n",
- state->ssrc, state->seq_offset);
+ state->patch = endp->allow_patch;
+ LOGP(DMGCP, LOGL_NOTICE,
+ "The SSRC changed on 0x%x SSRC: %u offset: %d from %s:%d in %d\n",
+ ENDPOINT_NUMBER(endp), state->ssrc, state->seq_offset,
+ inet_ntoa(addr->sin_addr), ntohs(addr->sin_port), endp->conn_mode);
}
/* apply the offset and store it back to the packet */
@@ -146,87 +154,50 @@
}
/*
- * There is data coming. We will have to figure out if it
- * came from the BTS or the MediaGateway of the MSC. On top
- * of that we need to figure out if it was RTP or RTCP.
- *
- * Currently we do not communicate with the BSC so we have
- * no idea where the BTS is listening for RTP and need to
- * do the classic routing trick. Wait for the first packet
- * from the BTS and then go ahead.
+ * The below code is for dispatching. We have a dedicated port for
+ * the data coming from the net and one to discover the BTS.
*/
-static int rtp_data_cb(struct bsc_fd *fd, unsigned int what)
+static int forward_data(int fd, struct mgcp_rtp_tap *tap, const char *buf, int len)
{
- char buf[4096];
- struct sockaddr_in addr;
- socklen_t slen = sizeof(addr);
- struct mgcp_endpoint *endp;
- struct mgcp_config *cfg;
- int rc, dest, proto;
-
- endp = (struct mgcp_endpoint *) fd->data;
- cfg = endp->cfg;
-
- rc = recvfrom(fd->fd, &buf, sizeof(buf), 0,
- (struct sockaddr *) &addr, &slen);
- if (rc < 0) {
- LOGP(DMGCP, LOGL_ERROR, "Failed to receive message on: 0x%x errno: %d/%s\n",
- ENDPOINT_NUMBER(endp), errno, strerror(errno));
- return -1;
- }
-
- /* do not forward aynthing... maybe there is a packet from the bts */
- if (endp->ci == CI_UNUSED)
- return -1;
-
- /*
- * Figure out where to forward it to. This code assumes that we
- * have received the Connection Modify and know who is a legitimate
- * partner. According to the spec we could attempt to forward even
- * after the Create Connection but we will not as we are not really
- * able to tell if this is legitimate.
- */
- #warning "Slight spec violation. With connection mode recvonly we should attempt to forward."
- dest = memcmp(&addr.sin_addr, &endp->remote, sizeof(addr.sin_addr)) == 0 &&
- (endp->net_rtp == addr.sin_port || endp->net_rtcp == addr.sin_port)
- ? DEST_BTS : DEST_NETWORK;
- proto = fd == &endp->local_rtp ? PROTO_RTP : PROTO_RTCP;
-
- /* We have no idea who called us, maybe it is the BTS. */
- if (dest == DEST_NETWORK && (endp->bts_rtp == 0 || cfg->forward_ip)) {
- /* it was the BTS... */
- if (!cfg->bts_ip
- || memcmp(&addr.sin_addr, &cfg->bts_in, sizeof(cfg->bts_in)) == 0
- || memcmp(&addr.sin_addr, &endp->bts, sizeof(endp->bts)) == 0) {
- if (fd == &endp->local_rtp) {
- endp->bts_rtp = addr.sin_port;
- } else {
- endp->bts_rtcp = addr.sin_port;
- }
-
- endp->bts = addr.sin_addr;
- LOGP(DMGCP, LOGL_NOTICE, "Found BTS for endpoint: 0x%x on port: %d/%d of %s\n",
- ENDPOINT_NUMBER(endp), ntohs(endp->bts_rtp), ntohs(endp->bts_rtcp),
- inet_ntoa(addr.sin_addr));
-
- }
- }
-
- /* throw away the dummy message */
- if (rc == 1 && buf[0] == DUMMY_LOAD) {
- LOGP(DMGCP, LOGL_NOTICE, "Filtered dummy on 0x%x\n",
- ENDPOINT_NUMBER(endp));
+ if (!tap->enabled)
return 0;
- }
- /* do this before the loop handling */
- if (dest == DEST_NETWORK)
- ++endp->in_bts;
- else
- ++endp->in_remote;
+ return sendto(fd, buf, len, 0,
+ (struct sockaddr *)&tap->forward, sizeof(tap->forward));
+}
+static int send_transcoder(struct mgcp_rtp_end *end, struct mgcp_config *cfg,
+ int is_rtp, const char *buf, int len)
+{
+ int rc;
+ int port;
+ struct sockaddr_in addr;
+
+ port = is_rtp ? end->rtp_port : end->rtcp_port;
+
+ addr.sin_family = AF_INET;
+ addr.sin_addr = cfg->transcoder_in;
+ addr.sin_port = port;
+
+ rc = sendto(is_rtp ?
+ end->rtp.fd :
+ end->rtcp.fd, buf, len, 0,
+ (struct sockaddr *) &addr, sizeof(addr));
+
+ if (rc != len)
+ LOGP(DMGCP, LOGL_ERROR,
+ "Failed to send data to the transcoder: %s\n",
+ strerror(errno));
+
+ return rc;
+}
+
+static int send_to(struct mgcp_endpoint *endp, int dest, int is_rtp,
+ struct sockaddr_in *addr, char *buf, int rc)
+{
+ struct mgcp_trunk_config *tcfg = endp->tcfg;
/* For loop toggle the destination and then dispatch. */
- if (cfg->audio_loop)
+ if (tcfg->audio_loop)
dest = !dest;
/* Loop based on the conn_mode, maybe undoing the above */
@@ -234,22 +205,239 @@
dest = !dest;
if (dest == DEST_NETWORK) {
- if (proto == PROTO_RTP)
- patch_and_count(&endp->bts_state,
- endp->net_payload_type, buf, rc);
- return udp_send(fd->fd, &endp->remote,
- proto == PROTO_RTP ? endp->net_rtp : endp->net_rtcp,
- buf, rc);
+ if (is_rtp) {
+ patch_and_count(endp, &endp->bts_state,
+ endp->net_end.payload_type,
+ addr, buf, rc);
+ forward_data(endp->net_end.rtp.fd,
+ &endp->taps[MGCP_TAP_NET_OUT], buf, rc);
+ return udp_send(endp->net_end.rtp.fd, &endp->net_end.addr,
+ endp->net_end.rtp_port, buf, rc);
+ } else {
+ return udp_send(endp->net_end.rtcp.fd, &endp->net_end.addr,
+ endp->net_end.rtcp_port, buf, rc);
+ }
} else {
- if (proto == PROTO_RTP)
- patch_and_count(&endp->net_state,
- endp->bts_payload_type, buf, rc);
- return udp_send(fd->fd, &endp->bts,
- proto == PROTO_RTP ? endp->bts_rtp : endp->bts_rtcp,
- buf, rc);
+ if (is_rtp) {
+ patch_and_count(endp, &endp->net_state,
+ endp->bts_end.payload_type,
+ addr, buf, rc);
+ forward_data(endp->bts_end.rtp.fd,
+ &endp->taps[MGCP_TAP_BTS_OUT], buf, rc);
+ return udp_send(endp->bts_end.rtp.fd, &endp->bts_end.addr,
+ endp->bts_end.rtp_port, buf, rc);
+ } else {
+ return udp_send(endp->bts_end.rtcp.fd, &endp->bts_end.addr,
+ endp->bts_end.rtcp_port, buf, rc);
+ }
}
}
+static int recevice_from(struct mgcp_endpoint *endp, int fd, struct sockaddr_in *addr,
+ char *buf, int bufsize)
+{
+ int rc;
+ socklen_t slen = sizeof(*addr);
+
+ rc = recvfrom(fd, buf, bufsize, 0,
+ (struct sockaddr *) addr, &slen);
+ if (rc < 0) {
+ LOGP(DMGCP, LOGL_ERROR, "Failed to receive message on: 0x%x errno: %d/%s\n",
+ ENDPOINT_NUMBER(endp), errno, strerror(errno));
+ return -1;
+ }
+
+ /* do not forward aynthing... maybe there is a packet from the bts */
+ if (!endp->allocated)
+ return -1;
+
+ #warning "Slight spec violation. With connection mode recvonly we should attempt to forward."
+
+ return rc;
+}
+
+static int rtp_data_net(struct bsc_fd *fd, unsigned int what)
+{
+ char buf[4096];
+ struct sockaddr_in addr;
+ struct mgcp_endpoint *endp;
+ int rc, proto;
+
+ endp = (struct mgcp_endpoint *) fd->data;
+
+ rc = recevice_from(endp, fd->fd, &addr, buf, sizeof(buf));
+ if (rc <= 0)
+ return -1;
+
+ if (memcmp(&addr.sin_addr, &endp->net_end.addr, sizeof(addr.sin_addr)) != 0) {
+ LOGP(DMGCP, LOGL_ERROR,
+ "Data from wrong address %s on 0x%x\n",
+ inet_ntoa(addr.sin_addr), ENDPOINT_NUMBER(endp));
+ return -1;
+ }
+
+ if (endp->net_end.rtp_port != addr.sin_port &&
+ endp->net_end.rtcp_port != addr.sin_port) {
+ LOGP(DMGCP, LOGL_ERROR,
+ "Data from wrong source port %d on 0x%x\n",
+ ntohs(addr.sin_port), ENDPOINT_NUMBER(endp));
+ return -1;
+ }
+
+ /* throw away the dummy message */
+ if (rc == 1 && buf[0] == DUMMY_LOAD) {
+ LOGP(DMGCP, LOGL_NOTICE, "Filtered dummy from network on 0x%x\n",
+ ENDPOINT_NUMBER(endp));
+ return 0;
+ }
+
+ proto = fd == &endp->net_end.rtp ? PROTO_RTP : PROTO_RTCP;
+ endp->net_end.packets += 1;
+
+ forward_data(fd->fd, &endp->taps[MGCP_TAP_NET_IN], buf, rc);
+ if (endp->is_transcoded)
+ return send_transcoder(&endp->trans_net, endp->cfg, proto == PROTO_RTP, &buf[0], rc);
+ else
+ return send_to(endp, DEST_BTS, proto == PROTO_RTP, &addr, &buf[0], rc);
+}
+
+static void discover_bts(struct mgcp_endpoint *endp, int proto, struct sockaddr_in *addr)
+{
+ struct mgcp_config *cfg = endp->cfg;
+
+ if (proto == PROTO_RTP && endp->bts_end.rtp_port == 0) {
+ if (!cfg->bts_ip ||
+ memcmp(&addr->sin_addr,
+ &cfg->bts_in, sizeof(cfg->bts_in)) == 0 ||
+ memcmp(&addr->sin_addr,
+ &endp->bts_end.addr, sizeof(endp->bts_end.addr)) == 0) {
+
+ endp->bts_end.rtp_port = addr->sin_port;
+ endp->bts_end.addr = addr->sin_addr;
+
+ LOGP(DMGCP, LOGL_NOTICE,
+ "Found BTS for endpoint: 0x%x on port: %d/%d of %s\n",
+ ENDPOINT_NUMBER(endp), ntohs(endp->bts_end.rtp_port),
+ ntohs(endp->bts_end.rtcp_port), inet_ntoa(addr->sin_addr));
+ }
+ } else if (proto == PROTO_RTCP && endp->bts_end.rtcp_port == 0) {
+ if (memcmp(&endp->bts_end.addr, &addr->sin_addr,
+ sizeof(endp->bts_end.addr)) == 0) {
+ endp->bts_end.rtcp_port = addr->sin_port;
+ }
+ }
+}
+
+static int rtp_data_bts(struct bsc_fd *fd, unsigned int what)
+{
+ char buf[4096];
+ struct sockaddr_in addr;
+ struct mgcp_endpoint *endp;
+ struct mgcp_config *cfg;
+ int rc, proto;
+
+ endp = (struct mgcp_endpoint *) fd->data;
+ cfg = endp->cfg;
+
+ rc = recevice_from(endp, fd->fd, &addr, buf, sizeof(buf));
+ if (rc <= 0)
+ return -1;
+
+ proto = fd == &endp->bts_end.rtp ? PROTO_RTP : PROTO_RTCP;
+
+ /* We have no idea who called us, maybe it is the BTS. */
+ /* it was the BTS... */
+ discover_bts(endp, proto, &addr);
+
+ if (memcmp(&endp->bts_end.addr, &addr.sin_addr, sizeof(addr.sin_addr)) != 0) {
+ LOGP(DMGCP, LOGL_ERROR,
+ "Data from wrong bts %s on 0x%x\n",
+ inet_ntoa(addr.sin_addr), ENDPOINT_NUMBER(endp));
+ return -1;
+ }
+
+ if (endp->bts_end.rtp_port != addr.sin_port &&
+ endp->bts_end.rtcp_port != addr.sin_port) {
+ LOGP(DMGCP, LOGL_ERROR,
+ "Data from wrong bts source port %d on 0x%x\n",
+ ntohs(addr.sin_port), ENDPOINT_NUMBER(endp));
+ return -1;
+ }
+
+ /* throw away the dummy message */
+ if (rc == 1 && buf[0] == DUMMY_LOAD) {
+ LOGP(DMGCP, LOGL_NOTICE, "Filtered dummy from bts on 0x%x\n",
+ ENDPOINT_NUMBER(endp));
+ return 0;
+ }
+
+ /* do this before the loop handling */
+ endp->bts_end.packets += 1;
+
+ forward_data(fd->fd, &endp->taps[MGCP_TAP_BTS_IN], buf, rc);
+ if (endp->is_transcoded)
+ return send_transcoder(&endp->trans_bts, endp->cfg, proto == PROTO_RTP, &buf[0], rc);
+ else
+ return send_to(endp, DEST_NETWORK, proto == PROTO_RTP, &addr, &buf[0], rc);
+}
+
+static int rtp_data_transcoder(struct mgcp_rtp_end *end, struct mgcp_endpoint *_endp,
+ int dest, struct bsc_fd *fd)
+{
+ char buf[4096];
+ struct sockaddr_in addr;
+ struct mgcp_config *cfg;
+ int rc, proto;
+
+ cfg = _endp->cfg;
+ rc = recevice_from(_endp, fd->fd, &addr, buf, sizeof(buf));
+ if (rc <= 0)
+ return -1;
+
+ proto = fd == &end->rtp ? PROTO_RTP : PROTO_RTCP;
+
+ if (memcmp(&addr.sin_addr, &cfg->transcoder_in, sizeof(addr.sin_addr)) != 0) {
+ LOGP(DMGCP, LOGL_ERROR,
+ "Data not coming from transcoder dest: %d %s on 0x%x\n",
+ dest, inet_ntoa(addr.sin_addr), ENDPOINT_NUMBER(_endp));
+ return -1;
+ }
+
+ if (end->rtp_port != addr.sin_port &&
+ end->rtcp_port != addr.sin_port) {
+ LOGP(DMGCP, LOGL_ERROR,
+ "Data from wrong transcoder dest %d source port %d on 0x%x\n",
+ dest, ntohs(addr.sin_port), ENDPOINT_NUMBER(_endp));
+ return -1;
+ }
+
+ /* throw away the dummy message */
+ if (rc == 1 && buf[0] == DUMMY_LOAD) {
+ LOGP(DMGCP, LOGL_NOTICE, "Filtered dummy from transcoder dest %d on 0x%x\n",
+ dest, ENDPOINT_NUMBER(_endp));
+ return 0;
+ }
+
+ end->packets += 1;
+ return send_to(_endp, dest, proto == PROTO_RTP, &addr, &buf[0], rc);
+}
+
+static int rtp_data_trans_net(struct bsc_fd *fd, unsigned int what)
+{
+ struct mgcp_endpoint *endp;
+ endp = (struct mgcp_endpoint *) fd->data;
+
+ return rtp_data_transcoder(&endp->trans_net, endp, DEST_NETWORK, fd);
+}
+
+static int rtp_data_trans_bts(struct bsc_fd *fd, unsigned int what)
+{
+ struct mgcp_endpoint *endp;
+ endp = (struct mgcp_endpoint *) fd->data;
+
+ return rtp_data_transcoder(&endp->trans_bts, endp, DEST_BTS, fd);
+}
+
static int create_bind(const char *source_addr, struct bsc_fd *fd, int port)
{
struct sockaddr_in addr;
@@ -268,6 +456,8 @@
inet_aton(source_addr, &addr.sin_addr);
if (bind(fd->fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
+ close(fd->fd);
+ fd->fd = -1;
return -1;
}
@@ -282,59 +472,107 @@
return ret != 0;
}
-static int bind_rtp(struct mgcp_endpoint *endp)
+static int bind_rtp(struct mgcp_config *cfg, struct mgcp_rtp_end *rtp_end, int endpno)
{
- struct mgcp_config *cfg = endp->cfg;
-
- if (create_bind(cfg->source_addr, &endp->local_rtp, endp->rtp_port) != 0) {
+ if (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, endp->rtp_port, ENDPOINT_NUMBER(endp));
+ cfg->source_addr, rtp_end->local_port, endpno);
goto cleanup0;
}
- if (create_bind(cfg->source_addr, &endp->local_rtcp, endp->rtp_port + 1) != 0) {
+ if (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, endp->rtp_port + 1, ENDPOINT_NUMBER(endp));
+ cfg->source_addr, rtp_end->local_port + 1, endpno);
goto cleanup1;
}
- set_ip_tos(endp->local_rtp.fd, cfg->endp_dscp);
- set_ip_tos(endp->local_rtcp.fd, cfg->endp_dscp);
+ set_ip_tos(rtp_end->rtp.fd, cfg->endp_dscp);
+ set_ip_tos(rtp_end->rtcp.fd, cfg->endp_dscp);
- endp->local_rtp.cb = rtp_data_cb;
- endp->local_rtp.data = endp;
- endp->local_rtp.when = BSC_FD_READ;
- if (bsc_register_fd(&endp->local_rtp) != 0) {
+ rtp_end->rtp.when = BSC_FD_READ;
+ if (bsc_register_fd(&rtp_end->rtp) != 0) {
LOGP(DMGCP, LOGL_ERROR, "Failed to register RTP port %d on 0x%x\n",
- endp->rtp_port, ENDPOINT_NUMBER(endp));
+ rtp_end->local_port, endpno);
goto cleanup2;
}
- endp->local_rtcp.cb = rtp_data_cb;
- endp->local_rtcp.data = endp;
- endp->local_rtcp.when = BSC_FD_READ;
- if (bsc_register_fd(&endp->local_rtcp) != 0) {
+ rtp_end->rtcp.when = BSC_FD_READ;
+ if (bsc_register_fd(&rtp_end->rtcp) != 0) {
LOGP(DMGCP, LOGL_ERROR, "Failed to register RTCP port %d on 0x%x\n",
- endp->rtp_port + 1, ENDPOINT_NUMBER(endp));
+ rtp_end->local_port + 1, endpno);
goto cleanup3;
}
return 0;
cleanup3:
- bsc_unregister_fd(&endp->local_rtp);
+ bsc_unregister_fd(&rtp_end->rtp);
cleanup2:
- close(endp->local_rtcp.fd);
- endp->local_rtcp.fd = -1;
+ close(rtp_end->rtcp.fd);
+ rtp_end->rtcp.fd = -1;
cleanup1:
- close(endp->local_rtp.fd);
- endp->local_rtp.fd = -1;
+ close(rtp_end->rtp.fd);
+ rtp_end->rtp.fd = -1;
cleanup0:
return -1;
}
-int mgcp_bind_rtp_port(struct mgcp_endpoint *endp, int rtp_port)
+static int int_bind(const char *port,
+ struct mgcp_rtp_end *end, int (*cb)(struct bsc_fd *, unsigned),
+ struct mgcp_endpoint *_endp, int rtp_port)
{
- endp->rtp_port = rtp_port;
- return bind_rtp(endp);
+ if (end->rtp.fd != -1 || end->rtcp.fd != -1) {
+ LOGP(DMGCP, LOGL_ERROR, "Previous %s was still bound on %d\n",
+ port, ENDPOINT_NUMBER(_endp));
+ mgcp_free_rtp_port(end);
+ }
+
+ end->local_port = rtp_port;
+ end->rtp.cb = cb;
+ end->rtp.data = _endp;
+ end->rtcp.data = _endp;
+ end->rtcp.cb = cb;
+ return bind_rtp(_endp->cfg, end, ENDPOINT_NUMBER(_endp));
+}
+
+
+int mgcp_bind_bts_rtp_port(struct mgcp_endpoint *endp, int rtp_port)
+{
+ return int_bind("bts-port", &endp->bts_end,
+ rtp_data_bts, endp, rtp_port);
+}
+
+int mgcp_bind_net_rtp_port(struct mgcp_endpoint *endp, int rtp_port)
+{
+ return int_bind("net-port", &endp->net_end,
+ rtp_data_net, endp, rtp_port);
+}
+
+int mgcp_bind_trans_net_rtp_port(struct mgcp_endpoint *endp, int rtp_port)
+{
+ return int_bind("trans-net", &endp->trans_net,
+ rtp_data_trans_net, endp, rtp_port);
+}
+
+int mgcp_bind_trans_bts_rtp_port(struct mgcp_endpoint *endp, int rtp_port)
+{
+ return int_bind("trans-bts", &endp->trans_bts,
+ rtp_data_trans_bts, endp, rtp_port);
+}
+
+int mgcp_free_rtp_port(struct mgcp_rtp_end *end)
+{
+ if (end->rtp.fd != -1) {
+ close(end->rtp.fd);
+ end->rtp.fd = -1;
+ bsc_unregister_fd(&end->rtp);
+ }
+
+ if (end->rtcp.fd != -1) {
+ close(end->rtcp.fd);
+ end->rtcp.fd = -1;
+ bsc_unregister_fd(&end->rtcp);
+ }
+
+ return 0;
}
diff --git a/src/mgcp/mgcp_protocol.c b/src/mgcp/mgcp_protocol.c
index 62a3a66..9233042 100644
--- a/src/mgcp/mgcp_protocol.c
+++ b/src/mgcp/mgcp_protocol.c
@@ -6,9 +6,9 @@
* (C) 2009-2011 by On-Waves
* All Rights Reserved
*
- * This program is free software: you can redistribute it and/or modify
+ * This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
+ * the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
@@ -29,16 +29,12 @@
#include <limits.h>
#include <unistd.h>
-#include <cellmgr_debug.h>
-
-#include <mgcp/mgcp.h>
-#include <mgcp/mgcp_internal.h>
-
#include <osmocore/msgb.h>
#include <osmocore/talloc.h>
#include <osmocore/select.h>
-#include <osmocore/utils.h>
+#include <mgcp/mgcp.h>
+#include <mgcp/mgcp_internal.h>
/**
* Macro for tokenizing MGCP messages and SDP in one go.
@@ -74,6 +70,7 @@
} \
}
+static void mgcp_rtp_end_reset(struct mgcp_rtp_end *end);
struct mgcp_request {
char *name;
@@ -91,6 +88,9 @@
static struct msgb *handle_rsip(struct mgcp_config *cfg, struct msgb *msg);
static struct msgb *handle_noti_req(struct mgcp_config *cfg, struct msgb *msg);
+static void create_transcoder(struct mgcp_endpoint *endp);
+static void delete_transcoder(struct mgcp_endpoint *endp);
+
static uint32_t generate_call_id(struct mgcp_config *cfg)
{
int i;
@@ -104,8 +104,8 @@
/* callstack can only be of size number_of_endpoints */
/* verify that the call id is free, e.g. in case of overrun */
- for (i = 1; i < cfg->number_endpoints; ++i)
- if (cfg->endpoints[i].ci == cfg->last_call_id)
+ for (i = 1; i < cfg->trunk.number_endpoints; ++i)
+ if (cfg->trunk.endpoints[i].ci == cfg->last_call_id)
return generate_call_id(cfg);
return cfg->last_call_id;
@@ -184,9 +184,9 @@
"c=IN IP4 %s\r\n"
"m=audio %d RTP/AVP %d\r\n"
"a=rtpmap:%d %s\r\n",
- endp->ci, addr, endp->rtp_port,
- endp->bts_payload_type, endp->bts_payload_type,
- endp->cfg->audio_name);
+ endp->ci, addr, endp->net_end.local_port,
+ endp->bts_end.payload_type, endp->bts_end.payload_type,
+ endp->tcfg->audio_name);
return mgcp_create_response_with_data(200, " OK", msg, trans_id, sdp_record);
}
@@ -270,7 +270,8 @@
const char *mgcp)
{
char *rest = NULL;
- int trunk, endp, mgcp_endp;
+ struct mgcp_trunk_config *tcfg;
+ int trunk, endp;
trunk = strtoul(mgcp + 6, &rest, 10);
if (rest == NULL || rest[0] != '/' || trunk < 1) {
@@ -288,13 +289,23 @@
if (endp == 1)
return NULL;
- mgcp_endp = mgcp_timeslot_to_endpoint(trunk - 1, endp);
- if (mgcp_endp < 1 || mgcp_endp >= cfg->number_endpoints) {
+ tcfg = mgcp_trunk_num(cfg, trunk);
+ if (!tcfg) {
+ LOGP(DMGCP, LOGL_ERROR, "The trunk %d is not declared.\n", trunk);
+ return NULL;
+ }
+
+ if (!tcfg->endpoints) {
+ LOGP(DMGCP, LOGL_ERROR, "Endpoints of trunk %d not allocated.\n", trunk);
+ return NULL;
+ }
+
+ if (endp < 1 || endp >= tcfg->number_endpoints) {
LOGP(DMGCP, LOGL_ERROR, "Failed to find endpoint '%s'\n", mgcp);
return NULL;
}
- return &cfg->endpoints[mgcp_endp];
+ return &tcfg->endpoints[endp];
}
static struct mgcp_endpoint *find_endpoint(struct mgcp_config *cfg, const char *mgcp)
@@ -306,8 +317,8 @@
return find_e1_endpoint(cfg, mgcp);
} else {
gw = strtoul(mgcp, &endptr, 16);
- if (gw > 0 && gw < cfg->number_endpoints && strcmp(endptr, "@mgw") == 0)
- return &cfg->endpoints[gw];
+ if (gw > 0 && gw < cfg->trunk.number_endpoints && strcmp(endptr, "@mgw") == 0)
+ return &cfg->trunk.endpoints[gw];
}
LOGP(DMGCP, LOGL_ERROR, "Not able to find endpoint: '%s'\n", mgcp);
@@ -399,7 +410,7 @@
return create_ok_response(200, "AUEP", trans_id);
}
-static int parse_conn_mode(const char* msg, int *conn_mode)
+static int parse_conn_mode(const char *msg, int *conn_mode)
{
int ret = 0;
if (strcmp(msg, "recvonly") == 0)
@@ -418,26 +429,98 @@
return ret;
}
+static int allocate_port(struct mgcp_endpoint *endp, struct mgcp_rtp_end *end,
+ struct mgcp_port_range *range,
+ int (*alloc)(struct mgcp_endpoint *endp, int port))
+{
+ int i;
+
+ if (range->mode == PORT_ALLOC_STATIC) {
+ end->local_alloc = PORT_ALLOC_STATIC;
+ return 0;
+ }
+
+ /* attempt to find a port */
+ for (i = 0; i < 200; ++i) {
+ int rc;
+
+ if (range->last_port >= range->range_end)
+ range->last_port = range->range_start;
+
+ rc = alloc(endp, range->last_port);
+
+ range->last_port += 2;
+ if (rc == 0) {
+ end->local_alloc = PORT_ALLOC_DYNAMIC;
+ return 0;
+ }
+
+ }
+
+ LOGP(DMGCP, LOGL_ERROR, "Allocating a RTP/RTCP port failed 200 times 0x%x.\n",
+ ENDPOINT_NUMBER(endp));
+ return -1;
+}
+
+static int allocate_ports(struct mgcp_endpoint *endp)
+{
+ if (allocate_port(endp, &endp->net_end, &endp->cfg->net_ports,
+ mgcp_bind_net_rtp_port) != 0)
+ return -1;
+
+ if (allocate_port(endp, &endp->bts_end, &endp->cfg->bts_ports,
+ mgcp_bind_bts_rtp_port) != 0) {
+ mgcp_rtp_end_reset(&endp->net_end);
+ return -1;
+ }
+
+ if (endp->cfg->transcoder_ip && endp->tcfg->trunk_type == MGCP_TRUNK_VIRTUAL) {
+ if (allocate_port(endp, &endp->trans_net,
+ &endp->cfg->transcoder_ports,
+ mgcp_bind_trans_net_rtp_port) != 0) {
+ mgcp_rtp_end_reset(&endp->net_end);
+ mgcp_rtp_end_reset(&endp->bts_end);
+ return -1;
+ }
+
+ if (allocate_port(endp, &endp->trans_bts,
+ &endp->cfg->transcoder_ports,
+ mgcp_bind_trans_bts_rtp_port) != 0) {
+ mgcp_rtp_end_reset(&endp->net_end);
+ mgcp_rtp_end_reset(&endp->bts_end);
+ mgcp_rtp_end_reset(&endp->trans_net);
+ return -1;
+ }
+
+ /* remember that we have set up transcoding */
+ endp->is_transcoded = 1;
+ }
+
+ return 0;
+}
+
static struct msgb *handle_create_con(struct mgcp_config *cfg, struct msgb *msg)
{
struct mgcp_msg_ptr data_ptrs[6];
int found, i, line_start;
const char *trans_id;
+ struct mgcp_trunk_config *tcfg;
struct mgcp_endpoint *endp;
- int error_code = 500;
- int port;
+ int error_code = 400;
found = mgcp_analyze_header(cfg, msg, data_ptrs, ARRAY_SIZE(data_ptrs), &trans_id, &endp);
if (found != 0)
return create_err_response(510, "CRCX", trans_id);
- if (endp->ci != CI_UNUSED) {
- if (cfg->force_realloc) {
+ tcfg = endp->tcfg;
+
+ if (endp->allocated) {
+ if (tcfg->force_realloc) {
LOGP(DMGCP, LOGL_NOTICE, "Endpoint 0x%x already allocated. Forcing realloc.\n",
ENDPOINT_NUMBER(endp));
mgcp_free_endp(endp);
if (cfg->realloc_cb)
- cfg->realloc_cb(cfg, ENDPOINT_NUMBER(endp));
+ cfg->realloc_cb(tcfg, ENDPOINT_NUMBER(endp));
} else {
LOGP(DMGCP, LOGL_ERROR, "Endpoint is already used. 0x%x\n",
ENDPOINT_NUMBER(endp));
@@ -449,11 +532,11 @@
MSG_TOKENIZE_START
switch (msg->l3h[line_start]) {
case 'L':
- endp->local_options = talloc_strdup(cfg->endpoints,
+ endp->local_options = talloc_strdup(tcfg->endpoints,
(const char *)&msg->l3h[line_start + 3]);
break;
case 'C':
- endp->callid = talloc_strdup(cfg->endpoints,
+ endp->callid = talloc_strdup(tcfg->endpoints,
(const char *)&msg->l3h[line_start + 3]);
break;
case 'M':
@@ -474,16 +557,13 @@
MSG_TOKENIZE_END
/* initialize */
- endp->net_rtp = endp->net_rtcp = endp->bts_rtp = endp->bts_rtcp = 0;
+ endp->net_end.rtp_port = endp->net_end.rtcp_port = endp->bts_end.rtp_port = endp->bts_end.rtcp_port = 0;
/* set to zero until we get the info */
- memset(&endp->remote, 0, sizeof(endp->remote));
+ memset(&endp->net_end.addr, 0, sizeof(endp->net_end.addr));
/* bind to the port now */
- port = rtp_calculate_port(ENDPOINT_NUMBER(endp), cfg->rtp_base_port);
- if (cfg->early_bind)
- endp->rtp_port = port;
- else if (mgcp_bind_rtp_port(endp, port) != 0)
+ if (allocate_ports(endp) != 0)
goto error2;
/* assign a local call identifier or fail */
@@ -491,11 +571,12 @@
if (endp->ci == CI_UNUSED)
goto error2;
- endp->bts_payload_type = cfg->audio_payload;
+ endp->allocated = 1;
+ endp->bts_end.payload_type = tcfg->audio_payload;
/* policy CB */
if (cfg->policy_cb) {
- switch (cfg->policy_cb(cfg, ENDPOINT_NUMBER(endp), MGCP_ENDP_CRCX, trans_id)) {
+ switch (cfg->policy_cb(tcfg, ENDPOINT_NUMBER(endp), MGCP_ENDP_CRCX, trans_id)) {
case MGCP_POLICY_REJECT:
LOGP(DMGCP, LOGL_NOTICE, "CRCX rejected by policy on 0x%x\n",
ENDPOINT_NUMBER(endp));
@@ -504,6 +585,7 @@
break;
case MGCP_POLICY_DEFER:
/* stop processing */
+ create_transcoder(endp);
return NULL;
break;
case MGCP_POLICY_CONT:
@@ -512,11 +594,13 @@
}
}
- LOGP(DMGCP, LOGL_NOTICE, "Creating endpoint on: 0x%x CI: %u port: %u\n",
- ENDPOINT_NUMBER(endp), endp->ci, endp->rtp_port);
+ LOGP(DMGCP, LOGL_DEBUG, "Creating endpoint on: 0x%x CI: %u port: %u/%u\n",
+ ENDPOINT_NUMBER(endp), endp->ci,
+ endp->net_end.local_port, endp->bts_end.local_port);
if (cfg->change_cb)
- cfg->change_cb(cfg, ENDPOINT_NUMBER(endp), MGCP_ENDP_CRCX, endp->rtp_port);
+ cfg->change_cb(tcfg, ENDPOINT_NUMBER(endp), MGCP_ENDP_CRCX);
+ create_transcoder(endp);
return create_response_with_sdp(endp, "CRCX", trans_id);
error:
LOGP(DMGCP, LOGL_ERROR, "Malformed line: %s on 0x%x with: line_start: %d %d\n",
@@ -525,6 +609,7 @@
return create_err_response(error_code, "CRCX", trans_id);
error2:
+ mgcp_free_endp(endp);
LOGP(DMGCP, LOGL_NOTICE, "Resource error on 0x%x\n", ENDPOINT_NUMBER(endp));
return create_err_response(error_code, "CRCX", trans_id);
}
@@ -589,9 +674,9 @@
const char *param = (const char *)&msg->l3h[line_start];
if (sscanf(param, "m=audio %d RTP/AVP %d", &port, &payload) == 2) {
- endp->net_rtp = htons(port);
- endp->net_rtcp = htons(port + 1);
- endp->net_payload_type = payload;
+ endp->net_end.rtp_port = htons(port);
+ endp->net_end.rtcp_port = htons(port + 1);
+ endp->net_end.payload_type = payload;
}
break;
}
@@ -600,7 +685,7 @@
const char *param = (const char *)&msg->l3h[line_start];
if (sscanf(param, "c=IN IP4 %15s", ipv4) == 1) {
- inet_aton(ipv4, &endp->remote);
+ inet_aton(ipv4, &endp->net_end.addr);
}
break;
}
@@ -614,7 +699,7 @@
/* policy CB */
if (cfg->policy_cb) {
- switch (cfg->policy_cb(cfg, ENDPOINT_NUMBER(endp), MGCP_ENDP_MDCX, trans_id)) {
+ switch (cfg->policy_cb(endp->tcfg, ENDPOINT_NUMBER(endp), MGCP_ENDP_MDCX, trans_id)) {
case MGCP_POLICY_REJECT:
LOGP(DMGCP, LOGL_NOTICE, "MDCX rejected by policy on 0x%x\n",
ENDPOINT_NUMBER(endp));
@@ -633,10 +718,10 @@
}
/* modify */
- LOGP(DMGCP, LOGL_NOTICE, "Modified endpoint on: 0x%x Server: %s:%u\n",
- ENDPOINT_NUMBER(endp), inet_ntoa(endp->remote), ntohs(endp->net_rtp));
+ LOGP(DMGCP, LOGL_DEBUG, "Modified endpoint on: 0x%x Server: %s:%u\n",
+ ENDPOINT_NUMBER(endp), inet_ntoa(endp->net_end.addr), ntohs(endp->net_end.rtp_port));
if (cfg->change_cb)
- cfg->change_cb(cfg, ENDPOINT_NUMBER(endp), MGCP_ENDP_MDCX, endp->rtp_port);
+ cfg->change_cb(endp->tcfg, ENDPOINT_NUMBER(endp), MGCP_ENDP_MDCX);
if (silent)
goto out_silent;
@@ -662,14 +747,14 @@
int found, i, line_start;
const char *trans_id;
struct mgcp_endpoint *endp;
- int error_code = 500;
+ int error_code = 400;
int silent = 0;
found = mgcp_analyze_header(cfg, msg, data_ptrs, ARRAY_SIZE(data_ptrs), &trans_id, &endp);
if (found != 0)
return create_err_response(error_code, "DLCX", trans_id);
- if (endp->ci == CI_UNUSED) {
+ if (!endp->allocated) {
LOGP(DMGCP, LOGL_ERROR, "Endpoint is not used. 0x%x\n", ENDPOINT_NUMBER(endp));
return create_err_response(400, "DLCX", trans_id);
}
@@ -699,7 +784,7 @@
/* policy CB */
if (cfg->policy_cb) {
- switch (cfg->policy_cb(cfg, ENDPOINT_NUMBER(endp), MGCP_ENDP_DLCX, trans_id)) {
+ switch (cfg->policy_cb(endp->tcfg, ENDPOINT_NUMBER(endp), MGCP_ENDP_DLCX, trans_id)) {
case MGCP_POLICY_REJECT:
LOGP(DMGCP, LOGL_NOTICE, "DLCX rejected by policy on 0x%x\n",
ENDPOINT_NUMBER(endp));
@@ -709,6 +794,7 @@
break;
case MGCP_POLICY_DEFER:
/* stop processing */
+ delete_transcoder(endp);
return NULL;
break;
case MGCP_POLICY_CONT:
@@ -718,11 +804,13 @@
}
/* free the connection */
- LOGP(DMGCP, LOGL_NOTICE, "Deleted endpoint on: 0x%x Server: %s:%u\n",
- ENDPOINT_NUMBER(endp), inet_ntoa(endp->remote), ntohs(endp->net_rtp));
+ LOGP(DMGCP, LOGL_DEBUG, "Deleted endpoint on: 0x%x Server: %s:%u\n",
+ ENDPOINT_NUMBER(endp), inet_ntoa(endp->net_end.addr), ntohs(endp->net_end.rtp_port));
+
+ delete_transcoder(endp);
mgcp_free_endp(endp);
if (cfg->change_cb)
- cfg->change_cb(cfg, ENDPOINT_NUMBER(endp), MGCP_ENDP_DLCX, endp->rtp_port);
+ cfg->change_cb(endp->tcfg, ENDPOINT_NUMBER(endp), MGCP_ENDP_DLCX);
if (silent)
goto out_silent;
@@ -764,13 +852,35 @@
if (found != 0)
return create_err_response(400, "RQNT", trans_id);
- if (endp->ci == CI_UNUSED) {
+ if (!endp->allocated) {
LOGP(DMGCP, LOGL_ERROR, "Endpoint is not used. 0x%x\n", ENDPOINT_NUMBER(endp));
return create_err_response(400, "RQNT", trans_id);
}
return create_ok_response(200, "RQNT", trans_id);
}
+static void trunk_init(struct mgcp_trunk_config *trunk)
+{
+ trunk->trunk_type = MGCP_TRUNK_VIRTUAL;
+ trunk->audio_name = talloc_strdup(trunk->cfg, "AMR/8000");
+ trunk->audio_payload = 126;
+
+ /* MGW handling */
+ trunk->target_trunk_start = 1;
+ trunk->endp_offset = 1;
+ trunk->vad_enabled = 1;
+ trunk->digital_inp_gain = 31;
+ trunk->digital_out_gain = 31;
+ trunk->upstr_agc_enbl = 0;
+ trunk->upstr_adp_rate = 100;
+ trunk->upstr_max_gain = 46;
+ trunk->upstr_target_lvl = 20;
+ trunk->dwnstr_agc_enbl = 0;
+ trunk->dwnstr_adp_rate = 100;
+ trunk->dwnstr_max_gain = 46;
+ trunk->dwnstr_target_lvl = 20;
+}
+
struct mgcp_config *mgcp_config_alloc(void)
{
struct mgcp_config *cfg;
@@ -783,31 +893,95 @@
cfg->source_port = 2427;
cfg->source_addr = talloc_strdup(cfg, "0.0.0.0");
- cfg->audio_name = talloc_strdup(cfg, "GSM-EFR/8000");
- cfg->audio_payload = 97;
- cfg->rtp_base_port = RTP_PORT_DEFAULT;
+
+ cfg->transcoder_remote_base = 4000;
+
+ cfg->bts_ports.base_port = RTP_PORT_DEFAULT;
+ cfg->net_ports.base_port = RTP_PORT_NET_DEFAULT;
+
+ /* default trunk handling */
+ cfg->trunk.cfg = cfg;
+ cfg->trunk.trunk_nr = 0;
+ trunk_init(&cfg->trunk);
+
+ INIT_LLIST_HEAD(&cfg->trunks);
return cfg;
}
-int mgcp_endpoints_allocate(struct mgcp_config *cfg)
+struct mgcp_trunk_config *mgcp_trunk_alloc(struct mgcp_config *cfg, int nr)
+{
+ struct mgcp_trunk_config *trunk;
+
+ trunk = talloc_zero(cfg, struct mgcp_trunk_config);
+ if (!trunk) {
+ LOGP(DMGCP, LOGL_ERROR, "Failed to allocate.\n");
+ return NULL;
+ }
+
+ trunk->cfg = cfg;
+ trunk->trunk_type = MGCP_TRUNK_E1;
+ trunk->trunk_nr = nr;
+ trunk_init(trunk);
+ trunk->number_endpoints = 33;
+ llist_add_tail(&trunk->entry, &cfg->trunks);
+ return trunk;
+}
+
+struct mgcp_trunk_config *mgcp_trunk_num(struct mgcp_config *cfg, int index)
+{
+ struct mgcp_trunk_config *trunk;
+
+ llist_for_each_entry(trunk, &cfg->trunks, entry)
+ if (trunk->trunk_nr == index)
+ return trunk;
+
+ return NULL;
+}
+
+static void mgcp_rtp_end_reset(struct mgcp_rtp_end *end)
+{
+ if (end->local_alloc == PORT_ALLOC_DYNAMIC) {
+ mgcp_free_rtp_port(end);
+ end->local_port = 0;
+ }
+
+ end->packets = 0;
+ memset(&end->addr, 0, sizeof(end->addr));
+ end->rtp_port = end->rtcp_port = 0;
+ end->payload_type = -1;
+ end->local_alloc = -1;
+}
+
+static void mgcp_rtp_end_init(struct mgcp_rtp_end *end)
+{
+ mgcp_rtp_end_reset(end);
+ end->rtp.fd = -1;
+ end->rtcp.fd = -1;
+}
+
+int mgcp_endpoints_allocate(struct mgcp_trunk_config *tcfg)
{
int i;
/* Initialize all endpoints */
- cfg->endpoints = _talloc_zero_array(cfg,
+ tcfg->endpoints = _talloc_zero_array(tcfg->cfg,
sizeof(struct mgcp_endpoint),
- cfg->number_endpoints, "endpoints");
- if (!cfg->endpoints)
+ tcfg->number_endpoints, "endpoints");
+ if (!tcfg->endpoints)
return -1;
- for (i = 0; i < cfg->number_endpoints; ++i) {
- cfg->endpoints[i].local_rtp.fd = -1;
- cfg->endpoints[i].local_rtcp.fd = -1;
- cfg->endpoints[i].ci = CI_UNUSED;
- cfg->endpoints[i].cfg = cfg;
- cfg->endpoints[i].net_payload_type = -1;
- cfg->endpoints[i].bts_payload_type = -1;
+ for (i = 0; i < tcfg->number_endpoints; ++i) {
+ tcfg->endpoints[i].ci = CI_UNUSED;
+ tcfg->endpoints[i].cfg = tcfg->cfg;
+ tcfg->endpoints[i].tcfg = tcfg;
+ mgcp_rtp_end_init(&tcfg->endpoints[i].net_end);
+ mgcp_rtp_end_init(&tcfg->endpoints[i].bts_end);
+ mgcp_rtp_end_init(&tcfg->endpoints[i].trans_net);
+ mgcp_rtp_end_init(&tcfg->endpoints[i].trans_bts);
+
+ /* MGW code */
+ tcfg->endpoints[i].audio_port = UINT_MAX;
}
return 0;
@@ -817,6 +991,7 @@
{
LOGP(DMGCP, LOGL_DEBUG, "Deleting endpoint on: 0x%x\n", ENDPOINT_NUMBER(endp));
endp->ci = CI_UNUSED;
+ endp->allocated = 0;
if (endp->callid) {
talloc_free(endp->callid);
@@ -828,19 +1003,121 @@
endp->local_options = NULL;
}
- if (!endp->cfg->early_bind) {
- bsc_unregister_fd(&endp->local_rtp);
- bsc_unregister_fd(&endp->local_rtcp);
- }
-
- endp->net_rtp = endp->net_rtcp = endp->bts_rtp = endp->bts_rtcp = 0;
- endp->net_payload_type = endp->bts_payload_type = -1;
- endp->in_bts = endp->in_remote = 0;
- memset(&endp->remote, 0, sizeof(endp->remote));
- memset(&endp->bts, 0, sizeof(endp->bts));
+ mgcp_rtp_end_reset(&endp->bts_end);
+ mgcp_rtp_end_reset(&endp->net_end);
+ mgcp_rtp_end_reset(&endp->trans_net);
+ mgcp_rtp_end_reset(&endp->trans_bts);
+ endp->is_transcoded = 0;
memset(&endp->net_state, 0, sizeof(endp->net_state));
memset(&endp->bts_state, 0, sizeof(endp->bts_state));
endp->conn_mode = endp->orig_mode = MGCP_CONN_NONE;
+ endp->allow_patch = 0;
+
+ memset(&endp->taps, 0, sizeof(endp->taps));
+}
+
+static int send_trans(struct mgcp_config *cfg, const char *buf, int len)
+{
+ struct sockaddr_in addr;
+
+ memset(&addr, 0, sizeof(addr));
+ addr.sin_family = AF_INET;
+ addr.sin_addr = cfg->transcoder_in;
+ addr.sin_port = htons(2427);
+ return sendto(cfg->gw_fd.bfd.fd, buf, len, 0,
+ (struct sockaddr *) &addr, sizeof(addr));
+}
+
+static void send_msg(struct mgcp_endpoint *endp, int endpoint, int port,
+ const char *msg, const char *mode)
+{
+ char buf[2096];
+ int len;
+
+ /* hardcoded to AMR right now, we do not know the real type at this point */
+ len = snprintf(buf, sizeof(buf),
+ "%s 42 %x@mgw MGCP 1.0\r\n"
+ "C: 4256\r\n"
+ "M: %s\r\n"
+ "\r\n"
+ "c=IN IP4 %s\r\n"
+ "m=audio %d RTP/AVP %d\r\n"
+ "a=rtpmap:%d %s\r\n",
+ msg, endpoint, mode, endp->cfg->source_addr,
+ port, endp->tcfg->audio_payload,
+ endp->tcfg->audio_payload, endp->tcfg->audio_name);
+
+ if (len < 0)
+ return;
+
+ buf[sizeof(buf) - 1] = '\0';
+
+ send_trans(endp->cfg, buf, len);
+}
+
+static void send_dlcx(struct mgcp_endpoint *endp, int endpoint)
+{
+ char buf[2096];
+ int len;
+
+ len = snprintf(buf, sizeof(buf),
+ "DLCX 43 %x@mgw MGCP 1.0\r\n"
+ "C: 4256\r\n"
+ , endpoint);
+
+ if (len < 0)
+ return;
+
+ buf[sizeof(buf) - 1] = '\0';
+
+ send_trans(endp->cfg, buf, len);
+}
+
+static void create_transcoder(struct mgcp_endpoint *endp)
+{
+ int port;
+ int in_endp = ENDPOINT_NUMBER(endp);
+ int out_endp = endp_back_channel(in_endp);
+
+ if (!endp->is_transcoded)
+ return;
+
+ send_msg(endp, in_endp, endp->trans_bts.local_port, "CRCX", "sendrecv");
+ send_msg(endp, in_endp, endp->trans_bts.local_port, "MDCX", "sendrecv");
+ send_msg(endp, out_endp, endp->trans_net.local_port, "CRCX", "sendrecv");
+ send_msg(endp, out_endp, endp->trans_net.local_port, "MDCX", "sendrecv");
+
+ port = rtp_calculate_port(in_endp, endp->cfg->transcoder_remote_base);
+ endp->trans_bts.rtp_port = htons(port);
+ endp->trans_bts.rtcp_port = htons(port + 1);
+
+ port = rtp_calculate_port(out_endp, endp->cfg->transcoder_remote_base);
+ endp->trans_net.rtp_port = htons(port);
+ endp->trans_net.rtcp_port = htons(port + 1);
+}
+
+static void delete_transcoder(struct mgcp_endpoint *endp)
+{
+ int in_endp = ENDPOINT_NUMBER(endp);
+ int out_endp = endp_back_channel(in_endp);
+
+ if (!endp->is_transcoded)
+ return;
+
+ send_dlcx(endp, in_endp);
+ send_dlcx(endp, out_endp);
+}
+
+int mgcp_reset_transcoder(struct mgcp_config *cfg)
+{
+ if (!cfg->transcoder_ip)
+ return 0;
+
+ static const char mgcp_reset[] = {
+ "RSIP 1 13@mgw MGCP 1.0\r\n"
+ };
+
+ return send_trans(cfg, mgcp_reset, sizeof mgcp_reset -1);
}
diff --git a/src/mgcp/mgcp_vty.c b/src/mgcp/mgcp_vty.c
index c35e864..1d81ce9 100644
--- a/src/mgcp/mgcp_vty.c
+++ b/src/mgcp/mgcp_vty.c
@@ -2,13 +2,13 @@
/* The protocol implementation */
/*
- * (C) 2009-2010 by Holger Hans Peter Freyther <zecke@selfish.org>
- * (C) 2009-2010 by On-Waves
+ * (C) 2009-2011 by Holger Hans Peter Freyther <zecke@selfish.org>
+ * (C) 2009-2011 by On-Waves
* All Rights Reserved
*
- * This program is free software: you can redistribute it and/or modify
+ * This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
+ * the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
@@ -23,32 +23,91 @@
#include <sys/types.h>
-#include <cellmgr_debug.h>
+#include <osmocore/talloc.h>
#include <mgcp/mgcp.h>
#include <mgcp/mgcp_internal.h>
-#include <mgcp_ss7.h>
-
-#include <osmocore/talloc.h>
-
-#include <osmocom/vty/command.h>
-#include <osmocom/vty/vty.h>
+#include <ss7_vty.h>
#include <string.h>
#include <netdb.h>
-static struct mgcp_config *g_cfg = NULL;
+
+/* MGW changes */
+extern void mgcp_write_extra(struct vty *vty, struct mgcp_config *cfg);
+extern void mgcp_write_trunk_extra(struct vty *vty, struct mgcp_trunk_config *cfg);
+
+
+DEFUN(ournode_exit, ournode_exit_cmd,
+ "exit", "Exit\n")
+{
+ switch (vty->node) {
+ case TRUNK_NODE:
+ vty->node = MGCP_NODE;
+ break;
+ default:
+ vty->node = CONFIG_NODE;
+ break;
+ }
+
+ return CMD_SUCCESS;
+}
+
+DEFUN(ournode_end, ournode_end_cmd,
+ "end", "End the current mode\n")
+{
+ switch (vty->node) {
+ case VIEW_NODE:
+ case ENABLE_NODE:
+ break;
+ default:
+ vty_config_unlock(vty);
+ vty->node = ENABLE_NODE;
+ vty->index = NULL;
+ vty->index_sub = NULL;
+ break;
+ }
+
+ return CMD_SUCCESS;
+}
+
+/* a talloc string replace routine */
+static void bsc_replace_string(void *ctx, char **dst, const char *newstr)
+{
+ if (*dst)
+ talloc_free(*dst);
+ *dst = talloc_strdup(ctx, newstr);
+}
+
+struct mgcp_config *g_cfg = NULL;
+
+static struct mgcp_trunk_config *find_trunk(struct mgcp_config *cfg, int nr)
+{
+ struct mgcp_trunk_config *trunk;
+
+ if (nr == 0)
+ trunk = &cfg->trunk;
+ else
+ trunk = mgcp_trunk_num(cfg, nr);
+
+ return trunk;
+}
/*
* vty code for mgcp below
*/
-static struct cmd_node mgcp_node = {
+struct cmd_node mgcp_node = {
MGCP_NODE,
"%s(mgcp)#",
1,
};
-extern void mgcp_write_extra(struct vty *vty);
+struct cmd_node trunk_node = {
+ TRUNK_NODE,
+ "%s(trunk)#",
+ 1,
+};
+
static int config_write_mgcp(struct vty *vty)
{
vty_out(vty, "mgcp%s", VTY_NEWLINE);
@@ -58,35 +117,83 @@
vty_out(vty, " mgw ip %s%s", g_cfg->bts_ip, VTY_NEWLINE);
vty_out(vty, " bind ip %s%s", g_cfg->source_addr, VTY_NEWLINE);
vty_out(vty, " bind port %u%s", g_cfg->source_port, VTY_NEWLINE);
- vty_out(vty, " rtp base %u%s", g_cfg->rtp_base_port, VTY_NEWLINE);
+
+ if (g_cfg->bts_ports.mode == PORT_ALLOC_STATIC)
+ vty_out(vty, " rtp bts-base %u%s", g_cfg->bts_ports.base_port, VTY_NEWLINE);
+ else
+ vty_out(vty, " rtp bts-range %u %u%s",
+ g_cfg->bts_ports.range_start, g_cfg->bts_ports.range_end, VTY_NEWLINE);
+
+ if (g_cfg->net_ports.mode == PORT_ALLOC_STATIC)
+ vty_out(vty, " rtp net-base %u%s", g_cfg->net_ports.base_port, VTY_NEWLINE);
+ else
+ vty_out(vty, " rtp net-range %u %u%s",
+ g_cfg->net_ports.range_start, g_cfg->net_ports.range_end, VTY_NEWLINE);
+
vty_out(vty, " rtp ip-dscp %d%s", g_cfg->endp_dscp, VTY_NEWLINE);
- if (g_cfg->audio_payload != -1)
- vty_out(vty, " sdp audio payload number %d%s", g_cfg->audio_payload, VTY_NEWLINE);
- if (g_cfg->audio_name)
- vty_out(vty, " sdp audio payload name %s%s", g_cfg->audio_name, VTY_NEWLINE);
- vty_out(vty, " loop %u%s", !!g_cfg->audio_loop, VTY_NEWLINE);
- vty_out(vty, " number endpoints %u%s", g_cfg->number_endpoints - 1, VTY_NEWLINE);
- mgcp_write_extra(vty);
+ if (g_cfg->trunk.audio_payload != -1)
+ vty_out(vty, " sdp audio payload number %d%s",
+ g_cfg->trunk.audio_payload, VTY_NEWLINE);
+ if (g_cfg->trunk.audio_name)
+ vty_out(vty, " sdp audio payload name %s%s",
+ g_cfg->trunk.audio_name, VTY_NEWLINE);
+ vty_out(vty, " loop %u%s", !!g_cfg->trunk.audio_loop, VTY_NEWLINE);
+ vty_out(vty, " number endpoints %u%s", g_cfg->trunk.number_endpoints - 1, VTY_NEWLINE);
+ if (g_cfg->call_agent_addr)
+ vty_out(vty, " call agent ip %s%s", g_cfg->call_agent_addr, VTY_NEWLINE);
+ if (g_cfg->transcoder_ip)
+ vty_out(vty, " transcoder-mgw %s%s", g_cfg->transcoder_ip, VTY_NEWLINE);
+
+ if (g_cfg->transcoder_ports.mode == PORT_ALLOC_STATIC)
+ vty_out(vty, " rtp transcoder-base %u%s", g_cfg->transcoder_ports.base_port, VTY_NEWLINE);
+ else
+ vty_out(vty, " rtp transcoder-range %u %u%s",
+ g_cfg->transcoder_ports.range_start, g_cfg->transcoder_ports.range_end, VTY_NEWLINE);
+ vty_out(vty, " transcoder-remote-base %u%s", g_cfg->transcoder_remote_base, VTY_NEWLINE);
+
+ mgcp_write_extra(vty, g_cfg);
return CMD_SUCCESS;
}
+static void dump_trunk(struct vty *vty, struct mgcp_trunk_config *cfg)
+{
+ int i;
+
+ vty_out(vty, "%s trunk nr %d with %d endpoints:%s",
+ cfg->trunk_type == MGCP_TRUNK_VIRTUAL ? "Virtual" : "E1",
+ cfg->trunk_nr, cfg->number_endpoints - 1, VTY_NEWLINE);
+
+ if (!cfg->endpoints) {
+ vty_out(vty, "No endpoints allocated yet.%s", VTY_NEWLINE);
+ return;
+ }
+
+ for (i = 1; i < cfg->number_endpoints; ++i) {
+ struct mgcp_endpoint *endp = &cfg->endpoints[i];
+ vty_out(vty,
+ " Endpoint 0x%.2x: CI: %d net: %u/%u bts: %u/%u on %s "
+ "traffic received bts: %u/%u remote: %u/%u transcoder: %u/%u%s",
+ i, endp->ci,
+ ntohs(endp->net_end.rtp_port), ntohs(endp->net_end.rtcp_port),
+ ntohs(endp->bts_end.rtp_port), ntohs(endp->bts_end.rtcp_port),
+ inet_ntoa(endp->bts_end.addr),
+ endp->bts_end.packets, endp->bts_state.lost_no,
+ endp->net_end.packets, endp->net_state.lost_no,
+ endp->trans_net.packets, endp->trans_bts.packets,
+ VTY_NEWLINE);
+ }
+}
+
DEFUN(show_mcgp, show_mgcp_cmd, "show mgcp",
SHOW_STR "Display information about the MGCP Media Gateway")
{
- int i;
+ struct mgcp_trunk_config *trunk;
- vty_out(vty, "MGCP is up and running with %u endpoints:%s", g_cfg->number_endpoints - 1, VTY_NEWLINE);
- for (i = 1; i < g_cfg->number_endpoints; ++i) {
- struct mgcp_endpoint *endp = &g_cfg->endpoints[i];
- vty_out(vty, " Endpoint 0x%.2x: CI: %d net: %u/%u bts: %u/%u on %s traffic received bts: %u/%u remote: %u/%u%s",
- i, endp->ci,
- ntohs(endp->net_rtp), ntohs(endp->net_rtcp),
- ntohs(endp->bts_rtp), ntohs(endp->bts_rtcp),
- inet_ntoa(endp->bts), endp->in_bts, endp->bts_state.lost_no,
- endp->in_remote, endp->net_state.lost_no,
- VTY_NEWLINE);
- }
+ dump_trunk(vty, &g_cfg->trunk);
+
+ llist_for_each_entry(trunk, &g_cfg->trunks, entry)
+ dump_trunk(vty, trunk);
return CMD_SUCCESS;
}
@@ -115,9 +222,7 @@
}
addr = (struct in_addr *) hosts->h_addr_list[0];
- if (g_cfg->local_ip)
- talloc_free(g_cfg->local_ip);
- g_cfg->local_ip = talloc_strdup(g_cfg, inet_ntoa(*addr));
+ bsc_replace_string(g_cfg, &g_cfg->local_ip, inet_ntoa(*addr));
return CMD_SUCCESS;
}
@@ -136,9 +241,7 @@
}
addr = (struct in_addr *) hosts->h_addr_list[0];
- if (g_cfg->bts_ip)
- talloc_free(g_cfg->bts_ip);
- g_cfg->bts_ip = talloc_strdup(g_cfg, inet_ntoa(*addr));
+ bsc_replace_string(g_cfg, &g_cfg->bts_ip, inet_ntoa(*addr));
inet_aton(g_cfg->bts_ip, &g_cfg->bts_in);
return CMD_SUCCESS;
}
@@ -148,9 +251,7 @@
"bind ip A.B.C.D",
"Bind the MGCP to this local addr")
{
- if (g_cfg->source_addr)
- talloc_free(g_cfg->source_addr);
- g_cfg->source_addr = talloc_strdup(g_cfg, argv[0]);
+ bsc_replace_string(g_cfg, &g_cfg->source_addr, argv[0]);
return CMD_SUCCESS;
}
@@ -164,13 +265,88 @@
return CMD_SUCCESS;
}
-DEFUN(cfg_mgcp_rtp_base_port,
- cfg_mgcp_rtp_base_port_cmd,
- "rtp base <0-65534>",
- "Base port to use")
+DEFUN(cfg_mgcp_bind_early,
+ cfg_mgcp_bind_early_cmd,
+ "bind early (0|1)",
+ "Bind all RTP ports early")
+{
+ vty_out(vty, "bind early is deprecated, remove it from the config.\n");
+ return CMD_WARNING;
+}
+
+static void parse_base(struct mgcp_port_range *range, const char **argv)
{
unsigned int port = atoi(argv[0]);
- g_cfg->rtp_base_port = port;
+ range->mode = PORT_ALLOC_STATIC;
+ range->base_port = port;
+}
+
+static void parse_range(struct mgcp_port_range *range, const char **argv)
+{
+ range->mode = PORT_ALLOC_DYNAMIC;
+ range->range_start = atoi(argv[0]);
+ range->range_end = atoi(argv[1]);
+ range->last_port = g_cfg->bts_ports.range_start;
+}
+
+
+DEFUN(cfg_mgcp_rtp_bts_base_port,
+ cfg_mgcp_rtp_bts_base_port_cmd,
+ "rtp bts-base <0-65534>",
+ "Base port to use")
+{
+ parse_base(&g_cfg->bts_ports, argv);
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_mgcp_rtp_bts_range,
+ cfg_mgcp_rtp_bts_range_cmd,
+ "rtp bts-range <0-65534> <0-65534>",
+ "Range of ports to allocate for endpoints\n"
+ "Start of the range of ports\n" "End of the range of ports\n")
+{
+ parse_range(&g_cfg->bts_ports, argv);
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_mgcp_rtp_net_range,
+ cfg_mgcp_rtp_net_range_cmd,
+ "rtp net-range <0-65534> <0-65534>",
+ "Range of ports to allocate for endpoints\n"
+ "Start of the range of ports\n" "End of the range of ports\n")
+{
+ parse_range(&g_cfg->net_ports, argv);
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_mgcp_rtp_net_base_port,
+ cfg_mgcp_rtp_net_base_port_cmd,
+ "rtp net-base <0-65534>",
+ "Base port to use for network port\n" "Port\n")
+{
+ parse_base(&g_cfg->net_ports, argv);
+ return CMD_SUCCESS;
+}
+
+ALIAS_DEPRECATED(cfg_mgcp_rtp_bts_base_port, cfg_mgcp_rtp_base_port_cmd,
+ "rtp base <0-65534>", "Base port to use")
+
+DEFUN(cfg_mgcp_rtp_transcoder_range,
+ cfg_mgcp_rtp_transcoder_range_cmd,
+ "rtp transcoder-range <0-65534> <0-65534>",
+ "Range of ports to allocate for the transcoder\n"
+ "Start of the range of ports\n" "End of the range of ports\n")
+{
+ parse_range(&g_cfg->transcoder_ports, argv);
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_mgcp_rtp_transcoder_base,
+ cfg_mgcp_rtp_transcoder_base_cmd,
+ "rtp transcoder-base <0-65534>",
+ "Base port for the transcoder range\n" "Port\n")
+{
+ parse_base(&g_cfg->transcoder_ports, argv);
return CMD_SUCCESS;
}
@@ -195,7 +371,7 @@
"Set the audio codec to use")
{
unsigned int payload = atoi(argv[0]);
- g_cfg->audio_payload = payload;
+ g_cfg->trunk.audio_payload = payload;
return CMD_SUCCESS;
}
@@ -204,9 +380,7 @@
"sdp audio payload name NAME",
"Set the audio name to use")
{
- if (g_cfg->audio_name)
- talloc_free(g_cfg->audio_name);
- g_cfg->audio_name = talloc_strdup(g_cfg, argv[0]);
+ bsc_replace_string(g_cfg, &g_cfg->trunk.audio_name, argv[0]);
return CMD_SUCCESS;
}
@@ -215,7 +389,7 @@
"loop (0|1)",
"Loop the audio")
{
- g_cfg->audio_loop = atoi(argv[0]);
+ g_cfg->trunk.audio_loop = atoi(argv[0]);
return CMD_SUCCESS;
}
@@ -225,65 +399,260 @@
"The number of endpoints to allocate. This is not dynamic.")
{
/* + 1 as we start counting at one */
- g_cfg->number_endpoints = atoi(argv[0]) + 1;
+ g_cfg->trunk.number_endpoints = atoi(argv[0]) + 1;
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_mgcp_agent_addr,
+ cfg_mgcp_agent_addr_cmd,
+ "call agent ip IP",
+ "Set the address of the call agent.")
+{
+ bsc_replace_string(g_cfg, &g_cfg->call_agent_addr, argv[0]);
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_mgcp_transcoder,
+ cfg_mgcp_transcoder_cmd,
+ "transcoder-mgw A.B.C.D",
+ "Use a MGW to detranscoder RTP\n"
+ "The IP address of the MGW")
+{
+ bsc_replace_string(g_cfg, &g_cfg->transcoder_ip, argv[0]);
+ inet_aton(g_cfg->transcoder_ip, &g_cfg->transcoder_in);
+
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_mgcp_no_transcoder,
+ cfg_mgcp_no_transcoder_cmd,
+ NO_STR "transcoder-mgw",
+ "Disable the transcoding\n")
+{
+ if (g_cfg->transcoder_ip) {
+ LOGP(DMGCP, LOGL_NOTICE, "Disabling transcoding on future calls.\n");
+ talloc_free(g_cfg->transcoder_ip);
+ g_cfg->transcoder_ip = NULL;
+ }
+
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_mgcp_transcoder_remote_base,
+ cfg_mgcp_transcoder_remote_base_cmd,
+ "transcoder-remote-base <0-65534>",
+ "Set the base port for the transcoder\n" "The RTP base port on the transcoder")
+{
+ g_cfg->transcoder_remote_base = atoi(argv[0]);
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_mgcp_trunk, cfg_mgcp_trunk_cmd,
+ "trunk <1-64>",
+ "Configure a SS7 trunk\n" "Trunk Nr\n")
+{
+ struct mgcp_trunk_config *trunk;
+ int index = atoi(argv[0]);
+
+ trunk = mgcp_trunk_num(g_cfg, index);
+ if (!trunk)
+ trunk = mgcp_trunk_alloc(g_cfg, index);
+
+ if (!trunk) {
+ vty_out(vty, "%%Unable to allocate trunk %u.%s",
+ index, VTY_NEWLINE);
+ return CMD_WARNING;
+ }
+
+ vty->node = TRUNK_NODE;
+ vty->index = trunk;
+ return CMD_SUCCESS;
+}
+
+static int config_write_trunk(struct vty *vty)
+{
+ struct mgcp_trunk_config *trunk;
+
+ llist_for_each_entry(trunk, &g_cfg->trunks, entry) {
+ vty_out(vty, " trunk %d%s", trunk->trunk_nr, VTY_NEWLINE);
+ vty_out(vty, " sdp audio payload number %d%s",
+ trunk->audio_payload, VTY_NEWLINE);
+ vty_out(vty, " sdp audio payload name %s%s",
+ trunk->audio_name, VTY_NEWLINE);
+ vty_out(vty, " loop %d%s",
+ trunk->audio_loop, VTY_NEWLINE);
+
+ mgcp_write_trunk_extra(vty, trunk);
+ }
+
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_trunk_payload_number,
+ cfg_trunk_payload_number_cmd,
+ "sdp audio payload number <1-255>",
+ "SDP related\n" "Audio\n" "Payload\n" "Payload Number\n")
+{
+ struct mgcp_trunk_config *trunk = vty->index;
+ unsigned int payload = atoi(argv[0]);
+
+ trunk->audio_payload = payload;
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_trunk_payload_name,
+ cfg_trunk_payload_name_cmd,
+ "sdp audio payload name NAME",
+ "SDP related\n" "Audio\n" "Payload\n" "Payload Name\n")
+{
+ struct mgcp_trunk_config *trunk = vty->index;
+
+ bsc_replace_string(g_cfg, &trunk->audio_name, argv[0]);
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_trunk_loop,
+ cfg_trunk_loop_cmd,
+ "loop (0|1)",
+ "Loop the audio")
+{
+ struct mgcp_trunk_config *trunk = vty->index;
+
+ trunk->audio_loop = atoi(argv[0]);
return CMD_SUCCESS;
}
DEFUN(loop_endp,
loop_endp_cmd,
- "loop-endpoint NAME (0|1)",
- "Loop a given endpoint\n"
+ "loop-endpoint <0-64> NAME (0|1)",
+ "Loop a given endpoint\n" "Trunk number\n"
"The name in hex of the endpoint\n" "Disable the loop\n" "Enable the loop\n")
{
+ struct mgcp_trunk_config *trunk;
struct mgcp_endpoint *endp;
- int endp_no = strtoul(argv[0], NULL, 16);
- if (endp_no < 1 || endp_no >= g_cfg->number_endpoints) {
+ trunk = find_trunk(g_cfg, atoi(argv[0]));
+ if (!trunk) {
+ vty_out(vty, "%%Trunk %d not found in the config.%s",
+ atoi(argv[0]), VTY_NEWLINE);
+ return CMD_WARNING;
+ }
+
+ if (!trunk->endpoints) {
+ vty_out(vty, "%%Trunk %d has no endpoints allocated.%s",
+ trunk->trunk_nr, VTY_NEWLINE);
+ return CMD_WARNING;
+ }
+
+ int endp_no = strtoul(argv[1], NULL, 16);
+ if (endp_no < 1 || endp_no >= trunk->number_endpoints) {
vty_out(vty, "Loopback number %s/%d is invalid.%s",
- argv[0], endp_no, VTY_NEWLINE);
+ argv[1], endp_no, VTY_NEWLINE);
return CMD_WARNING;
}
- endp = &g_cfg->endpoints[endp_no];
- int loop = atoi(argv[1]);
+ endp = &trunk->endpoints[endp_no];
+ int loop = atoi(argv[2]);
if (loop)
endp->conn_mode = MGCP_CONN_LOOPBACK;
else
endp->conn_mode = endp->orig_mode;
+ endp->allow_patch = 1;
return CMD_SUCCESS;
}
-DEFUN(ournode_exit,
- ournode_exit_cmd, "exit", "Exit current mode and down to previous node\n")
+DEFUN(tap_call,
+ tap_call_cmd,
+ "tap-call <0-64> ENDPOINT (bts-in|bts-out|net-in|net-out) A.B.C.D <0-65534>",
+ "Forward data on endpoint to a different system\n" "Trunk number\n"
+ "The endpoint in hex\n"
+ "Forward the data coming from the bts\n"
+ "Forward the data coming from the bts leaving to the network\n"
+ "Forward the data coming from the net\n"
+ "Forward the data coming from the net leaving to the bts\n"
+ "destination IP of the data\n" "destination port\n")
{
- switch (vty->node) {
- case MGCP_NODE:
- vty->node = CONFIG_NODE;
- vty->index = NULL;
- break;
+ struct mgcp_rtp_tap *tap;
+ struct mgcp_trunk_config *trunk;
+ struct mgcp_endpoint *endp;
+ int port = 0;
+
+ trunk = find_trunk(g_cfg, atoi(argv[0]));
+ if (!trunk) {
+ vty_out(vty, "%%Trunk %d not found in the config.%s",
+ atoi(argv[0]), VTY_NEWLINE);
+ return CMD_WARNING;
}
+ if (!trunk->endpoints) {
+ vty_out(vty, "%%Trunk %d has no endpoints allocated.%s",
+ trunk->trunk_nr, VTY_NEWLINE);
+ return CMD_WARNING;
+ }
+
+ int endp_no = strtoul(argv[1], NULL, 16);
+ if (endp_no < 1 || endp_no >= trunk->number_endpoints) {
+ vty_out(vty, "Endpoint number %s/%d is invalid.%s",
+ argv[1], endp_no, VTY_NEWLINE);
+ return CMD_WARNING;
+ }
+
+ endp = &trunk->endpoints[endp_no];
+
+ if (strcmp(argv[2], "bts-in") == 0) {
+ port = MGCP_TAP_BTS_IN;
+ } else if (strcmp(argv[2], "bts-out") == 0) {
+ port = MGCP_TAP_BTS_OUT;
+ } else if (strcmp(argv[2], "net-in") == 0) {
+ port = MGCP_TAP_NET_IN;
+ } else if (strcmp(argv[2], "net-out") == 0) {
+ port = MGCP_TAP_NET_OUT;
+ } else {
+ vty_out(vty, "Unknown mode... tricked vty?%s", VTY_NEWLINE);
+ return CMD_WARNING;
+ }
+
+ tap = &endp->taps[port];
+ memset(&tap->forward, 0, sizeof(tap->forward));
+ inet_aton(argv[3], &tap->forward.sin_addr);
+ tap->forward.sin_port = htons(atoi(argv[4]));
+ tap->enabled = 1;
return CMD_SUCCESS;
}
-DEFUN(ournode_end,
- ournode_end_cmd, "end", "End current mode and change to enable mode.")
+DEFUN(free_endp, free_endp_cmd,
+ "free-endpoint <0-64> NUMBER",
+ "Free the given endpoint\n" "Trunk number\n"
+ "Endpoint number in hex.\n")
{
- switch (vty->node) {
- case VIEW_NODE:
- case ENABLE_NODE:
- break;
- case MGCP_NODE:
- vty_config_unlock(vty);
- vty->node = ENABLE_NODE;
- vty->index = NULL;
- vty->index_sub = NULL;
- break;
+ struct mgcp_trunk_config *trunk;
+ struct mgcp_endpoint *endp;
+
+ trunk = find_trunk(g_cfg, atoi(argv[0]));
+ if (!trunk) {
+ vty_out(vty, "%%Trunk %d not found in the config.%s",
+ atoi(argv[0]), VTY_NEWLINE);
+ return CMD_WARNING;
}
+ if (!trunk->endpoints) {
+ vty_out(vty, "%%Trunk %d has no endpoints allocated.%s",
+ trunk->trunk_nr, VTY_NEWLINE);
+ return CMD_WARNING;
+ }
+
+ int endp_no = strtoul(argv[1], NULL, 16);
+ if (endp_no < 1 || endp_no >= trunk->number_endpoints) {
+ vty_out(vty, "Endpoint number %s/%d is invalid.%s",
+ argv[1], endp_no, VTY_NEWLINE);
+ return CMD_WARNING;
+ }
+
+ endp = &trunk->endpoints[endp_no];
+ mgcp_free_endp(endp);
return CMD_SUCCESS;
}
@@ -291,6 +660,8 @@
{
install_element_ve(&show_mgcp_cmd);
install_element(ENABLE_NODE, &loop_endp_cmd);
+ install_element(ENABLE_NODE, &tap_call_cmd);
+ install_element(ENABLE_NODE, &free_endp_cmd);
install_element(CONFIG_NODE, &cfg_mgcp_cmd);
install_node(&mgcp_node, config_write_mgcp);
@@ -302,18 +673,138 @@
install_element(MGCP_NODE, &cfg_mgcp_mgw_ip_cmd);
install_element(MGCP_NODE, &cfg_mgcp_bind_ip_cmd);
install_element(MGCP_NODE, &cfg_mgcp_bind_port_cmd);
+ install_element(MGCP_NODE, &cfg_mgcp_bind_early_cmd);
install_element(MGCP_NODE, &cfg_mgcp_rtp_base_port_cmd);
+ install_element(MGCP_NODE, &cfg_mgcp_rtp_bts_base_port_cmd);
+ install_element(MGCP_NODE, &cfg_mgcp_rtp_net_base_port_cmd);
+ install_element(MGCP_NODE, &cfg_mgcp_rtp_bts_range_cmd);
+ install_element(MGCP_NODE, &cfg_mgcp_rtp_net_range_cmd);
+ install_element(MGCP_NODE, &cfg_mgcp_rtp_transcoder_range_cmd);
+ install_element(MGCP_NODE, &cfg_mgcp_rtp_transcoder_base_cmd);
install_element(MGCP_NODE, &cfg_mgcp_rtp_ip_dscp_cmd);
install_element(MGCP_NODE, &cfg_mgcp_rtp_ip_tos_cmd);
+ install_element(MGCP_NODE, &cfg_mgcp_agent_addr_cmd);
+ install_element(MGCP_NODE, &cfg_mgcp_transcoder_cmd);
+ install_element(MGCP_NODE, &cfg_mgcp_no_transcoder_cmd);
+ install_element(MGCP_NODE, &cfg_mgcp_transcoder_remote_base_cmd);
install_element(MGCP_NODE, &cfg_mgcp_sdp_payload_number_cmd);
install_element(MGCP_NODE, &cfg_mgcp_sdp_payload_name_cmd);
install_element(MGCP_NODE, &cfg_mgcp_loop_cmd);
install_element(MGCP_NODE, &cfg_mgcp_number_endp_cmd);
+ install_element(MGCP_NODE, &cfg_mgcp_trunk_cmd);
+ install_node(&trunk_node, config_write_trunk);
+ install_default(TRUNK_NODE);
+ install_element(TRUNK_NODE, &ournode_exit_cmd);
+ install_element(TRUNK_NODE, &ournode_end_cmd);
+ install_element(TRUNK_NODE, &cfg_trunk_payload_number_cmd);
+ install_element(TRUNK_NODE, &cfg_trunk_payload_name_cmd);
+ install_element(TRUNK_NODE, &cfg_trunk_loop_cmd);
+
return 0;
}
-void mgcp_vty_set_config(struct mgcp_config *cfg)
+static int allocate_trunk(struct mgcp_trunk_config *trunk)
{
- g_cfg = cfg;
+ int i;
+ struct mgcp_config *cfg = trunk->cfg;
+
+ if (mgcp_endpoints_allocate(trunk) != 0) {
+ LOGP(DMGCP, LOGL_ERROR,
+ "Failed to allocate %d endpoints on trunk %d.\n",
+ trunk->number_endpoints, trunk->trunk_nr);
+ return -1;
+ }
+
+ /* early bind */
+ for (i = 1; i < trunk->number_endpoints; ++i) {
+ struct mgcp_endpoint *endp = &trunk->endpoints[i];
+
+ if (cfg->bts_ports.mode == PORT_ALLOC_STATIC) {
+ cfg->last_bts_port += 2;
+ if (mgcp_bind_bts_rtp_port(endp, cfg->last_bts_port) != 0) {
+ LOGP(DMGCP, LOGL_FATAL,
+ "Failed to bind: %d\n", cfg->last_bts_port);
+ return -1;
+ }
+ endp->bts_end.local_alloc = PORT_ALLOC_STATIC;
+ }
+
+ if (cfg->net_ports.mode == PORT_ALLOC_STATIC) {
+ cfg->last_net_port += 2;
+ if (mgcp_bind_net_rtp_port(endp, cfg->last_net_port) != 0) {
+ LOGP(DMGCP, LOGL_FATAL,
+ "Failed to bind: %d\n", cfg->last_net_port);
+ return -1;
+ }
+ endp->net_end.local_alloc = PORT_ALLOC_STATIC;
+ }
+
+ if (trunk->trunk_type == MGCP_TRUNK_VIRTUAL &&
+ cfg->transcoder_ip && cfg->transcoder_ports.mode == PORT_ALLOC_STATIC) {
+ int rtp_port;
+
+ /* network side */
+ rtp_port = rtp_calculate_port(ENDPOINT_NUMBER(endp),
+ cfg->transcoder_ports.base_port);
+ if (mgcp_bind_trans_net_rtp_port(endp, rtp_port) != 0) {
+ LOGP(DMGCP, LOGL_FATAL, "Failed to bind: %d\n", rtp_port);
+ return -1;
+ }
+ endp->trans_net.local_alloc = PORT_ALLOC_STATIC;
+
+ /* bts side */
+ rtp_port = rtp_calculate_port(endp_back_channel(ENDPOINT_NUMBER(endp)),
+ cfg->transcoder_ports.base_port);
+ if (mgcp_bind_trans_bts_rtp_port(endp, rtp_port) != 0) {
+ LOGP(DMGCP, LOGL_FATAL, "Failed to bind: %d\n", rtp_port);
+ return -1;
+ }
+ endp->trans_bts.local_alloc = PORT_ALLOC_STATIC;
+ }
+ }
+
+ return 0;
}
+
+int mgcp_parse_config(const char *config_file, struct mgcp_config *cfg)
+{
+ int rc;
+ struct mgcp_trunk_config *trunk;
+
+ g_cfg = cfg;
+ rc = vty_read_config_file(config_file, NULL);
+ if (rc < 0) {
+ fprintf(stderr, "Failed to parse the config file: '%s'\n", config_file);
+ return rc;
+ }
+
+
+ if (!g_cfg->bts_ip)
+ fprintf(stderr, "No BTS ip address specified. This will allow everyone to connect.\n");
+
+ if (!g_cfg->source_addr) {
+ fprintf(stderr, "You need to specify a bind address.\n");
+ return -1;
+ }
+
+ /* initialize the last ports */
+ g_cfg->last_bts_port = rtp_calculate_port(0, g_cfg->bts_ports.base_port);
+ g_cfg->last_net_port = rtp_calculate_port(0, g_cfg->net_ports.base_port);
+
+ if (allocate_trunk(&g_cfg->trunk) != 0) {
+ LOGP(DMGCP, LOGL_ERROR, "Failed to initialize the virtual trunk.\n");
+ return -1;
+ }
+
+ llist_for_each_entry(trunk, &g_cfg->trunks, entry) {
+ if (allocate_trunk(trunk) != 0) {
+ LOGP(DMGCP, LOGL_ERROR,
+ "Failed to initialize E1 trunk %d.\n", trunk->trunk_nr);
+ return -1;
+ }
+ }
+
+ return 0;
+}
+
diff --git a/src/mgcp_ss7.c b/src/mgcp_ss7.c
index b7429c0..11c1b63 100644
--- a/src/mgcp_ss7.c
+++ b/src/mgcp_ss7.c
@@ -29,7 +29,6 @@
#include <osmocore/talloc.h>
#include <osmocore/timer.h>
-#include <osmocom/vty/command.h>
#include <osmocom/vty/vty.h>
#include <osmocom/vty/telnet_interface.h>
@@ -57,35 +56,17 @@
static char *config_file = "mgcp_mgw.cfg";
static int exit_on_failure = 0;
-static int s_endp_offset = 1;
-#define TO_MGW_PORT(no) (no-s_endp_offset)
-#define FROM_MGW_PORT(no) (no+s_endp_offset)
+extern struct mgcp_config *g_cfg;
-static struct mgcp_ss7 *s_ss7;
-static struct mgcp_config *g_cfg;
-static int s_vad_enabled = 1;
+static void mgcp_ss7_endp_free(struct mgcp_endpoint *endp);
-/* gain settings */
-int s_digital_inp_gain = 31;
-int s_digital_out_gain = 31;
-int s_upstr_agc_enbl = 0;
-int s_upstr_adp_rate = 100;
-int s_upstr_max_gain = 46;
-int s_upstr_target_lvl = 20;
-int s_dwnstr_agc_enbl = 0;
-int s_dwnstr_adp_rate = 100;
-int s_dwnstr_max_gain = 46;
-int s_dwnstr_target_lvl = 20;
-struct mgcp_ss7_endpoint {
- unsigned int port;
- int block;
-};
+#ifndef NO_UNIPORTE
+static void mgcp_ss7_do_exec(struct mgcp_ss7 *mgcp, uint8_t type, struct mgcp_endpoint *, uint32_t param);
-static void mgcp_ss7_endp_free(struct mgcp_ss7* ss7, int endp);
-static void mgcp_ss7_do_exec(struct mgcp_ss7 *mgcp, uint8_t type, uint32_t port, uint32_t param);
-static void mgcp_mgw_vty_init();
+/* Contains a mapping from UniPorte to the MGCP side of things */
+static struct mgcp_endpoint *s_endpoints[240];
static void check_exit(int status)
{
@@ -95,7 +76,7 @@
}
}
-#ifndef NO_UNIPORTE
+
static void Force_Poll( int milliseconds )
{
int timeout = 0;
@@ -163,10 +144,10 @@
char text[128];
ManObjectInfoPtr info;
DataReceiveInfoPtr dataInfo;
+ struct mgcp_endpoint *endp;
int i;
ToneDetectionPtr tones;
-
/* Don't print output when we receive data or complete
* sending data. That would be too verbose.
*/
@@ -181,10 +162,20 @@
puts(text);
/* update the mgcp state */
- int mgcp_endp = FROM_MGW_PORT(port);
- if (s_ss7->mgw_end[mgcp_endp].block != 1)
+ if (port >= ARRAY_SIZE(s_endpoints)) {
+ fprintf(stderr, "The port is bigger than we can manage.\n");
+ return 0;
+ }
+
+ endp = s_endpoints[port];
+ if (!endp) {
+ fprintf(stderr, "Unexpected event on port %d\n", port);
+ return 0;
+ }
+
+ if (endp->block_processing != 1)
fprintf(stderr, "State change on a non blocked port. ERROR.\n");
- s_ss7->mgw_end[mgcp_endp].block = 0;
+ endp->block_processing = 0;
}
}
else if ( event == Event_MANAGED_OBJECT_SET_COMPLETE ) {
@@ -267,8 +258,6 @@
struct mgcp_ss7_cmd *cmd, *tmp;
struct mgcp_ss7 *ss7 = _ss7;
- s_ss7 = ss7;
-
if (initialize_uniporte(ss7) != 0) {
fprintf(stderr, "Failed to create Uniporte.\n");
exit(-1);
@@ -282,10 +271,10 @@
start_over:
/* handle items that are currently blocked */
llist_for_each_entry_safe(cmd, tmp, &blocked, entry) {
- if (ss7->mgw_end[cmd->port].block)
+ if (cmd->endp->block_processing)
continue;
- mgcp_ss7_do_exec(ss7, cmd->type, cmd->port, cmd->param);
+ mgcp_ss7_do_exec(ss7, cmd->type, cmd->endp, cmd->param);
llist_del(&cmd->entry);
free(cmd);
@@ -295,13 +284,13 @@
}
llist_for_each_entry_safe(cmd, tmp, ss7->cmd_queue->main_head, entry) {
- if (ss7->mgw_end[cmd->port].block) {
+ if (cmd->endp->block_processing) {
llist_del(&cmd->entry);
llist_add_tail(&cmd->entry, &blocked);
continue;
}
- mgcp_ss7_do_exec(ss7, cmd->type, cmd->port, cmd->param);
+ mgcp_ss7_do_exec(ss7, cmd->type, cmd->endp, cmd->param);
llist_del(&cmd->entry);
free(cmd);
@@ -315,11 +304,9 @@
return 0;
}
-#endif
static void update_mute_status(int mgw_port, int conn_mode)
{
-#ifndef NO_UNIPORTE
if (conn_mode == MGCP_CONN_NONE) {
MtnSaSetManObject(mgw_port, ChannelType_PORT, ManObj_C_VOICE_UPSTREAM_MUTE, 1, 0);
MtnSaSetManObject(mgw_port, ChannelType_PORT, ManObj_C_VOICE_DOWNSTREAM_MUTE, 1, 0);
@@ -335,137 +322,145 @@
} else {
LOGP(DMGCP, LOGL_ERROR, "Unhandled conn mode: %d\n", conn_mode);
}
-#endif
}
-#ifndef NO_UNIPORTE
-static void allocate_endp(struct mgcp_ss7 *ss7, int endp_no)
+static void allocate_endp(struct mgcp_ss7 *ss7, struct mgcp_endpoint *endp)
{
- int mgw_port;
+ int mgw_port, timeslot, multiplex;
unsigned long mgw_address, loc_address;
- struct mgcp_ss7_endpoint *mgw_endp = &ss7->mgw_end[endp_no];
- struct mgcp_endpoint *mg_endp = &ss7->cfg->endpoints[endp_no];
- mgw_port = TO_MGW_PORT(endp_no);
- mgw_endp->port = MtnSaAllocate(mgw_port);
- if (mgw_endp->port == UINT_MAX) {
- fprintf(stderr, "Failed to allocate the port: %d\n", endp_no);
+ mgcp_endpoint_to_timeslot(ENDPOINT_NUMBER(endp), &multiplex, ×lot);
+ mgw_port = timeslot - endp->tcfg->endp_offset;
+ fprintf(stderr, "TEST: Going to use MGW: %d for MUL: %d TS: %d\n",
+ mgw_port, multiplex, timeslot);
+
+ endp->audio_port = MtnSaAllocate(mgw_port);
+ if (endp->audio_port == UINT_MAX) {
+ fprintf(stderr, "Failed to allocate the port: %d\n", ENDPOINT_NUMBER(endp));
return;
}
+ if (mgw_port != endp->audio_port) {
+ fprintf(stderr, "Oh... a lot of assumptions are now broken %d %d %s:%d\n",
+ mgw_port, endp->audio_port, __func__, __LINE__);
+ }
+
+ s_endpoints[endp->audio_port] = endp;
+
/* Gain settings, apply before switching the port to voice */
MtnSaSetManObject(mgw_port, ChannelType_PORT,
- ManObj_C_VOICE_INPUT_DIGITAL_GAIN, s_digital_inp_gain, 0);
+ ManObj_C_VOICE_INPUT_DIGITAL_GAIN, endp->tcfg->digital_inp_gain, 0);
MtnSaSetManObject(mgw_port, ChannelType_PORT,
- ManObj_C_VOICE_OUTPUT_DIGITAL_GAIN, s_digital_out_gain, 0);
+ ManObj_C_VOICE_OUTPUT_DIGITAL_GAIN, endp->tcfg->digital_out_gain, 0);
MtnSaSetManObject(mgw_port, ChannelType_PORT,
- ManObj_G_US_AGC_ENABLE, s_upstr_agc_enbl, 0);
+ ManObj_G_US_AGC_ENABLE, endp->tcfg->upstr_agc_enbl, 0);
MtnSaSetManObject(mgw_port, ChannelType_PORT,
- ManObj_G_DS_AGC_ENABLE, s_dwnstr_agc_enbl, 0);
+ ManObj_G_DS_AGC_ENABLE, endp->tcfg->dwnstr_agc_enbl, 0);
MtnSaSetManObject(mgw_port, ChannelType_PORT,
- ManObj_G_US_ADAPTATION_RATE, s_upstr_adp_rate, 0);
+ ManObj_G_US_ADAPTATION_RATE, endp->tcfg->upstr_adp_rate, 0);
MtnSaSetManObject(mgw_port, ChannelType_PORT,
- ManObj_G_DS_ADAPTATION_RATE, s_dwnstr_adp_rate, 0);
+ ManObj_G_DS_ADAPTATION_RATE, endp->tcfg->dwnstr_adp_rate, 0);
MtnSaSetManObject(mgw_port, ChannelType_PORT,
- ManObj_G_US_MAX_APPLIED_GAIN, s_upstr_max_gain, 0);
+ ManObj_G_US_MAX_APPLIED_GAIN, endp->tcfg->upstr_max_gain, 0);
MtnSaSetManObject(mgw_port, ChannelType_PORT,
- ManObj_G_DS_MAX_APPLIED_GAIN, s_dwnstr_max_gain, 0);
+ ManObj_G_DS_MAX_APPLIED_GAIN, endp->tcfg->dwnstr_max_gain, 0);
MtnSaSetManObject(mgw_port, ChannelType_PORT,
- ManObj_C_US_TARGET_LEVEL, s_upstr_target_lvl, 0);
+ ManObj_C_US_TARGET_LEVEL, endp->tcfg->upstr_target_lvl, 0);
MtnSaSetManObject(mgw_port, ChannelType_PORT,
- ManObj_C_US_TARGET_LEVEL, s_dwnstr_target_lvl, 0);
+ ManObj_C_US_TARGET_LEVEL, endp->tcfg->dwnstr_target_lvl, 0);
/* Select AMR 5.9, Payload 98, no CRC, hardcoded */
MtnSaApplyProfile(mgw_port, ProfileType_VOICE, 0);
MtnSaSetManObject(mgw_port, ChannelType_PORT,
ManObj_G_DATA_PATH, DataPathT_ETHERNET, 0 );
MtnSaSetManObject(mgw_port, ChannelType_PORT,
- ManObj_C_VOICE_RTP_TELEPHONE_EVENT_PT_TX, ss7->cfg->audio_payload, 0);
+ ManObj_C_VOICE_RTP_TELEPHONE_EVENT_PT_TX,
+ endp->tcfg->audio_payload, 0);
MtnSaSetManObject(mgw_port, ChannelType_PORT,
- ManObj_G_RTP_AMR_PAYLOAD_TYPE, ss7->cfg->audio_payload, 0);
+ ManObj_G_RTP_AMR_PAYLOAD_TYPE,
+ endp->tcfg->audio_payload, 0);
MtnSaSetManObject(mgw_port, ChannelType_PORT,
- ManObj_G_RTP_AMR_PAYLOAD_FORMAT, RtpAmrPayloadFormat_OCTET_ALIGNED, 0);
+ ManObj_G_RTP_AMR_PAYLOAD_FORMAT,
+ RtpAmrPayloadFormat_OCTET_ALIGNED, 0);
MtnSaSetManObject(mgw_port, ChannelType_PORT,
ManObj_G_VOICE_ENCODING, Voice_Encoding_AMR_5_90, 0);
MtnSaSetManObject(mgw_port, ChannelType_PORT,
- ManObj_C_VOICE_VAD_CNG, s_vad_enabled, 0);
+ ManObj_C_VOICE_VAD_CNG, endp->tcfg->vad_enabled, 0);
- update_mute_status(mgw_port, mg_endp->conn_mode);
+ update_mute_status(mgw_port, endp->conn_mode);
/* set the addresses */
SysEthGetHostAddress(ss7->cfg->bts_ip, &mgw_address);
SysEthGetHostAddress(ss7->cfg->local_ip, &loc_address);
MtnSaSetVoIpAddresses(mgw_port,
- mgw_address, mg_endp->rtp_port,
- loc_address, mg_endp->rtp_port);
+ mgw_address, endp->bts_end.local_port,
+ loc_address, endp->bts_end.local_port);
MtnSaConnect(mgw_port, mgw_port);
- mgw_endp->block = 1;
+ endp->block_processing = 1;
}
-#endif
-static void mgcp_ss7_do_exec(struct mgcp_ss7 *mgcp, uint8_t type, uint32_t port, uint32_t param)
+static void mgcp_ss7_do_exec(struct mgcp_ss7 *mgcp, uint8_t type,
+ struct mgcp_endpoint *mgw_endp, uint32_t param)
{
-#ifndef NO_UNIPORTE
- struct mgcp_ss7_endpoint *mgw_endp = &mgcp->mgw_end[port];
int rc;
switch (type) {
case MGCP_SS7_MUTE_STATUS:
- if (mgw_endp->port != UINT_MAX)
- update_mute_status(TO_MGW_PORT(port), param);
+ if (mgw_endp->audio_port != UINT_MAX)
+ update_mute_status(mgw_endp->audio_port, param);
break;
case MGCP_SS7_DELETE:
- if (mgw_endp->port != UINT_MAX) {
- rc = MtnSaDisconnect(mgw_endp->port);
+ if (mgw_endp->audio_port != UINT_MAX) {
+ rc = MtnSaDisconnect(mgw_endp->audio_port);
if (rc != 0)
- fprintf(stderr, "Failed to disconnect port: %u\n", mgw_endp->port);
- rc = MtnSaDeallocate(mgw_endp->port);
+ fprintf(stderr, "Failed to disconnect port: %u\n", mgw_endp->audio_port);
+ rc = MtnSaDeallocate(mgw_endp->audio_port);
if (rc != 0)
- fprintf(stderr, "Failed to deallocate port: %u\n", mgw_endp->port);
- mgw_endp->port = UINT_MAX;
- mgw_endp->block = 1;
+ fprintf(stderr, "Failed to deallocate port: %u\n", mgw_endp->audio_port);
+
+ mgw_endp->audio_port = UINT_MAX;
+ mgw_endp->block_processing = 1;
}
break;
case MGCP_SS7_ALLOCATE:
- allocate_endp(mgcp, port);
- break;
- case MGCP_SS7_SHUTDOWN:
- MtnSaShutdown();
+ allocate_endp(mgcp, mgw_endp);
break;
}
-#endif
}
+#endif
-void mgcp_ss7_exec(struct mgcp_ss7 *mgcp, uint8_t type, uint32_t port, uint32_t param)
+void mgcp_ss7_exec(struct mgcp_endpoint *endp, int type, uint32_t param)
{
+ struct mgcp_ss7 *mgcp;
+
struct mgcp_ss7_cmd *cmd = malloc(sizeof(*cmd));
+ if (!cmd) {
+ LOGP(DMGCP, LOGL_ERROR, "Failed to send a command.\n");
+ return;
+ }
+
memset(cmd, 0, sizeof(*cmd));
cmd->type = type;
- cmd->port = port;
+ cmd->endp = endp;
cmd->param = param;
+ mgcp = endp->tcfg->cfg->data;
thread_safe_add(mgcp->cmd_queue, &cmd->entry);
}
-static int ss7_allocate_endpoint(struct mgcp_ss7 *ss7, int endp_no, struct mgcp_ss7_endpoint *endp)
+static int ss7_allocate_endpoint(struct mgcp_ss7 *ss7, struct mgcp_endpoint *mg_endp)
{
- struct mgcp_endpoint *mg_endp;
+ mg_endp->bts_end.rtp_port = htons(mg_endp->bts_end.local_port);
+ mg_endp->bts_end.rtcp_port = htons(mg_endp->bts_end.local_port + 1);
+ mg_endp->bts_end.addr = ss7->cfg->bts_in;
- mg_endp = &ss7->cfg->endpoints[endp_no];
- mg_endp->bts_rtp = htons(mg_endp->rtp_port);
- mg_endp->bts_rtcp = htons(mg_endp->rtp_port + 1);
- mg_endp->bts = ss7->cfg->bts_in;
-
- mgcp_ss7_exec(ss7, MGCP_SS7_ALLOCATE, endp_no, 0);
+ mgcp_ss7_exec(mg_endp, MGCP_SS7_ALLOCATE, 0);
return MGCP_POLICY_CONT;
}
-static int ss7_modify_endpoint(struct mgcp_ss7 *ss7, int endp_no, struct mgcp_ss7_endpoint *endp)
+static int ss7_modify_endpoint(struct mgcp_ss7 *ss7, struct mgcp_endpoint *mg_endp)
{
- struct mgcp_endpoint *mg_endp;
-
- mg_endp = &ss7->cfg->endpoints[endp_no];
- mgcp_ss7_exec(ss7, MGCP_SS7_MUTE_STATUS, endp_no, mg_endp->conn_mode);
+ mgcp_ss7_exec(mg_endp, MGCP_SS7_MUTE_STATUS, mg_endp->conn_mode);
/*
* Just assume that we have the data now.
@@ -476,32 +471,41 @@
return MGCP_POLICY_CONT;
}
-static int ss7_delete_endpoint(struct mgcp_ss7 *ss7, int endp_no, struct mgcp_ss7_endpoint *endp)
+static int ss7_delete_endpoint(struct mgcp_ss7 *ss7, struct mgcp_endpoint *endp)
{
- mgcp_ss7_endp_free(ss7, endp_no);
+ mgcp_ss7_endp_free(endp);
return MGCP_POLICY_CONT;
}
-static int mgcp_ss7_policy(struct mgcp_config *cfg, int endp_no, int state, const char *trans)
+static int mgcp_ss7_policy(struct mgcp_trunk_config *tcfg, int endp_no, int state, const char *trans)
{
int rc;
+ int multiplex, timeslot;
struct mgcp_ss7 *ss7;
- struct mgcp_ss7_endpoint *endp;
+ struct mgcp_endpoint *endp;
- ss7 = (struct mgcp_ss7 *) cfg->data;
- endp = &ss7->mgw_end[endp_no];
+ mgcp_endpoint_to_timeslot(endp_no, &multiplex, ×lot);
+
+ /* these endpoints are blocked */
+ if (timeslot == 0 || timeslot >= 0x1F) {
+ LOGP(DMGCP, LOGL_NOTICE, "Rejecting non voice timeslots %d\n", timeslot);
+ return MGCP_POLICY_REJECT;
+ }
+
+ endp = &tcfg->endpoints[endp_no];
+ ss7 = (struct mgcp_ss7 *) tcfg->cfg->data;
/* TODO: Make it async and wait for the port to be connected */
rc = MGCP_POLICY_REJECT;
switch (state) {
case MGCP_ENDP_CRCX:
- rc = ss7_allocate_endpoint(ss7, endp_no, endp);
+ rc = ss7_allocate_endpoint(ss7, endp);
break;
case MGCP_ENDP_MDCX:
- rc = ss7_modify_endpoint(ss7, endp_no, endp);
+ rc = ss7_modify_endpoint(ss7, endp);
break;
case MGCP_ENDP_DLCX:
- rc = ss7_delete_endpoint(ss7, endp_no, endp);
+ rc = ss7_delete_endpoint(ss7, endp);
break;
}
@@ -620,9 +624,9 @@
return 0;
}
-static void mgcp_ss7_endp_free(struct mgcp_ss7 *ss7, int endp)
+static void mgcp_ss7_endp_free(struct mgcp_endpoint *endp)
{
- mgcp_ss7_exec(ss7, MGCP_SS7_DELETE, endp, 0);
+ mgcp_ss7_exec(endp, MGCP_SS7_DELETE, 0);
}
static int reset_cb(struct mgcp_config *cfg)
@@ -631,25 +635,15 @@
return 0;
}
-static int realloc_cb(struct mgcp_config *cfg, int endp)
+static int realloc_cb(struct mgcp_trunk_config *tcfg, int endp_no)
{
- mgcp_ss7_endp_free((struct mgcp_ss7 *) cfg->data, endp);
+ struct mgcp_endpoint *endp = &tcfg->endpoints[endp_no];
+ mgcp_ss7_endp_free(endp);
return 0;
}
-static void mgcp_ss7_set_default(struct mgcp_config *cfg)
-{
- /* do not attempt to allocate call ids */
- cfg->early_bind = 1;
-
- talloc_free(cfg->audio_name);
- cfg->audio_payload = 126;
- cfg->audio_name = talloc_strdup(cfg, "AMR/8000");
-}
-
static struct mgcp_ss7 *mgcp_ss7_init(struct mgcp_config *cfg)
{
- int i;
struct mgcp_ss7 *conf = talloc_zero(NULL, struct mgcp_ss7);
if (!conf)
return NULL;
@@ -665,44 +659,13 @@
conf->cfg->realloc_cb = realloc_cb;
conf->cfg->data = conf;
-
- if (mgcp_endpoints_allocate(conf->cfg) != 0) {
- LOGP(DMGCP, LOGL_ERROR, "Failed to allocate endpoints: %d\n",
- cfg->number_endpoints - 1);
- talloc_free(conf);
- return NULL;
- }
-
if (create_socket(conf) != 0) {
LOGP(DMGCP, LOGL_ERROR, "Failed to create socket.\n");
talloc_free(conf);
return NULL;
}
- conf->mgw_end = _talloc_zero_array(conf, sizeof(struct mgcp_ss7_endpoint),
- conf->cfg->number_endpoints, "mgw endpoints");
- if (!conf->mgw_end) {
- LOGP(DMGCP, LOGL_ERROR, "Failed to allocate MGW endpoint array.\n");
- talloc_free(conf);
- return NULL;
- }
-
- for (i = 1; i < conf->cfg->number_endpoints; ++i) {
- struct mgcp_endpoint *endp;
- int rtp_port;
-
- /* initialize the MGW part */
- conf->mgw_end[i].port = UINT_MAX;
-
- /* allocate the ports */
- endp = &conf->cfg->endpoints[i];
- rtp_port = rtp_calculate_port(ENDPOINT_NUMBER(endp), conf->cfg->rtp_base_port);
- if (mgcp_bind_rtp_port(endp, rtp_port) != 0) {
- LOGP(DMGCP, LOGL_ERROR, "Failed to bind: %d\n", rtp_port);
- mgcp_ss7_free(conf);
- return NULL;
- }
- }
+ /* Now do the init of the trunks */
conf->cmd_queue = thread_notifier_alloc();
if (!conf->cmd_queue) {
@@ -719,33 +682,30 @@
return conf;
}
-void mgcp_ss7_free(struct mgcp_ss7 *mgcp)
+static void free_trunk(struct mgcp_trunk_config *trunk)
{
- /* close everything */
- mgcp_ss7_reset(mgcp);
-
- mgcp_ss7_exec(mgcp, MGCP_SS7_SHUTDOWN, 0, 0);
-
- close(mgcp->mgcp_fd.bfd.fd);
- bsc_unregister_fd(&mgcp->mgcp_fd.bfd);
- bsc_del_timer(&mgcp->poll_timer);
- talloc_free(mgcp);
+ int i;
+ for (i = 1; i < trunk->number_endpoints; ++i) {
+ struct mgcp_endpoint *endp = &trunk->endpoints[i];
+ mgcp_ss7_endp_free(endp);
+ mgcp_free_endp(endp);
+ }
}
void mgcp_ss7_reset(struct mgcp_ss7 *mgcp)
{
- int i;
+ struct mgcp_trunk_config *trunk;
if (!mgcp)
return;
LOGP(DMGCP, LOGL_INFO, "Resetting all endpoints.\n");
- /* free UniPorted and MGCP data */
- for (i = 1; i < mgcp->cfg->number_endpoints; ++i) {
- mgcp_ss7_endp_free(mgcp, i);
- mgcp_free_endp(&mgcp->cfg->endpoints[i]);
- }
+ /* free UniPorte and MGCP data */
+ free_trunk(&mgcp->cfg->trunk);
+
+ llist_for_each_entry(trunk, &mgcp->cfg->trunks, entry)
+ free_trunk(trunk);
}
static void print_help()
@@ -827,10 +787,9 @@
return -1;
}
- mgcp_ss7_set_default(g_cfg);
- mgcp_vty_set_config(g_cfg);
- if (vty_read_config_file(config_file, NULL) < 0) {
- fprintf(stderr, "Failed to parse the config file: '%s'\n", config_file);
+ if (mgcp_parse_config(config_file, g_cfg) != 0) {
+ LOGP(DMGCP, LOGL_ERROR,
+ "Failed to parse the config file: '%s'\n", config_file);
return -1;
}
@@ -838,9 +797,8 @@
if (rc < 0)
return rc;
- printf("Creating MGCP MGW with endpoints: %d ip: %s mgw: %s rtp-base: %d payload: %d\n",
- g_cfg->number_endpoints - 1, g_cfg->local_ip, g_cfg->bts_ip,
- g_cfg->rtp_base_port, g_cfg->audio_payload);
+ printf("Creating MGCP MGW ip: %s mgw: %s\n",
+ g_cfg->local_ip, g_cfg->bts_ip);
mgcp = mgcp_ss7_init(g_cfg);
if (!mgcp) {
@@ -853,171 +811,3 @@
return 0;
}
-static struct vty_app_info vty_info = {
- .name = "mgcp_ss7",
- .version = "0.0.1",
- .go_parent_cb = NULL,
-};
-
-void logging_vty_add_cmds(void);
-
-DEFUN(cfg_mgcp_vad, cfg_mgcp_vad_cmd,
- "vad (enabled|disabled)",
- "Enable the Voice Activity Detection\n"
- "Enable\n" "Disable\n")
-{
- if (argv[0][0] == 'e')
- s_vad_enabled = 1;
- else
- s_vad_enabled = 0;
- return CMD_SUCCESS;
-}
-
-DEFUN(cfg_mgcp_realloc, cfg_mgcp_realloc_cmd,
- "force-realloc (0|1)",
- "Force the reallocation of an endpoint\n"
- "Disable\n" "Enable\n")
-{
- g_cfg->force_realloc = atoi(argv[0]);
- return CMD_SUCCESS;
-}
-
-DEFUN(cfg_mgcp_inp_dig_gain, cfg_mgcp_inp_dig_gain_cmd,
- "input-digital-gain <0-62>",
- "Static Digital Input Gain\n"
- "Gain value")
-{
- s_digital_inp_gain = atoi(argv[0]);
- return CMD_SUCCESS;
-}
-
-DEFUN(cfg_mgcp_out_dig_gain, cfg_mgcp_out_dig_gain_cmd,
- "outut-digital-gain <0-62>",
- "Static Digital Output Gain\n"
- "Gain value")
-{
- s_digital_out_gain = atoi(argv[0]);
- return CMD_SUCCESS;
-}
-
-DEFUN(cfg_mgcp_upstr_agc, cfg_mgcp_upstr_agc_cmd,
- "upstream-automatic-gain (0|1)",
- "Enable automatic gain control on upstream\n"
- "Disable\n" "Enabled\n")
-{
- s_upstr_agc_enbl = argv[0][0] == '1';
- return CMD_SUCCESS;
-}
-
-DEFUN(cfg_mgc_upstr_adp, cfg_mgcp_upstr_adp_cmd,
- "upstream-adaptiton-rate <1-128>",
- "Set the adaption rate in (dB/sec) * 10\n"
- "Range\n")
-{
- s_upstr_adp_rate = atoi(argv[0]);
- return CMD_SUCCESS;
-}
-
-DEFUN(cfg_mgcp_upstr_max_gain, cfg_mgcp_upstr_max_gain_cmd,
- "upstream-max-applied-gain <0-49>",
- "Maximum applied gain from -31db to 18db\n"
- "Gain level\n")
-{
- s_upstr_max_gain = atoi(argv[0]);
- return CMD_SUCCESS;
-}
-
-DEFUN(cfg_mgcp_upstr_target, cfg_mgcp_upstr_target_cmd,
- "upstream-target-level <6-37>",
- "Set the desired level in db\n"
- "Desired lievel\n")
-{
- s_upstr_target_lvl = atoi(argv[0]);
- return CMD_SUCCESS;
-}
-
-DEFUN(cfg_mgcp_dwnstr_agc, cfg_mgcp_dwnstr_agc_cmd,
- "downstream-automatic-gain (0|1)",
- "Enable automatic gain control on downstream\n"
- "Disable\n" "Enabled\n")
-{
- s_dwnstr_agc_enbl = argv[0][0] == '1';
- return CMD_SUCCESS;
-}
-
-DEFUN(cfg_mgc_dwnstr_adp, cfg_mgcp_dwnstr_adp_cmd,
- "downstream-adaptation-rate <1-128>",
- "Set the adaption rate in (dB/sec) * 10\n"
- "Range\n")
-{
- s_dwnstr_adp_rate = atoi(argv[0]);
- return CMD_SUCCESS;
-}
-
-DEFUN(cfg_mgcp_dwnstr_max_gain, cfg_mgcp_dwnstr_max_gain_cmd,
- "downstream-max-applied-gain <0-49>",
- "Maximum applied gain from -31db to 18db\n"
- "Gain level\n")
-{
- s_dwnstr_max_gain = atoi(argv[0]);
- return CMD_SUCCESS;
-}
-
-DEFUN(cfg_mgcp_dwnstr_target, cfg_mgcp_dwnstr_target_cmd,
- "downstream-target-level <6-37>",
- "Set the desired level in db\n"
- "Desired lievel\n")
-{
- s_dwnstr_target_lvl = atoi(argv[0]);
- return CMD_SUCCESS;
-}
-
-DEFUN(endpoint_offset, endpoint_offset_cmd,
- "endpoint-offset <-60-60>",
- "Offset to the CIC map\n" "Value to set\n")
-{
- s_endp_offset = atoi(argv[0]);
- return CMD_SUCCESS;
-}
-
-void mgcp_write_extra(struct vty *vty)
-{
- vty_out(vty, " force-realloc %d%s", g_cfg->force_realloc, VTY_NEWLINE);
- vty_out(vty, " vad %s%s", s_vad_enabled ? "enabled" : "disabled", VTY_NEWLINE);
- vty_out(vty, " input-digital-gain %d%s", s_digital_inp_gain, VTY_NEWLINE);
- vty_out(vty, " output-digital-gain %d%s", s_digital_out_gain, VTY_NEWLINE);
- vty_out(vty, " upstream-automatic-gain %d%s", s_upstr_agc_enbl, VTY_NEWLINE);
- vty_out(vty, " upstream-adaptation-rate %d%s", s_upstr_adp_rate, VTY_NEWLINE);
- vty_out(vty, " upstream-max-applied-gain %d%s", s_upstr_max_gain, VTY_NEWLINE);
- vty_out(vty, " upstream-target-level %d%s", s_upstr_target_lvl, VTY_NEWLINE);
- vty_out(vty, " downstream-automatic-gain %d%s", s_dwnstr_agc_enbl, VTY_NEWLINE);
- vty_out(vty, " downstream-adaptation-rate %d%s", s_dwnstr_adp_rate, VTY_NEWLINE);
- vty_out(vty, " downstream-max-applied-gain %d%s", s_dwnstr_max_gain, VTY_NEWLINE);
- vty_out(vty, " downstream-target-level %d%s", s_dwnstr_target_lvl, VTY_NEWLINE);
- vty_out(vty, " endpoint-offset %d%s", s_endp_offset, VTY_NEWLINE);
-}
-
-static void mgcp_mgw_vty_init(void)
-{
- cmd_init(1);
- vty_init(&vty_info);
- logging_vty_add_cmds();
- mgcp_vty_init();
-
- install_element(MGCP_NODE, &cfg_mgcp_vad_cmd);
- install_element(MGCP_NODE, &cfg_mgcp_realloc_cmd);
- install_element(MGCP_NODE, &cfg_mgcp_inp_dig_gain_cmd);
- install_element(MGCP_NODE, &cfg_mgcp_out_dig_gain_cmd);
- install_element(MGCP_NODE, &cfg_mgcp_upstr_agc_cmd);
- install_element(MGCP_NODE, &cfg_mgcp_upstr_adp_cmd);
- install_element(MGCP_NODE, &cfg_mgcp_upstr_max_gain_cmd);
- install_element(MGCP_NODE, &cfg_mgcp_upstr_target_cmd);
- install_element(MGCP_NODE, &cfg_mgcp_dwnstr_agc_cmd);
- install_element(MGCP_NODE, &cfg_mgcp_dwnstr_adp_cmd);
- install_element(MGCP_NODE, &cfg_mgcp_dwnstr_max_gain_cmd);
- install_element(MGCP_NODE, &cfg_mgcp_dwnstr_target_cmd);
- install_element(MGCP_NODE, &endpoint_offset_cmd);
-}
-
-
-const char *openbsc_copyright = "";
diff --git a/src/mgcp_ss7_vty.c b/src/mgcp_ss7_vty.c
new file mode 100644
index 0000000..a2c4c3f
--- /dev/null
+++ b/src/mgcp_ss7_vty.c
@@ -0,0 +1,423 @@
+/* Extra vty handling for the SS7 code */
+/*
+ * (C) 2010-2011 by Holger Hans Peter Freyther <zecke@selfish.org>
+ * (C) 2010-2011 by On-Waves
+ * All Rights Reserved
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <mgcp_ss7.h>
+#include <ss7_vty.h>
+
+#include <mgcp/mgcp.h>
+
+#include <stdlib.h>
+
+extern struct mgcp_config *g_cfg;
+
+static struct vty_app_info vty_info = {
+ .name = "mgcp_ss7",
+ .version = "0.0.1",
+ .go_parent_cb = NULL,
+};
+
+void logging_vty_add_cmds(void);
+
+DEFUN(cfg_mgcp_configure, cfg_mgcp_configure_cmd,
+ "configure-trunks (0|1)",
+ "Reconfigure the Trunk Configuration\n" "Reconfigure\n" "Keep\n")
+{
+ g_cfg->configure_trunks = atoi(argv[0]);
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_mgcp_vad, cfg_mgcp_vad_cmd,
+ "vad (enabled|disabled)",
+ "Enable the Voice Activity Detection\n"
+ "Enable\n" "Disable\n")
+{
+ if (argv[0][0] == 'e')
+ g_cfg->trunk.vad_enabled = 1;
+ else
+ g_cfg->trunk.vad_enabled = 0;
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_mgcp_realloc, cfg_mgcp_realloc_cmd,
+ "force-realloc (0|1)",
+ "Force the reallocation of an endpoint\n"
+ "Disable\n" "Enable\n")
+{
+ g_cfg->trunk.force_realloc = atoi(argv[0]);
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_mgcp_inp_dig_gain, cfg_mgcp_inp_dig_gain_cmd,
+ "input-digital-gain <0-62>",
+ "Static Digital Input Gain\n"
+ "Gain value")
+{
+ g_cfg->trunk.digital_inp_gain = atoi(argv[0]);
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_mgcp_out_dig_gain, cfg_mgcp_out_dig_gain_cmd,
+ "outut-digital-gain <0-62>",
+ "Static Digital Output Gain\n"
+ "Gain value")
+{
+ g_cfg->trunk.digital_out_gain = atoi(argv[0]);
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_mgcp_upstr_agc, cfg_mgcp_upstr_agc_cmd,
+ "upstream-automatic-gain (0|1)",
+ "Enable automatic gain control on upstream\n"
+ "Disable\n" "Enabled\n")
+{
+ g_cfg->trunk.upstr_agc_enbl = argv[0][0] == '1';
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_mgc_upstr_adp, cfg_mgcp_upstr_adp_cmd,
+ "upstream-adaptiton-rate <1-128>",
+ "Set the adaption rate in (dB/sec) * 10\n"
+ "Range\n")
+{
+ g_cfg->trunk.upstr_adp_rate = atoi(argv[0]);
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_mgcp_upstr_max_gain, cfg_mgcp_upstr_max_gain_cmd,
+ "upstream-max-applied-gain <0-49>",
+ "Maximum applied gain from -31db to 18db\n"
+ "Gain level\n")
+{
+ g_cfg->trunk.upstr_max_gain = atoi(argv[0]);
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_mgcp_upstr_target, cfg_mgcp_upstr_target_cmd,
+ "upstream-target-level <6-37>",
+ "Set the desired level in db\n"
+ "Desired lievel\n")
+{
+ g_cfg->trunk.upstr_target_lvl = atoi(argv[0]);
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_mgcp_dwnstr_agc, cfg_mgcp_dwnstr_agc_cmd,
+ "downstream-automatic-gain (0|1)",
+ "Enable automatic gain control on downstream\n"
+ "Disable\n" "Enabled\n")
+{
+ g_cfg->trunk.dwnstr_agc_enbl = argv[0][0] == '1';
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_mgc_dwnstr_adp, cfg_mgcp_dwnstr_adp_cmd,
+ "downstream-adaptation-rate <1-128>",
+ "Set the adaption rate in (dB/sec) * 10\n"
+ "Range\n")
+{
+ g_cfg->trunk.dwnstr_adp_rate = atoi(argv[0]);
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_mgcp_dwnstr_max_gain, cfg_mgcp_dwnstr_max_gain_cmd,
+ "downstream-max-applied-gain <0-49>",
+ "Maximum applied gain from -31db to 18db\n"
+ "Gain level\n")
+{
+ g_cfg->trunk.dwnstr_max_gain = atoi(argv[0]);
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_mgcp_dwnstr_target, cfg_mgcp_dwnstr_target_cmd,
+ "downstream-target-level <6-37>",
+ "Set the desired level in db\n"
+ "Desired lievel\n")
+{
+ g_cfg->trunk.dwnstr_target_lvl = atoi(argv[0]);
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_mgcp_endp_offset, cfg_mgcp_endp_offset_cmd,
+ "endpoint-offset <-60-60>",
+ "Offset to the CIC map\n" "Value to set\n")
+{
+ g_cfg->trunk.endp_offset = atoi(argv[0]);
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_mgcp_target_trunk, cfg_mgcp_target_trunk_cmd,
+ "target-trunk-start <1-24>",
+ "Map the virtual trunk to start here\n" "Trunk Nr\n")
+{
+ g_cfg->trunk.target_trunk_start = atoi(argv[0]);
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_trunk_vad, cfg_trunk_vad_cmd,
+ "vad (enabled|disabled)",
+ "Enable the Voice Activity Detection\n"
+ "Enable\n" "Disable\n")
+{
+ struct mgcp_trunk_config *trunk = vty->index;
+
+ if (argv[0][0] == 'e')
+ trunk->vad_enabled = 1;
+ else
+ trunk->vad_enabled = 0;
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_trunk_realloc, cfg_trunk_realloc_cmd,
+ "force-realloc (0|1)",
+ "Force the reallocation of an endpoint\n"
+ "Disable\n" "Enable\n")
+{
+ struct mgcp_trunk_config *trunk = vty->index;
+
+ trunk->force_realloc = atoi(argv[0]);
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_trunk_inp_dig_gain, cfg_trunk_inp_dig_gain_cmd,
+ "input-digital-gain <0-62>",
+ "Static Digital Input Gain\n"
+ "Gain value")
+{
+ struct mgcp_trunk_config *trunk = vty->index;
+
+ trunk->digital_inp_gain = atoi(argv[0]);
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_trunk_out_dig_gain, cfg_trunk_out_dig_gain_cmd,
+ "outut-digital-gain <0-62>",
+ "Static Digital Output Gain\n"
+ "Gain value")
+{
+ struct mgcp_trunk_config *trunk = vty->index;
+
+ trunk->digital_out_gain = atoi(argv[0]);
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_trunk_upstr_agc, cfg_trunk_upstr_agc_cmd,
+ "upstream-automatic-gain (0|1)",
+ "Enable automatic gain control on upstream\n"
+ "Disable\n" "Enabled\n")
+{
+ struct mgcp_trunk_config *trunk = vty->index;
+
+ trunk->upstr_agc_enbl = argv[0][0] == '1';
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_trunk_upstr_adp, cfg_trunk_upstr_adp_cmd,
+ "upstream-adaptiton-rate <1-128>",
+ "Set the adaption rate in (dB/sec) * 10\n"
+ "Range\n")
+{
+ struct mgcp_trunk_config *trunk = vty->index;
+
+ trunk->upstr_adp_rate = atoi(argv[0]);
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_trunk_upstr_max_gain, cfg_trunk_upstr_max_gain_cmd,
+ "upstream-max-applied-gain <0-49>",
+ "Maximum applied gain from -31db to 18db\n"
+ "Gain level\n")
+{
+ struct mgcp_trunk_config *trunk = vty->index;
+
+ trunk->upstr_max_gain = atoi(argv[0]);
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_trunk_upstr_target, cfg_trunk_upstr_target_cmd,
+ "upstream-target-level <6-37>",
+ "Set the desired level in db\n"
+ "Desired lievel\n")
+{
+ struct mgcp_trunk_config *trunk = vty->index;
+
+ trunk->upstr_target_lvl = atoi(argv[0]);
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_trunk_dwnstr_agc, cfg_trunk_dwnstr_agc_cmd,
+ "downstream-automatic-gain (0|1)",
+ "Enable automatic gain control on downstream\n"
+ "Disable\n" "Enabled\n")
+{
+ struct mgcp_trunk_config *trunk = vty->index;
+
+ trunk->dwnstr_agc_enbl = argv[0][0] == '1';
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_trunk_dwnstr_adp, cfg_trunk_dwnstr_adp_cmd,
+ "downstream-adaptation-rate <1-128>",
+ "Set the adaption rate in (dB/sec) * 10\n"
+ "Range\n")
+{
+ struct mgcp_trunk_config *trunk = vty->index;
+
+ trunk->dwnstr_adp_rate = atoi(argv[0]);
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_trunk_dwnstr_max_gain, cfg_trunk_dwnstr_max_gain_cmd,
+ "downstream-max-applied-gain <0-49>",
+ "Maximum applied gain from -31db to 18db\n"
+ "Gain level\n")
+{
+ struct mgcp_trunk_config *trunk = vty->index;
+
+ trunk->dwnstr_max_gain = atoi(argv[0]);
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_trunk_dwnstr_target, cfg_trunk_dwnstr_target_cmd,
+ "downstream-target-level <6-37>",
+ "Set the desired level in db\n"
+ "Desired lievel\n")
+{
+ struct mgcp_trunk_config *trunk = vty->index;
+
+ trunk->dwnstr_target_lvl = atoi(argv[0]);
+ return CMD_SUCCESS;
+}
+
+DEFUN(cfg_trunk_endp_offset, cfg_trunk_endp_offset_cmd,
+ "endpoint-offset <-60-60>",
+ "Offset to the CIC map\n" "Value to set\n")
+{
+ struct mgcp_trunk_config *trunk = vty->index;
+
+ trunk->endp_offset = atoi(argv[0]);
+ return CMD_SUCCESS;
+}
+
+void mgcp_write_extra(struct vty *vty, struct mgcp_config *cfg)
+{
+ vty_out(vty, " configure-trunks %d%s",
+ cfg->configure_trunks, VTY_NEWLINE);
+ vty_out(vty, " force-realloc %d%s",
+ cfg->trunk.force_realloc, VTY_NEWLINE);
+ vty_out(vty, " vad %s%s",
+ cfg->trunk.vad_enabled ? "enabled" : "disabled", VTY_NEWLINE);
+ vty_out(vty, " input-digital-gain %d%s",
+ cfg->trunk.digital_inp_gain, VTY_NEWLINE);
+ vty_out(vty, " output-digital-gain %d%s",
+ cfg->trunk.digital_out_gain, VTY_NEWLINE);
+ vty_out(vty, " upstream-automatic-gain %d%s",
+ cfg->trunk.upstr_agc_enbl, VTY_NEWLINE);
+ vty_out(vty, " upstream-adaptation-rate %d%s",
+ cfg->trunk.upstr_adp_rate, VTY_NEWLINE);
+ vty_out(vty, " upstream-max-applied-gain %d%s",
+ cfg->trunk.upstr_max_gain, VTY_NEWLINE);
+ vty_out(vty, " upstream-target-level %d%s",
+ cfg->trunk.upstr_target_lvl, VTY_NEWLINE);
+ vty_out(vty, " downstream-automatic-gain %d%s",
+ cfg->trunk.dwnstr_agc_enbl, VTY_NEWLINE);
+ vty_out(vty, " downstream-adaptation-rate %d%s",
+ cfg->trunk.dwnstr_adp_rate, VTY_NEWLINE);
+ vty_out(vty, " downstream-max-applied-gain %d%s",
+ cfg->trunk.dwnstr_max_gain, VTY_NEWLINE);
+ vty_out(vty, " downstream-target-level %d%s",
+ cfg->trunk.dwnstr_target_lvl, VTY_NEWLINE);
+ vty_out(vty, " endpoint-offset %d%s",
+ cfg->trunk.endp_offset, VTY_NEWLINE);
+ vty_out(vty, " target-trunk-start %d%s",
+ cfg->trunk.target_trunk_start, VTY_NEWLINE);
+}
+
+void mgcp_write_trunk_extra(struct vty *vty, struct mgcp_trunk_config *trunk)
+{
+ vty_out(vty, " force-realloc %d%s",
+ trunk->force_realloc, VTY_NEWLINE);
+ vty_out(vty, " vad %s%s",
+ trunk->vad_enabled ? "enabled" : "disabled", VTY_NEWLINE);
+ vty_out(vty, " input-digital-gain %d%s",
+ trunk->digital_inp_gain, VTY_NEWLINE);
+ vty_out(vty, " output-digital-gain %d%s",
+ trunk->digital_out_gain, VTY_NEWLINE);
+ vty_out(vty, " upstream-automatic-gain %d%s",
+ trunk->upstr_agc_enbl, VTY_NEWLINE);
+ vty_out(vty, " upstream-adaptation-rate %d%s",
+ trunk->upstr_adp_rate, VTY_NEWLINE);
+ vty_out(vty, " upstream-max-applied-gain %d%s",
+ trunk->upstr_max_gain, VTY_NEWLINE);
+ vty_out(vty, " upstream-target-level %d%s",
+ trunk->upstr_target_lvl, VTY_NEWLINE);
+ vty_out(vty, " downstream-automatic-gain %d%s",
+ trunk->dwnstr_agc_enbl, VTY_NEWLINE);
+ vty_out(vty, " downstream-adaptation-rate %d%s",
+ trunk->dwnstr_adp_rate, VTY_NEWLINE);
+ vty_out(vty, " downstream-max-applied-gain %d%s",
+ trunk->dwnstr_max_gain, VTY_NEWLINE);
+ vty_out(vty, " downstream-target-level %d%s",
+ trunk->dwnstr_target_lvl, VTY_NEWLINE);
+ vty_out(vty, " endpoint-offset %d%s",
+ trunk->endp_offset, VTY_NEWLINE);
+}
+
+
+void mgcp_mgw_vty_init(void)
+{
+ cmd_init(1);
+ vty_init(&vty_info);
+ logging_vty_add_cmds();
+ mgcp_vty_init();
+
+ install_element(MGCP_NODE, &cfg_mgcp_configure_cmd);
+ install_element(MGCP_NODE, &cfg_mgcp_vad_cmd);
+ install_element(MGCP_NODE, &cfg_mgcp_realloc_cmd);
+ install_element(MGCP_NODE, &cfg_mgcp_inp_dig_gain_cmd);
+ install_element(MGCP_NODE, &cfg_mgcp_out_dig_gain_cmd);
+ install_element(MGCP_NODE, &cfg_mgcp_upstr_agc_cmd);
+ install_element(MGCP_NODE, &cfg_mgcp_upstr_adp_cmd);
+ install_element(MGCP_NODE, &cfg_mgcp_upstr_max_gain_cmd);
+ install_element(MGCP_NODE, &cfg_mgcp_upstr_target_cmd);
+ install_element(MGCP_NODE, &cfg_mgcp_dwnstr_agc_cmd);
+ install_element(MGCP_NODE, &cfg_mgcp_dwnstr_adp_cmd);
+ install_element(MGCP_NODE, &cfg_mgcp_dwnstr_max_gain_cmd);
+ install_element(MGCP_NODE, &cfg_mgcp_dwnstr_target_cmd);
+ install_element(MGCP_NODE, &cfg_mgcp_endp_offset_cmd);
+ install_element(MGCP_NODE, &cfg_mgcp_target_trunk_cmd);
+
+ install_element(TRUNK_NODE, &cfg_trunk_vad_cmd);
+ install_element(TRUNK_NODE, &cfg_trunk_realloc_cmd);
+ install_element(TRUNK_NODE, &cfg_trunk_inp_dig_gain_cmd);
+ install_element(TRUNK_NODE, &cfg_trunk_out_dig_gain_cmd);
+ install_element(TRUNK_NODE, &cfg_trunk_upstr_agc_cmd);
+ install_element(TRUNK_NODE, &cfg_trunk_upstr_adp_cmd);
+ install_element(TRUNK_NODE, &cfg_trunk_upstr_max_gain_cmd);
+ install_element(TRUNK_NODE, &cfg_trunk_upstr_target_cmd);
+ install_element(TRUNK_NODE, &cfg_trunk_dwnstr_agc_cmd);
+ install_element(TRUNK_NODE, &cfg_trunk_dwnstr_adp_cmd);
+ install_element(TRUNK_NODE, &cfg_trunk_dwnstr_max_gain_cmd);
+ install_element(TRUNK_NODE, &cfg_trunk_dwnstr_target_cmd);
+ install_element(TRUNK_NODE, &cfg_trunk_endp_offset_cmd);
+}
+
+
+const char *openbsc_copyright = "";