static void int_parse_hdr_authenticate( pj_scanner *scanner, pj_pool_t *pool,
pjsip_www_authenticate_hdr *hdr)
{
const pjsip_parser_const_t *pc = pjsip_parser_const();
if (*scanner->curptr == '"') {
pj_scan_get_quote(scanner, '"', '"', &hdr->scheme);
hdr->scheme.ptr++;
hdr->scheme.slen -= 2;
} else {
pj_scan_get(scanner, &pc->pjsip_TOKEN_SPEC, &hdr->scheme);
}
if (!pj_stricmp(&hdr->scheme, &pjsip_DIGEST_STR)) {
parse_digest_challenge(scanner, pool, &hdr->challenge.digest);
} else if (!pj_stricmp(&hdr->scheme, &pjsip_PGP_STR)) {
parse_pgp_challenge(scanner, pool, &hdr->challenge.pgp);
} else {
PJ_THROW(PJSIP_SYN_ERR_EXCEPTION);
}
pjsip_parse_end_hdr_imp( scanner );
}
/*
* This is the global handler for memory allocation failure, for pools that
* are created by the endpoint (by default, all pools ARE allocated by
* endpoint). The error is handled by throwing exception, and hopefully,
* the exception will be handled by the application (or this library).
*/
static void pool_callback( pj_pool_t *pool, pj_size_t size )
{
PJ_UNUSED_ARG(pool);
PJ_UNUSED_ARG(size);
PJ_THROW(PJSIP_EX_NO_MEMORY);
}
static void *my_malloc(size_t size)
{
void *ptr = malloc(size);
if (!ptr)
PJ_THROW(NO_MEMORY);
return ptr;
}
static void default_pool_callback(pj_pool_t *pool, pj_size_t size)
{
PJ_CHECK_STACK();
PJ_UNUSED_ARG(pool);
PJ_UNUSED_ARG(size);
PJ_THROW(PJ_NO_MEMORY_EXCEPTION);
}
static int throw_in_handler(void)
{
PJ_USE_EXCEPTION;
int rc = 0;
PJ_TRY {
PJ_THROW(ID_1);
}
PJ_CATCH_ANY {
if (PJ_GET_EXCEPTION() != ID_1)
rc = -300;
else
PJ_THROW(ID_2);
}
PJ_END;
return rc;
}
static void parse_pgp_credential( pj_scanner *scanner, pj_pool_t *pool,
pjsip_pgp_credential *cred)
{
PJ_UNUSED_ARG(scanner);
PJ_UNUSED_ARG(pool);
PJ_UNUSED_ARG(cred);
PJ_THROW(PJSIP_SYN_ERR_EXCEPTION);
}
static void parse_pgp_challenge( pj_scanner *scanner, pj_pool_t *pool,
pjsip_pgp_challenge *chal)
{
PJ_UNUSED_ARG(scanner);
PJ_UNUSED_ARG(pool);
PJ_UNUSED_ARG(chal);
PJ_THROW(PJSIP_SYN_ERR_EXCEPTION);
}
static void parse_media(pj_scanner *scanner, pjmedia_sdp_media *med,
parse_context *ctx)
{
pj_str_t str;
ctx->last_error = PJMEDIA_SDP_EINMEDIA;
/* check the equal sign */
if (*(scanner->curptr+1) != '=') {
on_scanner_error(scanner);
return;
}
/* m= */
pj_scan_advance_n(scanner, 2, SKIP_WS);
/* type */
pj_scan_get_until_ch(scanner, ' ', &med->desc.media);
pj_scan_get_char(scanner);
/* port */
pj_scan_get(scanner, &cs_token, &str);
med->desc.port = (unsigned short)pj_strtoul(&str);
if (*scanner->curptr == '/') {
/* port count */
pj_scan_get_char(scanner);
pj_scan_get(scanner, &cs_token, &str);
med->desc.port_count = pj_strtoul(&str);
} else {
med->desc.port_count = 0;
}
if (pj_scan_get_char(scanner) != ' ') {
PJ_THROW(SYNTAX_ERROR);
}
/* transport */
pj_scan_get_until_ch(scanner, ' ', &med->desc.transport);
/* format list */
med->desc.fmt_count = 0;
while (*scanner->curptr == ' ') {
pj_scan_get_char(scanner);
/* Check again for the end of the line */
if ((*scanner->curptr == '\r') || (*scanner->curptr == '\n'))
break;
pj_scan_get(scanner, &cs_token, &med->desc.fmt[med->desc.fmt_count++]);
}
/* We've got what we're looking for, skip anything until newline */
pj_scan_skip_line(scanner);
}
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;
}
static int return_in_handler(void)
{
PJ_USE_EXCEPTION;
PJ_TRY {
PJ_THROW(ID_1);
}
PJ_CATCH_ANY {
return 0;
}
PJ_END;
return -400;
}
static int try_catch_test(void)
{
PJ_USE_EXCEPTION;
int rc = -200;
PJ_TRY {
PJ_THROW(ID_1);
}
PJ_CATCH_ANY {
rc = 0;
}
PJ_END;
return rc;
}
/* Parse tel: URI
* THis actually returns (pjsip_tel_uri *) type.
*/
static void* tel_uri_parse( pj_scanner *scanner, pj_pool_t *pool,
pj_bool_t parse_params)
{
pjsip_tel_uri *uri;
pj_str_t token;
int skip_ws = scanner->skip_ws;
const pjsip_parser_const_t *pc = pjsip_parser_const();
scanner->skip_ws = 0;
/* Parse scheme. */
pj_scan_get(scanner, &pc->pjsip_TOKEN_SPEC, &token);
if (pj_scan_get_char(scanner) != ':')
PJ_THROW(PJSIP_SYN_ERR_EXCEPTION);
if (pj_stricmp_alnum(&token, &pc->pjsip_TEL_STR) != 0)
PJ_THROW(PJSIP_SYN_ERR_EXCEPTION);
/* Create URI */
uri = pjsip_tel_uri_create(pool);
/* Get the phone number. */
#if defined(PJSIP_UNESCAPE_IN_PLACE) && PJSIP_UNESCAPE_IN_PLACE!=0
pj_scan_get_unescape(scanner, &pjsip_TEL_NUMBER_SPEC, &uri->number);
#else
pj_scan_get(scanner, &pjsip_TEL_NUMBER_SPEC, &uri->number);
uri->number = pj_str_unescape(pool, &uri->number);
#endif
/* Get all parameters. */
if (parse_params && *scanner->curptr==';') {
pj_str_t pname, pvalue;
const pjsip_parser_const_t *pc = pjsip_parser_const();
do {
/* Eat the ';' separator. */
pj_scan_get_char(scanner);
/* Get pname. */
pj_scan_get(scanner, &pc->pjsip_PARAM_CHAR_SPEC, &pname);
if (*scanner->curptr == '=') {
pj_scan_get_char(scanner);
# if defined(PJSIP_UNESCAPE_IN_PLACE) && PJSIP_UNESCAPE_IN_PLACE!=0
pj_scan_get_unescape(scanner,
&pjsip_TEL_PARSING_PVALUE_SPEC_ESC,
&pvalue);
# else
pj_scan_get(scanner, &pjsip_TEL_PARSING_PVALUE_SPEC,
&pvalue);
pvalue = pj_str_unescape(pool, &pvalue);
# endif
} else {
pvalue.slen = 0;
pvalue.ptr = NULL;
}
/* Save the parameters. */
if (pj_stricmp_alnum(&pname, &pjsip_ISUB_STR)==0) {
uri->isub_param = pvalue;
} else if (pj_stricmp_alnum(&pname, &pjsip_EXT_STR)==0) {
uri->ext_param = pvalue;
} else if (pj_stricmp_alnum(&pname, &pjsip_PH_CTX_STR)==0) {
uri->context = pvalue;
} else {
pjsip_param *param = PJ_POOL_ALLOC_T(pool, pjsip_param);
param->name = pname;
param->value = pvalue;
pj_list_insert_before(&uri->other_param, param);
}
} while (*scanner->curptr==';');
}
scanner->skip_ws = skip_ws;
pj_scan_skip_whitespace(scanner);
return uri;
}
pjsip_hdr* parse_hdr_p_charging_vector(pjsip_parse_ctx* ctx)
{
// The P-Charging-Vector header has the following ABNF:
//
// P-Charging-Vector = "P-Charging-Vector" HCOLON icid-value
// *(SEMI charge-params)
// charge-params = icid-gen-addr / orig-ioi /
// term-ioi / generic-param
// icid-value = "icid-value" EQUAL gen-value
// icid-gen-addr = "icid-generated-at" EQUAL host
// orig-ioi = "orig-ioi" EQUAL gen-value
// term-ioi = "term-ioi" EQUAL gen-value
pj_pool_t* pool = ctx->pool;
pj_scanner* scanner = ctx->scanner;
pjsip_p_c_v_hdr* hdr = pjsip_p_c_v_hdr_create(pool);
pj_str_t name;
pj_str_t value;
// Parse the required icid-value parameter first.
pjsip_parse_param_imp(scanner, pool, &name, &value,
PJSIP_PARSE_REMOVE_QUOTE);
if (!pj_stricmp2(&name, "icid-value")) {
hdr->icid = value;
} else {
PJ_THROW(PJSIP_SYN_ERR_EXCEPTION); // LCOV_EXCL_LINE
}
for (;;) {
pj_scan_skip_whitespace(scanner);
// If we just parsed the last parameter we will have reached the end of the
// header and have nothing more to do.
if (pj_scan_is_eof(scanner) ||
(*scanner->curptr == '\r') ||
(*scanner->curptr == '\n')) {
break;
}
// There's more content in the header so the next character must be the ";"
// separator.
if (*scanner->curptr == ';') {
pj_scan_get_char(scanner);
} else {
PJ_THROW(PJSIP_SYN_ERR_EXCEPTION); // LCOV_EXCL_LINE
}
pjsip_parse_param_imp(scanner, pool, &name, &value,
PJSIP_PARSE_REMOVE_QUOTE);
if (!pj_stricmp2(&name, "orig-ioi")) {
hdr->orig_ioi = value;
} else if (!pj_stricmp2(&name, "term-ioi")) {
hdr->term_ioi = value;
} else if (!pj_stricmp2(&name, "icid-generated-at")) {
hdr->icid_gen_addr = value;
} 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;
}
static int throw_id_1(void)
{
PJ_THROW( ID_1 );
return -1;
}
static int throw_id_2(void)
{
PJ_THROW( ID_2 );
return -1;
}
static void on_syntax_error(struct pj_scanner *scanner)
{
PJ_THROW(scanner->inst_id, EX_SYNTAX_ERROR);
}
/**
* This method is to parse and add the command attribute to command structure.
**/
static pj_status_t add_cmd_node(pj_cli_t *cli,
pj_cli_cmd_spec *group,
pj_xml_node *xml_node,
pj_cli_cmd_handler handler,
pj_cli_cmd_spec **p_cmd,
pj_cli_get_dyn_choice get_choice)
{
pj_xml_node *root = xml_node;
pj_xml_attr *attr;
pj_xml_node *sub_node;
pj_cli_cmd_spec *cmd;
pj_cli_arg_spec args[PJ_CLI_MAX_ARGS];
pj_str_t sc[PJ_CLI_MAX_SHORTCUTS];
pj_status_t status = PJ_SUCCESS;
if (pj_stricmp2(&root->name, "CMD"))
return PJ_EINVAL;
/* Initialize the command spec */
cmd = PJ_POOL_ZALLOC_T(cli->pool, struct pj_cli_cmd_spec);
/* Get the command attributes */
attr = root->attr_head.next;
while (attr != &root->attr_head) {
if (!pj_stricmp2(&attr->name, "name")) {
pj_strltrim(&attr->value);
if (!attr->value.slen ||
cmd_name_exists(cli, group, &attr->value))
{
return PJ_CLI_EBADNAME;
}
pj_strdup(cli->pool, &cmd->name, &attr->value);
} else if (!pj_stricmp2(&attr->name, "id")) {
pj_bool_t is_valid = PJ_FALSE;
if (attr->value.slen) {
pj_cli_cmd_id cmd_id = pj_strtol(&attr->value);
if (!pj_hash_get(cli->cmd_id_hash, &cmd_id,
sizeof(pj_cli_cmd_id), NULL))
is_valid = PJ_TRUE;
}
if (!is_valid)
return PJ_CLI_EBADID;
cmd->id = (pj_cli_cmd_id)pj_strtol(&attr->value);
} else if (!pj_stricmp2(&attr->name, "sc")) {
pj_scanner scanner;
pj_str_t str;
PJ_USE_EXCEPTION;
pj_scan_init(&scanner, attr->value.ptr, attr->value.slen,
PJ_SCAN_AUTOSKIP_WS, &on_syntax_error);
PJ_TRY {
while (!pj_scan_is_eof(&scanner)) {
pj_scan_get_until_ch(&scanner, ',', &str);
pj_strrtrim(&str);
if (!pj_scan_is_eof(&scanner))
pj_scan_advance_n(&scanner, 1, PJ_TRUE);
if (!str.slen)
continue;
if (cmd->sc_cnt >= PJ_CLI_MAX_SHORTCUTS) {
PJ_THROW(PJ_CLI_ETOOMANYARGS);
}
/* Check whether the shortcuts are already used */
if (cmd_name_exists(cli, group, &str)) {
PJ_THROW(PJ_CLI_EBADNAME);
}
pj_strassign(&sc[cmd->sc_cnt++], &str);
}
}
PJ_CATCH_ANY {
pj_scan_fini(&scanner);
return (PJ_GET_EXCEPTION());
}
PJ_END;
} else if (!pj_stricmp2(&attr->name, "desc")) {
static int throw_id_2(void)
{
PJ_THROW( ID_2 );
PJ_UNREACHED(return -1;)
}
static void on_syntax_error(struct pj_scanner *scanner)
{
PJ_UNUSED_ARG(scanner);
PJ_THROW(EX_SYNTAX_ERROR);
}
static void on_scanner_error(pj_scanner *scanner)
{
PJ_UNUSED_ARG(scanner);
PJ_THROW(SYNTAX_ERROR);
}
/*
* This is the global handler for memory allocation failure, for pools that
* are created by the endpoint (by default, all pools ARE allocated by
* endpoint). The error is handled by throwing exception, and hopefully,
* the exception will be handled by the application (or this library).
*/
static void pool_callback( pj_pool_t *pool, pj_size_t size )
{
PJ_UNUSED_ARG(size);
PJ_THROW(pool->factory->inst_id, PJSIP_EX_NO_MEMORY);
}
static void on_syntax_error(pj_scanner *scanner)
{
PJ_UNUSED_ARG(scanner);
PJ_THROW(11);
}
static void randomly_throw_exception()
{
if (pj_rand() % 2)
PJ_THROW(OTHER_EXCEPTION);
}