mirror of
https://github.com/signalwire/freeswitch.git
synced 2025-02-15 22:46:59 +00:00
7897701da9
git-svn-id: http://svn.openzap.org/svn/openzap/trunk@392 a93c3328-9c30-0410-af19-c9cd2b2d52af
416 lines
12 KiB
C
416 lines
12 KiB
C
/*
|
|
* Copyright (c) 2007, Anthony Minessale II, Nenad Corbic
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
*
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* * Neither the name of the original author; nor the names of any contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
|
|
* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
|
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
|
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
#include "openzap.h"
|
|
#include <ss7_boost_client.h>
|
|
|
|
#ifndef gethostbyname_r
|
|
extern int gethostbyname_r (__const char *__restrict __name,
|
|
struct hostent *__restrict __result_buf,
|
|
char *__restrict __buf, size_t __buflen,
|
|
struct hostent **__restrict __result,
|
|
int *__restrict __h_errnop);
|
|
#endif
|
|
|
|
struct ss7bc_map {
|
|
uint32_t event_id;
|
|
char *name;
|
|
};
|
|
|
|
static struct ss7bc_map ss7bc_table[] = {
|
|
{SIGBOOST_EVENT_CALL_START, "CALL_START"},
|
|
{SIGBOOST_EVENT_CALL_START_ACK, "CALL_START_ACK"},
|
|
{SIGBOOST_EVENT_CALL_START_NACK, "CALL_START_NACK"},
|
|
{SIGBOOST_EVENT_CALL_START_NACK_ACK, "CALL_START_NACK_ACK"},
|
|
{SIGBOOST_EVENT_CALL_ANSWERED, "CALL_ANSWERED"},
|
|
{SIGBOOST_EVENT_CALL_STOPPED, "CALL_STOPPED"},
|
|
{SIGBOOST_EVENT_CALL_STOPPED_ACK, "CALL_STOPPED_ACK"},
|
|
{SIGBOOST_EVENT_SYSTEM_RESTART, "SYSTEM_RESTART"},
|
|
{SIGBOOST_EVENT_SYSTEM_RESTART_ACK, "SYSTEM_RESTART_ACK"},
|
|
{SIGBOOST_EVENT_HEARTBEAT, "HEARTBEAT"},
|
|
{SIGBOOST_EVENT_INSERT_CHECK_LOOP, "LOOP START"},
|
|
{SIGBOOST_EVENT_REMOVE_CHECK_LOOP, "LOOP STOP"}
|
|
};
|
|
|
|
|
|
|
|
static int create_conn_socket(ss7bc_connection_t *mcon, char *local_ip, int local_port, char *ip, int port)
|
|
{
|
|
int rc;
|
|
struct hostent *result, *local_result;
|
|
char buf[512], local_buf[512];
|
|
int err = 0;
|
|
|
|
memset(&mcon->remote_hp, 0, sizeof(mcon->remote_hp));
|
|
memset(&mcon->local_hp, 0, sizeof(mcon->local_hp));
|
|
#ifdef SS7BC_USE_SCTP
|
|
mcon->socket = socket(AF_INET, SOCK_SEQPACKET, IPPROTO_SCTP);
|
|
#else
|
|
mcon->socket = socket(AF_INET, SOCK_DGRAM, 0);
|
|
#endif
|
|
|
|
zap_log(ZAP_LOG_DEBUG, "Creating L=%s:%d R=%s:%d\n",
|
|
local_ip,local_port,ip,port);
|
|
|
|
if (mcon->socket >= 0) {
|
|
int flag;
|
|
|
|
flag = 1;
|
|
gethostbyname_r(ip, &mcon->remote_hp, buf, sizeof(buf), &result, &err);
|
|
gethostbyname_r(local_ip, &mcon->local_hp, local_buf, sizeof(local_buf), &local_result, &err);
|
|
if (result && local_result) {
|
|
mcon->remote_addr.sin_family = mcon->remote_hp.h_addrtype;
|
|
memcpy((char *) &mcon->remote_addr.sin_addr.s_addr, mcon->remote_hp.h_addr_list[0], mcon->remote_hp.h_length);
|
|
mcon->remote_addr.sin_port = htons(port);
|
|
|
|
mcon->local_addr.sin_family = mcon->local_hp.h_addrtype;
|
|
memcpy((char *) &mcon->local_addr.sin_addr.s_addr, mcon->local_hp.h_addr_list[0], mcon->local_hp.h_length);
|
|
mcon->local_addr.sin_port = htons(local_port);
|
|
|
|
#ifdef SS7BC_USE_SCTP
|
|
setsockopt(mcon->socket, IPPROTO_SCTP, SCTP_NODELAY,
|
|
(char *)&flag, sizeof(int));
|
|
#endif
|
|
|
|
if ((rc = bind(mcon->socket,
|
|
(struct sockaddr *) &mcon->local_addr,
|
|
sizeof(mcon->local_addr))) < 0) {
|
|
close(mcon->socket);
|
|
mcon->socket = -1;
|
|
} else {
|
|
#ifdef SS7BC_USE_SCTP
|
|
rc=listen(mcon->socket,100);
|
|
if (rc) {
|
|
close(mcon->socket);
|
|
mcon->socket = -1;
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
return mcon->socket;
|
|
}
|
|
|
|
int ss7bc_connection_close(ss7bc_connection_t *mcon)
|
|
{
|
|
close(mcon->socket);
|
|
mcon->socket = -1;
|
|
memset(mcon, 0, sizeof(*mcon));
|
|
|
|
return 0;
|
|
}
|
|
|
|
int ss7bc_connection_open(ss7bc_connection_t *mcon, char *local_ip, int local_port, char *ip, int port)
|
|
{
|
|
create_conn_socket(mcon, local_ip, local_port, ip, port);
|
|
return mcon->socket;
|
|
}
|
|
|
|
ss7bc_event_t *ss7bc_connection_read(ss7bc_connection_t *mcon, int iteration)
|
|
{
|
|
unsigned int fromlen = sizeof(struct sockaddr_in);
|
|
#if 0
|
|
ss7bc_event_t *event = &mcon->event;
|
|
#endif
|
|
int bytes = 0;
|
|
|
|
bytes = recvfrom(mcon->socket, &mcon->event, sizeof(mcon->event), MSG_DONTWAIT,
|
|
(struct sockaddr *) &mcon->local_addr, &fromlen);
|
|
|
|
if (bytes == sizeof(mcon->event) ||
|
|
bytes == (sizeof(mcon->event)-sizeof(uint32_t))) {
|
|
|
|
if (mcon->rxseq_reset) {
|
|
if (mcon->event.event_id == SIGBOOST_EVENT_SYSTEM_RESTART_ACK) {
|
|
zap_log(ZAP_LOG_DEBUG, "Rx sync ok\n");
|
|
mcon->rxseq=mcon->event.fseqno;
|
|
return &mcon->event;
|
|
}
|
|
errno=EAGAIN;
|
|
zap_log(ZAP_LOG_DEBUG, "Waiting for rx sync...\n");
|
|
return NULL;
|
|
}
|
|
|
|
mcon->txwindow = mcon->txseq - mcon->event.bseqno;
|
|
mcon->rxseq++;
|
|
|
|
if (mcon->rxseq != mcon->event.fseqno) {
|
|
zap_log(ZAP_LOG_DEBUG,
|
|
"------------------------------------------\n");
|
|
zap_log(ZAP_LOG_DEBUG,
|
|
"Critical Error: Invalid Sequence Number Expect=%i Rx=%i\n",
|
|
mcon->rxseq,mcon->event.fseqno);
|
|
zap_log(ZAP_LOG_DEBUG,
|
|
"------------------------------------------\n");
|
|
}
|
|
|
|
#if 0
|
|
/* Debugging only not to be used in production because span/chan can be invalid */
|
|
if (mcon->event.span < 0 || mcon->event.chan < 0 || mcon->event.span > 16 || mcon->event.chan > 31) {
|
|
zap_log(ZAP_LOG_DEBUG,
|
|
"------------------------------------------\n");
|
|
zap_log(ZAP_LOG_DEBUG,
|
|
"Critical Error: RX Cmd=%s Invalid Span=%i Chan=%i\n",
|
|
ss7bc_event_id_name(event->event_id), event->span,event->chan);
|
|
zap_log(ZAP_LOG_DEBUG,
|
|
"------------------------------------------\n");
|
|
|
|
errno=EAGAIN;
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
|
|
return &mcon->event;
|
|
} else {
|
|
if (iteration == 0) {
|
|
zap_log(ZAP_LOG_DEBUG,
|
|
"------------------------------------------\n");
|
|
zap_log(ZAP_LOG_DEBUG,
|
|
"Critical Error: Invalid Event lenght from boost rxlen=%i evsz=%i\n",
|
|
bytes, sizeof(mcon->event));
|
|
zap_log(ZAP_LOG_DEBUG,
|
|
"------------------------------------------\n");
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
ss7bc_event_t *ss7bc_connection_readp(ss7bc_connection_t *mcon, int iteration)
|
|
{
|
|
unsigned int fromlen = sizeof(struct sockaddr_in);
|
|
#if 0
|
|
ss7bc_event_t *event = &mcon->event;
|
|
#endif
|
|
int bytes = 0;
|
|
|
|
bytes = recvfrom(mcon->socket, &mcon->event, sizeof(mcon->event), MSG_DONTWAIT,
|
|
(struct sockaddr *) &mcon->local_addr, &fromlen);
|
|
|
|
if (bytes == sizeof(mcon->event) ||
|
|
bytes == (sizeof(mcon->event)-sizeof(uint32_t))) {
|
|
|
|
#if 0
|
|
/* Debugging only not to be used in production because span/chan can be invalid */
|
|
if (mcon->event.span < 0 || mcon->event.chan < 0 || mcon->event.span > 16 || mcon->event.chan > 31) {
|
|
zap_log(ZAP_LOG_DEBUG,
|
|
"------------------------------------------\n");
|
|
zap_log(ZAP_LOG_DEBUG,
|
|
"Critical Error: RXp Cmd=%s Invalid Span=%i Chan=%i\n",
|
|
ss7bc_event_id_name(event->event_id), event->span,event->chan);
|
|
zap_log(ZAP_LOG_DEBUG,
|
|
"------------------------------------------\n");
|
|
|
|
errno=EAGAIN;
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
return &mcon->event;
|
|
} else {
|
|
if (iteration == 0) {
|
|
zap_log(ZAP_LOG_DEBUG,
|
|
"------------------------------------------\n");
|
|
zap_log(ZAP_LOG_DEBUG,
|
|
"Critical Error: PQ Invalid Event lenght from boost rxlen=%i evsz=%i\n",
|
|
bytes, sizeof(mcon->event));
|
|
zap_log(ZAP_LOG_DEBUG,
|
|
"------------------------------------------\n");
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
int ss7bc_connection_write(ss7bc_connection_t *mcon, ss7bc_event_t *event)
|
|
{
|
|
int err;
|
|
if (!event) {
|
|
zap_log(ZAP_LOG_DEBUG, "Critical Error: No Event Device\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (event->span > 16 || event->chan > 31) {
|
|
zap_log(ZAP_LOG_DEBUG,
|
|
"------------------------------------------\n");
|
|
zap_log(ZAP_LOG_DEBUG,
|
|
"Critical Error: TX Cmd=%s Invalid Span=%i Chan=%i\n",
|
|
ss7bc_event_id_name(event->event_id), event->span,event->chan);
|
|
zap_log(ZAP_LOG_DEBUG,
|
|
"------------------------------------------\n");
|
|
|
|
return -1;
|
|
}
|
|
|
|
gettimeofday(&event->tv,NULL);
|
|
|
|
pthread_mutex_lock(&mcon->lock);
|
|
event->fseqno=mcon->txseq++;
|
|
event->bseqno=mcon->rxseq;
|
|
err=sendto(mcon->socket, event, sizeof(ss7bc_event_t), 0,
|
|
(struct sockaddr *) &mcon->remote_addr, sizeof(mcon->remote_addr));
|
|
pthread_mutex_unlock(&mcon->lock);
|
|
|
|
if (err != sizeof(ss7bc_event_t)) {
|
|
err = -1;
|
|
}
|
|
|
|
#if 0
|
|
zap_log(ZAP_LOG_DEBUG, "TX EVENT\n");
|
|
zap_log(ZAP_LOG_DEBUG, "===================================\n");
|
|
zap_log(ZAP_LOG_DEBUG, " tType: %s (%0x HEX)\n",
|
|
ss7bc_event_id_name(event->event_id),event->event_id);
|
|
zap_log(ZAP_LOG_DEBUG, " tSpan: [%d]\n",event->span+1);
|
|
zap_log(ZAP_LOG_DEBUG, " tChan: [%d]\n",event->chan+1);
|
|
zap_log(ZAP_LOG_DEBUG, " tCalledNum: %s\n",
|
|
(event->called_number_digits_count ? (char *) event->called_number_digits : "N/A"));
|
|
zap_log(ZAP_LOG_DEBUG, " tCallingNum: %s\n",
|
|
(event->calling_number_digits_count ? (char *) event->calling_number_digits : "N/A"));
|
|
zap_log(ZAP_LOG_DEBUG, " tCause: %d\n",event->release_cause);
|
|
zap_log(ZAP_LOG_DEBUG, " tInterface: [w%dg%d]\n",event->span+1,event->chan+1);
|
|
zap_log(ZAP_LOG_DEBUG, " tEvent ID: [%d]\n",event->event_id);
|
|
zap_log(ZAP_LOG_DEBUG, " tSetup ID: [%d]\n",event->call_setup_id);
|
|
zap_log(ZAP_LOG_DEBUG, " tSeq: [%d]\n",event->fseqno);
|
|
zap_log(ZAP_LOG_DEBUG, "===================================\n");
|
|
#endif
|
|
|
|
#if 1
|
|
zap_log(ZAP_LOG_DEBUG,
|
|
"TX EVENT: %s:(%X) [w%dg%d] Rc=%i CSid=%i Seq=%i Cd=[%s] Ci=[%s]\n",
|
|
ss7bc_event_id_name(event->event_id),
|
|
event->event_id,
|
|
event->span+1,
|
|
event->chan+1,
|
|
event->release_cause,
|
|
event->call_setup_id,
|
|
event->fseqno,
|
|
(event->called_number_digits_count ? (char *) event->called_number_digits : "N/A"),
|
|
(event->calling_number_digits_count ? (char *) event->calling_number_digits : "N/A")
|
|
);
|
|
#endif
|
|
|
|
|
|
#if 0
|
|
|
|
zap_log(ZAP_LOG_DEBUG,
|
|
"\nTX EVENT\n"
|
|
"===================================\n"
|
|
" tType: %s (%0x HEX)\n"
|
|
" tSpan: [%d]\n"
|
|
" tChan: [%d]\n"
|
|
" tCalledNum: %s\n"
|
|
" tCallingNum: %s\n"
|
|
" tCause: %d\n"
|
|
" tInterface: [w%dg%d]\n"
|
|
" tEvent ID: [%d]\n"
|
|
" tSetup ID: [%d]\n"
|
|
" tSeq: [%d]\n"
|
|
"===================================\n"
|
|
"\n",
|
|
ss7bc_event_id_name(event->event_id),
|
|
event->event_id,
|
|
event->span+1,
|
|
event->chan+1,
|
|
(event->called_number_digits_count ? (char *) event->called_number_digits : "N/A"),
|
|
(event->calling_number_digits_count ? (char *) event->calling_number_digits : "N/A"),
|
|
event->release_cause,
|
|
event->span+1,
|
|
event->chan+1,
|
|
event->event_id,
|
|
event->call_setup_id,
|
|
event->fseqno
|
|
);
|
|
#endif
|
|
|
|
|
|
return err;
|
|
}
|
|
|
|
void ss7bc_call_init(ss7bc_event_t *event, char *calling, char *called, int setup_id)
|
|
{
|
|
memset(event, 0, sizeof(ss7bc_event_t));
|
|
event->event_id = SIGBOOST_EVENT_CALL_START;
|
|
|
|
if (calling) {
|
|
strncpy((char*)event->calling_number_digits, calling, sizeof(event->calling_number_digits)-1);
|
|
event->calling_number_digits_count = strlen(calling);
|
|
}
|
|
|
|
if (called) {
|
|
strncpy((char*)event->called_number_digits, called, sizeof(event->called_number_digits)-1);
|
|
event->called_number_digits_count = strlen(called);
|
|
}
|
|
|
|
event->call_setup_id = setup_id;
|
|
|
|
}
|
|
|
|
void ss7bc_event_init(ss7bc_event_t *event, ss7bc_event_id_t event_id, int chan, int span)
|
|
{
|
|
memset(event, 0, sizeof(ss7bc_event_t));
|
|
event->event_id = event_id;
|
|
event->chan = chan;
|
|
event->span = span;
|
|
}
|
|
|
|
char *ss7bc_event_id_name(uint32_t event_id)
|
|
{
|
|
unsigned int x;
|
|
char *ret = NULL;
|
|
|
|
for (x = 0 ; x < sizeof(ss7bc_table)/sizeof(struct ss7bc_map); x++) {
|
|
if (ss7bc_table[x].event_id == event_id) {
|
|
ret = ss7bc_table[x].name;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* For Emacs:
|
|
* Local Variables:
|
|
* mode:c
|
|
* indent-tabs-mode:t
|
|
* tab-width:4
|
|
* c-basic-offset:4
|
|
* End:
|
|
* For VIM:
|
|
* vim:set softtabstop=4 shiftwidth=4 tabstop=4 expandtab:
|
|
*/
|
|
|