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;
}
/* Resolve the IP address of local machine */
PJ_DEF(pj_status_t) pj_gethostip(int af, pj_sockaddr *addr)
{
unsigned i, count, cand_cnt;
enum {
CAND_CNT = 8,
/* Weighting to be applied to found addresses */
WEIGHT_HOSTNAME = 1, /* hostname IP is not always valid! */
WEIGHT_DEF_ROUTE = 2,
WEIGHT_INTERFACE = 1,
WEIGHT_LOOPBACK = -5,
WEIGHT_LINK_LOCAL = -4,
WEIGHT_DISABLED = -50,
MIN_WEIGHT = WEIGHT_DISABLED+1 /* minimum weight to use */
};
/* candidates: */
pj_sockaddr cand_addr[CAND_CNT];
int cand_weight[CAND_CNT];
int selected_cand;
char strip[PJ_INET6_ADDRSTRLEN+10];
/* Special IPv4 addresses. */
struct spec_ipv4_t
{
pj_uint32_t addr;
pj_uint32_t mask;
int weight;
} spec_ipv4[] =
{
/* 127.0.0.0/8, loopback addr will be used if there is no other
* addresses.
*/
{ 0x7f000000, 0xFF000000, WEIGHT_LOOPBACK },
/* 0.0.0.0/8, special IP that doesn't seem to be practically useful */
{ 0x00000000, 0xFF000000, WEIGHT_DISABLED },
/* 169.254.0.0/16, a zeroconf/link-local address, which has higher
* priority than loopback and will be used if there is no other
* valid addresses.
*/
{ 0xa9fe0000, 0xFFFF0000, WEIGHT_LINK_LOCAL }
};
/* Special IPv6 addresses */
struct spec_ipv6_t
{
pj_uint8_t addr[16];
pj_uint8_t mask[16];
int weight;
} spec_ipv6[] =
{
/* Loopback address, ::1/128 */
{ {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
{0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff},
WEIGHT_LOOPBACK
},
/* Link local, fe80::/10 */
{ {0xfe,0x80,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0xff,0xc0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
WEIGHT_LINK_LOCAL
},
/* Disabled, ::/128 */
{ {0x0,0x0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{ 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff},
WEIGHT_DISABLED
}
};
pj_addrinfo ai;
pj_status_t status;
/* May not be used if TRACE_ is disabled */
PJ_UNUSED_ARG(strip);
#ifdef _MSC_VER
/* Get rid of "uninitialized he variable" with MS compilers */
pj_bzero(&ai, sizeof(ai));
#endif
cand_cnt = 0;
pj_bzero(cand_addr, sizeof(cand_addr));
pj_bzero(cand_weight, sizeof(cand_weight));
for (i=0; i<PJ_ARRAY_SIZE(cand_addr); ++i) {
cand_addr[i].addr.sa_family = (pj_uint16_t)af;
PJ_SOCKADDR_RESET_LEN(&cand_addr[i]);
}
addr->addr.sa_family = (pj_uint16_t)af;
PJ_SOCKADDR_RESET_LEN(addr);
#if !defined(PJ_GETHOSTIP_DISABLE_LOCAL_RESOLUTION) || \
PJ_GETHOSTIP_DISABLE_LOCAL_RESOLUTION == 0
TRACE_((THIS_FILE, "pj_gethostip() pj_getaddrinfo1"));
/* Get hostname's IP address */
count = 1;
status = pj_getaddrinfo(af, pj_gethostname(), &count, &ai);
if (status == PJ_SUCCESS) {
pj_assert(ai.ai_addr.addr.sa_family == (pj_uint16_t)af);
pj_sockaddr_copy_addr(&cand_addr[cand_cnt], &ai.ai_addr);
pj_sockaddr_set_port(&cand_addr[cand_cnt], 0);
cand_weight[cand_cnt] += WEIGHT_HOSTNAME;
++cand_cnt;
TRACE_((THIS_FILE, "hostname IP is %s",
pj_sockaddr_print(&ai.ai_addr, strip, sizeof(strip), 0)));
}
TRACE_((THIS_FILE, "pj_gethostip() pj_getaddrinfo2"));
#else
PJ_UNUSED_ARG(ai);
PJ_UNUSED_ARG(count);
#endif
/* Get default interface (interface for default route) */
if (cand_cnt < PJ_ARRAY_SIZE(cand_addr)) {
status = pj_getdefaultipinterface(af, addr);
if (status == PJ_SUCCESS) {
TRACE_((THIS_FILE, "default IP is %s",
pj_sockaddr_print(addr, strip, sizeof(strip), 0)));
pj_sockaddr_set_port(addr, 0);
for (i=0; i<cand_cnt; ++i) {
if (pj_sockaddr_cmp(&cand_addr[i], addr)==0)
break;
}
cand_weight[i] += WEIGHT_DEF_ROUTE;
if (i >= cand_cnt) {
pj_sockaddr_copy_addr(&cand_addr[i], addr);
++cand_cnt;
}
}
}
/* Enumerate IP interfaces */
if (cand_cnt < PJ_ARRAY_SIZE(cand_addr)) {
unsigned start_if = cand_cnt;
unsigned count = PJ_ARRAY_SIZE(cand_addr) - start_if;
status = pj_enum_ip_interface(af, &count, &cand_addr[start_if]);
if (status == PJ_SUCCESS && count) {
/* Clear the port number */
for (i=0; i<count; ++i)
pj_sockaddr_set_port(&cand_addr[start_if+i], 0);
/* For each candidate that we found so far (that is the hostname
* address and default interface address, check if they're found
* in the interface list. If found, add the weight, and if not,
* decrease the weight.
*/
for (i=0; i<cand_cnt; ++i) {
unsigned j;
for (j=0; j<count; ++j) {
if (pj_sockaddr_cmp(&cand_addr[i],
&cand_addr[start_if+j])==0)
break;
}
if (j == count) {
/* Not found */
cand_weight[i] -= WEIGHT_INTERFACE;
} else {
cand_weight[i] += WEIGHT_INTERFACE;
}
}
/* Add remaining interface to candidate list. */
for (i=0; i<count; ++i) {
unsigned j;
for (j=0; j<cand_cnt; ++j) {
if (pj_sockaddr_cmp(&cand_addr[start_if+i],
&cand_addr[j])==0)
break;
}
if (j == cand_cnt) {
pj_sockaddr_copy_addr(&cand_addr[cand_cnt],
&cand_addr[start_if+i]);
cand_weight[cand_cnt] += WEIGHT_INTERFACE;
++cand_cnt;
}
}
}
}
/* Apply weight adjustment for special IPv4/IPv6 addresses
* See http://trac.pjsip.org/repos/ticket/1046
*/
if (af == PJ_AF_INET) {
for (i=0; i<cand_cnt; ++i) {
unsigned j;
for (j=0; j<PJ_ARRAY_SIZE(spec_ipv4); ++j) {
pj_uint32_t a = pj_ntohl(cand_addr[i].ipv4.sin_addr.s_addr);
pj_uint32_t pa = spec_ipv4[j].addr;
pj_uint32_t pm = spec_ipv4[j].mask;
if ((a & pm) == pa) {
cand_weight[i] += spec_ipv4[j].weight;
break;
}
}
}
} else if (af == PJ_AF_INET6) {
for (i=0; i<PJ_ARRAY_SIZE(spec_ipv6); ++i) {
unsigned j;
for (j=0; j<cand_cnt; ++j) {
pj_uint8_t *a = cand_addr[j].ipv6.sin6_addr.s6_addr;
pj_uint8_t am[16];
pj_uint8_t *pa = spec_ipv6[i].addr;
pj_uint8_t *pm = spec_ipv6[i].mask;
unsigned k;
for (k=0; k<16; ++k) {
am[k] = (pj_uint8_t)((a[k] & pm[k]) & 0xFF);
}
if (pj_memcmp(am, pa, 16)==0) {
cand_weight[j] += spec_ipv6[i].weight;
}
}
}
} else {
return PJ_EAFNOTSUP;
}
/* Enumerate candidates to get the best IP address to choose */
selected_cand = -1;
for (i=0; i<cand_cnt; ++i) {
TRACE_((THIS_FILE, "Checking candidate IP %s, weight=%d",
pj_sockaddr_print(&cand_addr[i], strip, sizeof(strip), 0),
cand_weight[i]));
if (cand_weight[i] < MIN_WEIGHT) {
continue;
}
if (selected_cand == -1)
selected_cand = i;
else if (cand_weight[i] > cand_weight[selected_cand])
selected_cand = i;
}
/* If else fails, returns loopback interface as the last resort */
if (selected_cand == -1) {
if (af==PJ_AF_INET) {
addr->ipv4.sin_addr.s_addr = pj_htonl (0x7f000001);
} else {
pj_in6_addr *s6_addr;
s6_addr = (pj_in6_addr*) pj_sockaddr_get_addr(addr);
pj_bzero(s6_addr, sizeof(pj_in6_addr));
s6_addr->s6_addr[15] = 1;
}
TRACE_((THIS_FILE, "Loopback IP %s returned",
pj_sockaddr_print(addr, strip, sizeof(strip), 0)));
} else {
pj_sockaddr_copy_addr(addr, &cand_addr[selected_cand]);
TRACE_((THIS_FILE, "Candidate %s selected",
pj_sockaddr_print(addr, strip, sizeof(strip), 0)));
}
return PJ_SUCCESS;
}
pj_status_t init_stack(const std::string& system_name,
const std::string& sas_address,
int trusted_port,
int untrusted_port,
const std::string& local_host,
const std::string& home_domain,
const std::string& sprout_cluster_domain,
const std::string& alias_hosts,
int num_pjsip_threads,
int num_worker_threads)
{
pj_status_t status;
pj_sockaddr pri_addr;
pj_sockaddr addr_list[16];
unsigned addr_cnt = PJ_ARRAY_SIZE(addr_list);
unsigned i;
// Set up the vectors of threads. The threads don't get created until
// start_stack is called.
pjsip_threads.resize(num_pjsip_threads);
worker_threads.resize(num_worker_threads);
// Get ports and host names specified on options. If local host was not
// specified, use the host name returned by pj_gethostname.
memset(&stack_data, 0, sizeof(stack_data));
char* local_host_cstr = strdup(local_host.c_str());
char* home_domain_cstr = strdup(home_domain.c_str());
char* sprout_cluster_domain_cstr = strdup(sprout_cluster_domain.c_str());
stack_data.trusted_port = trusted_port;
stack_data.untrusted_port = untrusted_port;
stack_data.local_host = (local_host != "") ? pj_str(local_host_cstr) : *pj_gethostname();
stack_data.home_domain = (home_domain != "") ? pj_str(home_domain_cstr) : stack_data.local_host;
stack_data.sprout_cluster_domain = (sprout_cluster_domain != "") ? pj_str(sprout_cluster_domain_cstr) : stack_data.local_host;
// Initialize SAS logging.
if (system_name != "")
{
SAS::init(system_name.length(), system_name.c_str(), sas_address);
}
else
{
SAS::init(stack_data.local_host.slen, stack_data.local_host.ptr, sas_address);
}
// Initialise PJSIP and all the associated resources.
status = init_pjsip();
// Register the stack module.
pjsip_endpt_register_module(stack_data.endpt, &mod_stack);
stack_data.module_id = mod_stack.id;
// Create listening transports for trusted and untrusted ports.
if (stack_data.trusted_port != 0)
{
status = create_listener_transports(stack_data.trusted_port, &stack_data.tcp_factory);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, status);
}
if (stack_data.untrusted_port != 0)
{
status = create_listener_transports(stack_data.untrusted_port, NULL);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, status);
}
// List all names matching local endpoint.
// Note that PJLIB version 0.6 and newer has a function to
// enumerate local IP interface (pj_enum_ip_interface()), so
// by using it would be possible to list all IP interfaces in
// this host.
// The first address is important since this would be the one
// to be added in Record-Route.
stack_data.name[stack_data.name_cnt] = stack_data.local_host;
stack_data.name_cnt++;
if (pj_gethostip(pj_AF_INET(), &pri_addr) == PJ_SUCCESS)
{
pj_strdup2(stack_data.pool, &stack_data.name[stack_data.name_cnt],
pj_inet_ntoa(pri_addr.ipv4.sin_addr));
stack_data.name_cnt++;
}
// Get the rest of IP interfaces.
if (pj_enum_ip_interface(pj_AF_INET(), &addr_cnt, addr_list) == PJ_SUCCESS)
{
for (i = 0; i < addr_cnt; ++i)
{
if (addr_list[i].ipv4.sin_addr.s_addr == pri_addr.ipv4.sin_addr.s_addr)
{
continue;
}
pj_strdup2(stack_data.pool, &stack_data.name[stack_data.name_cnt],
pj_inet_ntoa(addr_list[i].ipv4.sin_addr));
stack_data.name_cnt++;
}
}
// Add loopback address.
#if PJ_IP_HELPER_IGNORE_LOOPBACK_IF
stack_data.name[stack_data.name_cnt] = pj_str("127.0.0.1");
stack_data.name_cnt++;
#endif
stack_data.name[stack_data.name_cnt] = pj_str("localhost");
stack_data.name_cnt++;
// Parse the list of alias host names.
if (alias_hosts != "")
{
std::list<std::string> hosts;
Utils::split_string(alias_hosts, ',', hosts, 0, true);
for (std::list<std::string>::iterator it = hosts.begin();
it != hosts.end();
++it)
{
pj_strdup2(stack_data.pool, &stack_data.name[stack_data.name_cnt], it->c_str());
stack_data.name_cnt++;
}
}
LOG_STATUS("Local host aliases:");
for (i = 0; i < stack_data.name_cnt; ++i)
{
LOG_STATUS(" %.*s",
(int)stack_data.name[i].slen,
stack_data.name[i].ptr);
}
stack_data.stats_aggregator = new LastValueCache(Statistic::known_stats_count(),
Statistic::known_stats());
latency_accumulator = new StatisticAccumulator("latency_us");
return status;
}
static int purity_test(void)
{
PJ_LOG(3,("test", "...purity_test()"));
#if defined(PJ_SOCKADDR_HAS_LEN) && PJ_SOCKADDR_HAS_LEN!=0
/* Check on "sin_len" member of sockaddr */
{
const pj_str_t str_ip = {"1.1.1.1", 7};
pj_sockaddr addr[16];
pj_addrinfo ai[16];
unsigned cnt;
pj_status_t rc;
/* pj_enum_ip_interface() */
cnt = PJ_ARRAY_SIZE(addr);
rc = pj_enum_ip_interface(pj_AF_UNSPEC(), &cnt, addr);
if (rc == PJ_SUCCESS) {
while (cnt--)
CHECK_SA_ZERO_LEN(&addr[cnt], -10);
}
/* pj_gethostip() on IPv4 */
rc = pj_gethostip(pj_AF_INET(), &addr[0]);
if (rc == PJ_SUCCESS)
CHECK_SA_ZERO_LEN(&addr[0], -20);
/* pj_gethostip() on IPv6 */
rc = pj_gethostip(pj_AF_INET6(), &addr[0]);
if (rc == PJ_SUCCESS)
CHECK_SA_ZERO_LEN(&addr[0], -30);
/* pj_getdefaultipinterface() on IPv4 */
rc = pj_getdefaultipinterface(pj_AF_INET(), &addr[0]);
if (rc == PJ_SUCCESS)
CHECK_SA_ZERO_LEN(&addr[0], -40);
/* pj_getdefaultipinterface() on IPv6 */
rc = pj_getdefaultipinterface(pj_AF_INET6(), &addr[0]);
if (rc == PJ_SUCCESS)
CHECK_SA_ZERO_LEN(&addr[0], -50);
/* pj_getaddrinfo() on a host name */
cnt = PJ_ARRAY_SIZE(ai);
rc = pj_getaddrinfo(pj_AF_UNSPEC(), pj_gethostname(), &cnt, ai);
if (rc == PJ_SUCCESS) {
while (cnt--)
CHECK_SA_ZERO_LEN(&ai[cnt].ai_addr, -60);
}
/* pj_getaddrinfo() on an IP address */
cnt = PJ_ARRAY_SIZE(ai);
rc = pj_getaddrinfo(pj_AF_UNSPEC(), &str_ip, &cnt, ai);
if (rc == PJ_SUCCESS) {
pj_assert(cnt == 1);
CHECK_SA_ZERO_LEN(&ai[0].ai_addr, -70);
}
}
#endif
return 0;
}
/* Get info */
PJ_DEF(pj_status_t) pj_stun_sock_get_info( pj_stun_sock *stun_sock,
pj_stun_sock_info *info)
{
int addr_len;
pj_status_t status;
PJ_ASSERT_RETURN(stun_sock && info, PJ_EINVAL);
/* Copy STUN server address and mapped address */
pj_memcpy(&info->srv_addr, &stun_sock->srv_addr,
sizeof(pj_sockaddr));
pj_memcpy(&info->mapped_addr, &stun_sock->mapped_addr,
sizeof(pj_sockaddr));
/* Retrieve bound address */
addr_len = sizeof(info->bound_addr);
status = pj_sock_getsockname(stun_sock->sock_fd, &info->bound_addr,
&addr_len);
if (status != PJ_SUCCESS)
return status;
/* If socket is bound to a specific interface, then only put that
* interface in the alias list. Otherwise query all the interfaces
* in the host.
*/
if (pj_sockaddr_has_addr(&info->bound_addr)) {
info->alias_cnt = 1;
pj_sockaddr_cp(&info->aliases[0], &info->bound_addr);
} else {
pj_sockaddr def_addr;
pj_uint16_t port = pj_sockaddr_get_port(&info->bound_addr);
unsigned i;
/* Get the default address */
status = pj_gethostip(stun_sock->af, &def_addr);
if (status != PJ_SUCCESS)
return status;
pj_sockaddr_set_port(&def_addr, port);
/* Enum all IP interfaces in the host */
info->alias_cnt = PJ_ARRAY_SIZE(info->aliases);
status = pj_enum_ip_interface(stun_sock->af, &info->alias_cnt,
info->aliases);
if (status != PJ_SUCCESS)
return status;
/* Set the port number for each address.
*/
for (i=0; i<info->alias_cnt; ++i) {
pj_sockaddr_set_port(&info->aliases[i], port);
}
/* Put the default IP in the first slot */
for (i=0; i<info->alias_cnt; ++i) {
if (pj_sockaddr_cmp(&info->aliases[i], &def_addr)==0) {
if (i!=0) {
pj_sockaddr_cp(&info->aliases[i], &info->aliases[0]);
pj_sockaddr_cp(&info->aliases[0], &def_addr);
}
break;
}
}
}
return PJ_SUCCESS;
}
static pj_status_t init_proxy(void)
{
pj_sockaddr pri_addr;
pj_sockaddr addr_list[16];
unsigned addr_cnt = PJ_ARRAY_SIZE(addr_list);
unsigned i;
/* List all names matching local endpoint.
* Note that PJLIB version 0.6 and newer has a function to
* enumerate local IP interface (pj_enum_ip_interface()), so
* by using it would be possible to list all IP interfaces in
* this host.
*/
/* The first address is important since this would be the one
* to be added in Record-Route.
*/
if (pj_gethostip(pj_AF_INET(), &pri_addr)==PJ_SUCCESS) {
pj_strdup2(global.pool, &global.name[global.name_cnt].host,
pj_inet_ntoa(pri_addr.ipv4.sin_addr));
global.name[global.name_cnt].port = global.port;
global.name_cnt++;
}
/* Get the rest of IP interfaces */
if (pj_enum_ip_interface(pj_AF_INET(), &addr_cnt, addr_list) == PJ_SUCCESS) {
for (i=0; i<addr_cnt; ++i) {
if (addr_list[i].ipv4.sin_addr.s_addr == pri_addr.ipv4.sin_addr.s_addr)
continue;
pj_strdup2(global.pool, &global.name[global.name_cnt].host,
pj_inet_ntoa(addr_list[i].ipv4.sin_addr));
global.name[global.name_cnt].port = global.port;
global.name_cnt++;
}
}
/* Add loopback address. */
#if PJ_IP_HELPER_IGNORE_LOOPBACK_IF
global.name[global.name_cnt].host = pj_str("127.0.0.1");
global.name[global.name_cnt].port = global.port;
global.name_cnt++;
#endif
global.name[global.name_cnt].host = *pj_gethostname();
global.name[global.name_cnt].port = global.port;
global.name_cnt++;
global.name[global.name_cnt].host = pj_str("localhost");
global.name[global.name_cnt].port = global.port;
global.name_cnt++;
PJ_LOG(3,(THIS_FILE, "Proxy started, listening on port %d", global.port));
PJ_LOG(3,(THIS_FILE, "Local host aliases:"));
for (i=0; i<global.name_cnt; ++i) {
PJ_LOG(3,(THIS_FILE, " %.*s:%d",
(int)global.name[i].host.slen,
global.name[i].host.ptr,
global.name[i].port));
}
if (global.record_route) {
PJ_LOG(3,(THIS_FILE, "Using Record-Route mode"));
}
return PJ_SUCCESS;
}
pj_status_t init_stack(const std::string& system_name,
const std::string& sas_address,
int pcscf_trusted_port,
int pcscf_untrusted_port,
int scscf_port,
int icscf_port,
const std::string& local_host,
const std::string& public_host,
const std::string& home_domain,
const std::string& additional_home_domains,
const std::string& scscf_uri,
const std::string& alias_hosts,
SIPResolver* sipresolver,
int num_pjsip_threads,
int num_worker_threads,
int record_routing_model,
const int default_session_expires,
QuiescingManager *quiescing_mgr_arg,
LoadMonitor *load_monitor_arg,
const std::string& cdf_domain)
{
pj_status_t status;
pj_sockaddr pri_addr;
pj_sockaddr addr_list[16];
unsigned addr_cnt = PJ_ARRAY_SIZE(addr_list);
unsigned i;
// Set up the vectors of threads. The threads don't get created until
// start_stack is called.
pjsip_threads.resize(num_pjsip_threads);
worker_threads.resize(num_worker_threads);
// Get ports and host names specified on options. If local host was not
// specified, use the host name returned by pj_gethostname.
char* local_host_cstr = strdup(local_host.c_str());
char* public_host_cstr = strdup(public_host.c_str());
char* home_domain_cstr = strdup(home_domain.c_str());
char* scscf_uri_cstr;
if (scscf_uri.empty())
{
// Create a default S-CSCF URI using the localhost and S-CSCF port.
std::string tmp_scscf_uri = "sip:" + local_host + ":" + std::to_string(scscf_port) + ";transport=TCP";
scscf_uri_cstr = strdup(tmp_scscf_uri.c_str());
}
else
{
// Use the specified URI.
scscf_uri_cstr = strdup(scscf_uri.c_str());
}
// This is only set on Bono nodes (it's the empty string otherwise)
char* cdf_domain_cstr = strdup(cdf_domain.c_str());
// Copy port numbers to stack data.
stack_data.pcscf_trusted_port = pcscf_trusted_port;
stack_data.pcscf_untrusted_port = pcscf_untrusted_port;
stack_data.scscf_port = scscf_port;
stack_data.icscf_port = icscf_port;
stack_data.sipresolver = sipresolver;
// Copy other functional options to stack data.
stack_data.default_session_expires = default_session_expires;
// Work out local and public hostnames and cluster domain names.
stack_data.local_host = (local_host != "") ? pj_str(local_host_cstr) : *pj_gethostname();
stack_data.public_host = (public_host != "") ? pj_str(public_host_cstr) : stack_data.local_host;
stack_data.default_home_domain = (home_domain != "") ? pj_str(home_domain_cstr) : stack_data.local_host;
stack_data.scscf_uri = pj_str(scscf_uri_cstr);
stack_data.cdf_domain = pj_str(cdf_domain_cstr);
// Build a set of home domains
stack_data.home_domains = std::unordered_set<std::string>();
stack_data.home_domains.insert(PJUtils::pj_str_to_string(&stack_data.default_home_domain));
if (additional_home_domains != "")
{
std::list<std::string> domains;
Utils::split_string(additional_home_domains, ',', domains, 0, true);
stack_data.home_domains.insert(domains.begin(), domains.end());
}
// Set up the default address family. This is IPv4 unless our local host is an IPv6 address.
stack_data.addr_family = AF_INET;
struct in6_addr dummy_addr;
if (inet_pton(AF_INET6, local_host_cstr, &dummy_addr) == 1)
{
LOG_DEBUG("Local host is an IPv6 address - enabling IPv6 mode");
stack_data.addr_family = AF_INET6;
}
stack_data.record_route_on_every_hop = false;
stack_data.record_route_on_initiation_of_originating = false;
stack_data.record_route_on_initiation_of_terminating = false;
stack_data.record_route_on_completion_of_originating = false;
stack_data.record_route_on_completion_of_terminating = false;
stack_data.record_route_on_diversion = false;
if (scscf_port != 0)
{
switch (record_routing_model)
{
case 1:
stack_data.record_route_on_initiation_of_originating = true;
stack_data.record_route_on_completion_of_terminating = true;
break;
case 2:
stack_data.record_route_on_initiation_of_originating = true;
stack_data.record_route_on_initiation_of_terminating = true;
stack_data.record_route_on_completion_of_originating = true;
stack_data.record_route_on_completion_of_terminating = true;
stack_data.record_route_on_diversion = true;
break;
case 3:
stack_data.record_route_on_every_hop = true;
stack_data.record_route_on_initiation_of_originating = true;
stack_data.record_route_on_initiation_of_terminating = true;
stack_data.record_route_on_completion_of_originating = true;
stack_data.record_route_on_completion_of_terminating = true;
stack_data.record_route_on_diversion = true;
break;
default:
LOG_ERROR("Record-Route setting should be 1, 2, or 3, is %d. Defaulting to Record-Route on every hop.", record_routing_model);
stack_data.record_route_on_every_hop = true;
}
}
std::string system_name_sas = system_name;
std::string system_type_sas = (pcscf_trusted_port != 0) ? "bono" : "sprout";
// Initialize SAS logging.
if (system_name_sas == "")
{
system_name_sas = std::string(stack_data.local_host.ptr, stack_data.local_host.slen);
}
SAS::init(system_name,
system_type_sas,
SASEvent::CURRENT_RESOURCE_BUNDLE,
sas_address,
sas_write);
// Initialise PJSIP and all the associated resources.
status = init_pjsip();
// Register the stack module.
pjsip_endpt_register_module(stack_data.endpt, &mod_stack);
stack_data.module_id = mod_stack.id;
// Initialize the PJUtils module.
PJUtils::init();
// Create listening transports for the ports whichtrusted and untrusted ports.
stack_data.pcscf_trusted_tcp_factory = NULL;
if (stack_data.pcscf_trusted_port != 0)
{
status = start_transports(stack_data.pcscf_trusted_port,
stack_data.local_host,
&stack_data.pcscf_trusted_tcp_factory);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, status);
}
stack_data.pcscf_untrusted_tcp_factory = NULL;
if (stack_data.pcscf_untrusted_port != 0)
{
status = start_transports(stack_data.pcscf_untrusted_port,
stack_data.public_host,
&stack_data.pcscf_untrusted_tcp_factory);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, status);
}
stack_data.scscf_tcp_factory = NULL;
if (stack_data.scscf_port != 0)
{
status = start_transports(stack_data.scscf_port,
stack_data.public_host,
&stack_data.scscf_tcp_factory);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, status);
}
stack_data.icscf_tcp_factory = NULL;
if (stack_data.icscf_port != 0)
{
status = start_transports(stack_data.icscf_port,
stack_data.public_host,
&stack_data.icscf_tcp_factory);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, status);
}
// List all names matching local endpoint.
// Note that PJLIB version 0.6 and newer has a function to
// enumerate local IP interface (pj_enum_ip_interface()), so
// by using it would be possible to list all IP interfaces in
// this host.
// The first address is important since this would be the one
// to be added in Record-Route.
stack_data.name[stack_data.name_cnt] = stack_data.local_host;
stack_data.name_cnt++;
if (strcmp(local_host_cstr, public_host_cstr))
{
stack_data.name[stack_data.name_cnt] = stack_data.public_host;
stack_data.name_cnt++;
}
if ((scscf_port != 0) &&
(!scscf_uri.empty()))
{
// S-CSCF enabled with a specified URI, so add host name from the URI to hostnames.
pjsip_sip_uri* uri = (pjsip_sip_uri*)PJUtils::uri_from_string(scscf_uri,
stack_data.pool);
if (uri != NULL)
{
stack_data.name[stack_data.name_cnt] = uri->host;
stack_data.name_cnt++;
}
}
if (pj_gethostip(pj_AF_INET(), &pri_addr) == PJ_SUCCESS)
{
pj_strdup2(stack_data.pool, &stack_data.name[stack_data.name_cnt],
pj_inet_ntoa(pri_addr.ipv4.sin_addr));
stack_data.name_cnt++;
}
// Get the rest of IP interfaces.
if (pj_enum_ip_interface(pj_AF_INET(), &addr_cnt, addr_list) == PJ_SUCCESS)
{
for (i = 0; i < addr_cnt; ++i)
{
if (addr_list[i].ipv4.sin_addr.s_addr == pri_addr.ipv4.sin_addr.s_addr)
{
continue;
}
pj_strdup2(stack_data.pool, &stack_data.name[stack_data.name_cnt],
pj_inet_ntoa(addr_list[i].ipv4.sin_addr));
stack_data.name_cnt++;
}
}
// Note that we no longer consider 127.0.0.1 and localhost as aliases.
// Parse the list of alias host names.
stack_data.aliases = std::unordered_set<std::string>();
if (alias_hosts != "")
{
std::list<std::string> aliases;
Utils::split_string(alias_hosts, ',', aliases, 0, true);
stack_data.aliases.insert(aliases.begin(), aliases.end());
for (std::unordered_set<std::string>::iterator it = stack_data.aliases.begin();
it != stack_data.aliases.end();
++it)
{
pj_strdup2(stack_data.pool, &stack_data.name[stack_data.name_cnt], it->c_str());
stack_data.name_cnt++;
}
}
LOG_STATUS("Local host aliases:");
for (i = 0; i < stack_data.name_cnt; ++i)
{
LOG_STATUS(" %.*s",
(int)stack_data.name[i].slen,
stack_data.name[i].ptr);
}
// Set up the Last Value Cache, accumulators and counters.
std::string zmq_port = SPROUT_ZMQ_PORT;
if ((stack_data.pcscf_trusted_port != 0) &&
(stack_data.pcscf_untrusted_port != 0))
{
zmq_port = BONO_ZMQ_PORT;
}
stack_data.stats_aggregator = new LastValueCache(num_known_stats,
known_statnames,
zmq_port);
latency_accumulator = new StatisticAccumulator("latency_us",
stack_data.stats_aggregator);
queue_size_accumulator = new StatisticAccumulator("queue_size",
stack_data.stats_aggregator);
requests_counter = new StatisticCounter("incoming_requests",
stack_data.stats_aggregator);
overload_counter = new StatisticCounter("rejected_overload",
stack_data.stats_aggregator);
if (load_monitor_arg != NULL)
{
load_monitor = load_monitor_arg;
}
if (quiescing_mgr_arg != NULL)
{
quiescing_mgr = quiescing_mgr_arg;
// Create an instance of the stack quiesce handler. This acts as a glue
// class between the stack modulem connections tracker, and the quiescing
// manager.
stack_quiesce_handler = new StackQuiesceHandler();
// Create a new connection tracker, and register the quiesce handler with
// it.
connection_tracker = new ConnectionTracker(stack_quiesce_handler);
// Register the quiesce handler with the quiescing manager (the former
// implements the connection handling interface).
quiescing_mgr->register_conns_handler(stack_quiesce_handler);
}
return status;
}
