PJ_DEF(pjpidf_note*) pjpidf_tuple_add_note(pj_pool_t *pool, pjpidf_tuple *t,
const pj_str_t *text)
{
pjpidf_note *note = PJ_POOL_ALLOC_T(pool, pjpidf_note);
xml_init_node(pool, note, &NOTE, text);
pj_xml_add_node(t, note);
return note;
}
static pj_xml_attr* xml_create_attr(pj_pool_t *pool, pj_str_t *name,
const pj_str_t *value)
{
pj_xml_attr *attr = PJ_POOL_ALLOC_T(pool, pj_xml_attr);
attr->name = *name;
pj_strdup(pool, &attr->value, value);
return attr;
}
PJ_DEF(pjpidf_tuple*) pjpidf_pres_add_tuple(pj_pool_t *pool, pjpidf_pres *pres,
const pj_str_t *id)
{
pjpidf_tuple *t = PJ_POOL_ALLOC_T(pool, pjpidf_tuple);
pjpidf_tuple_construct(pool, t, id);
pj_xml_add_node(pres, t);
return t;
}
/*!
* \internal
* \brief Add privacy and screen parameters to a Remote-Party-ID header.
*
* If privacy is requested, then the privacy and screen parameters need to
* reflect this. Similarly, if no privacy or screening is to be communicated,
* we need to make sure that any previously set values are updated.
*
* \param tdata The message where the Remote-Party-ID header is
* \param hdr The header on which the parameters are being added
* \param id The identification information used to determine privacy
*/
static void add_privacy_params(pjsip_tx_data *tdata, pjsip_fromto_hdr *hdr, const struct ast_party_id *id)
{
static const pj_str_t privacy_str = { "privacy", 7 };
static const pj_str_t screen_str = { "screen", 6 };
static const pj_str_t privacy_full_str = { "full", 4 };
static const pj_str_t privacy_off_str = { "off", 3 };
static const pj_str_t screen_yes_str = { "yes", 3 };
static const pj_str_t screen_no_str = { "no", 2 };
pjsip_param *old_privacy;
pjsip_param *old_screen;
pjsip_param *privacy;
pjsip_param *screen;
int presentation;
old_privacy = pjsip_param_find(&hdr->other_param, &privacy_str);
old_screen = pjsip_param_find(&hdr->other_param, &screen_str);
if (!old_privacy) {
privacy = PJ_POOL_ALLOC_T(tdata->pool, pjsip_param);
privacy->name = privacy_str;
pj_list_insert_before(&hdr->other_param, privacy);
} else {
privacy = old_privacy;
}
if (!old_screen) {
screen = PJ_POOL_ALLOC_T(tdata->pool, pjsip_param);
screen->name = screen_str;
pj_list_insert_before(&hdr->other_param, screen);
} else {
screen = old_screen;
}
presentation = ast_party_id_presentation(id);
if ((presentation & AST_PRES_RESTRICTION) == AST_PRES_ALLOWED) {
privacy->value = privacy_off_str;
} else {
privacy->value = privacy_full_str;
}
if ((presentation & AST_PRES_NUMBER_TYPE) == AST_PRES_USER_NUMBER_PASSED_SCREEN) {
screen->value = screen_yes_str;
} else {
screen->value = screen_no_str;
}
}
static pjsip_min_se_hdr* min_se_hdr_shallow_clone(
pj_pool_t *pool,
const pjsip_min_se_hdr* hsrc)
{
pjsip_min_se_hdr *hdr = PJ_POOL_ALLOC_T(pool, pjsip_min_se_hdr);
pj_memcpy(hdr, hsrc, sizeof(*hdr));
pjsip_param_shallow_clone(pool, &hdr->other_param, &hsrc->other_param);
return hdr;
}
PJ_DECL(pjdialog_info_dialog*) pjdialog_info_dialog_info_add_dialog(pj_pool_t *pool,
pjdialog_info_dialog_info *dialog_info,
const pj_str_t *id)
{
pjdialog_info_dialog *dialog = PJ_POOL_ALLOC_T(pool, pjdialog_info_dialog);
pjdialog_info_dialog_construct(pool, dialog, id);
pj_xml_add_node(dialog_info, dialog);
return dialog;
}
/* Status */
PJ_DEF(void) pjpidf_status_construct(pj_pool_t *pool, pjpidf_status *st)
{
pj_xml_node *node;
xml_init_node(pool, st, &STATUS, NULL);
node = PJ_POOL_ALLOC_T(pool, pj_xml_node);
xml_init_node(pool, node, &BASIC, &CLOSED);
pj_xml_add_node(st, node);
}
static pjsip_event_hdr*
pjsip_event_hdr_shallow_clone( pj_pool_t *pool,
const pjsip_event_hdr *rhs )
{
pjsip_event_hdr *hdr = PJ_POOL_ALLOC_T(pool, pjsip_event_hdr);
pj_memcpy(hdr, rhs, sizeof(*hdr));
pjsip_param_shallow_clone(pool, &hdr->other_param, &rhs->other_param);
return hdr;
}
/* Dialog */
PJ_DECL(void) pjdialog_info_dialog_construct(pj_pool_t *pool,
pjdialog_info_dialog *dialog,
const pj_str_t *id)
{
pj_xml_attr *attr;
pjdialog_info_local *local;
pjdialog_info_remote *remote;
xml_init_node(pool, dialog, &DIALOG, NULL);
attr = xml_create_attr(pool, &ID, id);
pj_xml_add_attr(dialog, attr);
local = PJ_POOL_ALLOC_T(pool, pjdialog_info_local);
pjdialog_info_local_construct(pool, local);
pj_xml_add_node(dialog, local);
remote = PJ_POOL_ALLOC_T(pool, pjdialog_info_remote);
pjdialog_info_remote_construct(pool, remote);
pj_xml_add_node(dialog, remote);
}
/* Remote */
PJ_DEF(void) pjdialog_info_remote_construct(pj_pool_t *pool,
pjdialog_info_remote *remote)
{
pj_xml_node *node;
xml_init_node(pool, remote, &REMOTE, NULL);
node = PJ_POOL_ALLOC_T(pool, pj_xml_node);
xml_init_node(pool, node, NULL, NULL);
pj_xml_add_node(remote, node);
}
/* Local */
PJ_DECL(void) pjdialog_info_local_construct(pj_pool_t *pool,
pjdialog_info_local *local)
{
pj_xml_node *node;
xml_init_node(pool, local, &LOCAL, NULL);
node = PJ_POOL_ALLOC_T(pool, pj_xml_node);
xml_init_node(pool, node, NULL, NULL);
pj_xml_add_node(local, node);
}
static pjsip_sip_uri* pjsip_url_clone(pj_pool_t *pool, const pjsip_sip_uri *rhs)
{
pjsip_sip_uri *url = PJ_POOL_ALLOC_T(pool, pjsip_sip_uri);
if (!url)
return NULL;
pjsip_sip_uri_init(url, IS_SIPS(rhs));
pjsip_sip_uri_assign(pool, url, rhs);
return url;
}
static void parse_digest_credential( pj_scanner *scanner, pj_pool_t *pool,
pjsip_digest_credential *cred)
{
pj_list_init(&cred->other_param);
for (;;) {
pj_str_t name, value;
pjsip_parse_param_imp(scanner, pool, &name, &value,
PJSIP_PARSE_REMOVE_QUOTE);
if (!pj_stricmp(&name, &pjsip_USERNAME_STR)) {
cred->username = value;
} else if (!pj_stricmp(&name, &pjsip_REALM_STR)) {
cred->realm = value;
} else if (!pj_stricmp(&name, &pjsip_NONCE_STR)) {
cred->nonce = value;
} else if (!pj_stricmp(&name, &pjsip_URI_STR)) {
cred->uri = value;
} else if (!pj_stricmp(&name, &pjsip_RESPONSE_STR)) {
cred->response = value;
} else if (!pj_stricmp(&name, &pjsip_ALGORITHM_STR)) {
cred->algorithm = value;
} else if (!pj_stricmp(&name, &pjsip_CNONCE_STR)) {
cred->cnonce = value;
} else if (!pj_stricmp(&name, &pjsip_OPAQUE_STR)) {
cred->opaque = value;
} else if (!pj_stricmp(&name, &pjsip_QOP_STR)) {
cred->qop = value;
} else if (!pj_stricmp(&name, &pjsip_NC_STR)) {
cred->nc = value;
} else {
pjsip_param *p = PJ_POOL_ALLOC_T(pool, pjsip_param);
p->name = name;
p->value = value;
pj_list_insert_before(&cred->other_param, p);
}
/* Eat comma */
if (!pj_scan_is_eof(scanner) && *scanner->curptr == ',')
pj_scan_get_char(scanner);
else
break;
}
}
static pjsip_name_addr* pjsip_name_addr_clone( pj_pool_t *pool,
const pjsip_name_addr *rhs)
{
pjsip_name_addr *addr = PJ_POOL_ALLOC_T(pool, pjsip_name_addr);
if (!addr)
return NULL;
pjsip_name_addr_init(addr);
pjsip_name_addr_assign(pool, addr, rhs);
return addr;
}
static pjsip_www_authenticate_hdr* pjsip_www_authenticate_hdr_shallow_clone( pj_pool_t *pool,
const pjsip_www_authenticate_hdr *rhs)
{
/* This function also serves Proxy-Authenticate header. */
pjsip_www_authenticate_hdr *hdr;
hdr = PJ_POOL_ALLOC_T(pool, pjsip_www_authenticate_hdr);
pj_memcpy(hdr, rhs, sizeof(*hdr));
pjsip_param_shallow_clone(pool, &hdr->challenge.common.other_param,
&rhs->challenge.common.other_param);
return hdr;
}
pjsip_hdr* parse_hdr_session_expires(pjsip_parse_ctx* ctx)
{
pj_pool_t* pool = ctx->pool;
pj_scanner* scanner = ctx->scanner;
pjsip_session_expires_hdr* hdr = pjsip_session_expires_hdr_create(pool);
const pjsip_parser_const_t* pc = pjsip_parser_const();
// Parse the expiry number
pj_str_t int_str;
pj_scan_get(scanner, &pc->pjsip_DIGIT_SPEC, &int_str);
hdr->expires = pj_strtoul(&int_str);
pj_scan_skip_whitespace(scanner);
// Parse the rest of the params, looking for the refresher param
while (*scanner->curptr == ';')
{
// Consume the ';'.
pj_scan_get_char(scanner);
pj_scan_skip_whitespace(scanner);
// Parse the param.
pj_str_t name;
pj_str_t value;
pjsip_parse_param_imp(scanner, pool, &name, &value,
PJSIP_PARSE_REMOVE_QUOTE);
if (!pj_stricmp2(&name, "refresher"))
{
if (!pj_stricmp2(&value, "uac"))
{
hdr->refresher = SESSION_REFRESHER_UAC;
}
else if (!pj_stricmp2(&value, "uas"))
{
hdr->refresher = SESSION_REFRESHER_UAS;
}
else
{
PJ_THROW(PJSIP_SYN_ERR_EXCEPTION); // LCOV_EXCL_LINE
}
}
else
{
pjsip_param* param = PJ_POOL_ALLOC_T(pool, pjsip_param);
param->name = name;
param->value = value;
pj_list_insert_before(&hdr->other_param, param);
}
}
// We're done parsing this header.
pjsip_parse_end_hdr_imp(scanner);
return (pjsip_hdr*)hdr;
}
PJ_DEF(void) pjpidf_tuple_set_timestamp_np(pj_pool_t *pool, pjpidf_tuple *t,
pj_str_t *ts)
{
pj_xml_node *node = pj_xml_find_node(t, &TIMESTAMP);
if (!node) {
node = PJ_POOL_ALLOC_T(pool, pj_xml_node);
xml_init_node(pool, node, &TIMESTAMP, ts);
} else {
node->content = *ts;
}
}
pjmedia_sdp_bandw_clone (pj_pool_t *pool,
const pjmedia_sdp_bandw *rhs)
{
pjmedia_sdp_bandw *b = PJ_POOL_ALLOC_T(pool, pjmedia_sdp_bandw);
if (!b) return NULL;
if (!pj_strdup (pool, &b->modifier, &rhs->modifier)) return NULL;
b->value = rhs->value;
return b;
}
PJ_DEF(pj_status_t) pjmedia_sdp_attr_to_rtpmap(pj_pool_t *pool,
const pjmedia_sdp_attr *attr,
pjmedia_sdp_rtpmap **p_rtpmap)
{
PJ_ASSERT_RETURN(pool && attr && p_rtpmap, PJ_EINVAL);
*p_rtpmap = PJ_POOL_ALLOC_T(pool, pjmedia_sdp_rtpmap);
PJ_ASSERT_RETURN(*p_rtpmap, PJ_ENOMEM);
return pjmedia_sdp_attr_get_rtpmap(attr, *p_rtpmap);
}
pjsip_hdr* parse_hdr_p_charging_function_addresses(pjsip_parse_ctx* ctx)
{
// The P-Charging-Function-Addresses header has the following ABNF:
//
// P-Charging-Addr = "P-Charging-Function-Addresses" HCOLON
// charge-addr-params
// *(SEMI charge-addr-params)
// charge-addr-params = ccf / ecf / generic-param
// ccf = "ccf" EQUAL gen-value
// ecf = "ecf" EQUAL gen-value
//
// Where the ccf and ecf elements may be repeated to specify backup CDFs
// for redundancy.
pj_pool_t* pool = ctx->pool;
pj_scanner* scanner = ctx->scanner;
pjsip_p_c_f_a_hdr* hdr = pjsip_p_c_f_a_hdr_create(pool);
pj_str_t name;
pj_str_t value;
pjsip_param *param;
for (;;) {
pjsip_parse_param_imp(scanner, pool, &name, &value,
PJSIP_PARSE_REMOVE_QUOTE);
param = PJ_POOL_ALLOC_T(pool, pjsip_param);
param->name = name;
param->value = value;
if (!pj_stricmp2(&name, "ccf")) {
pj_list_insert_before(&hdr->ccf, param);
} else if (!pj_stricmp2(&name, "ecf")) {
pj_list_insert_before(&hdr->ecf, param);
} else {
pj_list_insert_before(&hdr->other_param, param);
}
// We might need to swallow the ';'.
if (!pj_scan_is_eof(scanner) && *scanner->curptr == ';') {
pj_scan_get_char(scanner);
}
// If we're EOF or looking at a newline, we're done.
pj_scan_skip_whitespace(scanner);
if (pj_scan_is_eof(scanner) ||
(*scanner->curptr == '\r') ||
(*scanner->curptr == '\n')) {
break;
}
}
// We're done parsing this header.
pjsip_parse_end_hdr_imp(scanner);
return (pjsip_hdr*)hdr;
}
/*
* Create media clock.
*/
PJ_DEF(pj_status_t) pjmedia_clock_create( pj_pool_t *pool,
unsigned clock_rate,
unsigned channel_count,
unsigned samples_per_frame,
unsigned options,
pjmedia_clock_callback *cb,
void *user_data,
pjmedia_clock **p_clock)
{
pjmedia_clock *clock;
pj_status_t status;
PJ_ASSERT_RETURN(pool && clock_rate && samples_per_frame && p_clock,
PJ_EINVAL);
clock = PJ_POOL_ALLOC_T(pool, pjmedia_clock);
status = pj_get_timestamp_freq(&clock->freq);
if (status != PJ_SUCCESS)
return status;
clock->interval.u64 = samples_per_frame * clock->freq.u64 /
channel_count / clock_rate;
clock->next_tick.u64 = 0;
clock->timestamp.u64 = 0;
clock->max_jump = MAX_JUMP_MSEC * clock->freq.u64 / 1000;
clock->timestamp_inc = samples_per_frame / channel_count;
clock->options = options;
clock->cb = cb;
clock->user_data = user_data;
clock->thread = NULL;
clock->running = PJ_FALSE;
clock->quitting = PJ_FALSE;
/* I don't think we need a mutex, so we'll use null. */
status = pj_lock_create_null_mutex(pool, "clock", &clock->lock);
if (status != PJ_SUCCESS)
return status;
if ((clock->options & PJMEDIA_CLOCK_NO_ASYNC) == 0) {
status = pj_thread_create(pool, "clock", &clock_thread, clock,
0, 0, &clock->thread);
if (status != PJ_SUCCESS) {
pj_lock_destroy(clock->lock);
return status;
}
}
*p_clock = clock;
return PJ_SUCCESS;
}
PJ_DEF(void) pjpidf_tuple_set_contact(pj_pool_t *pool, pjpidf_tuple *t,
const pj_str_t *contact)
{
pj_xml_node *node = pj_xml_find_node(t, &CONTACT);
if (!node) {
node = PJ_POOL_ALLOC_T(pool, pj_xml_node);
xml_init_node(pool, node, &CONTACT, contact);
pj_xml_add_node(t, node);
} else {
pj_strdup(pool, &node->content, contact);
}
}
/* Encode and add "a=ice-mismatch" attribute in the SDP */
static void encode_ice_mismatch(pj_pool_t *sdp_pool,
pjmedia_sdp_session *sdp_local,
unsigned media_index)
{
pjmedia_sdp_attr *attr;
pjmedia_sdp_media *m = sdp_local->media[media_index];
attr = PJ_POOL_ALLOC_T(sdp_pool, pjmedia_sdp_attr);
attr->name = STR_ICE_MISMATCH;
attr->value.slen = 0;
pjmedia_sdp_attr_add(&m->attr_count, m->attr, attr);
}
PJ_DEF(pjmedia_sdp_conn*) pjmedia_sdp_conn_clone (pj_pool_t *pool,
const pjmedia_sdp_conn *rhs)
{
pjmedia_sdp_conn *c = PJ_POOL_ALLOC_T(pool, pjmedia_sdp_conn);
if (!c) return NULL;
if (!pj_strdup (pool, &c->net_type, &rhs->net_type)) return NULL;
if (!pj_strdup (pool, &c->addr_type, &rhs->addr_type)) return NULL;
if (!pj_strdup (pool, &c->addr, &rhs->addr)) return NULL;
return c;
}
pjsip_hdr* parse_hdr_reject_contact(pjsip_parse_ctx* ctx)
{
// The Reject-Contact header has the following ABNF:
//
// Reject-Contact = ("Reject-Contact" / "j") HCOLON rc-value
// *(COMMA rc-value)
// rc-value = "*" *(SEMI rc-params)
// rc-params = feature-param / generic-param
//
// But we allow any value for the header (not just *).
pj_pool_t* pool = ctx->pool;
pj_scanner* scanner = ctx->scanner;
const pjsip_parser_const_t* pc = pjsip_parser_const();
pjsip_reject_contact_hdr* hdr = pjsip_reject_contact_hdr_create(pool);
pj_str_t name;
pj_str_t value;
pjsip_param *param;
// Read and ignore the value.
pj_str_t header_value;
pj_scan_get(scanner, &pc->pjsip_TOKEN_SPEC, &header_value);
for (;;)
{
// We might need to swallow the ';'.
if (!pj_scan_is_eof(scanner) && *scanner->curptr == ';')
{
pj_scan_get_char(scanner);
}
pjsip_parse_param_imp(scanner, pool, &name, &value, 0);
param = PJ_POOL_ALLOC_T(pool, pjsip_param);
param->name = name;
param->value = value;
pj_list_insert_before(&hdr->feature_set, param);
// If we're EOF or looking at a newline, we're done.
pj_scan_skip_whitespace(scanner);
if (pj_scan_is_eof(scanner) ||
(*scanner->curptr == '\r') ||
(*scanner->curptr == '\n'))
{
break;
}
}
// We're done parsing this header.
pjsip_parse_end_hdr_imp(scanner);
return (pjsip_hdr*)hdr;
}
/* Tuple */
PJ_DEF(void) pjpidf_tuple_construct(pj_pool_t *pool, pjpidf_tuple *t,
const pj_str_t *id)
{
pj_xml_attr *attr;
pjpidf_status *st;
xml_init_node(pool, t, &TUPLE, NULL);
attr = xml_create_attr(pool, &ID, id);
pj_xml_add_attr(t, attr);
st = PJ_POOL_ALLOC_T(pool, pjpidf_status);
pjpidf_status_construct(pool, st);
pj_xml_add_node(t, st);
}
PJ_DECL(void) pjdialog_info_local_add_identity(pj_pool_t *pool,
pjdialog_info_local *local,
const pj_str_t *identity)
{
pj_xml_node *node = pj_xml_find_node((pj_xml_node*)local, &IDENTITY);
if (!node) {
node = PJ_POOL_ALLOC_T(pool, pj_xml_node);
xml_init_node(pool, node, &IDENTITY, identity);
pj_xml_add_node(local, node);
} else {
pj_strdup(pool, &node->content, identity);
}
}
PJ_DECL(void) pjdialog_info_dialog_set_state(pj_pool_t *pool,
pjdialog_info_dialog *dialog,
const pj_str_t *state)
{
pj_xml_node *node = pj_xml_find_node((pj_xml_node*)dialog, &STATE);
if (!node) {
node = PJ_POOL_ALLOC_T(pool, pj_xml_node);
xml_init_node(pool, node, &STATE, state);
pj_xml_add_node(dialog, node);
} else {
pj_strdup(pool, &node->content, state);
}
}
PJ_DECL(void) pjdialog_info_dialog_set_duration(pj_pool_t *pool,
pjdialog_info_dialog *dialog,
const pj_str_t *duration)
{
pj_xml_node *node = pj_xml_find_node((pj_xml_node*)dialog, &DURATION);
if (!node) {
node = PJ_POOL_ALLOC_T(pool, pj_xml_node);
xml_init_node(pool, node, &DURATION, duration);
pj_xml_add_node(dialog, node);
} else {
pj_strdup(pool, &node->content, duration);
}
}
/* "tel:911;p1=p1;p2=p2" */
static pjsip_uri *create_uri34(pj_pool_t *pool)
{
pjsip_tel_uri *uri = pjsip_tel_uri_create(pool);
pjsip_param *p;
uri->number = pj_str("911");
p = PJ_POOL_ALLOC_T(pool, pjsip_param);
p->name = p->value = pj_str("p1");
pj_list_insert_before(&uri->other_param, p);
return (pjsip_uri*)uri;
}
