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;
}
/* 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);
}
/* TODO : pass a max len for the line2 buffer */
static pj_status_t sipclf_add_timestamp(pj_str_t* line2, pj_time_val ts)
{
char* line2ptr = line2->ptr;
line2ptr += line2->slen;
// sec since epoch
pj_utoa_pad(ts.sec, line2ptr, TIMESTAMP_SEC_LEN, '0');
line2->slen += TIMESTAMP_SEC_LEN;
line2ptr += TIMESTAMP_SEC_LEN;
// dot
pj_strcat2(line2, ".");
line2ptr++;
// ms
pj_utoa_pad(ts.msec, line2ptr, TIMESTAMP_MSEC_LEN, '0');
line2->slen += TIMESTAMP_MSEC_LEN;
line2ptr += TIMESTAMP_MSEC_LEN;
return PJ_SUCCESS;
}
/* 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);
}
/*
* 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;
}
