void *ProxyListSessions(struct mansession *s) {
struct message m;
struct mansession *c;
char iabuf[INET_ADDRSTRLEN];
memset(&m, 0, sizeof(struct message));
AddHeader(&m, "ProxyResponse: Success");
pthread_rwlock_rdlock(&sessionlock);
c = sessions;
while (c && (m.hdrcount < MAX_HEADERS - 4) ) {
if (!c->server) {
AddHeader(&m, "ProxyClientSession: %s", ast_inet_ntoa(iabuf, sizeof(iabuf), c->sin.sin_addr));
AddHeader(&m, "ProxyClientActionID: %s", c->actionid);
AddHeader(&m, "ProxyClientInputHandler: %s", c->input->formatname);
AddHeader(&m, "ProxyClientOutputHandler: %s", c->output->formatname);
} else
AddHeader(&m, "ProxyServerSession: %s", ast_inet_ntoa(iabuf, sizeof(iabuf), c->sin.sin_addr));
c = c->next;
}
pthread_rwlock_unlock(&sessionlock);
s->output->write(s, &m);
FreeHeaders(&m);
return 0;
}
int ooGetLocalIPAddress(char * pIPAddrs)
{
int ret;
struct hostent *hp;
struct ast_hostent phost;
char hostname[100];
if(pIPAddrs == NULL)
return -1; /* Need to find suitable return value */
ret = gethostname(hostname, 100);
if(ret == 0)
{
if ((hp = ast_gethostbyname(hostname, &phost))) {
if (hp->h_addrtype == AF_INET6) {
struct in6_addr i;
memcpy(&i, hp->h_addr, sizeof(i));
strcpy(pIPAddrs, (inet_ntop(AF_INET6, &i,
hostname, sizeof(hostname))) == NULL ? "::1" :
inet_ntop(AF_INET6, &i, hostname, sizeof(hostname)));
} else {
struct in_addr i;
memcpy(&i, hp->h_addr, sizeof(i));
strcpy(pIPAddrs, (ast_inet_ntoa(i) == NULL) ? "127.0.0.1" : ast_inet_ntoa(i));
}
} else {
return -1;
}
}
else{
return -1;
}
return ASN_OK;
}
static void http_server_start(struct sockaddr_in *sin)
{
char iabuf[INET_ADDRSTRLEN];
int flags;
int x = 1;
/* Do nothing if nothing has changed */
if (!memcmp(&oldsin, sin, sizeof(oldsin))) {
ast_log(LOG_DEBUG, "Nothing changed in http\n");
return;
}
memcpy(&oldsin, sin, sizeof(oldsin));
/* Shutdown a running server if there is one */
if (master != AST_PTHREADT_NULL) {
pthread_cancel(master);
pthread_kill(master, SIGURG);
pthread_join(master, NULL);
}
if (httpfd != -1)
close(httpfd);
/* If there's no new server, stop here */
if (!sin->sin_family)
return;
httpfd = socket(AF_INET, SOCK_STREAM, 0);
if (httpfd < 0) {
ast_log(LOG_WARNING, "Unable to allocate socket: %s\n", strerror(errno));
return;
}
setsockopt(httpfd, SOL_SOCKET, SO_REUSEADDR, &x, sizeof(x));
if (bind(httpfd, (struct sockaddr *)sin, sizeof(*sin))) {
ast_log(LOG_NOTICE, "Unable to bind http server to %s:%d: %s\n",
ast_inet_ntoa(iabuf, sizeof(iabuf), sin->sin_addr), ntohs(sin->sin_port),
strerror(errno));
close(httpfd);
httpfd = -1;
return;
}
if (listen(httpfd, 10)) {
ast_log(LOG_NOTICE, "Unable to listen!\n");
close(httpfd);
httpfd = -1;
return;
}
flags = fcntl(httpfd, F_GETFL);
fcntl(httpfd, F_SETFL, flags | O_NONBLOCK);
if (ast_pthread_create(&master, NULL, http_root, NULL)) {
ast_log(LOG_NOTICE, "Unable to launch http server on %s:%d: %s\n",
ast_inet_ntoa(iabuf, sizeof(iabuf), sin->sin_addr), ntohs(sin->sin_port),
strerror(errno));
close(httpfd);
httpfd = -1;
}
}
int ooSocketRecvFrom (OOSOCKET socket, ASN1OCTET* pbuf, ASN1UINT bufsize,
char* remotehost, ASN1UINT hostBufLen, int * remoteport)
{
struct sockaddr_in m_addr;
int len, addrlen;
const char * host=NULL;
if (socket == OOSOCKET_INVALID) return ASN_E_INVSOCKET;
addrlen = sizeof(m_addr);
memset (&m_addr, 0, sizeof (m_addr));
if ((len = recvfrom (socket, (char*) pbuf, bufsize, 0,
(struct sockaddr*)&m_addr, (socklen_t *) &addrlen)) == -1)
return ASN_E_INVSOCKET;
if(remoteport)
*remoteport = ntohs(m_addr.sin_port);
if(remotehost)
{
host = ast_inet_ntoa(m_addr.sin_addr);
if(strlen(host) < (hostBufLen-1))
strcpy(remotehost, host);
else
return -1;
}
return len;
}
static int add_ipv4_ie(struct ast_event **event, enum ast_event_ie_type ie_type,
const struct ast_security_event_ipv4_addr *addr)
{
struct ast_str *str = ast_str_alloca(64);
ast_str_set(&str, 0, "IPV4/");
switch (addr->transport) {
case AST_SECURITY_EVENT_TRANSPORT_UDP:
ast_str_append(&str, 0, "UDP/");
break;
case AST_SECURITY_EVENT_TRANSPORT_TCP:
ast_str_append(&str, 0, "TCP/");
break;
case AST_SECURITY_EVENT_TRANSPORT_TLS:
ast_str_append(&str, 0, "TLS/");
break;
}
ast_str_append(&str, 0, "%s/%hu",
ast_inet_ntoa(addr->sin->sin_addr),
ntohs(addr->sin->sin_port));
return ast_event_append_ie_str(event, ie_type, ast_str_buffer(str));
}
/**
* close a connection
* @param c: the connection which will be closed
************************************************************/
void connection_close(connection_t *connection) {
assert(connection != NULL);
char iabuf[INET_ADDRSTRLEN];
LM_DBG("*** Disconnect from [%s]\n", ast_inet_ntoa(iabuf, sizeof(iabuf), connection->sin.sin_addr));
connection_remove_from_list(connection);
//if (!ret)
// return;
event_del(&connection->event);
close(connection->sfd);
pthread_mutex_destroy(&connection->lock);
/*
if (c->pair) {
close(c->pair->sfd);
pthread_mutex_destroy(&c->pair->lock);
free(c->pair);
}
*/
free(connection);
return;
}
void *ProxyListServers(struct mansession *s) {
struct message m;
struct mansession *c;
char iabuf[INET_ADDRSTRLEN];
memset(&m, 0, sizeof(struct message));
AddHeader(&m, "ProxyResponse: Success");
pthread_rwlock_rdlock(&sessionlock);
c = sessions;
while (c) {
if (c->server) {
AddHeader(&m, "ProxyListServer I: %s H: %s U: %s P: %s E: %s ",
ast_inet_ntoa(iabuf, sizeof(iabuf), c->sin.sin_addr),
c->server->ast_host, c->server->ast_user,
c->server->ast_port, c->server->ast_events);
}
c = c->next;
}
pthread_rwlock_unlock(&sessionlock);
s->output->write(s, &m);
FreeHeaders(&m);
return 0;
}
static int handle_show_http(int fd, int argc, char *argv[])
{
struct ast_http_uri *urih;
if (argc != 3)
return RESULT_SHOWUSAGE;
ast_cli(fd, "HTTP Server Status:\n");
ast_cli(fd, "Prefix: %s\n", prefix);
if (oldsin.sin_family)
ast_cli(fd, "Server Enabled and Bound to %s:%d\n\n",
ast_inet_ntoa(oldsin.sin_addr),
ntohs(oldsin.sin_port));
else
ast_cli(fd, "Server Disabled\n\n");
ast_cli(fd, "Enabled URI's:\n");
ast_rwlock_rdlock(&uris_lock);
urih = uris;
while(urih){
ast_cli(fd, "%s/%s%s => %s\n", prefix, urih->uri, (urih->has_subtree ? "/..." : "" ), urih->description);
urih = urih->next;
}
if (!uris)
ast_cli(fd, "None.\n");
ast_rwlock_unlock(&uris_lock);
return RESULT_SUCCESS;
}
int ooSocketGetIpAndPort(OOSOCKET socket, char *ip, int len, int *port)
{
int ret=ASN_OK;
socklen_t size;
struct sockaddr_in addr;
const char *host=NULL;
size = sizeof(addr);
ret = ooSocketGetSockName(socket, &addr, &size);
if(ret != 0)
return ASN_E_INVSOCKET;
host = ast_inet_ntoa(addr.sin_addr);
if(host && strlen(host) < (unsigned)len)
strcpy(ip, host);
else{
OOTRACEERR1("Error:Insufficient buffer for ip address - "
"ooSocketGetIpAndPort\n");
return -1;
}
*port = addr.sin_port;
return ASN_OK;
}
/**
* connect to as server
* @param s: the the connection
************************************************************/
int emp_server_connect(connection_t *connection) {
int r = 0, res = 0;
char iabuf[INET_ADDRSTRLEN];
const char *ipaddr = (const char*)ast_inet_ntoa(iabuf, sizeof(iabuf), connection->sin.sin_addr);
if (ipaddr == NULL)
ipaddr = "n/a";
for (;;) {
if (connect(connection->sfd, (struct sockaddr *) &connection->sin, sizeof(connection->sin)) < 0) {
++r;
if (errno == EISCONN) {
pthread_mutex_lock(&connection->lock);
connection->sfd = socket(AF_INET, SOCK_STREAM, 0);
// set socket to nonblock
/*
int flags = 1;
if ((flags = fcntl(s->sfd, F_GETFL, 0)) < 0 || fcntl(s->sfd, F_SETFL, flags | O_NONBLOCK) < 0) {
LM_ERR("setting O_NONBLOCK fail \n");
close(s->sfd);
continue;
}
*/
struct event_base *base = connection->event.ev_base;
if (event_del(&connection->event) == -1) {
pthread_mutex_unlock(&connection->lock);
LM_ERR("event_del failed \n");
continue;
}
event_assign(&connection->event, base, connection->sfd, EV_READ | EV_PERSIST, server_message_got, (void *)connection);
if (event_add(&connection->event, 0) == -1) {
pthread_mutex_unlock(&connection->lock);
LM_ERR("event_del failed \n");
continue;
}
pthread_mutex_unlock(&connection->lock);
}
LM_DBG("%d> emp_server@%s: Connect failed, Retrying (%04d) %s\n",
connection->sfd, ipaddr, r, strerror(errno));
if (proxy_config.maxretries && (r > proxy_config.maxretries)) {
res = 1;
break;
} else
sleep(proxy_config.retryinterval);
} else {
LM_DBG("%d> emp_server@%s connect to emp_server\n", connection->sfd, ipaddr);
res = 0;
break;
}
}
return res;
}
static void score_address(const struct sockaddr_in *sin, struct in_addr *best_addr, int *best_score)
{
const char *address;
int score;
address = ast_inet_ntoa(sin->sin_addr);
/* RFC 1700 alias for the local network */
if (address[0] == '0')
score = -25;
/* RFC 1700 localnet */
else if (strncmp(address, "127", 3) == 0)
score = -20;
/* RFC 1918 non-public address space */
else if (strncmp(address, "10.", 3) == 0)
score = -5;
/* RFC 1918 non-public address space */
else if (strncmp(address, "172", 3) == 0) {
/* 172.16.0.0 - 172.19.255.255, but not 172.160.0.0 - 172.169.255.255 */
if (address[4] == '1' && address[5] >= '6' && address[6] == '.')
score = -5;
/* 172.20.0.0 - 172.29.255.255, but not 172.200.0.0 - 172.255.255.255 nor 172.2.0.0 - 172.2.255.255 */
else if (address[4] == '2' && address[6] == '.')
score = -5;
/* 172.30.0.0 - 172.31.255.255 */
else if (address[4] == '3' && address[5] <= '1')
score = -5;
/* All other 172 addresses are public */
else
score = 0;
/* RFC 2544 Benchmark test range */
} else if (strncmp(address, "198.1", 5) == 0 && address[5] >= '8' && address[6] == '.')
score = -10;
/* RFC 1918 non-public address space */
else if (strncmp(address, "192.168", 7) == 0)
score = -5;
/* RFC 3330 Zeroconf network */
else if (strncmp(address, "169.254", 7) == 0)
/*!\note Better score than a test network, but not quite as good as RFC 1918
* address space. The reason is that some Linux distributions automatically
* configure a Zeroconf address before trying DHCP, so we want to prefer a
* DHCP lease to a Zeroconf address.
*/
score = -10;
/* RFC 3330 Test network */
else if (strncmp(address, "192.0.2.", 8) == 0)
score = -15;
/* Every other address should be publically routable */
else
score = 0;
if (score > *best_score) {
*best_score = score;
memcpy(best_addr, &sin->sin_addr, sizeof(*best_addr));
}
}
static void dump_addr(char *output, int maxlen, void *value, int len)
{
struct sockaddr_in sin;
if (len == (int)sizeof(sin)) {
memcpy(&sin, value, len);
snprintf(output, maxlen, "IPV4 %s:%d", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
} else {
ast_copy_string(output, "Invalid Address", maxlen);
}
}
struct ast_tcptls_session_instance *ast_tcptls_client_create(struct ast_tcptls_session_args *desc)
{
int x = 1;
struct ast_tcptls_session_instance *tcptls_session = NULL;
/* Do nothing if nothing has changed */
if (!memcmp(&desc->old_address, &desc->remote_address, sizeof(desc->old_address))) {
ast_debug(1, "Nothing changed in %s\n", desc->name);
return NULL;
}
desc->old_address = desc->remote_address;
if (desc->accept_fd != -1)
close(desc->accept_fd);
desc->accept_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (desc->accept_fd < 0) {
ast_log(LOG_WARNING, "Unable to allocate socket for %s: %s\n",
desc->name, strerror(errno));
return NULL;
}
/* if a local address was specified, bind to it so the connection will
originate from the desired address */
if (desc->local_address.sin_family != 0) {
setsockopt(desc->accept_fd, SOL_SOCKET, SO_REUSEADDR, &x, sizeof(x));
if (bind(desc->accept_fd, (struct sockaddr *) &desc->local_address, sizeof(desc->local_address))) {
ast_log(LOG_ERROR, "Unable to bind %s to %s:%d: %s\n",
desc->name,
ast_inet_ntoa(desc->local_address.sin_addr), ntohs(desc->local_address.sin_port),
strerror(errno));
goto error;
}
}
if (!(tcptls_session = ao2_alloc(sizeof(*tcptls_session), session_instance_destructor)))
goto error;
ast_mutex_init(&tcptls_session->lock);
tcptls_session->client = 1;
tcptls_session->fd = desc->accept_fd;
tcptls_session->parent = desc;
tcptls_session->parent->worker_fn = NULL;
memcpy(&tcptls_session->remote_address, &desc->remote_address, sizeof(tcptls_session->remote_address));
return tcptls_session;
error:
close(desc->accept_fd);
desc->accept_fd = -1;
if (tcptls_session)
ao2_ref(tcptls_session, -1);
return NULL;
}
int geo_acl_check(struct sockaddr_in *sin, char *allowed_countries, char *peername)
{
GeoIP * gi;
const char * returnedCountry;
gi = GeoIP_open("/opt/GeoIP/share/GeoIP/GeoIP.dat", GEOIP_STANDARD | GEOIP_CHECK_CACHE);
int retValue = 0;
int j, i=0; // used to iterate through array
char lookup[255];
char *token[86];
if (gi == NULL) {
ast_log(LOG_WARNING, "Failed to open GeoIP Lookup database - ignoring GeoACL");
} else {
if((allowed_countries == NULL) || (strlen(allowed_countries) == 0) ) {
ast_log(LOG_NOTICE, "GeoACL - Peer %s does not have allowed/denied countries defined, ignoring check\n", peername);
} else {
ast_log(LOG_DEBUG, "Using %s for allowed geo acl list\n", allowed_countries);
returnedCountry = GeoIP_country_code_by_addr(gi,ast_inet_ntoa(sin->sin_addr));
if (returnedCountry == NULL) {
ast_log(LOG_WARNING, "GeoACL Lookup failed for '%s' - ignoring GeoACL\n", ast_inet_ntoa(sin->sin_addr));
} else {
// Now we default to deny since we know what they want and where the IP is from
strcpy(lookup, allowed_countries);
retValue = 1;
//ast_log(LOG_NOTICE, "GeoACL - value of allowed_countries is %s", allowed_countries);
token[0] = strtok (lookup,",");
while(token[i]!= NULL) { //ensure a pointer was found
i++;
token[i] = strtok(NULL, ","); //continue to tokenize the string
}
for(j = 0; j <= i-1; j++) {
// ast_log(LOG_DEBUG, "Checking token %s", token[j]);
if (strncmp(returnedCountry, token[j], 2) == 0) {
retValue = 0;
}
}
if (retValue == 1) {
ast_log(LOG_NOTICE, "GeoACL - peer '%s' failed ACL check. Allowed from %s but connected from %s\n", peername, allowed_countries, returnedCountry);
} else {
ast_log(LOG_NOTICE, "GeoACL passed for peer '%s' - connected from '%s'\n", peername, returnedCountry);
}
}
}
}
// Free resources
GeoIP_delete(gi);
return retValue;
}
static char *httpstatus_callback(struct sockaddr_in *req, const char *uri, struct ast_variable *vars, int *status, char **title, int *contentlength)
{
char result[4096];
size_t reslen = sizeof(result);
char *c=result;
struct ast_variable *v;
char iabuf[INET_ADDRSTRLEN];
ast_build_string(&c, &reslen,
"\r\n"
"<title>Asterisk HTTP Status</title>\r\n"
"<body bgcolor=\"#ffffff\">\r\n"
"<table bgcolor=\"#f1f1f1\" align=\"center\"><tr><td bgcolor=\"#e0e0ff\" colspan=\"2\" width=\"500\">\r\n"
"<h2> Asterisk™ HTTP Status</h2></td></tr>\r\n");
ast_build_string(&c, &reslen, "<tr><td><i>Prefix</i></td><td><b>%s</b></td></tr>\r\n", prefix);
ast_build_string(&c, &reslen, "<tr><td><i>Bind Address</i></td><td><b>%s</b></td></tr>\r\n",
ast_inet_ntoa(iabuf, sizeof(iabuf), oldsin.sin_addr));
ast_build_string(&c, &reslen, "<tr><td><i>Bind Port</i></td><td><b>%d</b></td></tr>\r\n",
ntohs(oldsin.sin_port));
ast_build_string(&c, &reslen, "<tr><td colspan=\"2\"><hr></td></tr>\r\n");
v = vars;
while(v) {
if (strncasecmp(v->name, "cookie_", 7))
ast_build_string(&c, &reslen, "<tr><td><i>Submitted Variable '%s'</i></td><td>%s</td></tr>\r\n", v->name, v->value);
v = v->next;
}
ast_build_string(&c, &reslen, "<tr><td colspan=\"2\"><hr></td></tr>\r\n");
v = vars;
while(v) {
if (!strncasecmp(v->name, "cookie_", 7))
ast_build_string(&c, &reslen, "<tr><td><i>Cookie '%s'</i></td><td>%s</td></tr>\r\n", v->name, v->value);
v = v->next;
}
ast_build_string(&c, &reslen, "</table><center><font size=\"-1\"><i>Asterisk and Digium are registered trademarks of Digium, Inc.</i></font></center></body>\r\n");
return strdup(result);
}
struct ast_tcptls_session_instance *ast_tcptls_client_start(struct ast_tcptls_session_instance *tcptls_session)
{
struct ast_tcptls_session_args *desc;
int flags;
if (!(desc = tcptls_session->parent)) {
goto client_start_error;
}
if (connect(desc->accept_fd, (const struct sockaddr *) &desc->remote_address, sizeof(desc->remote_address))) {
ast_log(LOG_ERROR, "Unable to connect %s to %s:%d: %s\n",
desc->name,
ast_inet_ntoa(desc->remote_address.sin_addr), ntohs(desc->remote_address.sin_port),
strerror(errno));
goto client_start_error;
}
flags = fcntl(desc->accept_fd, F_GETFL);
fcntl(desc->accept_fd, F_SETFL, flags & ~O_NONBLOCK);
if (desc->tls_cfg) {
desc->tls_cfg->enabled = 1;
__ssl_setup(desc->tls_cfg, 1);
}
return handle_tcptls_connection(tcptls_session);
client_start_error:
close(desc->accept_fd);
desc->accept_fd = -1;
if (tcptls_session) {
ao2_ref(tcptls_session, -1);
}
return NULL;
}
void ast_tcptls_server_start(struct ast_tcptls_session_args *desc)
{
int flags;
int x = 1;
/* Do nothing if nothing has changed */
if (!memcmp(&desc->old_address, &desc->local_address, sizeof(desc->old_address))) {
ast_debug(1, "Nothing changed in %s\n", desc->name);
return;
}
desc->old_address = desc->local_address;
/* Shutdown a running server if there is one */
if (desc->master != AST_PTHREADT_NULL) {
pthread_cancel(desc->master);
pthread_kill(desc->master, SIGURG);
pthread_join(desc->master, NULL);
}
if (desc->accept_fd != -1)
close(desc->accept_fd);
/* If there's no new server, stop here */
if (desc->local_address.sin_family == 0) {
ast_debug(2, "Server disabled: %s\n", desc->name);
return;
}
desc->accept_fd = socket(AF_INET, SOCK_STREAM, 0);
if (desc->accept_fd < 0) {
ast_log(LOG_ERROR, "Unable to allocate socket for %s: %s\n", desc->name, strerror(errno));
return;
}
setsockopt(desc->accept_fd, SOL_SOCKET, SO_REUSEADDR, &x, sizeof(x));
if (bind(desc->accept_fd, (struct sockaddr *) &desc->local_address, sizeof(desc->local_address))) {
ast_log(LOG_ERROR, "Unable to bind %s to %s:%d: %s\n",
desc->name,
ast_inet_ntoa(desc->local_address.sin_addr), ntohs(desc->local_address.sin_port),
strerror(errno));
goto error;
}
if (listen(desc->accept_fd, 10)) {
ast_log(LOG_ERROR, "Unable to listen for %s!\n", desc->name);
goto error;
}
flags = fcntl(desc->accept_fd, F_GETFL);
fcntl(desc->accept_fd, F_SETFL, flags | O_NONBLOCK);
if (ast_pthread_create_background(&desc->master, NULL, desc->accept_fn, desc)) {
ast_log(LOG_ERROR, "Unable to launch thread for %s on %s:%d: %s\n",
desc->name,
ast_inet_ntoa(desc->local_address.sin_addr), ntohs(desc->local_address.sin_port),
strerror(errno));
goto error;
}
return;
error:
close(desc->accept_fd);
desc->accept_fd = -1;
}
/* \brief called by scheduler to send STUN request */
static int stun_monitor_request(const void *blarg)
{
int res;
struct sockaddr_in answer;
static const struct sockaddr_in no_addr = { 0, };
ast_mutex_lock(&args.lock);
if (!args.monitor_enabled) {
goto monitor_request_cleanup;
}
if (args.stun_sock < 0) {
struct ast_sockaddr stun_addr;
/* STUN socket not open. Refresh the server DNS address resolution. */
if (!args.server_hostname) {
/* No STUN hostname? */
goto monitor_request_cleanup;
}
/* Lookup STUN address. */
memset(&stun_addr, 0, sizeof(stun_addr));
stun_addr.ss.ss_family = AF_INET;
if (ast_get_ip(&stun_addr, args.server_hostname)) {
/* Lookup failed. */
ast_log(LOG_WARNING, "Unable to lookup STUN server '%s'\n",
args.server_hostname);
goto monitor_request_cleanup;
}
ast_sockaddr_set_port(&stun_addr, args.stun_port);
/* open socket binding */
args.stun_sock = socket(AF_INET, SOCK_DGRAM, 0);
if (args.stun_sock < 0) {
ast_log(LOG_WARNING, "Unable to create STUN socket: %s\n", strerror(errno));
goto monitor_request_cleanup;
}
if (ast_connect(args.stun_sock, &stun_addr)) {
ast_log(LOG_WARNING, "STUN Failed to connect to %s: %s\n",
ast_sockaddr_stringify(&stun_addr), strerror(errno));
stun_close_sock();
goto monitor_request_cleanup;
}
}
res = ast_stun_request(args.stun_sock, NULL, NULL, &answer);
if (res) {
/*
* STUN request timed out or errored.
*
* Refresh the server DNS address resolution next time around.
*/
if (!args.stun_poll_failed_gripe) {
args.stun_poll_failed_gripe = 1;
ast_log(LOG_WARNING, "STUN poll %s. Re-evaluating STUN server address.\n",
res < 0 ? "failed" : "got no response");
}
stun_close_sock();
} else {
args.stun_poll_failed_gripe = 0;
if (memcmp(&no_addr, &answer, sizeof(no_addr))
&& memcmp(&args.external_addr, &answer, sizeof(args.external_addr))) {
const char *newaddr = ast_strdupa(ast_inet_ntoa(answer.sin_addr));
int newport = ntohs(answer.sin_port);
ast_log(LOG_NOTICE, "Old external address/port %s:%d now seen as %s:%d.\n",
ast_inet_ntoa(args.external_addr.sin_addr),
ntohs(args.external_addr.sin_port), newaddr, newport);
args.external_addr = answer;
if (args.external_addr_known) {
struct ast_event *event;
/*
* The external address was already known, and has changed...
* generate event.
*/
event = ast_event_new(AST_EVENT_NETWORK_CHANGE, AST_EVENT_IE_END);
if (!event) {
ast_log(LOG_ERROR, "Could not create AST_EVENT_NETWORK_CHANGE event.\n");
} else if (ast_event_queue(event)) {
ast_event_destroy(event);
ast_log(LOG_ERROR, "Could not queue AST_EVENT_NETWORK_CHANGE event.\n");
}
} else {
/* this was the first external address we found, do not alert listeners
* until this address changes to something else. */
args.external_addr_known = 1;
}
}
}
monitor_request_cleanup:
/* always refresh this scheduler item. It will be removed elsewhere when
* it is supposed to go away */
res = args.refresh * 1000;
ast_mutex_unlock(&args.lock);
return res;
}
static void vgsm_mesim_clnt_activate(struct vgsm_mesim_driver *driver)
{
struct vgsm_mesim_clnt *mesim_clnt =
container_of(driver, struct vgsm_mesim_clnt, driver);
struct vgsm_mesim *mesim = mesim_clnt->mesim;
assert(mesim_clnt->listen_fd == -1);
assert(mesim_clnt->sock_fd == -1);
if (ioctl(mesim->fd, VGSM_IOC_SET_SIM_ROUTE,
VGSM_SIM_ROUTE_EXTERNAL) < 0) {
ast_log(LOG_ERROR,
"%s: ioctl(IOC_SET_SIM_ROUTE, EXTERN)"
" failed: %s\n",
mesim->name,
strerror(errno));
return;
}
mesim_clnt->bind_addr.sin_family = AF_INET;
mesim_clnt->listen_fd = socket(AF_INET, SOCK_STREAM, 0);
if (mesim_clnt->listen_fd < 0) {
ast_log(LOG_WARNING,
"Unable to create MESIM socket: %s\n",
strerror(errno));
return;
}
int on = 1;
if(setsockopt(mesim_clnt->listen_fd, SOL_SOCKET, SO_REUSEADDR,
&on, sizeof(on)) == -1) {
ast_log(LOG_ERROR,
"Set Socket Options failed: %s\n",
strerror(errno));
return;
}
if (bind(mesim_clnt->listen_fd,
(struct sockaddr *)&mesim_clnt->bind_addr,
sizeof(mesim_clnt->bind_addr)) < 0) {
#if ASTERISK_VERSION_NUM < 010400 || (ASTERISK_VERSION_NUM >= 10200 && ASTERISK_VERSION_NUM < 10400)
{
char tmpstr[32];
ast_inet_ntoa(tmpstr, sizeof(tmpstr),
mesim_clnt->bind_addr.sin_addr);
ast_log(LOG_WARNING,
"Unable to bind MESIM socket to"
" %s:%d: %s\n",
tmpstr,
ntohs(mesim_clnt->bind_addr.sin_port),
strerror(errno));
}
#else
ast_log(LOG_WARNING,
"Unable to bind MESIM socket to"
" %s:%d: %s\n",
ast_inet_ntoa(mesim_clnt->bind_addr.
sin_addr),
ntohs(mesim_clnt->bind_addr.sin_port),
strerror(errno));
#endif
return;
}
if (listen(mesim_clnt->listen_fd, 10)) {
#if ASTERISK_VERSION_NUM < 010400 || (ASTERISK_VERSION_NUM >= 10200 && ASTERISK_VERSION_NUM < 10400)
{
char tmpstr[32];
ast_inet_ntoa(tmpstr, sizeof(tmpstr),
mesim_clnt->bind_addr.sin_addr);
ast_log(LOG_WARNING,
"Unable to start listening on"
" %s:%d: %s\n",
tmpstr,
ntohs(mesim_clnt->bind_addr.sin_port),
strerror(errno));
}
#else
ast_log(LOG_WARNING,
"Unable to start listening on"
" %s:%d: %s\n",
ast_inet_ntoa(mesim_clnt->bind_addr.
sin_addr),
ntohs(mesim_clnt->bind_addr.sin_port),
strerror(errno));
#endif
return;
}
vgsm_mesim_change_state(mesim, VGSM_MESIM_HOLDER_REMOVED, -1);
}
int ooSocketGetInterfaceList(OOCTXT *pctxt, OOInterface **ifList)
{
OOSOCKET sock;
struct ifconf ifc;
int ifNum;
OOInterface *pIf=NULL;
struct sockaddr_in sin;
OOTRACEDBGA1("Retrieving local interfaces\n");
if(ooSocketCreateUDP(&sock, 4)!= ASN_OK)
{
OOTRACEERR1("Error:Failed to create udp socket - "
"ooSocketGetInterfaceList\n");
return -1;
}
#ifdef SIOCGIFNUM
if(ioctl(sock, SIOCGIFNUM, &ifNum) >= 0)
{
OOTRACEERR1("Error: ioctl for ifNum failed\n");
return -1;
}
#else
ifNum = 50;
#endif
ifc.ifc_len = ifNum * sizeof(struct ifreq);
ifc.ifc_req = (struct ifreq *)memAlloc(pctxt, ifNum *sizeof(struct ifreq));
if(!ifc.ifc_req)
{
OOTRACEERR1("Error:Memory - ooSocketGetInterfaceList - ifc.ifc_req\n");
return -1;
}
if (ioctl(sock, SIOCGIFCONF, &ifc) >= 0) {
void * ifEndList = (char *)ifc.ifc_req + ifc.ifc_len;
struct ifreq *ifName;
struct ifreq ifReq;
int flags;
for (ifName = ifc.ifc_req; (void*)ifName < ifEndList; ifName++) {
char *pName=NULL;
char addr[50];
#ifdef ifr_netmask
char mask[50];
#endif
pIf = (struct OOInterface*)memAlloc(pctxt, sizeof(struct OOInterface));
pName = (char*)memAlloc(pctxt, strlen(ifName->ifr_name)+1);
if(!pIf)
{
OOTRACEERR1("Error:Memory - ooSocketGetInterfaceList - "
"pIf/pName\n");
return -1;
}
OOTRACEDBGA2("\tInterface name: %s\n", ifName->ifr_name);
strcpy(ifReq.ifr_name, ifName->ifr_name);
strcpy(pName, ifName->ifr_name);
pIf->name = pName;
/* Check whether the interface is up*/
if (ioctl(sock, SIOCGIFFLAGS, &ifReq) < 0) {
OOTRACEERR2("Error:Unable to determine status of interface %s\n",
pName);
memFreePtr(pctxt, pIf->name);
memFreePtr(pctxt, pIf);
continue;
}
flags = ifReq.ifr_flags;
if (!(flags & IFF_UP)) {
OOTRACEWARN2("Warn:Interface %s is not up\n", pName);
memFreePtr(pctxt, pIf->name);
memFreePtr(pctxt, pIf);
continue;
}
/* Retrieve interface address */
if (ioctl(sock, SIOCGIFADDR, &ifReq) < 0)
{
OOTRACEWARN2("Warn:Unable to determine address of interface %s\n",
pName);
memFreePtr(pctxt, pIf->name);
memFreePtr(pctxt, pIf);
continue;
}
memcpy(&sin, &ifReq.ifr_addr, sizeof(struct sockaddr_in));
strcpy(addr, ast_inet_ntoa(sin.sin_addr));
OOTRACEDBGA2("\tIP address is %s\n", addr);
pIf->addr = (char*)memAlloc(pctxt, strlen(addr)+1);
if(!pIf->addr)
{
OOTRACEERR1("Error:Memory - ooSocketGetInterfaceList - "
"pIf->addr\n");
memFreePtr(pctxt, pIf->name);
memFreePtr(pctxt, pIf);
return -1;
}
strcpy(pIf->addr, addr);
#ifdef ifr_netmask
if (ioctl(sock, SIOCGIFNETMASK, &ifReq) < 0)
{
OOTRACEWARN2("Warn:Unable to determine mask for interface %s\n",
pName);
memFreePtr(pctxt, pIf->name);
memFreePtr(pctxt, pIf->addr);
memFreePtr(pctxt, pIf);
continue;
}
memcpy(&sin, &ifReq.ifr_netmask, sizeof(struct sockaddr_in));
strcpy(mask, ast_inet_ntoa(sin.sin_addr));
OOTRACEDBGA2("\tMask is %s\n", mask);
pIf->mask = (char*)memAlloc(pctxt, strlen(mask)+1);
if(!pIf->mask)
{
OOTRACEERR1("Error:Memory - ooSocketGetInterfaceList - "
"pIf->mask\n");
memFreePtr(pctxt, pIf->name);
memFreePtr(pctxt, pIf->addr);
memFreePtr(pctxt, pIf);
return -1;
}
strcpy(pIf->mask, mask);
#endif
pIf->next = NULL;
/* Add to the list */
if(!*ifList)
{
*ifList = pIf;
pIf = NULL;
}
else{
pIf->next = *ifList;
*ifList = pIf;
pIf=NULL;
}
/*
#if defined(OO_FREEBSD) || defined(OO_OPENBSD) || defined(OO_NETBSD) || defined(OO_MACOSX) || defined(OO_VXWORKS) || defined(OO_RTEMS) || defined(OO_QNX)
#ifndef _SIZEOF_ADDR_IFREQ
#define _SIZEOF_ADDR_IFREQ(ifr) \
((ifr).ifr_addr.sa_len > sizeof(struct sockaddr) ? \
(sizeof(struct ifreq) - sizeof(struct sockaddr) + \
(ifr).ifr_addr.sa_len) : sizeof(struct ifreq))
#endif
ifName = (struct ifreq *)((char *)ifName + _SIZEOF_ADDR_IFREQ(*ifName));
#else
ifName++;
*/
}
}
return ASN_OK;
}
/**
* This routine based on get_input from asterisk manager.c
* Good generic line-based input routine for \r\n\r\n terminated input
* Used by standard.c and other input handlers
* @param s: the connection
* @param output: the buffer save the message
************************************************************/
int get_input(connection_t *connection, char *output) {
/* output must have at least sizeof(s->inbuf) space */
int res;
int x;
struct pollfd fds[1];
//char iabuf[INET_ADDRSTRLEN];
//LM_DBG("s->inbuf = %s\n", s->inbuf);
/* Look for \r\n from the front, our preferred end of line */
for (x = 0; x < connection->inlen; x++) {
int xtra = 0;
if (connection->inbuf[x] == '\n') {
if (x && connection->inbuf[x-1] == '\r') {
xtra = 1;
}
/* Copy output data not including \r\n */
memcpy(output, connection->inbuf, x - xtra);
/* Add trailing \0 */
output[x-xtra] = '\0';
/* Move remaining data back to the front */
memmove(connection->inbuf, connection->inbuf + x + 1, connection->inlen - x);
connection->inlen -= (x + 1);
return 1;
}
}
if ((unsigned int)connection->inlen >= sizeof(connection->inbuf) - 1) {
char iabuf[INET_ADDRSTRLEN];
const char *ipaddr = (const char*)ast_inet_ntoa(iabuf, sizeof(iabuf), connection->sin.sin_addr);
if (ipaddr == NULL)
ipaddr = "n/a";
if (connection->server)
LM_ERR("Warning: got wrong msg from server[%s]\n", ipaddr);
else
LM_ERR("Warning: got wrong msg from client[%s]\n", ipaddr);
connection->inlen = 0;
// return -1;
}
fds[0].fd = connection->sfd;
fds[0].events = POLLIN;
res = poll(fds, 1, -1);
if (res < 0) {
LM_ERR("Select returned error from fd[%d], error:%s\n", fds[0].fd, strerror(errno));
return 0;
} else if (res > 0) {
pthread_mutex_lock(&connection->lock);
res = read(connection->sfd, connection->inbuf + connection->inlen, sizeof(connection->inbuf) - 1 - connection->inlen);
pthread_mutex_unlock(&connection->lock);
if (res < 1)
return -1;
}
connection->inlen += res;
connection->inbuf[connection->inlen] = '\0';
//LM_DBG("s->inbuf = %s\n", s->inbuf);
return 0;
/* We have some input, but it's not ready for processing */
}
