static pj_status_t register_account(pj_cli_cmd_val *cval) {
{
print_msg(("", "Registering account sip:%.*s@%.*s ... ",
(int)cval->argv[1].slen, cval->argv[1].ptr,
(int)cval->argv[3].slen, cval->argv[3].ptr));
pjsua_acc_config cfg;
pj_status_t status;
pjsua_acc_config_default(&cfg);
pj_str_t acc_name = cval->argv[1];
pj_str_t acc_pwd = cval->argv[2];
pj_str_t acc_domain = cval->argv[3];
char buff1[acc_name.slen+acc_domain.slen+20];
pj_str_t id;
id.ptr = buff1;
pj_bzero(buff1, sizeof(buff1));
pj_strcat2(&id, "sip:");
pj_strcat(&id, &acc_name);
pj_strcat2(&id, "@");
pj_strcat(&id, &acc_domain);
char buff2[acc_domain.slen+20];
pj_str_t reg_uri;
reg_uri.ptr = buff2;
pj_bzero(buff2, sizeof(buff2));
pj_strcat2(®_uri, "sip:");
pj_strcat(®_uri, &acc_domain);
// char id[acc_name.slen+acc_domain.slen+10];
// char reg_uri[acc_domain.slen+10];
// pj_ansi_sprintf(id, "sip:%s@%s",
// acc_name.ptr, acc_domain.ptr);
// pj_ansi_sprintf(reg_uri, "sip:%s",
// acc_domain.ptr);
cfg.id = id;
cfg.reg_uri = reg_uri;
cfg.cred_count = 1;
cfg.cred_info[0].realm = pj_str("*"); //or set to acc_domain
cfg.cred_info[0].scheme = pj_str("digest");
cfg.cred_info[0].username = acc_name;
cfg.cred_info[0].data_type = PJSIP_CRED_DATA_PLAIN_PASSWD;
cfg.cred_info[0].data = acc_pwd;
status = pjsua_acc_add(&cfg, PJ_TRUE, &main_account);
printf("done \r\n");
if (status != PJ_SUCCESS)
error_exit("Error adding account", status);
}
return PJ_SUCCESS;
}
/*
* Get hostname.
*/
PJ_DEF(const pj_str_t*) pj_gethostname(void)
{
static char buf[PJ_MAX_HOSTNAME];
static pj_str_t hostname;
PJ_CHECK_STACK();
if (hostname.ptr == NULL) {
hostname.ptr = buf;
if (gethostname(buf, sizeof(buf)) != 0) {
hostname.ptr[0] = '\0';
hostname.slen = 0;
} else {
hostname.slen = strlen(buf);
#if defined(PJ_GETHOSTNAME_APPEND_LOCAL_SUFFIX) && \
PJ_GETHOSTNAME_APPEND_LOCAL_SUFFIX!=0
{
const pj_str_t suffix = {".local", 6};
if (hostname.slen < suffix.slen ||
pj_ansi_strnicmp(hostname.ptr + hostname.slen -
suffix.slen, suffix.ptr, suffix.slen))
{
if (hostname.slen + suffix.slen + 1 < sizeof(buf))
pj_strcat(&hostname, &suffix);
else
hostname.slen = 0;
hostname.ptr[hostname.slen] = '\0';
}
}
#endif
}
}
return &hostname;
}
/* Add command to the command hash */
static void add_cmd_name(pj_cli_t *cli, pj_cli_cmd_spec *group,
pj_cli_cmd_spec *cmd, pj_str_t *cmd_name)
{
pj_str_t cmd_val;
pj_str_t add_cmd;
char cmd_ptr[64];
cmd_val.ptr = &cmd_ptr[0];
cmd_val.slen = 0;
if (group) {
pj_strcat(&cmd_val, &group->name);
}
pj_strcat(&cmd_val, cmd_name);
pj_strdup(cli->pool, &add_cmd, &cmd_val);
pj_hash_set(cli->pool, cli->cmd_name_hash,
cmd_val.ptr, cmd_val.slen, 0, cmd);
}
PJ_DEF(pjxpidf_pres*) pjxpidf_create(pj_pool_t *pool, const pj_str_t *uri_cstr)
{
pjxpidf_pres *pres;
pj_xml_node *presentity;
pj_xml_node *atom;
pj_xml_node *addr;
pj_xml_node *status;
pj_xml_attr *attr;
pj_str_t uri;
pj_str_t tmp;
/* <presence> */
pres = xml_create_node(pool, &STR_PRESENCE, NULL);
/* <presentity> */
presentity = xml_create_node(pool, &STR_PRESENTITY, NULL);
pj_xml_add_node(pres, presentity);
/* uri attribute */
uri.ptr = (char*) pj_pool_alloc(pool, uri_cstr->slen +
STR_SUBSCRIBE_PARAM.slen);
pj_strcpy( &uri, uri_cstr);
pj_strcat( &uri, &STR_SUBSCRIBE_PARAM);
attr = xml_create_attr(pool, &STR_URI, &uri);
pj_xml_add_attr(presentity, attr);
/* <atom> */
atom = xml_create_node(pool, &STR_ATOM, NULL);
pj_xml_add_node(pres, atom);
/* atom id */
pj_create_unique_string(pool, &tmp);
attr = xml_create_attr(pool, &STR_ATOMID, &tmp);
pj_xml_add_attr(atom, attr);
/* address */
addr = xml_create_node(pool, &STR_ADDRESS, NULL);
pj_xml_add_node(atom, addr);
/* address'es uri */
attr = xml_create_attr(pool, &STR_URI, uri_cstr);
pj_xml_add_attr(addr, attr);
/* status */
status = xml_create_node(pool, &STR_STATUS, NULL);
pj_xml_add_node(addr, status);
/* status attr */
attr = xml_create_attr(pool, &STR_STATUS, &STR_OPEN);
pj_xml_add_attr(status, attr);
return pres;
}
static int xpidf_generate_body_content(void *body, void *data)
{
pjxpidf_pres *pres = body;
struct ast_sip_exten_state_data *state_data = data;
static pj_str_t STR_ADDR_PARAM = { ";user=ip", 8 };
char *statestring = NULL, *pidfstate = NULL, *pidfnote = NULL;
pj_xml_attr *attr;
enum ast_sip_pidf_state local_state;
pj_str_t uri;
char sanitized[PJSIP_MAX_URL_SIZE];
pj_xml_node *atom;
pj_xml_node *address;
pj_xml_node *status;
pj_xml_node *msnsubstatus;
ast_sip_presence_exten_state_to_str(state_data->exten_state, &statestring,
&pidfstate, &pidfnote, &local_state);
ast_sip_presence_xml_find_node_attr(state_data->pool, pres, "atom", "id",
&atom, &attr);
pj_strdup2(state_data->pool, &attr->value, state_data->exten);
ast_sip_presence_xml_find_node_attr(state_data->pool, atom, "address",
"uri", &address, &attr);
ast_sip_sanitize_xml(state_data->remote, sanitized, sizeof(sanitized));
uri.ptr = (char*) pj_pool_alloc(state_data->pool,
strlen(sanitized) + STR_ADDR_PARAM.slen);
pj_strcpy2( &uri, sanitized);
pj_strcat( &uri, &STR_ADDR_PARAM);
pj_strdup(state_data->pool, &attr->value, &uri);
ast_sip_presence_xml_create_attr(state_data->pool, address, "priority", "0.80000");
ast_sip_presence_xml_find_node_attr(state_data->pool, address,
"status", "status", &status, &attr);
pj_strdup2(state_data->pool, &attr->value,
(local_state == NOTIFY_OPEN) ? "open" :
(local_state == NOTIFY_INUSE) ? "inuse" : "closed");
ast_sip_presence_xml_find_node_attr(state_data->pool, address,
"msnsubstatus", "substatus", &msnsubstatus, &attr);
pj_strdup2(state_data->pool, &attr->value,
(local_state == NOTIFY_OPEN) ? "online" :
(local_state == NOTIFY_INUSE) ? "onthephone" : "offline");
return 0;
}
/* Check if command already added to command hash */
static pj_bool_t cmd_name_exists(pj_cli_t *cli, pj_cli_cmd_spec *group,
pj_str_t *cmd)
{
pj_str_t cmd_val;
char cmd_ptr[64];
cmd_val.ptr = &cmd_ptr[0];
cmd_val.slen = 0;
if (group) {
char cmd_str[16];
pj_ansi_sprintf(&cmd_str[0], "%d", group->id);
pj_strcat2(&cmd_val, &cmd_str[0]);
}
pj_strcat(&cmd_val, cmd);
return (pj_hash_get(cli->cmd_name_hash,
cmd_val.ptr, cmd_val.slen, NULL) != 0);
}
/* Get the command from the command hash */
static pj_cli_cmd_spec *get_cmd_name(const pj_cli_t *cli,
const pj_cli_cmd_spec *group,
const pj_str_t *cmd)
{
pj_str_t cmd_val;
char cmd_ptr[MAX_CMD_HASH_NAME_LENGTH];
cmd_val.ptr = cmd_ptr;
cmd_val.slen = 0;
if (group) {
char cmd_str[MAX_CMD_ID_LENGTH];
pj_ansi_sprintf(cmd_str, "%d", group->id);
pj_strcat2(&cmd_val, cmd_str);
}
pj_strcat(&cmd_val, cmd);
return (pj_cli_cmd_spec *)pj_hash_get(cli->cmd_name_hash, cmd_val.ptr,
(unsigned)cmd_val.slen, NULL);
}
/* Add command to the command hash */
static void add_cmd_name(pj_cli_t *cli, pj_cli_cmd_spec *group,
pj_cli_cmd_spec *cmd, pj_str_t *cmd_name)
{
pj_str_t cmd_val;
pj_str_t add_cmd;
char cmd_ptr[MAX_CMD_HASH_NAME_LENGTH];
cmd_val.ptr = cmd_ptr;
cmd_val.slen = 0;
if (group) {
char cmd_str[MAX_CMD_ID_LENGTH];
pj_ansi_sprintf(cmd_str, "%d", group->id);
pj_strcat2(&cmd_val, cmd_str);
}
pj_strcat(&cmd_val, cmd_name);
pj_strdup(cli->pool, &add_cmd, &cmd_val);
pj_hash_set(cli->pool, cli->cmd_name_hash, cmd_val.ptr,
(unsigned)cmd_val.slen, 0, cmd);
}
int transport_rt_test( pjsip_transport_type_e tp_type,
pjsip_transport *ref_tp,
char *target_url,
int *lost)
{
enum { THREADS = 4, INTERVAL = 10 };
int i;
pj_status_t status;
pj_pool_t *pool;
pj_bool_t logger_enabled;
pj_timestamp zero_time, total_time;
unsigned usec_rt;
unsigned total_sent;
unsigned total_recv;
PJ_UNUSED_ARG(tp_type);
PJ_UNUSED_ARG(ref_tp);
PJ_LOG(3,(THIS_FILE, " multithreaded round-trip test (%d threads)...",
THREADS));
PJ_LOG(3,(THIS_FILE, " this will take approx %d seconds, please wait..",
INTERVAL));
/* Make sure msg logger is disabled. */
logger_enabled = msg_logger_set_enabled(0);
/* Register module (if not yet registered) */
if (rt_module.id == -1) {
status = pjsip_endpt_register_module( endpt, &rt_module );
if (status != PJ_SUCCESS) {
app_perror(" error: unable to register module", status);
return -600;
}
}
/* Create pool for this test. */
pool = pjsip_endpt_create_pool(endpt, NULL, 4000, 4000);
if (!pool)
return -610;
/* Initialize static test data. */
pj_ansi_strcpy(rt_target_uri, target_url);
rt_call_id = pj_str("RT-Call-Id/");
rt_stop = PJ_FALSE;
/* Initialize thread data. */
for (i=0; i<THREADS; ++i) {
char buf[1];
pj_str_t str_id;
pj_strset(&str_id, buf, 1);
pj_bzero(&rt_test_data[i], sizeof(rt_test_data[i]));
/* Init timer entry */
rt_test_data[i].tx_timer.id = i;
rt_test_data[i].tx_timer.cb = &rt_tx_timer;
rt_test_data[i].timeout_timer.id = i;
rt_test_data[i].timeout_timer.cb = &rt_timeout_timer;
/* Generate Call-ID for each thread. */
rt_test_data[i].call_id.ptr = (char*) pj_pool_alloc(pool, rt_call_id.slen+1);
pj_strcpy(&rt_test_data[i].call_id, &rt_call_id);
buf[0] = '0' + (char)i;
pj_strcat(&rt_test_data[i].call_id, &str_id);
/* Init mutex. */
status = pj_mutex_create_recursive(pool, "rt", &rt_test_data[i].mutex);
if (status != PJ_SUCCESS) {
app_perror(" error: unable to create mutex", status);
return -615;
}
/* Create thread, suspended. */
status = pj_thread_create(pool, "rttest%p", &rt_worker_thread, (void*)(long)i, 0,
PJ_THREAD_SUSPENDED, &rt_test_data[i].thread);
if (status != PJ_SUCCESS) {
app_perror(" error: unable to create thread", status);
return -620;
}
}
/* Start threads! */
for (i=0; i<THREADS; ++i) {
pj_time_val delay = {0,0};
pj_thread_resume(rt_test_data[i].thread);
/* Schedule first message transmissions. */
rt_test_data[i].tx_timer.user_data = (void*)1;
pjsip_endpt_schedule_timer(endpt, &rt_test_data[i].tx_timer, &delay);
}
/* Sleep for some time. */
pj_thread_sleep(INTERVAL * 1000);
/* Signal thread to stop. */
rt_stop = PJ_TRUE;
/* Wait threads to complete. */
for (i=0; i<THREADS; ++i) {
pj_thread_join(rt_test_data[i].thread);
pj_thread_destroy(rt_test_data[i].thread);
}
/* Destroy rt_test_data */
for (i=0; i<THREADS; ++i) {
pj_mutex_destroy(rt_test_data[i].mutex);
pjsip_endpt_cancel_timer(endpt, &rt_test_data[i].timeout_timer);
}
/* Gather statistics. */
pj_bzero(&total_time, sizeof(total_time));
pj_bzero(&zero_time, sizeof(zero_time));
usec_rt = total_sent = total_recv = 0;
for (i=0; i<THREADS; ++i) {
total_sent += rt_test_data[i].sent_request_count;
total_recv += rt_test_data[i].recv_response_count;
pj_add_timestamp(&total_time, &rt_test_data[i].total_rt_time);
}
/* Display statistics. */
if (total_recv)
total_time.u64 = total_time.u64/total_recv;
else
total_time.u64 = 0;
usec_rt = pj_elapsed_usec(&zero_time, &total_time);
PJ_LOG(3,(THIS_FILE, " done."));
PJ_LOG(3,(THIS_FILE, " total %d messages sent", total_sent));
PJ_LOG(3,(THIS_FILE, " average round-trip=%d usec", usec_rt));
pjsip_endpt_release_pool(endpt, pool);
*lost = total_sent-total_recv;
/* Flush events. */
flush_events(500);
/* Restore msg logger. */
msg_logger_set_enabled(logger_enabled);
return 0;
}
/*
* The public API to invoke DNS SRV resolution.
*/
PJ_DEF(pj_status_t) pj_dns_srv_resolve( const pj_str_t *domain_name,
const pj_str_t *res_name,
unsigned def_port,
pj_pool_t *pool,
pj_dns_resolver *resolver,
unsigned option,
void *token,
pj_dns_srv_resolver_cb *cb,
pj_dns_srv_async_query **p_query)
{
pj_size_t len;
pj_str_t target_name;
pj_dns_srv_async_query *query_job;
pj_status_t status;
PJ_ASSERT_RETURN(domain_name && domain_name->slen &&
res_name && res_name->slen &&
pool && resolver && cb, PJ_EINVAL);
/* Build full name */
len = domain_name->slen + res_name->slen + 2;
target_name.ptr = (char*) pj_pool_alloc(pool, len);
pj_strcpy(&target_name, res_name);
if (res_name->ptr[res_name->slen-1] != '.')
pj_strcat2(&target_name, ".");
len = target_name.slen;
pj_strcat(&target_name, domain_name);
target_name.ptr[target_name.slen] = '\0';
/* Build the query_job state */
query_job = PJ_POOL_ZALLOC_T(pool, pj_dns_srv_async_query);
query_job->common.type = PJ_DNS_TYPE_SRV;
query_job->objname = target_name.ptr;
query_job->resolver = resolver;
query_job->token = token;
query_job->cb = cb;
query_job->option = option;
query_job->full_name = target_name;
query_job->domain_part.ptr = target_name.ptr + len;
query_job->domain_part.slen = target_name.slen - len;
query_job->def_port = (pj_uint16_t)def_port;
/* Start the asynchronous query_job */
query_job->dns_state = PJ_DNS_TYPE_SRV;
PJ_LOG(5, (query_job->objname,
"Starting async DNS %s query_job: target=%.*s:%d",
pj_dns_get_type_name(query_job->dns_state),
(int)target_name.slen, target_name.ptr,
def_port));
status = pj_dns_resolver_start_query(resolver, &target_name,
query_job->dns_state, 0,
&dns_callback,
query_job, &query_job->q_srv);
if (status==PJ_SUCCESS && p_query)
*p_query = query_job;
return status;
}
PJ_END_DECL
/* Get Symbian phone model info, returning length of model info */
unsigned pj_symbianos_get_model_info(char *buf, unsigned buf_size)
{
pj_str_t model_name;
/* Get machine UID */
TInt hal_val;
HAL::Get(HAL::EMachineUid, hal_val);
pj_ansi_snprintf(buf, buf_size, "0x%08X", hal_val);
pj_strset2(&model_name, buf);
/* Get model name */
const pj_str_t st_copyright = {"(C)", 3};
const pj_str_t st_nokia = {"Nokia", 5};
char tmp_buf[64];
pj_str_t tmp_str;
_LIT(KModelFilename,"Z:\\resource\\versions\\model.txt");
RFile file;
RFs fs;
TInt err;
fs.Connect(1);
err = file.Open(fs, KModelFilename, EFileRead);
if (err == KErrNone) {
TFileText text;
text.Set(file);
TBuf16<64> ModelName16;
err = text.Read(ModelName16);
if (err == KErrNone) {
TPtr8 ptr8((TUint8*)tmp_buf, sizeof(tmp_buf));
ptr8.Copy(ModelName16);
pj_strset(&tmp_str, tmp_buf, ptr8.Length());
pj_strtrim(&tmp_str);
}
file.Close();
}
fs.Close();
if (err != KErrNone)
goto on_return;
/* The retrieved model name is usually in long format, e.g:
* "© Nokia N95 (01.01)", "(C) Nokia E52". As we need only
* the short version, let's clean it up.
*/
/* Remove preceding non-ASCII chars, e.g: "©" */
char *p = tmp_str.ptr;
while (!pj_isascii(*p)) { p++; }
pj_strset(&tmp_str, p, tmp_str.slen - (p - tmp_str.ptr));
/* Remove "(C)" */
p = pj_stristr(&tmp_str, &st_copyright);
if (p) {
p += st_copyright.slen;
pj_strset(&tmp_str, p, tmp_str.slen - (p - tmp_str.ptr));
}
/* Remove "Nokia" */
p = pj_stristr(&tmp_str, &st_nokia);
if (p) {
p += st_nokia.slen;
pj_strset(&tmp_str, p, tmp_str.slen - (p - tmp_str.ptr));
}
/* Remove language version, e.g: "(01.01)" */
p = pj_strchr(&tmp_str, '(');
if (p) {
tmp_str.slen = p - tmp_str.ptr;
}
pj_strtrim(&tmp_str);
if (tmp_str.slen == 0)
goto on_return;
if ((unsigned)tmp_str.slen > buf_size - model_name.slen - 3)
tmp_str.slen = buf_size - model_name.slen - 3;
pj_strcat2(&model_name, "(");
pj_strcat(&model_name, &tmp_str);
pj_strcat2(&model_name, ")");
/* Zero terminate */
buf[model_name.slen] = '\0';
on_return:
return model_name.slen;
}
//
// Concatenate string.
//
void strcat(const Pj_String &rhs)
{
pj_strcat(this, &rhs);
}
static void add_dns_entries(pj_dns_resolver *resv)
{
/* Inject DNS SRV entry */
pj_dns_parsed_packet pkt;
pj_dns_parsed_query q;
pj_dns_parsed_rr ans[4];
pj_dns_parsed_rr ar[5];
pj_str_t tmp;
unsigned i;
/*
* This is answer to SRV query to "example.com" domain, and
* the answer contains full reference to the A records of
* the server. The full DNS records is :
_sip._udp.example.com 3600 IN SRV 0 0 5060 sip01.example.com.
_sip._udp.example.com 3600 IN SRV 0 20 5060 sip02.example.com.
_sip._udp.example.com 3600 IN SRV 0 10 5060 sip03.example.com.
_sip._udp.example.com 3600 IN SRV 1 0 5060 sip04.example.com.
sip01.example.com. 3600 IN A 1.1.1.1
sip02.example.com. 3600 IN A 2.2.2.2
sip03.example.com. 3600 IN A 3.3.3.3
sip04.example.com. 3600 IN A 4.4.4.4
; Additionally, add A record for "example.com"
example.com. 3600 IN A 5.5.5.5
*/
pj_bzero(&pkt, sizeof(pkt));
pj_bzero(ans, sizeof(ans));
pj_bzero(ar, sizeof(ar));
pkt.hdr.flags = PJ_DNS_SET_QR(1);
pkt.hdr.anscount = PJ_ARRAY_SIZE(ans);
pkt.hdr.arcount = 0;
pkt.ans = ans;
pkt.arr = ar;
ans[0].name = pj_str("_sip._udp.example.com");
ans[0].type = PJ_DNS_TYPE_SRV;
ans[0].dnsclass = PJ_DNS_CLASS_IN;
ans[0].ttl = 3600;
ans[0].rdata.srv.prio = 0;
ans[0].rdata.srv.weight = 0;
ans[0].rdata.srv.port = 5060;
ans[0].rdata.srv.target = pj_str("sip01.example.com");
ans[1].name = pj_str("_sip._udp.example.com");
ans[1].type = PJ_DNS_TYPE_SRV;
ans[1].dnsclass = PJ_DNS_CLASS_IN;
ans[1].ttl = 3600;
ans[1].rdata.srv.prio = 0;
ans[1].rdata.srv.weight = 20;
ans[1].rdata.srv.port = 5060;
ans[1].rdata.srv.target = pj_str("sip02.example.com");
ans[2].name = pj_str("_sip._udp.example.com");
ans[2].type = PJ_DNS_TYPE_SRV;
ans[2].dnsclass = PJ_DNS_CLASS_IN;
ans[2].ttl = 3600;
ans[2].rdata.srv.prio = 0;
ans[2].rdata.srv.weight = 10;
ans[2].rdata.srv.port = 5060;
ans[2].rdata.srv.target = pj_str("sip03.example.com");
ans[3].name = pj_str("_sip._udp.example.com");
ans[3].type = PJ_DNS_TYPE_SRV;
ans[3].dnsclass = PJ_DNS_CLASS_IN;
ans[3].ttl = 3600;
ans[3].rdata.srv.prio = 1;
ans[3].rdata.srv.weight = 0;
ans[3].rdata.srv.port = 5060;
ans[3].rdata.srv.target = pj_str("sip04.example.com");
pj_dns_resolver_add_entry( resv, &pkt, PJ_FALSE);
ar[0].name = pj_str("sip01.example.com");
ar[0].type = PJ_DNS_TYPE_A;
ar[0].dnsclass = PJ_DNS_CLASS_IN;
ar[0].ttl = 3600;
ar[0].rdata.a.ip_addr = pj_inet_addr(pj_cstr(&tmp, "1.1.1.1"));
ar[1].name = pj_str("sip02.example.com");
ar[1].type = PJ_DNS_TYPE_A;
ar[1].dnsclass = PJ_DNS_CLASS_IN;
ar[1].ttl = 3600;
ar[1].rdata.a.ip_addr = pj_inet_addr(pj_cstr(&tmp, "2.2.2.2"));
ar[2].name = pj_str("sip03.example.com");
ar[2].type = PJ_DNS_TYPE_A;
ar[2].dnsclass = PJ_DNS_CLASS_IN;
ar[2].ttl = 3600;
ar[2].rdata.a.ip_addr = pj_inet_addr(pj_cstr(&tmp, "3.3.3.3"));
ar[3].name = pj_str("sip04.example.com");
ar[3].type = PJ_DNS_TYPE_A;
ar[3].dnsclass = PJ_DNS_CLASS_IN;
ar[3].ttl = 3600;
ar[3].rdata.a.ip_addr = pj_inet_addr(pj_cstr(&tmp, "4.4.4.4"));
ar[4].name = pj_str("example.com");
ar[4].type = PJ_DNS_TYPE_A;
ar[4].dnsclass = PJ_DNS_CLASS_IN;
ar[4].ttl = 3600;
ar[4].rdata.a.ip_addr = pj_inet_addr(pj_cstr(&tmp, "5.5.5.5"));
/*
* Create individual A records for all hosts in "example.com" domain.
*/
for (i=0; i<PJ_ARRAY_SIZE(ar); ++i) {
pj_bzero(&pkt, sizeof(pkt));
pkt.hdr.flags = PJ_DNS_SET_QR(1);
pkt.hdr.qdcount = 1;
pkt.q = &q;
q.name = ar[i].name;
q.type = ar[i].type;
q.dnsclass = PJ_DNS_CLASS_IN;
pkt.hdr.anscount = 1;
pkt.ans = &ar[i];
pj_dns_resolver_add_entry( resv, &pkt, PJ_FALSE);
}
/*
* Simulate DNS error response by creating these answers.
* Sample of invalid SRV records: _sip._udp.sip01.example.com.
*/
for (i=0; i<PJ_ARRAY_SIZE(ans); ++i) {
pj_dns_parsed_query q;
char buf[128];
char *services[] = { "_sip._udp.", "_sip._tcp.", "_sips._tcp."};
unsigned j;
for (j=0; j<PJ_ARRAY_SIZE(services); ++j) {
q.dnsclass = PJ_DNS_CLASS_IN;
q.type = PJ_DNS_TYPE_SRV;
q.name.ptr = buf;
pj_bzero(buf, sizeof(buf));
pj_strcpy2(&q.name, services[j]);
pj_strcat(&q.name, &ans[i].rdata.srv.target);
pj_bzero(&pkt, sizeof(pkt));
pkt.hdr.qdcount = 1;
pkt.hdr.flags = PJ_DNS_SET_QR(1) |
PJ_DNS_SET_RCODE(PJ_DNS_RCODE_NXDOMAIN);
pkt.q = &q;
pj_dns_resolver_add_entry( resv, &pkt, PJ_FALSE);
}
}
/*
* ANOTHER DOMAIN.
*
* This time we let SRV and A get answered in different DNS
* query.
*/
/* The "domain.com" DNS records (note the different the port):
_sip._tcp.domain.com 3600 IN SRV 1 0 50060 sip06.domain.com.
_sip._tcp.domain.com 3600 IN SRV 2 0 50060 sip07.domain.com.
sip06.domain.com. 3600 IN A 6.6.6.6
sip07.domain.com. 3600 IN A 7.7.7.7
*/
pj_bzero(&pkt, sizeof(pkt));
pj_bzero(&ans, sizeof(ans));
pkt.hdr.flags = PJ_DNS_SET_QR(1);
pkt.hdr.anscount = 2;
pkt.ans = ans;
/* Add the SRV records, with reverse priority (to test that sorting
* works.
*/
ans[0].name = pj_str("_sip._tcp.domain.com");
ans[0].type = PJ_DNS_TYPE_SRV;
ans[0].dnsclass = PJ_DNS_CLASS_IN;
ans[0].ttl = 3600;
ans[0].rdata.srv.prio = 2;
ans[0].rdata.srv.weight = 0;
ans[0].rdata.srv.port = 50060;
ans[0].rdata.srv.target = pj_str("SIP07.DOMAIN.COM");
ans[1].name = pj_str("_sip._tcp.domain.com");
ans[1].type = PJ_DNS_TYPE_SRV;
ans[1].dnsclass = PJ_DNS_CLASS_IN;
ans[1].ttl = 3600;
ans[1].rdata.srv.prio = 1;
ans[1].rdata.srv.weight = 0;
ans[1].rdata.srv.port = 50060;
ans[1].rdata.srv.target = pj_str("SIP06.DOMAIN.COM");
pj_dns_resolver_add_entry( resv, &pkt, PJ_FALSE);
/* From herein there is only one answer */
pkt.hdr.anscount = 1;
/* Add a single SRV for UDP */
ans[0].name = pj_str("_sip._udp.domain.com");
ans[0].type = PJ_DNS_TYPE_SRV;
ans[0].dnsclass = PJ_DNS_CLASS_IN;
ans[0].ttl = 3600;
ans[0].rdata.srv.prio = 0;
ans[0].rdata.srv.weight = 0;
ans[0].rdata.srv.port = 50060;
ans[0].rdata.srv.target = pj_str("SIP06.DOMAIN.COM");
pj_dns_resolver_add_entry( resv, &pkt, PJ_FALSE);
/* Add the A record for sip06.domain.com */
ans[0].name = pj_str("sip06.domain.com");
ans[0].type = PJ_DNS_TYPE_A;
ans[0].dnsclass = PJ_DNS_CLASS_IN;
ans[0].ttl = 3600;
ans[0].rdata.a.ip_addr = pj_inet_addr(pj_cstr(&tmp, "6.6.6.6"));
pkt.hdr.qdcount = 1;
pkt.q = &q;
q.name = ans[0].name;
q.type = ans[0].type;
q.dnsclass = ans[0].dnsclass;
pj_dns_resolver_add_entry( resv, &pkt, PJ_FALSE);
/* Add the A record for sip07.domain.com */
ans[0].name = pj_str("sip07.domain.com");
ans[0].type = PJ_DNS_TYPE_A;
ans[0].dnsclass = PJ_DNS_CLASS_IN;
ans[0].ttl = 3600;
ans[0].rdata.a.ip_addr = pj_inet_addr(pj_cstr(&tmp, "7.7.7.7"));
pkt.hdr.qdcount = 1;
pkt.q = &q;
q.name = ans[0].name;
q.type = ans[0].type;
q.dnsclass = ans[0].dnsclass;
pj_dns_resolver_add_entry( resv, &pkt, PJ_FALSE);
pkt.hdr.qdcount = 0;
}
int string_test(void)
{
const pj_str_t hello_world = { HELLO_WORLD, HELLO_WORLD_LEN };
const pj_str_t just_hello = { JUST_HELLO, JUST_HELLO_LEN };
pj_str_t s1, s2, s3, s4, s5;
enum { RCOUNT = 10, RLEN = 16 };
pj_str_t random[RCOUNT];
pj_pool_t *pool;
int i;
pool = pj_pool_create(mem, SNULL, 4096, 0, SNULL);
if (!pool) return -5;
/*
* pj_str(), pj_strcmp(), pj_stricmp(), pj_strlen(),
* pj_strncmp(), pj_strchr()
*/
s1 = pj_str(HELLO_WORLD);
if (pj_strcmp(&s1, &hello_world) != 0)
return -10;
if (pj_stricmp(&s1, &hello_world) != 0)
return -20;
if (pj_strcmp(&s1, &just_hello) <= 0)
return -30;
if (pj_stricmp(&s1, &just_hello) <= 0)
return -40;
if (pj_strlen(&s1) != strlen(HELLO_WORLD))
return -50;
if (pj_strncmp(&s1, &hello_world, 5) != 0)
return -60;
if (pj_strnicmp(&s1, &hello_world, 5) != 0)
return -70;
if (pj_strchr(&s1, HELLO_WORLD[1]) != s1.ptr+1)
return -80;
/*
* pj_strdup()
*/
if (!pj_strdup(pool, &s2, &s1))
return -100;
if (pj_strcmp(&s1, &s2) != 0)
return -110;
/*
* pj_strcpy(), pj_strcat()
*/
s3.ptr = (char*) pj_pool_alloc(pool, 256);
if (!s3.ptr)
return -200;
pj_strcpy(&s3, &s2);
pj_strcat(&s3, &just_hello);
if (pj_strcmp2(&s3, HELLO_WORLD JUST_HELLO) != 0)
return -210;
/*
* pj_strdup2(), pj_strtrim().
*/
pj_strdup2(pool, &s4, " " HELLO_WORLD "\t ");
pj_strtrim(&s4);
if (pj_strcmp2(&s4, HELLO_WORLD) != 0)
return -250;
/*
* pj_utoa()
*/
s5.ptr = (char*) pj_pool_alloc(pool, 16);
if (!s5.ptr)
return -270;
s5.slen = pj_utoa(UL_VALUE, s5.ptr);
/*
* pj_strtoul()
*/
if (pj_strtoul(&s5) != UL_VALUE)
return -280;
/*
* pj_strtoul2()
*/
s5 = pj_str("123456");
pj_strtoul2(&s5, SNULL, 10); /* Crash test */
if (pj_strtoul2(&s5, &s4, 10) != 123456UL)
return -290;
if (s4.slen != 0)
return -291;
if (pj_strtoul2(&s5, &s4, 16) != 0x123456UL)
return -292;
s5 = pj_str("0123ABCD");
if (pj_strtoul2(&s5, &s4, 10) != 123)
return -293;
if (s4.slen != 4)
return -294;
if (s4.ptr == SNULL || *s4.ptr != 'A')
return -295;
if (pj_strtoul2(&s5, &s4, 16) != 0x123ABCDUL)
return -296;
if (s4.slen != 0)
return -297;
/*
* pj_create_random_string()
* Check that no duplicate strings are returned.
*/
for (i=0; i<RCOUNT; ++i) {
int j;
random[i].ptr = (char*) pj_pool_alloc(pool, RLEN);
if (!random[i].ptr)
return -320;
random[i].slen = RLEN;
pj_create_random_string(random[i].ptr, RLEN);
for (j=0; j<i; ++j) {
if (pj_strcmp(&random[i], &random[j])==0)
return -330;
}
}
/* Done. */
pj_pool_release(pool);
/* Case sensitive comparison test. */
i = strcmp_test();
if (i != 0)
return i;
/* Caseless comparison test. */
i = stricmp_test();
if (i != 0)
return i;
return 0;
}