static void
sockaddr_to_host_port(pj_pool_t* pool,
pjsip_host_port* host_port,
const pj_sockaddr* addr)
{
host_port->host.ptr = (char*) pj_pool_alloc(pool, PJ_INET6_ADDRSTRLEN+4);
pj_sockaddr_print(addr, host_port->host.ptr, PJ_INET6_ADDRSTRLEN+4, 0);
host_port->host.slen = pj_ansi_strlen(host_port->host.ptr);
host_port->port = pj_sockaddr_get_port(addr);
}
/*!
* \internal
* \brief Converts a pjsip_rx_data structure to an ast_msg structure.
*
* \details Attempts to fill in as much information as possible into the given
* msg structure copied from the given request data.
*
* \param rdata The SIP request
* \param msg The asterisk message structure to fill in.
*/
static enum pjsip_status_code rx_data_to_ast_msg(pjsip_rx_data *rdata, struct ast_msg *msg)
{
#define CHECK_RES(z_) do { if (z_) { ast_msg_destroy(msg); \
return PJSIP_SC_INTERNAL_SERVER_ERROR; } } while (0)
int size;
char buf[MAX_BODY_SIZE];
pjsip_name_addr *name_addr;
const char *field;
pjsip_status_code code;
struct ast_sip_endpoint *endpt = ast_pjsip_rdata_get_endpoint(rdata);
const char *context = S_OR(endpt->message_context, endpt->context);
/* make sure there is an appropriate context and extension*/
if ((code = get_destination(rdata, context, buf)) != PJSIP_SC_OK) {
return code;
}
CHECK_RES(ast_msg_set_context(msg, "%s", context));
CHECK_RES(ast_msg_set_exten(msg, "%s", buf));
/* to header */
name_addr = (pjsip_name_addr *)rdata->msg_info.to->uri;
if ((size = pjsip_uri_print(PJSIP_URI_IN_FROMTO_HDR, name_addr, buf, sizeof(buf)-1)) > 0) {
buf[size] = '\0';
/* prepend the tech */
CHECK_RES(ast_msg_set_to(msg, "%s", sip_to_pjsip(buf, ++size, sizeof(buf)-1)));
}
/* from header */
name_addr = (pjsip_name_addr *)rdata->msg_info.from->uri;
if ((size = pjsip_uri_print(PJSIP_URI_IN_FROMTO_HDR, name_addr, buf, sizeof(buf)-1)) > 0) {
buf[size] = '\0';
CHECK_RES(ast_msg_set_from(msg, "%s", buf));
}
/* receive address */
field = pj_sockaddr_print(&rdata->pkt_info.src_addr, buf, sizeof(buf)-1, 1);
CHECK_RES(ast_msg_set_var(msg, "PJSIP_RECVADDR", field));
/* body */
if (print_body(rdata, buf, sizeof(buf) - 1) > 0) {
CHECK_RES(ast_msg_set_body(msg, "%s", buf));
}
/* endpoint name */
if (endpt->id.self.name.valid) {
CHECK_RES(ast_msg_set_var(msg, "PJSIP_PEERNAME", endpt->id.self.name.str));
}
CHECK_RES(headers_to_vars(rdata, msg));
return PJSIP_SC_OK;
}
/* Create SDP candidate attribute */
static int print_sdp_cand_attr(char *buffer, int max_len,
const pj_ice_sess_cand *cand)
{
char ipaddr[PJ_INET6_ADDRSTRLEN+2];
int len, len2;
len = pj_ansi_snprintf( buffer, max_len,
"%.*s %u UDP %u %s %u typ ",
(int)cand->foundation.slen,
cand->foundation.ptr,
(unsigned)cand->comp_id,
cand->prio,
pj_sockaddr_print(&cand->addr, ipaddr,
sizeof(ipaddr), 0),
(unsigned)pj_sockaddr_get_port(&cand->addr));
if (len < 1 || len >= max_len)
return -1;
switch (cand->type) {
case PJ_ICE_CAND_TYPE_HOST:
len2 = pj_ansi_snprintf(buffer+len, max_len-len, "host");
break;
case PJ_ICE_CAND_TYPE_SRFLX:
case PJ_ICE_CAND_TYPE_RELAYED:
case PJ_ICE_CAND_TYPE_PRFLX:
len2 = pj_ansi_snprintf(buffer+len, max_len-len,
"%s raddr %s rport %d",
pj_ice_get_cand_type_name(cand->type),
pj_sockaddr_print(&cand->rel_addr, ipaddr,
sizeof(ipaddr), 0),
(int)pj_sockaddr_get_port(&cand->rel_addr));
break;
default:
pj_assert(!"Invalid candidate type");
len2 = -1;
break;
}
if (len2 < 1 || len2 >= max_len)
return -1;
return len+len2;
}
static void menu(void)
{
pj_turn_session_info info;
char client_state[20], relay_addr[80], peer0_addr[80], peer1_addr[80];
if (g.relay) {
pj_turn_sock_get_info(g.relay, &info);
strcpy(client_state, pj_turn_state_name(info.state));
if (info.state >= PJ_TURN_STATE_READY)
pj_sockaddr_print(&info.relay_addr, relay_addr, sizeof(relay_addr), 3);
else
strcpy(relay_addr, "0.0.0.0:0");
} else {
strcpy(client_state, "NULL");
strcpy(relay_addr, "0.0.0.0:0");
}
pj_sockaddr_print(&g.peer[0].mapped_addr, peer0_addr, sizeof(peer0_addr), 3);
pj_sockaddr_print(&g.peer[1].mapped_addr, peer1_addr, sizeof(peer1_addr), 3);
puts("\n");
puts("+=====================================================================+");
puts("| CLIENT | PEER-0 |");
puts("| | |");
printf("| State : %-12s | Address: %-21s |\n",
client_state, peer0_addr);
printf("| Relay addr: %-21s | |\n",
relay_addr);
puts("| | 0 Send data to relay address |");
puts("| a Allocate relay | |");
puts("| p,pp Set permission for peer 0/1 +--------------------------------+");
puts("| s,ss Send data to peer 0/1 | PEER-1 |");
puts("| b,bb BindChannel to peer 0/1 | |");
printf("| x Delete allocation | Address: %-21s |\n",
peer1_addr);
puts("+------------------------------------+ |");
puts("| q Quit d Dump | 1 Send data to relay adderss |");
puts("+------------------------------------+--------------------------------+");
printf(">>> ");
fflush(stdout);
}
static pj_status_t logging_on_tx_msg(pjsip_tx_data *tdata)
{
char local_buf[256];
char remote_buf[256];
char *uuid;
struct hepv3_capture_info *capture_info;
pjsip_cid_hdr *cid_hdr;
pjsip_from_hdr *from_hdr;
pjsip_to_hdr *to_hdr;
capture_info = hepv3_create_capture_info(tdata->buf.start, (size_t)(tdata->buf.cur - tdata->buf.start));
if (!capture_info) {
return PJ_SUCCESS;
}
pj_sockaddr_print(&tdata->tp_info.transport->local_addr, local_buf, sizeof(local_buf), 3);
pj_sockaddr_print(&tdata->tp_info.dst_addr, remote_buf, sizeof(remote_buf), 3);
cid_hdr = PJSIP_MSG_CID_HDR(tdata->msg);
from_hdr = PJSIP_MSG_FROM_HDR(tdata->msg);
to_hdr = PJSIP_MSG_TO_HDR(tdata->msg);
uuid = assign_uuid(&cid_hdr->id, &to_hdr->tag, &from_hdr->tag);
if (!uuid) {
ao2_ref(capture_info, -1);
return PJ_SUCCESS;
}
ast_sockaddr_parse(&capture_info->src_addr, local_buf, PARSE_PORT_REQUIRE);
ast_sockaddr_parse(&capture_info->dst_addr, remote_buf, PARSE_PORT_REQUIRE);
capture_info->capture_time = ast_tvnow();
capture_info->capture_type = HEPV3_CAPTURE_TYPE_SIP;
capture_info->uuid = uuid;
capture_info->zipped = 0;
hepv3_send_packet(capture_info);
return PJ_SUCCESS;
}
static void dump_status(pj_turn_srv *srv)
{
char addr[80];
pj_hash_iterator_t itbuf, *it;
pj_time_val now;
unsigned i;
for (i=0; i<srv->core.lis_cnt; ++i) {
pj_turn_listener *lis = srv->core.listener[i];
printf("Server address : %s\n", lis->info);
}
printf("Worker threads : %d\n", srv->core.thread_cnt);
printf("Total mem usage: %u.%03uMB\n", (unsigned)(g_cp.used_size / 1000000),
(unsigned)((g_cp.used_size % 1000000)/1000));
printf("UDP port range : %u %u %u (next/min/max)\n", srv->ports.next_udp,
srv->ports.min_udp, srv->ports.max_udp);
printf("TCP port range : %u %u %u (next/min/max)\n", srv->ports.next_tcp,
srv->ports.min_tcp, srv->ports.max_tcp);
printf("Clients # : %u\n", pj_hash_count(srv->tables.alloc));
puts("");
if (pj_hash_count(srv->tables.alloc)==0) {
return;
}
puts("# Client addr. Alloc addr. Username Lftm Expy #prm #chl");
puts("------------------------------------------------------------------------------");
pj_gettimeofday(&now);
it = pj_hash_first(srv->tables.alloc, &itbuf);
i=1;
while (it) {
pj_turn_allocation *alloc = (pj_turn_allocation*)
pj_hash_this(srv->tables.alloc, it);
printf("%-3d %-22s %-22s %-8.*s %-4d %-4ld %-4d %-4d\n",
i,
alloc->info,
pj_sockaddr_print(&alloc->relay.hkey.addr, addr, sizeof(addr), 3),
(int)alloc->cred.data.static_cred.username.slen,
alloc->cred.data.static_cred.username.ptr,
alloc->relay.lifetime,
alloc->relay.expiry.sec - now.sec,
pj_hash_count(alloc->peer_table),
pj_hash_count(alloc->ch_table));
it = pj_hash_next(srv->tables.alloc, it);
++i;
}
}
/*
* This callback is called by active socket when pending accept() operation
* has completed.
*/
static pj_bool_t on_accept_complete(pj_activesock_t *asock,
pj_sock_t sock,
const pj_sockaddr_t *src_addr,
int src_addr_len)
{
struct tcp_listener *listener;
struct tcp_transport *tcp;
char addr[PJ_INET6_ADDRSTRLEN+10];
pj_status_t status;
PJ_UNUSED_ARG(src_addr_len);
listener = (struct tcp_listener*) pj_activesock_get_user_data(asock);
PJ_ASSERT_RETURN(sock != PJ_INVALID_SOCKET, PJ_TRUE);
PJ_LOG(4,(listener->factory.obj_name,
"TCP listener %.*s:%d: got incoming TCP connection "
"from %s, sock=%d",
(int)listener->factory.addr_name.host.slen,
listener->factory.addr_name.host.ptr,
listener->factory.addr_name.port,
pj_sockaddr_print(src_addr, addr, sizeof(addr), 3),
sock));
/*
* Incoming connection!
* Create TCP transport for the new socket.
*/
status = tcp_create( listener, NULL, sock, PJ_TRUE,
(const pj_sockaddr_in*)&listener->factory.local_addr,
(const pj_sockaddr_in*)src_addr, &tcp);
if (status == PJ_SUCCESS) {
status = tcp_start_read(tcp);
if (status != PJ_SUCCESS) {
PJ_LOG(3,(tcp->base.obj_name, "New transport cancelled"));
tcp_destroy(&tcp->base, status);
} else {
/* Start keep-alive timer */
if (PJSIP_TCP_KEEP_ALIVE_INTERVAL) {
pj_time_val delay = {PJSIP_TCP_KEEP_ALIVE_INTERVAL, 0};
pjsip_endpt_schedule_timer(listener->endpt,
&tcp->ka_timer,
&delay);
tcp->ka_timer.id = PJ_TRUE;
pj_gettimeofday(&tcp->last_activity);
}
}
}
return PJ_TRUE;
}
static void turn_on_rx_data(pj_turn_sock *relay,
void *pkt,
unsigned pkt_len,
const pj_sockaddr_t *peer_addr,
unsigned addr_len)
{
char addrinfo[80];
pj_sockaddr_print(peer_addr, addrinfo, sizeof(addrinfo), 3);
PJ_LOG(3,(THIS_FILE, "Client received %d bytes data from %s: %.*s",
pkt_len, addrinfo, pkt_len, pkt));
}
/* Notification from ioqueue about incoming RTCP packet */
static void on_rx_rtcp(pj_ioqueue_key_t *key,
pj_ioqueue_op_key_t *op_key,
pj_ssize_t bytes_read)
{
struct transport_udp *udp;
pj_status_t status;
PJ_UNUSED_ARG(op_key);
udp = (struct transport_udp*) pj_ioqueue_get_user_data(key);
do {
void (*cb)(void*,void*,pj_ssize_t);
void *user_data;
cb = udp->rtcp_cb;
user_data = udp->user_data;
if (udp->attached && cb)
(*cb)(user_data, udp->rtcp_pkt, bytes_read);
/* Check if RTCP source address is the same as the configured
* remote address, and switch the address when they are
* different.
*/
if (bytes_read>0 &&
(udp->options & PJMEDIA_UDP_NO_SRC_ADDR_CHECKING)==0 &&
pj_sockaddr_cmp(&udp->rem_rtcp_addr, &udp->rtcp_src_addr) != 0)
{
char addr_text[80];
pj_memcpy(&udp->rem_rtcp_addr, &udp->rtcp_src_addr,
sizeof(pj_sockaddr));
PJ_LOG(4,(udp->base.name,
"Remote RTCP address switched to %s",
pj_sockaddr_print(&udp->rtcp_src_addr, addr_text,
sizeof(addr_text), 3)));
}
bytes_read = sizeof(udp->rtcp_pkt);
udp->rtcp_addr_len = sizeof(udp->rtcp_src_addr);
status = pj_ioqueue_recvfrom(udp->rtcp_key, &udp->rtcp_read_op,
udp->rtcp_pkt, &bytes_read, 0,
&udp->rtcp_src_addr,
&udp->rtcp_addr_len);
if (status != PJ_EPENDING && status != PJ_SUCCESS)
bytes_read = -status;
} while (status != PJ_EPENDING && status != PJ_ECANCELLED);
}
static pj_bool_t logging_on_rx_msg(pjsip_rx_data *rdata)
{
char local_buf[256];
char remote_buf[256];
char *uuid;
struct hepv3_capture_info *capture_info;
capture_info = hepv3_create_capture_info(&rdata->pkt_info.packet, rdata->pkt_info.len);
if (!capture_info) {
return PJ_SUCCESS;
}
if (rdata->tp_info.transport->addr_len) {
pj_sockaddr_print(&rdata->tp_info.transport->local_addr, local_buf, sizeof(local_buf), 3);
}
if (rdata->pkt_info.src_addr_len) {
pj_sockaddr_print(&rdata->pkt_info.src_addr, remote_buf, sizeof(remote_buf), 3);
}
uuid = assign_uuid(&rdata->msg_info.cid->id, &rdata->msg_info.to->tag, &rdata->msg_info.from->tag);
if (!uuid) {
ao2_ref(capture_info, -1);
return PJ_SUCCESS;
}
ast_sockaddr_parse(&capture_info->src_addr, remote_buf, PARSE_PORT_REQUIRE);
ast_sockaddr_parse(&capture_info->dst_addr, local_buf, PARSE_PORT_REQUIRE);
capture_info->capture_time.tv_sec = rdata->pkt_info.timestamp.sec;
capture_info->capture_time.tv_usec = rdata->pkt_info.timestamp.msec * 1000;
capture_info->capture_type = HEPV3_CAPTURE_TYPE_SIP;
capture_info->uuid = uuid;
capture_info->zipped = 0;
hepv3_send_packet(capture_info);
return PJ_FALSE;
}
/**
* Create a "blank" SDP session description. The SDP will contain basic SDP
* fields such as origin, time, and name, but without any media lines.
*/
PJ_DEF(pj_status_t) pjmedia_endpt_create_base_sdp( pjmedia_endpt *endpt,
pj_pool_t *pool,
const pj_str_t *sess_name,
const pj_sockaddr *origin,
pjmedia_sdp_session **p_sdp)
{
pj_time_val tv;
pjmedia_sdp_session *sdp;
/* Sanity check arguments */
PJ_ASSERT_RETURN(endpt && pool && p_sdp, PJ_EINVAL);
sdp = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_session);
pj_gettimeofday(&tv);
sdp->origin.user = pj_str("-");
sdp->origin.version = sdp->origin.id = tv.sec + 2208988800UL;
sdp->origin.net_type = STR_IN;
if (origin->addr.sa_family == pj_AF_INET()) {
sdp->origin.addr_type = STR_IP4;
pj_strdup2(pool, &sdp->origin.addr,
pj_inet_ntoa(origin->ipv4.sin_addr));
} else if (origin->addr.sa_family == pj_AF_INET6()) {
char tmp_addr[PJ_INET6_ADDRSTRLEN];
sdp->origin.addr_type = STR_IP6;
pj_strdup2(pool, &sdp->origin.addr,
pj_sockaddr_print(origin, tmp_addr, sizeof(tmp_addr), 0));
} else {
pj_assert(!"Invalid address family");
return PJ_EAFNOTSUP;
}
if (sess_name)
pj_strdup(pool, &sdp->name, sess_name);
else
sdp->name = STR_SDP_NAME;
/* SDP time and attributes. */
sdp->time.start = sdp->time.stop = 0;
sdp->attr_count = 0;
/* Done */
*p_sdp = sdp;
return PJ_SUCCESS;
}
static pj_status_t logging_on_tx_msg(pjsip_tx_data *tdata)
{
char buffer[AST_SOCKADDR_BUFLEN];
if (!pjsip_log_test_addr(tdata->tp_info.dst_name, tdata->tp_info.dst_port)) {
return PJ_SUCCESS;
}
ast_verbose("<--- Transmitting SIP %s (%d bytes) to %s:%s --->\n%.*s\n",
tdata->msg->type == PJSIP_REQUEST_MSG ? "request" : "response",
(int) (tdata->buf.cur - tdata->buf.start),
tdata->tp_info.transport->type_name,
pj_sockaddr_print(&tdata->tp_info.dst_addr, buffer, sizeof(buffer), 3),
(int) (tdata->buf.end - tdata->buf.start), tdata->buf.start);
return PJ_SUCCESS;
}
static pj_bool_t stun_sock_on_rx_data(pj_stun_sock *stun_sock,
void *pkt,
unsigned pkt_len,
const pj_sockaddr_t *src_addr,
unsigned addr_len)
{
struct peer *peer = (struct peer*) pj_stun_sock_get_user_data(stun_sock);
char straddr[PJ_INET6_ADDRSTRLEN+10];
((char*)pkt)[pkt_len] = '\0';
pj_sockaddr_print(src_addr, straddr, sizeof(straddr), 3);
PJ_LOG(3,(THIS_FILE, "peer%d: received %d bytes data from %s: %s",
peer-g.peer, pkt_len, straddr, (char*)pkt));
return PJ_TRUE;
}
/*
* This utility function creates receive data buffers and start
* asynchronous recv() operations from the socket. It is called after
* accept() or connect() operation complete.
*/
static pj_status_t tcp_start_read(struct tcp_transport *tcp)
{
pj_pool_t *pool;
pj_ssize_t size;
pj_sockaddr *rem_addr;
void *readbuf[1];
pj_status_t status;
/* Init rdata */
pool = pjsip_endpt_create_pool(tcp->base.endpt,
"rtd%p",
PJSIP_POOL_RDATA_LEN,
PJSIP_POOL_RDATA_INC);
if (!pool) {
tcp_perror(tcp->base.obj_name, "Unable to create pool", PJ_ENOMEM);
return PJ_ENOMEM;
}
tcp->rdata.tp_info.pool = pool;
tcp->rdata.tp_info.transport = &tcp->base;
tcp->rdata.tp_info.tp_data = tcp;
tcp->rdata.tp_info.op_key.rdata = &tcp->rdata;
pj_ioqueue_op_key_init(&tcp->rdata.tp_info.op_key.op_key,
sizeof(pj_ioqueue_op_key_t));
tcp->rdata.pkt_info.src_addr = tcp->base.key.rem_addr;
tcp->rdata.pkt_info.src_addr_len = sizeof(tcp->rdata.pkt_info.src_addr);
rem_addr = &tcp->base.key.rem_addr;
pj_sockaddr_print(rem_addr, tcp->rdata.pkt_info.src_name,
sizeof(tcp->rdata.pkt_info.src_name), 0);
tcp->rdata.pkt_info.src_port = pj_sockaddr_get_port(rem_addr);
size = sizeof(tcp->rdata.pkt_info.packet);
readbuf[0] = tcp->rdata.pkt_info.packet;
status = pj_activesock_start_read2(tcp->asock, tcp->base.pool, size,
readbuf, 0);
if (status != PJ_SUCCESS && status != PJ_EPENDING) {
PJ_LOG(4, (tcp->base.obj_name,
"pj_activesock_start_read() error, status=%d",
status));
return status;
}
return PJ_SUCCESS;
}
/* Common initialization for both audio and video SDP media line */
static pj_status_t init_sdp_media(pjmedia_sdp_media *m,
pj_pool_t *pool,
const pj_str_t *media_type,
const pjmedia_sock_info *sock_info)
{
char tmp_addr[PJ_INET6_ADDRSTRLEN];
pjmedia_sdp_attr *attr;
const pj_sockaddr *addr;
pj_strdup(pool, &m->desc.media, media_type);
addr = &sock_info->rtp_addr_name;
/* Validate address family */
PJ_ASSERT_RETURN(addr->addr.sa_family == pj_AF_INET() ||
addr->addr.sa_family == pj_AF_INET6(),
PJ_EAFNOTSUP);
/* SDP connection line */
m->conn = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_conn);
m->conn->net_type = STR_IN;
m->conn->addr_type = (addr->addr.sa_family==pj_AF_INET())? STR_IP4:STR_IP6;
pj_sockaddr_print(addr, tmp_addr, sizeof(tmp_addr), 0);
pj_strdup2(pool, &m->conn->addr, tmp_addr);
/* Port and transport in media description */
m->desc.port = pj_sockaddr_get_port(addr);
m->desc.port_count = 1;
pj_strdup (pool, &m->desc.transport, &STR_RTP_AVP);
/* Add "rtcp" attribute */
#if defined(PJMEDIA_HAS_RTCP_IN_SDP) && PJMEDIA_HAS_RTCP_IN_SDP!=0
if (sock_info->rtcp_addr_name.addr.sa_family != 0) {
attr = pjmedia_sdp_attr_create_rtcp(pool, &sock_info->rtcp_addr_name);
if (attr)
pjmedia_sdp_attr_add(&m->attr_count, m->attr, attr);
}
#endif
/* Add sendrecv attribute. */
attr = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_attr);
attr->name = STR_SENDRECV;
m->attr[m->attr_count++] = attr;
return PJ_SUCCESS;
}
std::vector<std::string>
ip_utils::getAllIpInterface()
{
pj_sockaddr addrList[16];
unsigned addrCnt = PJ_ARRAY_SIZE(addrList);
std::vector<std::string> ifaceList;
if (pj_enum_ip_interface(pj_AF_UNSPEC(), &addrCnt, addrList) == PJ_SUCCESS) {
for (unsigned i = 0; i < addrCnt; i++) {
char addr[PJ_INET6_ADDRSTRLEN];
pj_sockaddr_print(&addrList[i], addr, sizeof(addr), 0);
ifaceList.push_back(std::string(addr));
}
}
return ifaceList;
}
static int transport_bind_to_str(const void *obj, const intptr_t *args, char **buf)
{
const struct ast_sip_transport *transport = obj;
RAII_VAR(struct ast_sip_transport_state *, state, find_state_by_transport(transport), ao2_cleanup);
if (!state) {
return -1;
}
if (!(*buf = ast_calloc(MAX_OBJECT_FIELD, sizeof(char)))) {
return -1;
}
/* include port as well as brackets if IPv6 */
pj_sockaddr_print(&state->host, *buf, MAX_OBJECT_FIELD, 1 | 2);
return 0;
}
/// Find or create a flow corresponding to the specified transport and remote
/// IP address and port. This is a single method to ensure it is atomic.
Flow* FlowTable::find_create_flow(pjsip_transport* transport, const pj_sockaddr* raddr)
{
Flow* flow = NULL;
FlowKey key(transport->key.type, raddr);
char buf[100];
LOG_DEBUG("Find or create flow for transport %s (%d), remote address %s",
transport->obj_name, transport->key.type,
pj_sockaddr_print(raddr, buf, sizeof(buf), 3));
pthread_mutex_lock(&_flow_map_lock);
std::map<FlowKey, Flow*>::iterator i = _tp2flow_map.find(key);
if (i == _tp2flow_map.end())
{
// No matching flow, so create a new one.
flow = new Flow(this, transport, raddr);
// Add the new flow to the maps.
_tp2flow_map.insert(std::make_pair(key, flow));
_tk2flow_map.insert(std::make_pair(flow->token(), flow));
LOG_DEBUG("Added flow record %p", flow);
report_flow_count();
}
else
{
// Found a matching flow, so return this one.
flow = i->second;
LOG_DEBUG("Found flow record %p", flow);
}
// Add a reference to the flow.
flow->inc_ref();
pthread_mutex_unlock(&_flow_map_lock);
return flow;
}
static pj_bool_t logging_on_rx_msg(pjsip_rx_data *rdata)
{
char buffer[AST_SOCKADDR_BUFLEN];
if (!pjsip_log_test_addr(rdata->pkt_info.src_name, rdata->pkt_info.src_port)) {
return PJ_FALSE;
}
if (!rdata->msg_info.msg) {
return PJ_FALSE;
}
ast_verbose("<--- Received SIP %s (%d bytes) from %s:%s --->\n%s\n",
rdata->msg_info.msg->type == PJSIP_REQUEST_MSG ? "request" : "response",
rdata->msg_info.len,
rdata->tp_info.transport->type_name,
pj_sockaddr_print(&rdata->pkt_info.src_addr, buffer, sizeof(buffer), 3),
rdata->pkt_info.packet);
return PJ_FALSE;
}
/* Set local peer address */
PJ_DEF(void) pj_tcp_session_set_local_addr( pj_tcp_session *sess,
const pj_sockaddr_t *addr)
{
char buf[PJ_INET6_ADDRSTRLEN+20];
if (!sess)
return;
if (!sess->local_addr) {
sess->local_addr = (pj_sockaddr_t *)
pj_pool_calloc(sess->pool, 1,
pj_sockaddr_get_len(addr));
}
sess->local_addr_len = pj_sockaddr_get_len(addr);
pj_sockaddr_cp(sess->local_addr, addr);
//pj_sockaddr_set_str_addr(pj_AF_INET(), (pj_sockaddr *)sess->peer_addr, &str_addr);
PJ_LOG(4, (THIS_FILE, "pj_tcp_session_set_remote_peer_addr() %s",
pj_sockaddr_print(sess->local_addr, buf, sizeof(buf), 3)));
}
/*
* This is the callback that is registered to the ICE stream transport to
* receive notification about incoming data. By "data" it means application
* data such as RTP/RTCP, and not packets that belong to ICE signaling (such
* as STUN connectivity checks or TURN signaling).
*/
static void cb_on_rx_data(pj_ice_strans *ice_st,
unsigned comp_id,
void *pkt, pj_size_t size,
const pj_sockaddr_t *src_addr,
unsigned src_addr_len)
{
char ipstr[PJ_INET6_ADDRSTRLEN+10];
PJ_UNUSED_ARG(ice_st);
PJ_UNUSED_ARG(src_addr_len);
PJ_UNUSED_ARG(pkt);
// Don't do this! It will ruin the packet buffer in case TCP is used!
//((char*)pkt)[size] = '\0';
PJ_LOG(3,(THIS_FILE, "Component %d: received %d bytes data from %s: \"%.*s\"",
comp_id, size,
pj_sockaddr_print(src_addr, ipstr, sizeof(ipstr), 3),
(unsigned)size,
(char*)pkt));
}
static pj_bool_t stun_sock_on_status(pj_stun_sock *stun_sock,
pj_stun_sock_op op,
pj_status_t status)
{
struct peer *peer = (struct peer*) pj_stun_sock_get_user_data(stun_sock);
if (status == PJ_SUCCESS) {
PJ_LOG(4,(THIS_FILE, "peer%d: %s success", peer-g.peer,
pj_stun_sock_op_name(op)));
} else {
char errmsg[PJ_ERR_MSG_SIZE];
pj_strerror(status, errmsg, sizeof(errmsg));
PJ_LOG(1,(THIS_FILE, "peer%d: %s error: %s", peer-g.peer,
pj_stun_sock_op_name(op), errmsg));
return PJ_FALSE;
}
if (op==PJ_STUN_SOCK_BINDING_OP || op==PJ_STUN_SOCK_KEEP_ALIVE_OP) {
pj_stun_sock_info info;
int cmp;
pj_stun_sock_get_info(stun_sock, &info);
cmp = pj_sockaddr_cmp(&info.mapped_addr, &peer->mapped_addr);
if (cmp) {
char straddr[PJ_INET6_ADDRSTRLEN+10];
pj_sockaddr_cp(&peer->mapped_addr, &info.mapped_addr);
pj_sockaddr_print(&peer->mapped_addr, straddr, sizeof(straddr), 3);
PJ_LOG(3,(THIS_FILE, "peer%d: STUN mapped address is %s",
peer-g.peer, straddr));
}
}
return PJ_TRUE;
}
/* Set the published address of the transport */
static void udp_set_pub_name(struct udp_transport *tp,
const pjsip_host_port *a_name)
{
enum { INFO_LEN = 80 };
char local_addr[PJ_INET6_ADDRSTRLEN+10];
pj_assert(a_name->host.slen != 0);
pj_strdup_with_null(tp->base.pool, &tp->base.local_name.host,
&a_name->host);
tp->base.local_name.port = a_name->port;
/* Update transport info. */
if (tp->base.info == NULL) {
tp->base.info = (char*) pj_pool_alloc(tp->base.pool, INFO_LEN);
}
pj_sockaddr_print(&tp->base.local_addr, local_addr, sizeof(local_addr), 3);
pj_ansi_snprintf(
tp->base.info, INFO_LEN, "udp %s [published as %s:%d]",
local_addr,
tp->base.local_name.host.ptr,
tp->base.local_name.port);
}
/*
* Create new allocation.
*/
PJ_DEF(pj_status_t) pj_turn_allocation_create(pj_turn_transport *transport,
const pj_sockaddr_t *src_addr,
unsigned src_addr_len,
const pj_stun_rx_data *rdata,
pj_stun_session *srv_sess,
pj_turn_allocation **p_alloc)
{
pj_turn_srv *srv = transport->listener->server;
const pj_stun_msg *msg = rdata->msg;
pj_pool_t *pool;
alloc_request req;
pj_turn_allocation *alloc;
pj_stun_session_cb sess_cb;
char str_tmp[80];
pj_status_t status;
/* Parse ALLOCATE request */
status = parse_allocate_req(&req, srv_sess, rdata, src_addr, src_addr_len);
if (status != PJ_SUCCESS)
return status;
pool = pj_pool_create(srv->core.pf, "alloc%p", 1000, 1000, NULL);
/* Init allocation structure */
alloc = PJ_POOL_ZALLOC_T(pool, pj_turn_allocation);
alloc->pool = pool;
alloc->obj_name = pool->obj_name;
alloc->relay.tp.sock = PJ_INVALID_SOCKET;
alloc->server = transport->listener->server;
alloc->bandwidth = req.bandwidth;
/* Set transport */
alloc->transport = transport;
pj_turn_transport_add_ref(transport, alloc);
alloc->hkey.tp_type = transport->listener->tp_type;
pj_memcpy(&alloc->hkey.clt_addr, src_addr, src_addr_len);
status = pj_lock_create_recursive_mutex(pool, alloc->obj_name,
&alloc->lock);
if (status != PJ_SUCCESS) {
goto on_error;
}
/* Create peer hash table */
alloc->peer_table = pj_hash_create(pool, PEER_TABLE_SIZE);
/* Create channel hash table */
alloc->ch_table = pj_hash_create(pool, PEER_TABLE_SIZE);
/* Print info */
pj_ansi_strcpy(alloc->info,
pj_turn_tp_type_name(transport->listener->tp_type));
alloc->info[3] = ':';
pj_sockaddr_print(src_addr, alloc->info+4, sizeof(alloc->info)-4, 3);
/* Create STUN session to handle STUN communication with client */
pj_bzero(&sess_cb, sizeof(sess_cb));
sess_cb.on_send_msg = &stun_on_send_msg;
sess_cb.on_rx_request = &stun_on_rx_request;
sess_cb.on_rx_indication = &stun_on_rx_indication;
status = pj_stun_session_create(&srv->core.stun_cfg, alloc->obj_name,
&sess_cb, PJ_FALSE, NULL, &alloc->sess);
if (status != PJ_SUCCESS) {
goto on_error;
}
/* Attach to STUN session */
pj_stun_session_set_user_data(alloc->sess, alloc);
/* Init authentication credential */
status = init_cred(alloc, msg);
if (status != PJ_SUCCESS) {
goto on_error;
}
/* Attach authentication credential to STUN session */
pj_stun_session_set_credential(alloc->sess, PJ_STUN_AUTH_LONG_TERM,
&alloc->cred);
/* Create the relay resource */
status = create_relay(srv, alloc, msg, &req, &alloc->relay);
if (status != PJ_SUCCESS) {
goto on_error;
}
/* Register this allocation */
pj_turn_srv_register_allocation(srv, alloc);
/* Respond to ALLOCATE request */
status = send_allocate_response(alloc, srv_sess, transport, rdata);
if (status != PJ_SUCCESS)
goto on_error;
/* Done */
pj_sockaddr_print(&alloc->relay.hkey.addr, str_tmp,
sizeof(str_tmp), 3);
PJ_LOG(4,(alloc->obj_name, "Client %s created, relay addr=%s:%s",
alloc->info, pj_turn_tp_type_name(req.tp_type), str_tmp));
/* Success */
*p_alloc = alloc;
return PJ_SUCCESS;
on_error:
/* Send reply to the ALLOCATE request */
pj_strerror(status, str_tmp, sizeof(str_tmp));
pj_stun_session_respond(srv_sess, rdata, PJ_STUN_SC_BAD_REQUEST, str_tmp,
transport, PJ_TRUE, src_addr, src_addr_len);
/* Cleanup */
destroy_allocation(alloc);
return status;
}
/*
* Handle incoming packet from peer. This function is called by
* on_rx_from_peer().
*/
static void handle_peer_pkt(pj_turn_allocation *alloc,
pj_turn_relay_res *rel,
char *pkt, pj_size_t len,
const pj_sockaddr *src_addr)
{
pj_turn_permission *perm;
/* Lookup permission */
perm = lookup_permission_by_addr(alloc, src_addr,
pj_sockaddr_get_len(src_addr));
if (perm == NULL) {
/* No permission, discard data */
return;
}
/* Send Data Indication or ChannelData, depends on whether
* this permission is attached to a channel number.
*/
if (perm->channel != PJ_TURN_INVALID_CHANNEL) {
/* Send ChannelData */
pj_turn_channel_data *cd = (pj_turn_channel_data*)rel->tp.tx_pkt;
if (len > PJ_TURN_MAX_PKT_LEN) {
char peer_addr[80];
pj_sockaddr_print(src_addr, peer_addr, sizeof(peer_addr), 3);
PJ_LOG(4,(alloc->obj_name, "Client %s: discarded data from %s "
"because it's too long (%d bytes)",
alloc->info, peer_addr, len));
return;
}
/* Init header */
cd->ch_number = pj_htons(perm->channel);
cd->length = pj_htons((pj_uint16_t)len);
/* Copy data */
pj_memcpy(rel->tp.tx_pkt+sizeof(pj_turn_channel_data), pkt, len);
/* Send to client */
alloc->transport->sendto(alloc->transport, rel->tp.tx_pkt,
len+sizeof(pj_turn_channel_data), 0,
&alloc->hkey.clt_addr,
pj_sockaddr_get_len(&alloc->hkey.clt_addr));
} else {
/* Send Data Indication */
pj_stun_tx_data *tdata;
pj_status_t status;
status = pj_stun_session_create_ind(alloc->sess,
PJ_STUN_DATA_INDICATION, &tdata);
if (status != PJ_SUCCESS) {
alloc_err(alloc, "Error creating Data indication", status);
return;
}
pj_stun_msg_add_sockaddr_attr(tdata->pool, tdata->msg,
PJ_STUN_ATTR_XOR_PEER_ADDR, PJ_TRUE,
src_addr, pj_sockaddr_get_len(src_addr));
pj_stun_msg_add_binary_attr(tdata->pool, tdata->msg,
PJ_STUN_ATTR_DATA,
(const pj_uint8_t*)pkt, len);
pj_stun_session_send_msg(alloc->sess, NULL, PJ_FALSE,
PJ_FALSE, &alloc->hkey.clt_addr,
pj_sockaddr_get_len(&alloc->hkey.clt_addr),
tdata);
}
}
/**
* Create a SDP session description that describes the endpoint
* capability.
*/
PJ_DEF(pj_status_t) pjmedia_endpt_create_sdp( pjmedia_endpt *endpt,
pj_pool_t *pool,
unsigned stream_cnt,
const pjmedia_sock_info sock_info[],
pjmedia_sdp_session **p_sdp )
{
pj_time_val tv;
unsigned i;
const pj_sockaddr *addr0;
pjmedia_sdp_session *sdp;
pjmedia_sdp_media *m;
pjmedia_sdp_attr *attr;
/* Sanity check arguments */
PJ_ASSERT_RETURN(endpt && pool && p_sdp && stream_cnt, PJ_EINVAL);
/* Check that there are not too many codecs */
PJ_ASSERT_RETURN(endpt->codec_mgr.codec_cnt <= PJMEDIA_MAX_SDP_FMT,
PJ_ETOOMANY);
/* Create and initialize basic SDP session */
sdp = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_session);
addr0 = &sock_info[0].rtp_addr_name;
pj_gettimeofday(&tv);
sdp->origin.user = pj_str("-");
sdp->origin.version = sdp->origin.id = tv.sec + 2208988800UL;
sdp->origin.net_type = STR_IN;
if (addr0->addr.sa_family == pj_AF_INET()) {
sdp->origin.addr_type = STR_IP4;
pj_strdup2(pool, &sdp->origin.addr,
pj_inet_ntoa(addr0->ipv4.sin_addr));
} else if (addr0->addr.sa_family == pj_AF_INET6()) {
char tmp_addr[PJ_INET6_ADDRSTRLEN];
sdp->origin.addr_type = STR_IP6;
pj_strdup2(pool, &sdp->origin.addr,
pj_sockaddr_print(addr0, tmp_addr, sizeof(tmp_addr), 0));
} else {
pj_assert(!"Invalid address family");
return PJ_EAFNOTSUP;
}
sdp->name = STR_SDP_NAME;
/* Since we only support one media stream at present, put the
* SDP connection line in the session level.
*/
sdp->conn = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_conn);
sdp->conn->net_type = sdp->origin.net_type;
sdp->conn->addr_type = sdp->origin.addr_type;
sdp->conn->addr = sdp->origin.addr;
/* SDP time and attributes. */
sdp->time.start = sdp->time.stop = 0;
sdp->attr_count = 0;
/* Create media stream 0: */
sdp->media_count = 1;
m = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_media);
sdp->media[0] = m;
/* Standard media info: */
pj_strdup(pool, &m->desc.media, &STR_AUDIO);
m->desc.port = pj_sockaddr_get_port(addr0);
m->desc.port_count = 1;
pj_strdup (pool, &m->desc.transport, &STR_RTP_AVP);
/* Init media line and attribute list. */
m->desc.fmt_count = 0;
m->attr_count = 0;
/* Add "rtcp" attribute */
#if defined(PJMEDIA_HAS_RTCP_IN_SDP) && PJMEDIA_HAS_RTCP_IN_SDP!=0
if (sock_info->rtcp_addr_name.addr.sa_family != 0) {
attr = pjmedia_sdp_attr_create_rtcp(pool, &sock_info->rtcp_addr_name);
if (attr)
pjmedia_sdp_attr_add(&m->attr_count, m->attr, attr);
}
#endif
/* Add format, rtpmap, and fmtp (when applicable) for each codec */
for (i=0; i<endpt->codec_mgr.codec_cnt; ++i) {
pjmedia_codec_info *codec_info;
pjmedia_sdp_rtpmap rtpmap;
char tmp_param[3];
pjmedia_sdp_attr *attr;
pjmedia_codec_param codec_param;
pj_str_t *fmt;
if (endpt->codec_mgr.codec_desc[i].prio == PJMEDIA_CODEC_PRIO_DISABLED)
break;
codec_info = &endpt->codec_mgr.codec_desc[i].info;
pjmedia_codec_mgr_get_default_param(&endpt->codec_mgr, codec_info,
&codec_param);
fmt = &m->desc.fmt[m->desc.fmt_count++];
fmt->ptr = (char*) pj_pool_alloc(pool, 8);
fmt->slen = pj_utoa(codec_info->pt, fmt->ptr);
rtpmap.pt = *fmt;
rtpmap.enc_name = codec_info->encoding_name;
#if defined(PJMEDIA_HANDLE_G722_MPEG_BUG) && (PJMEDIA_HANDLE_G722_MPEG_BUG != 0)
if (codec_info->pt == PJMEDIA_RTP_PT_G722)
rtpmap.clock_rate = 8000;
else
rtpmap.clock_rate = codec_info->clock_rate;
#else
rtpmap.clock_rate = codec_info->clock_rate;
#endif
/* For audio codecs, rtpmap parameters denotes the number
* of channels, which can be omited if the value is 1.
*/
if (codec_info->type == PJMEDIA_TYPE_AUDIO &&
codec_info->channel_cnt > 1)
{
/* Can only support one digit channel count */
pj_assert(codec_info->channel_cnt < 10);
tmp_param[0] = (char)('0' + codec_info->channel_cnt);
rtpmap.param.ptr = tmp_param;
rtpmap.param.slen = 1;
} else {
rtpmap.param.slen = 0;
}
if (codec_info->pt >= 96 || pjmedia_add_rtpmap_for_static_pt) {
pjmedia_sdp_rtpmap_to_attr(pool, &rtpmap, &attr);
m->attr[m->attr_count++] = attr;
}
/* Add fmtp params */
if (codec_param.setting.dec_fmtp.cnt > 0) {
enum { MAX_FMTP_STR_LEN = 160 };
char buf[MAX_FMTP_STR_LEN];
unsigned buf_len = 0, i;
pjmedia_codec_fmtp *dec_fmtp = &codec_param.setting.dec_fmtp;
/* Print codec PT */
buf_len += pj_ansi_snprintf(buf,
MAX_FMTP_STR_LEN - buf_len,
"%d",
codec_info->pt);
for (i = 0; i < dec_fmtp->cnt; ++i) {
unsigned test_len = 2;
/* Check if buf still available */
test_len = dec_fmtp->param[i].val.slen +
dec_fmtp->param[i].name.slen;
if (test_len + buf_len >= MAX_FMTP_STR_LEN)
return PJ_ETOOBIG;
/* Print delimiter */
buf_len += pj_ansi_snprintf(&buf[buf_len],
MAX_FMTP_STR_LEN - buf_len,
(i == 0?" ":";"));
/* Print an fmtp param */
if (dec_fmtp->param[i].name.slen)
buf_len += pj_ansi_snprintf(
&buf[buf_len],
MAX_FMTP_STR_LEN - buf_len,
"%.*s=%.*s",
(int)dec_fmtp->param[i].name.slen,
dec_fmtp->param[i].name.ptr,
(int)dec_fmtp->param[i].val.slen,
dec_fmtp->param[i].val.ptr);
else
buf_len += pj_ansi_snprintf(&buf[buf_len],
MAX_FMTP_STR_LEN - buf_len,
"%.*s",
(int)dec_fmtp->param[i].val.slen,
dec_fmtp->param[i].val.ptr);
}
attr = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_attr);
attr->name = pj_str("fmtp");
attr->value = pj_strdup3(pool, buf);
m->attr[m->attr_count++] = attr;
}
}
/* Add sendrecv attribute. */
attr = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_attr);
attr->name = STR_SENDRECV;
m->attr[m->attr_count++] = attr;
#if defined(PJMEDIA_RTP_PT_TELEPHONE_EVENTS) && \
PJMEDIA_RTP_PT_TELEPHONE_EVENTS != 0
/*
* Add support telephony event
*/
m->desc.fmt[m->desc.fmt_count++] =
pj_str(PJMEDIA_RTP_PT_TELEPHONE_EVENTS_STR);
/* Add rtpmap. */
attr = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_attr);
attr->name = pj_str("rtpmap");
attr->value = pj_str(PJMEDIA_RTP_PT_TELEPHONE_EVENTS_STR
" telephone-event/8000");
m->attr[m->attr_count++] = attr;
/* Add fmtp */
attr = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_attr);
attr->name = pj_str("fmtp");
attr->value = pj_str(PJMEDIA_RTP_PT_TELEPHONE_EVENTS_STR " 0-15");
m->attr[m->attr_count++] = attr;
#endif
/* Done */
*p_sdp = sdp;
return PJ_SUCCESS;
}
static pj_bool_t ssl_on_data_read(pj_ssl_sock_t *ssock,
void *data,
pj_size_t size,
pj_status_t status,
pj_size_t *remainder)
{
struct test_state *st = (struct test_state*)
pj_ssl_sock_get_user_data(ssock);
PJ_UNUSED_ARG(remainder);
PJ_UNUSED_ARG(data);
if (size > 0) {
pj_size_t consumed;
/* Set random remainder */
*remainder = pj_rand() % 100;
/* Apply zero remainder if:
* - remainder is less than size, or
* - connection closed/error
* - echo/check_eco set
*/
if (*remainder > size || status != PJ_SUCCESS || st->echo || st->check_echo)
*remainder = 0;
consumed = size - *remainder;
st->recv += consumed;
//printf("%.*s", consumed, (char*)data);
pj_memmove(data, (char*)data + consumed, *remainder);
/* Echo data when specified to */
if (st->echo) {
pj_ssize_t size_ = consumed;
status = pj_ssl_sock_send(ssock, (pj_ioqueue_op_key_t*)&st->send_key, data, &size_, 0);
if (status != PJ_SUCCESS && status != PJ_EPENDING) {
app_perror("...ERROR pj_ssl_sock_send()", status);
goto on_return;
}
if (status == PJ_SUCCESS)
st->sent += size_;
}
/* Verify echoed data when specified to */
if (st->check_echo) {
if (!st->check_echo_ptr)
st->check_echo_ptr = st->send_str;
if (pj_memcmp(st->check_echo_ptr, data, consumed)) {
status = PJ_EINVAL;
app_perror("...ERROR echoed data not exact", status);
goto on_return;
}
st->check_echo_ptr += consumed;
/* Echo received completely */
if (st->send_str_len == st->recv) {
pj_ssl_sock_info info;
char buf[64];
status = pj_ssl_sock_get_info(ssock, &info);
if (status != PJ_SUCCESS) {
app_perror("...ERROR pj_ssl_sock_get_info()", status);
goto on_return;
}
pj_sockaddr_print((pj_sockaddr_t*)&info.local_addr, buf, sizeof(buf), 1);
PJ_LOG(3, ("", "...%s successfully recv %d bytes echo", buf, st->recv));
st->done = PJ_TRUE;
}
}
}
if (status != PJ_SUCCESS) {
if (status == PJ_EEOF) {
status = PJ_SUCCESS;
st->done = PJ_TRUE;
} else {
app_perror("...ERROR ssl_on_data_read()", status);
}
}
on_return:
st->err = status;
if (st->err != PJ_SUCCESS || st->done) {
pj_ssl_sock_close(ssock);
if (!st->is_server)
clients_num--;
return PJ_FALSE;
}
return PJ_TRUE;
}
static pj_bool_t logging_on_rx_msg(pjsip_rx_data *rdata)
{
char local_buf[256];
char remote_buf[256];
char *uuid;
struct hepv3_capture_info *capture_info;
capture_info = hepv3_create_capture_info(&rdata->pkt_info.packet, rdata->pkt_info.len);
if (!capture_info) {
return PJ_SUCCESS;
}
if (!rdata->pkt_info.src_addr_len) {
return PJ_SUCCESS;
}
pj_sockaddr_print(&rdata->pkt_info.src_addr, remote_buf, sizeof(remote_buf), 3);
if (!(rdata->tp_info.transport->flag & PJSIP_TRANSPORT_RELIABLE)) {
pjsip_tpmgr_fla2_param prm;
/* Attempt to determine what IP address we probably received this packet on */
pjsip_tpmgr_fla2_param_default(&prm);
prm.tp_type = rdata->tp_info.transport->key.type;
pj_strset2(&prm.dst_host, rdata->pkt_info.src_name);
prm.local_if = PJ_TRUE;
/* If we can't get the local address use what we have already */
if (pjsip_tpmgr_find_local_addr2(pjsip_endpt_get_tpmgr(ast_sip_get_pjsip_endpoint()), rdata->tp_info.pool, &prm) != PJ_SUCCESS) {
pj_sockaddr_print(&rdata->tp_info.transport->local_addr, local_buf, sizeof(local_buf), 3);
} else {
if (prm.tp_type & PJSIP_TRANSPORT_IPV6) {
snprintf(local_buf, sizeof(local_buf), "[%.*s]:%hu",
(int)pj_strlen(&prm.ret_addr),
pj_strbuf(&prm.ret_addr),
prm.ret_port);
} else {
snprintf(local_buf, sizeof(local_buf), "%.*s:%hu",
(int)pj_strlen(&prm.ret_addr),
pj_strbuf(&prm.ret_addr),
prm.ret_port);
}
}
} else {
pj_sockaddr_print(&rdata->tp_info.transport->local_addr, local_buf, sizeof(local_buf), 3);
}
uuid = assign_uuid(&rdata->msg_info.cid->id, &rdata->msg_info.to->tag, &rdata->msg_info.from->tag);
if (!uuid) {
ao2_ref(capture_info, -1);
return PJ_SUCCESS;
}
ast_sockaddr_parse(&capture_info->src_addr, remote_buf, PARSE_PORT_REQUIRE);
ast_sockaddr_parse(&capture_info->dst_addr, local_buf, PARSE_PORT_REQUIRE);
capture_info->protocol_id = transport_to_protocol_id(rdata->tp_info.transport);
capture_info->capture_time.tv_sec = rdata->pkt_info.timestamp.sec;
capture_info->capture_time.tv_usec = rdata->pkt_info.timestamp.msec * 1000;
capture_info->capture_type = HEPV3_CAPTURE_TYPE_SIP;
capture_info->uuid = uuid;
capture_info->zipped = 0;
hepv3_send_packet(capture_info);
return PJ_FALSE;
}
static pj_status_t logging_on_tx_msg(pjsip_tx_data *tdata)
{
char local_buf[256];
char remote_buf[256];
char *uuid;
struct hepv3_capture_info *capture_info;
pjsip_cid_hdr *cid_hdr;
pjsip_from_hdr *from_hdr;
pjsip_to_hdr *to_hdr;
capture_info = hepv3_create_capture_info(tdata->buf.start, (size_t)(tdata->buf.cur - tdata->buf.start));
if (!capture_info) {
return PJ_SUCCESS;
}
if (!(tdata->tp_info.transport->flag & PJSIP_TRANSPORT_RELIABLE)) {
pjsip_tpmgr_fla2_param prm;
/* Attempt to determine what IP address will we send this packet out of */
pjsip_tpmgr_fla2_param_default(&prm);
prm.tp_type = tdata->tp_info.transport->key.type;
pj_strset2(&prm.dst_host, tdata->tp_info.dst_name);
prm.local_if = PJ_TRUE;
/* If we can't get the local address use what we have already */
if (pjsip_tpmgr_find_local_addr2(pjsip_endpt_get_tpmgr(ast_sip_get_pjsip_endpoint()), tdata->pool, &prm) != PJ_SUCCESS) {
pj_sockaddr_print(&tdata->tp_info.transport->local_addr, local_buf, sizeof(local_buf), 3);
} else {
if (prm.tp_type & PJSIP_TRANSPORT_IPV6) {
snprintf(local_buf, sizeof(local_buf), "[%.*s]:%hu",
(int)pj_strlen(&prm.ret_addr),
pj_strbuf(&prm.ret_addr),
prm.ret_port);
} else {
snprintf(local_buf, sizeof(local_buf), "%.*s:%hu",
(int)pj_strlen(&prm.ret_addr),
pj_strbuf(&prm.ret_addr),
prm.ret_port);
}
}
} else {
/* For reliable transports they can only ever come from the transport
* local address.
*/
pj_sockaddr_print(&tdata->tp_info.transport->local_addr, local_buf, sizeof(local_buf), 3);
}
pj_sockaddr_print(&tdata->tp_info.dst_addr, remote_buf, sizeof(remote_buf), 3);
cid_hdr = PJSIP_MSG_CID_HDR(tdata->msg);
from_hdr = PJSIP_MSG_FROM_HDR(tdata->msg);
to_hdr = PJSIP_MSG_TO_HDR(tdata->msg);
uuid = assign_uuid(&cid_hdr->id, &to_hdr->tag, &from_hdr->tag);
if (!uuid) {
ao2_ref(capture_info, -1);
return PJ_SUCCESS;
}
ast_sockaddr_parse(&capture_info->src_addr, local_buf, PARSE_PORT_REQUIRE);
ast_sockaddr_parse(&capture_info->dst_addr, remote_buf, PARSE_PORT_REQUIRE);
capture_info->protocol_id = transport_to_protocol_id(tdata->tp_info.transport);
capture_info->capture_time = ast_tvnow();
capture_info->capture_type = HEPV3_CAPTURE_TYPE_SIP;
capture_info->uuid = uuid;
capture_info->zipped = 0;
hepv3_send_packet(capture_info);
return PJ_SUCCESS;
}
/*
* This callback is called by SSL socket when pending accept() operation
* has completed.
*/
static pj_bool_t on_accept_complete(pj_ssl_sock_t *ssock,
pj_ssl_sock_t *new_ssock,
const pj_sockaddr_t *src_addr,
int src_addr_len)
{
struct tls_listener *listener;
struct tls_transport *tls;
pj_ssl_sock_info ssl_info;
char addr[PJ_INET6_ADDRSTRLEN+10];
pjsip_tp_state_callback state_cb;
pj_bool_t is_shutdown;
pj_status_t status;
PJ_UNUSED_ARG(src_addr_len);
listener = (struct tls_listener*) pj_ssl_sock_get_user_data(ssock);
PJ_ASSERT_RETURN(new_ssock, PJ_TRUE);
PJ_LOG(4,(listener->factory.obj_name,
"TLS listener %.*s:%d: got incoming TLS connection "
"from %s, sock=%d",
(int)listener->factory.addr_name.host.slen,
listener->factory.addr_name.host.ptr,
listener->factory.addr_name.port,
pj_sockaddr_print(src_addr, addr, sizeof(addr), 3),
new_ssock));
/* Retrieve SSL socket info, close the socket if this is failed
* as the SSL socket info availability is rather critical here.
*/
status = pj_ssl_sock_get_info(new_ssock, &ssl_info);
if (status != PJ_SUCCESS) {
pj_ssl_sock_close(new_ssock);
return PJ_TRUE;
}
/*
* Incoming connection!
* Create TLS transport for the new socket.
*/
status = tls_create( listener, NULL, new_ssock, PJ_TRUE,
(const pj_sockaddr_in*)&listener->factory.local_addr,
(const pj_sockaddr_in*)src_addr, NULL, &tls);
if (status != PJ_SUCCESS)
return PJ_TRUE;
/* Set the "pending" SSL socket user data */
pj_ssl_sock_set_user_data(new_ssock, tls);
/* Prevent immediate transport destroy as application may access it
* (getting info, etc) in transport state notification callback.
*/
pjsip_transport_add_ref(&tls->base);
/* If there is verification error and verification is mandatory, shutdown
* and destroy the transport.
*/
if (ssl_info.verify_status && listener->tls_setting.verify_client) {
if (tls->close_reason == PJ_SUCCESS)
tls->close_reason = PJSIP_TLS_ECERTVERIF;
pjsip_transport_shutdown(&tls->base);
}
/* Notify transport state to application */
state_cb = pjsip_tpmgr_get_state_cb(tls->base.tpmgr);
if (state_cb) {
pjsip_transport_state_info state_info;
pjsip_tls_state_info tls_info;
pjsip_transport_state tp_state;
/* Init transport state info */
pj_bzero(&tls_info, sizeof(tls_info));
pj_bzero(&state_info, sizeof(state_info));
tls_info.ssl_sock_info = &ssl_info;
state_info.ext_info = &tls_info;
/* Set transport state based on verification status */
if (ssl_info.verify_status && listener->tls_setting.verify_client)
{
tp_state = PJSIP_TP_STATE_DISCONNECTED;
state_info.status = PJSIP_TLS_ECERTVERIF;
} else {
tp_state = PJSIP_TP_STATE_CONNECTED;
state_info.status = PJ_SUCCESS;
}
(*state_cb)(&tls->base, tp_state, &state_info);
}
/* Release transport reference. If transport is shutting down, it may
* get destroyed here.
*/
is_shutdown = tls->base.is_shutdown;
pjsip_transport_dec_ref(&tls->base);
if (is_shutdown)
return PJ_TRUE;
status = tls_start_read(tls);
if (status != PJ_SUCCESS) {
PJ_LOG(3,(tls->base.obj_name, "New transport cancelled"));
tls_init_shutdown(tls, status);
tls_destroy(&tls->base, status);
} else {
/* Start keep-alive timer */
if (PJSIP_TLS_KEEP_ALIVE_INTERVAL) {
pj_time_val delay = {PJSIP_TLS_KEEP_ALIVE_INTERVAL, 0};
pjsip_endpt_schedule_timer(listener->endpt,
&tls->ka_timer,
&delay);
tls->ka_timer.id = PJ_TRUE;
pj_gettimeofday(&tls->last_activity);
}
}
return PJ_TRUE;
}
