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; }