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;
}
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;
}
pj_status_t UE::init_int(pj_log_func* logger,
std::string realm,
std::string myurl,
std::string username,
std::string password,
std::string outbound_proxy)
{
pj_status_t status;
char errmsg[PJ_ERR_MSG_SIZE];
pj_sockaddr addr;
pj_str_t remote;
pj_sockaddr remote_addr;
init_pjsip(logger);
std::string server_uri = std::string("sip:") + realm + std::string(";lr;transport=tcp");
_pool = pj_pool_create(get_global_pool_factory(), "a", 256, 256, NULL);
pj_sockaddr_init(pj_AF_INET(), &addr, NULL, (pj_uint16_t)0);
//status = pjsip_udp_transport_start(get_global_endpoint(), &addr.ipv4, NULL, 1, &_transport);
//assert(status == PJ_SUCCESS);
if (outbound_proxy.empty())
{
outbound_proxy = realm;
}
pj_cstr(&remote, outbound_proxy.c_str());
pj_sockaddr_init(pj_AF_INET(), &remote_addr, &remote, (pj_uint16_t)5060);
pjsip_tpselector sel2;
sel2.type = PJSIP_TPSELECTOR_LISTENER;
sel2.u.listener = get_global_tcp_factory();
status = pjsip_endpt_acquire_transport(get_global_endpoint(),
PJSIP_TRANSPORT_TCP,
&remote_addr,
pj_sockaddr_get_len(&remote_addr),
&sel2,
&_transport);
if (status != PJ_SUCCESS)
{
pj_strerror(status, errmsg, sizeof(errmsg));
PJ_LOG(1, (__FILE__, "TCP connection to %s failed: %s (%d)", outbound_proxy.c_str(), errmsg, status));
return status;
}
transport_mapping[_transport] = this;
status = pjsip_regc_create(get_global_endpoint(), this, ®c_cb, &_regc);
if (status != PJ_SUCCESS)
{
pj_strerror(status, errmsg, sizeof(errmsg));
PJ_LOG(1, (__FILE__, "Creating the REGISTER session failed: %s (%d)", errmsg, status));
return status;
}
pjsip_regc_set_reg_tsx_cb(_regc, ®_tsx_cb);
pjsip_tpselector sel;
sel.type = PJSIP_TPSELECTOR_TRANSPORT;
sel.u.transport = _transport;
pjsip_regc_set_transport(_regc, &sel);
pjsip_auth_clt_pref prefs = {};
prefs.initial_auth = PJ_TRUE;
pjsip_regc_set_prefs(_regc, &prefs);
pjsip_cred_info cred;
stra(&cred.realm, realm.c_str());
stra(&cred.scheme, "Digest");
stra(&cred.username, username.c_str());
stra(&cred.data, password.c_str());
cred.data_type = 0; // Plaintext password
pjsip_cred_info creds[1] = {cred};
pjsip_regc_set_credentials(_regc, 1, creds);
char contact[32];
snprintf(contact, 32, "sip:phone@%.*s:%d", (int)_transport->local_name.host.slen, _transport->local_name.host.ptr, _transport->local_name.port);
stra(&_realm, realm.c_str());
stra(&_server, server_uri.c_str());
_server_uri = pjsip_parse_uri(_pool, _server.ptr, _server.slen, 0);
stra(&_my_uri, myurl.c_str());
stra(&_username, username.c_str());
stra(&_contact, contact);
return PJ_SUCCESS;
}
