Asterisk - The Open Source Telephony Project GIT-master-25686a5
res_pjsip.c
Go to the documentation of this file.
1/*
2 * Asterisk -- An open source telephony toolkit.
3 *
4 * Copyright (C) 2013, Digium, Inc.
5 *
6 * Mark Michelson <mmichelson@digium.com>
7 *
8 * See http://www.asterisk.org for more information about
9 * the Asterisk project. Please do not directly contact
10 * any of the maintainers of this project for assistance;
11 * the project provides a web site, mailing lists and IRC
12 * channels for your use.
13 *
14 * This program is free software, distributed under the terms of
15 * the GNU General Public License Version 2. See the LICENSE file
16 * at the top of the source tree.
17 */
18
19#include "asterisk.h"
20
21#include <pjsip.h>
22/* Needed for SUBSCRIBE, NOTIFY, and PUBLISH method definitions */
23#include <pjsip_simple.h>
24#include <pjsip/sip_transaction.h>
25#include <pj/timer.h>
26#include <pjlib.h>
27#include <pjmedia/errno.h>
28
29#include "asterisk/res_pjsip.h"
30#include "asterisk/strings.h"
31#include "pjsip/sip_parser.h"
34#include "asterisk/logger.h"
35#include "asterisk/lock.h"
36#include "asterisk/utils.h"
37#include "asterisk/astobj2.h"
38#include "asterisk/module.h"
39#include "asterisk/serializer.h"
40#include "asterisk/threadpool.h"
42#include "asterisk/uuid.h"
43#include "asterisk/sorcery.h"
44#include "asterisk/file.h"
45#include "asterisk/causes.h"
46#include "asterisk/cli.h"
47#include "asterisk/callerid.h"
49#include "asterisk/test.h"
52#include "asterisk/utf8.h"
53#include "asterisk/acl.h"
54
55/*** MODULEINFO
56 <depend>pjproject</depend>
57 <depend>res_pjproject</depend>
58 <depend>res_sorcery_config</depend>
59 <depend>res_sorcery_memory</depend>
60 <depend>res_sorcery_astdb</depend>
61 <use type="module">res_statsd</use>
62 <use type="module">res_geolocation</use>
63 <support_level>core</support_level>
64 ***/
65
66#define MOD_DATA_CONTACT "contact"
67
68/*! Number of serializers in pool if one not supplied. */
69#define SERIALIZER_POOL_SIZE 8
70
71/*! Pool of serializers to use if not supplied. */
73
74static pjsip_endpoint *ast_pjsip_endpoint;
75
77
78/*! Local host address for IPv4 */
79static pj_sockaddr host_ip_ipv4;
80
81/*! Local host address for IPv4 (string form) */
82static char host_ip_ipv4_string[PJ_INET6_ADDRSTRLEN];
83
84/*! Local host address for IPv6 */
85static pj_sockaddr host_ip_ipv6;
86
87/*! Local host address for IPv6 (string form) */
88static char host_ip_ipv6_string[PJ_INET6_ADDRSTRLEN];
89
90void ast_sip_add_date_header(pjsip_tx_data *tdata)
91{
92 char date[256];
93 struct tm tm;
94 time_t t = time(NULL);
95
96 gmtime_r(&t, &tm);
97 strftime(date, sizeof(date), "%a, %d %b %Y %T GMT", &tm);
98
99 ast_sip_add_header(tdata, "Date", date);
100}
101
102static int register_service(void *data)
103{
104 pjsip_module **module = data;
105 if (!ast_pjsip_endpoint) {
106 ast_log(LOG_ERROR, "There is no PJSIP endpoint. Unable to register services\n");
107 return -1;
108 }
109 if (pjsip_endpt_register_module(ast_pjsip_endpoint, *module) != PJ_SUCCESS) {
110 ast_log(LOG_ERROR, "Unable to register module %.*s\n", (int) pj_strlen(&(*module)->name), pj_strbuf(&(*module)->name));
111 return -1;
112 }
113 ast_debug(1, "Registered SIP service %.*s (%p)\n", (int) pj_strlen(&(*module)->name), pj_strbuf(&(*module)->name), *module);
114 return 0;
115}
116
117int ast_sip_register_service(pjsip_module *module)
118{
120}
121
122static int unregister_service(void *data)
123{
124 pjsip_module **module = data;
125 if (!ast_pjsip_endpoint) {
126 return -1;
127 }
128 pjsip_endpt_unregister_module(ast_pjsip_endpoint, *module);
129 ast_debug(1, "Unregistered SIP service %.*s\n", (int) pj_strlen(&(*module)->name), pj_strbuf(&(*module)->name));
130 return 0;
131}
132
133void ast_sip_unregister_service(pjsip_module *module)
134{
136}
137
139
141{
143 ast_log(LOG_WARNING, "Authenticator %p is already registered. Cannot register a new one\n", registered_authenticator);
144 return -1;
145 }
147 ast_debug(1, "Registered SIP authenticator module %p\n", auth);
148
149 return 0;
150}
151
153{
154 if (registered_authenticator != auth) {
155 ast_log(LOG_WARNING, "Trying to unregister authenticator %p but authenticator %p registered\n",
157 return;
158 }
160 ast_debug(1, "Unregistered SIP authenticator %p\n", auth);
161}
162
163int ast_sip_requires_authentication(struct ast_sip_endpoint *endpoint, pjsip_rx_data *rdata)
164{
166 && !pjsip_method_cmp(&rdata->msg_info.msg->line.req.method, &pjsip_options_method)) {
167 ast_debug(3, "Skipping OPTIONS authentication due to endpoint configuration\n");
168 return 0;
169 }
170
172 ast_log(LOG_WARNING, "No SIP authenticator registered. Assuming authentication is not required\n");
173 return 0;
174 }
175
176 return registered_authenticator->requires_authentication(endpoint, rdata);
177}
178
180 pjsip_rx_data *rdata, pjsip_tx_data *tdata)
181{
183 ast_log(LOG_WARNING, "No SIP authenticator registered. Assuming authentication is successful\n");
185 }
186 return registered_authenticator->check_authentication(endpoint, rdata, tdata);
187}
188
190
192{
194 ast_log(LOG_WARNING, "Outbound authenticator %p is already registered. Cannot register a new one\n", registered_outbound_authenticator);
195 return -1;
196 }
198 ast_debug(1, "Registered SIP outbound authenticator module %p\n", auth);
199
200 return 0;
201}
202
204{
206 ast_log(LOG_WARNING, "Trying to unregister outbound authenticator %p but outbound authenticator %p registered\n",
208 return;
209 }
211 ast_debug(1, "Unregistered SIP outbound authenticator %p\n", auth);
212}
213
214int ast_sip_create_request_with_auth(const struct ast_sip_auth_vector *auths, pjsip_rx_data *challenge,
215 pjsip_tx_data *old_request, pjsip_tx_data **new_request)
216{
218 ast_log(LOG_WARNING, "No SIP outbound authenticator registered. Cannot respond to authentication challenge\n");
219 return -1;
220 }
221 return registered_outbound_authenticator->create_request_with_auth(auths, challenge, old_request, new_request);
222}
223
225 const char *name;
226 unsigned int priority;
229};
230
232
234 const char *name)
235{
236 char *prev, *current, *identifier_order;
237 struct endpoint_identifier_list *iter, *id_list_item;
239
240 id_list_item = ast_calloc(1, sizeof(*id_list_item));
241 if (!id_list_item) {
242 ast_log(LOG_ERROR, "Unable to add endpoint identifier. Out of memory.\n");
243 return -1;
244 }
245 id_list_item->identifier = identifier;
246 id_list_item->name = name;
247
248 ast_debug(1, "Register endpoint identifier %s(%p)\n", name ?: "", identifier);
249
250 if (ast_strlen_zero(name)) {
251 /* if an identifier has no name then place in front */
252 AST_RWLIST_INSERT_HEAD(&endpoint_identifiers, id_list_item, list);
253 return 0;
254 }
255
256 /* see if the name of the identifier is in the global endpoint_identifier_order list */
257 identifier_order = prev = current = ast_sip_get_endpoint_identifier_order();
258
259 if (ast_strlen_zero(identifier_order)) {
260 id_list_item->priority = UINT_MAX;
261 AST_RWLIST_INSERT_TAIL(&endpoint_identifiers, id_list_item, list);
262 ast_free(identifier_order);
263 return 0;
264 }
265
266 id_list_item->priority = 0;
267 while ((current = strchr(current, ','))) {
268 ++id_list_item->priority;
269 if (!strncmp(prev, name, current - prev)
270 && strlen(name) == current - prev) {
271 break;
272 }
273 prev = ++current;
274 }
275
276 if (!current) {
277 /* check to see if it is the only or last item */
278 if (!strcmp(prev, name)) {
279 ++id_list_item->priority;
280 } else {
281 id_list_item->priority = UINT_MAX;
282 }
283 }
284
285 if (id_list_item->priority == UINT_MAX || AST_RWLIST_EMPTY(&endpoint_identifiers)) {
286 /* if not in the endpoint_identifier_order list then consider it less in
287 priority and add it to the end */
288 AST_RWLIST_INSERT_TAIL(&endpoint_identifiers, id_list_item, list);
289 ast_free(identifier_order);
290 return 0;
291 }
292
294 if (id_list_item->priority < iter->priority) {
295 AST_RWLIST_INSERT_BEFORE_CURRENT(id_list_item, list);
296 break;
297 }
298
299 if (!AST_RWLIST_NEXT(iter, list)) {
300 AST_RWLIST_INSERT_AFTER(&endpoint_identifiers, iter, id_list_item, list);
301 break;
302 }
303 }
305
306 ast_free(identifier_order);
307 return 0;
308}
309
311{
313}
314
316{
317 struct endpoint_identifier_list *iter;
320 if (iter->identifier == identifier) {
322 ast_free(iter);
323 ast_debug(1, "Unregistered endpoint identifier %p\n", identifier);
324 break;
325 }
326 }
328}
329
330struct ast_sip_endpoint *ast_sip_identify_endpoint(pjsip_rx_data *rdata)
331{
332 struct endpoint_identifier_list *iter;
333 struct ast_sip_endpoint *endpoint = NULL;
337 endpoint = iter->identifier->identify_endpoint(rdata);
338 if (endpoint) {
339 break;
340 }
341 }
342 return endpoint;
343}
344
345char *ast_sip_rdata_get_header_value(pjsip_rx_data *rdata, const pj_str_t str)
346{
347 pjsip_generic_string_hdr *hdr;
348 pj_str_t hdr_val;
349
350 hdr = pjsip_msg_find_hdr_by_name(rdata->msg_info.msg, &str, NULL);
351 if (!hdr) {
352 return NULL;
353 }
354
355 pj_strdup_with_null(rdata->tp_info.pool, &hdr_val, &hdr->hvalue);
356
357 return hdr_val.ptr;
358}
359
360static int do_cli_dump_endpt(void *v_a)
361{
362 struct ast_cli_args *a = v_a;
363
365 pjsip_endpt_dump(ast_sip_get_pjsip_endpoint(), a->argc == 4 ? PJ_TRUE : PJ_FALSE);
367
368 return 0;
369}
370
371static char *cli_dump_endpt(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
372{
373 switch (cmd) {
374 case CLI_INIT:
375#ifdef AST_DEVMODE
376 e->command = "pjsip dump endpt [details]";
377 e->usage =
378 "Usage: pjsip dump endpt [details]\n"
379 " Dump the res_pjsip endpt internals.\n"
380 "\n"
381 "Warning: PJPROJECT documents that the function used by this\n"
382 "CLI command may cause a crash when asking for details because\n"
383 "it tries to access all active memory pools.\n";
384#else
385 /*
386 * In non-developer mode we will not document or make easily accessible
387 * the details option even though it is still available. The user has
388 * to know it exists to use it. Presumably they would also be aware of
389 * the potential crash warning.
390 */
391 e->command = "pjsip dump endpt";
392 e->usage =
393 "Usage: pjsip dump endpt\n"
394 " Dump the res_pjsip endpt internals.\n";
395#endif /* AST_DEVMODE */
396 return NULL;
397 case CLI_GENERATE:
398 return NULL;
399 }
400
401 if (4 < a->argc
402 || (a->argc == 4 && strcasecmp(a->argv[3], "details"))) {
403 return CLI_SHOWUSAGE;
404 }
405
407
408 return CLI_SUCCESS;
409}
410
411static char *cli_show_endpoint_identifiers(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
412{
413#define ENDPOINT_IDENTIFIER_FORMAT "%-20.20s\n"
414 struct endpoint_identifier_list *iter;
415
416 switch (cmd) {
417 case CLI_INIT:
418 e->command = "pjsip show identifiers";
419 e->usage = "Usage: pjsip show identifiers\n"
420 " List all registered endpoint identifiers\n";
421 return NULL;
422 case CLI_GENERATE:
423 return NULL;
424 }
425
426 if (a->argc != 3) {
427 return CLI_SHOWUSAGE;
428 }
429
430 ast_cli(a->fd, ENDPOINT_IDENTIFIER_FORMAT, "Identifier Names:");
431 {
435 iter->name ? iter->name : "name not specified");
436 }
437 }
438 return CLI_SUCCESS;
439#undef ENDPOINT_IDENTIFIER_FORMAT
440}
441
442static char *cli_show_settings(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
443{
445
446 switch (cmd) {
447 case CLI_INIT:
448 e->command = "pjsip show settings";
449 e->usage = "Usage: pjsip show settings\n"
450 " Show global and system configuration options\n";
451 return NULL;
452 case CLI_GENERATE:
453 return NULL;
454 }
455
456 context.output_buffer = ast_str_create(256);
457 if (!context.output_buffer) {
458 ast_cli(a->fd, "Could not allocate output buffer.\n");
459 return CLI_FAILURE;
460 }
461
463 ast_free(context.output_buffer);
464 ast_cli(a->fd, "Error retrieving settings.\n");
465 return CLI_FAILURE;
466 }
467
468 ast_cli(a->fd, "%s", ast_str_buffer(context.output_buffer));
469 ast_free(context.output_buffer);
470 return CLI_SUCCESS;
471}
472
473static struct ast_cli_entry cli_commands[] = {
474 AST_CLI_DEFINE(cli_dump_endpt, "Dump the res_pjsip endpt internals"),
475 AST_CLI_DEFINE(cli_show_settings, "Show global and system configuration options"),
476 AST_CLI_DEFINE(cli_show_endpoint_identifiers, "List registered endpoint identifiers")
477};
478
480
482{
485}
486
488{
491
493 if (i == obj) {
495 break;
496 }
497 }
499}
500
502 struct ast_sip_ami *ami, int *count)
503{
504 int res = 0;
507 *count = 0;
509 if (i->format_ami && ((res = i->format_ami(endpoint, ami)) < 0)) {
510 return res;
511 }
512
513 if (!res) {
514 (*count)++;
515 }
516 }
517 return 0;
518}
519
520pjsip_endpoint *ast_sip_get_pjsip_endpoint(void)
521{
522 return ast_pjsip_endpoint;
523}
524
525int ast_sip_will_uri_survive_restart(pjsip_sip_uri *uri, struct ast_sip_endpoint *endpoint,
526 pjsip_rx_data *rdata)
527{
528 pj_str_t host_name;
529 int result = 1;
530
531 /* Determine if the contact cannot survive a restart/boot. */
532 if (uri->port == rdata->pkt_info.src_port
533 && !pj_strcmp(&uri->host,
534 pj_cstr(&host_name, rdata->pkt_info.src_name))
535 /* We have already checked if the URI scheme is sip: or sips: */
536 && PJSIP_TRANSPORT_IS_RELIABLE(rdata->tp_info.transport)) {
537 pj_str_t type_name;
538
539 /* Determine the transport parameter value */
540 if (!strcasecmp("WSS", rdata->tp_info.transport->type_name)) {
541 /* WSS is special, as it needs to be ws. */
542 pj_cstr(&type_name, "ws");
543 } else {
544 pj_cstr(&type_name, rdata->tp_info.transport->type_name);
545 }
546
547 if (!pj_stricmp(&uri->transport_param, &type_name)
548 && (endpoint->nat.rewrite_contact
549 /* Websockets are always rewritten */
550 || !pj_stricmp(&uri->transport_param,
551 pj_cstr(&type_name, "ws")))) {
552 /*
553 * The contact was rewritten to the reliable transport's
554 * source address. Disconnecting the transport for any
555 * reason invalidates the contact.
556 */
557 result = 0;
558 }
559 }
560
561 return result;
562}
563
564pjsip_sip_uri *ast_sip_get_contact_sip_uri(pjsip_tx_data *tdata)
565{
566 pjsip_contact_hdr *contact = pjsip_msg_find_hdr(tdata->msg, PJSIP_H_CONTACT, NULL);
567
568 if (!contact || (!PJSIP_URI_SCHEME_IS_SIP(contact->uri) && !PJSIP_URI_SCHEME_IS_SIPS(contact->uri))) {
569 return NULL;
570 }
571
572 return pjsip_uri_get_uri(contact->uri);
573}
574
575/*! \brief Callback function for finding the transport the request is going out on */
576static int find_transport_state_in_use(void *obj, void *arg, int flags)
577{
578 struct ast_sip_transport_state *transport_state = obj;
579 struct ast_sip_request_transport_details *details = arg;
580
581 /* If an explicit transport or factory matches then this is what is in use, if we are unavailable
582 * to compare based on that we make sure that the type is the same and the source IP address/port are the same
583 */
584 if (transport_state && ((details->transport && details->transport == transport_state->transport) ||
585 (details->factory && details->factory == transport_state->factory) ||
586 ((details->type == transport_state->type) && (transport_state->factory) &&
587 !pj_strcmp(&transport_state->factory->addr_name.host, &details->local_address) &&
588 transport_state->factory->addr_name.port == details->local_port))) {
589 return CMP_MATCH | CMP_STOP;
590 }
591
592 return 0;
593}
594
597
599 return NULL;
600 }
601
603}
604
605int ast_sip_rewrite_uri_to_local(pjsip_sip_uri *uri, pjsip_tx_data *tdata) {
607 RAII_VAR(struct ast_sip_transport_state *, transport_state, NULL, ao2_cleanup);
608 struct ast_sip_request_transport_details details = { 0, };
609 pjsip_sip_uri *tmp_uri;
610 pjsip_dialog *dlg;
611 struct ast_sockaddr addr = { { 0, } };
612
613 if ((tmp_uri = ast_sip_get_contact_sip_uri(tdata))) {
614 pj_strdup(tdata->pool, &uri->host, &tmp_uri->host);
615 uri->port = tmp_uri->port;
616 } else if ((dlg = pjsip_tdata_get_dlg(tdata))
617 && (tmp_uri = pjsip_uri_get_uri(dlg->local.info->uri))
618 && (PJSIP_URI_SCHEME_IS_SIP(tmp_uri) || PJSIP_URI_SCHEME_IS_SIPS(tmp_uri))) {
619 pj_strdup(tdata->pool, &uri->host, &tmp_uri->host);
620 uri->port = tmp_uri->port;
621 }
622
623 if (ast_sip_set_request_transport_details(&details, tdata, 1)
624 || !(transport_state = ast_sip_find_transport_state_in_use(&details))
625 || !(transport = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "transport", transport_state->id))) {
626 return 0;
627 }
628
629 if (transport_state->localnet) {
630 ast_sockaddr_parse(&addr, tdata->tp_info.dst_name, PARSE_PORT_FORBID);
631 ast_sockaddr_set_port(&addr, tdata->tp_info.dst_port);
632 if (ast_sip_transport_is_local(transport_state, &addr)) {
633 return 0;
634 }
635 }
636
637 if (!ast_sockaddr_isnull(&transport_state->external_signaling_address)) {
638 pj_strdup2(tdata->pool, &uri->host, ast_sockaddr_stringify_host(&transport_state->external_signaling_address));
639 }
640
641 if (transport->external_signaling_port) {
642 uri->port = transport->external_signaling_port;
643 }
644
645 return 0;
646}
647
649 int use_ipv6) {
650 pjsip_sip_uri *uri;
651 pjsip_via_hdr *via;
652 long transport_type;
653
654 if (!details || !tdata) {
655 return -1;
656 }
657
658 /* If IPv6 should be considered, un-set Bit 7 to make TCP6 equal to TCP and TLS6 equal to TLS */
659 transport_type = use_ipv6 ? tdata->tp_info.transport->key.type & ~(PJSIP_TRANSPORT_IPV6)
660 : tdata->tp_info.transport->key.type;
661
662 if (tdata->tp_sel.type == PJSIP_TPSELECTOR_TRANSPORT) {
663 details->transport = tdata->tp_sel.u.transport;
664 } else if (tdata->tp_sel.type == PJSIP_TPSELECTOR_LISTENER) {
665 details->factory = tdata->tp_sel.u.listener;
666 } else if (transport_type == PJSIP_TRANSPORT_UDP || transport_type == PJSIP_TRANSPORT_UDP6) {
667 /* Connectionless uses the same transport for all requests */
668 details->type = AST_TRANSPORT_UDP;
669 details->transport = tdata->tp_info.transport;
670 } else {
671 if (transport_type == PJSIP_TRANSPORT_TCP) {
672 details->type = AST_TRANSPORT_TCP;
673 } else if (transport_type == PJSIP_TRANSPORT_TLS) {
674 details->type = AST_TRANSPORT_TLS;
675 } else {
676 /* Unknown transport type, we can't map. */
677 return -1;
678 }
679
680 if ((uri = ast_sip_get_contact_sip_uri(tdata))) {
681 details->local_address = uri->host;
682 details->local_port = uri->port;
683 } else if ((tdata->msg->type == PJSIP_REQUEST_MSG) &&
684 (via = pjsip_msg_find_hdr(tdata->msg, PJSIP_H_VIA, NULL))) {
685 details->local_address = via->sent_by.host;
686 details->local_port = via->sent_by.port;
687 } else {
688 return -1;
689 }
690
691 if (!details->local_port) {
692 details->local_port = (details->type == AST_TRANSPORT_TLS) ? 5061 : 5060;
693 }
694 }
695 return 0;
696}
697
699 pjsip_sip_uri *sip_uri, char *buf, size_t buf_len)
700{
701 char *host = NULL;
702 static const pj_str_t x_name = { AST_SIP_X_AST_TXP, AST_SIP_X_AST_TXP_LEN };
703 pjsip_param *x_transport;
704
705 if (!ast_strlen_zero(endpoint->transport)) {
706 ast_copy_string(buf, endpoint->transport, buf_len);
707 return 0;
708 }
709
710 x_transport = pjsip_param_find(&sip_uri->other_param, &x_name);
711 if (!x_transport) {
712 return -1;
713 }
714
715 /* Only use x_transport if the uri host is an ip (4 or 6) address */
716 host = ast_alloca(sip_uri->host.slen + 1);
717 ast_copy_pj_str(host, &sip_uri->host, sip_uri->host.slen + 1);
719 return -1;
720 }
721
722 ast_copy_pj_str(buf, &x_transport->value, buf_len);
723
724 return 0;
725}
726
727int ast_sip_dlg_set_transport(const struct ast_sip_endpoint *endpoint, pjsip_dialog *dlg,
728 pjsip_tpselector *selector)
729{
730 pjsip_sip_uri *uri;
731 pjsip_tpselector sel = { .type = PJSIP_TPSELECTOR_NONE, };
732
733 uri = pjsip_uri_get_uri(dlg->target);
734 if (!selector) {
735 selector = &sel;
736 }
737
738 ast_sip_set_tpselector_from_ep_or_uri(endpoint, uri, selector);
739
740 pjsip_dlg_set_transport(dlg, selector);
741
742 if (selector == &sel) {
744 }
745
746 return 0;
747}
748
749static int sip_dialog_create_from(pj_pool_t *pool, pj_str_t *from, const char *user,
750 const char *domain, const pj_str_t *target, pjsip_tpselector *selector)
751{
752 pj_str_t tmp, local_addr;
753 pjsip_uri *uri;
754 pjsip_sip_uri *sip_uri;
755 pjsip_transport_type_e type;
756 int local_port;
757 char default_user[PJSIP_MAX_URL_SIZE];
758
759 if (ast_strlen_zero(user)) {
760 ast_sip_get_default_from_user(default_user, sizeof(default_user));
761 user = default_user;
762 }
763
764 /* Parse the provided target URI so we can determine what transport it will end up using */
765 pj_strdup_with_null(pool, &tmp, target);
766
767 if (!(uri = pjsip_parse_uri(pool, tmp.ptr, tmp.slen, 0)) ||
768 (!PJSIP_URI_SCHEME_IS_SIP(uri) && !PJSIP_URI_SCHEME_IS_SIPS(uri))) {
769 return -1;
770 }
771
772 sip_uri = pjsip_uri_get_uri(uri);
773
774 /* Determine the transport type to use */
775 type = pjsip_transport_get_type_from_name(&sip_uri->transport_param);
776 if (PJSIP_URI_SCHEME_IS_SIPS(sip_uri)) {
777 if (type == PJSIP_TRANSPORT_UNSPECIFIED
778 || !(pjsip_transport_get_flag_from_type(type) & PJSIP_TRANSPORT_SECURE)) {
779 type = PJSIP_TRANSPORT_TLS;
780 }
781 } else if (!sip_uri->transport_param.slen) {
782 type = PJSIP_TRANSPORT_UDP;
783 } else if (type == PJSIP_TRANSPORT_UNSPECIFIED) {
784 return -1;
785 }
786
787 /* If the host is IPv6 turn the transport into an IPv6 version */
788 if (pj_strchr(&sip_uri->host, ':')) {
789 type |= PJSIP_TRANSPORT_IPV6;
790 }
791
792 /* In multidomain scenario, username may contain @ with domain info */
793 if (!ast_sip_get_disable_multi_domain() && strchr(user, '@')) {
794 from->ptr = pj_pool_alloc(pool, PJSIP_MAX_URL_SIZE);
795 from->slen = pj_ansi_snprintf(from->ptr, PJSIP_MAX_URL_SIZE,
796 "<sip:%s%s%s>",
797 user,
798 (type != PJSIP_TRANSPORT_UDP && type != PJSIP_TRANSPORT_UDP6) ? ";transport=" : "",
799 (type != PJSIP_TRANSPORT_UDP && type != PJSIP_TRANSPORT_UDP6) ? pjsip_transport_get_type_name(type) : "");
800 return 0;
801 }
802
803 if (!ast_strlen_zero(domain)) {
804 from->ptr = pj_pool_alloc(pool, PJSIP_MAX_URL_SIZE);
805 from->slen = pj_ansi_snprintf(from->ptr, PJSIP_MAX_URL_SIZE,
806 "<sip:%s@%s%s%s>",
807 user,
808 domain,
809 (type != PJSIP_TRANSPORT_UDP && type != PJSIP_TRANSPORT_UDP6) ? ";transport=" : "",
810 (type != PJSIP_TRANSPORT_UDP && type != PJSIP_TRANSPORT_UDP6) ? pjsip_transport_get_type_name(type) : "");
811 return 0;
812 }
813
814 /* Get the local bound address for the transport that will be used when communicating with the provided URI */
815 if (pjsip_tpmgr_find_local_addr(pjsip_endpt_get_tpmgr(ast_sip_get_pjsip_endpoint()), pool, type, selector,
816 &local_addr, &local_port) != PJ_SUCCESS) {
817
818 /* If no local address can be retrieved using the transport manager use the host one */
819 pj_strdup(pool, &local_addr, pj_gethostname());
820 local_port = pjsip_transport_get_default_port_for_type(PJSIP_TRANSPORT_UDP);
821 }
822
823 /* If IPv6 was specified in the transport, set the proper type */
824 if (pj_strchr(&local_addr, ':')) {
825 type |= PJSIP_TRANSPORT_IPV6;
826 }
827
828 from->ptr = pj_pool_alloc(pool, PJSIP_MAX_URL_SIZE);
829 from->slen = pj_ansi_snprintf(from->ptr, PJSIP_MAX_URL_SIZE,
830 "<sip:%s@%s%.*s%s:%d%s%s>",
831 user,
832 (type & PJSIP_TRANSPORT_IPV6) ? "[" : "",
833 (int)local_addr.slen,
834 local_addr.ptr,
835 (type & PJSIP_TRANSPORT_IPV6) ? "]" : "",
836 local_port,
837 (type != PJSIP_TRANSPORT_UDP && type != PJSIP_TRANSPORT_UDP6) ? ";transport=" : "",
838 (type != PJSIP_TRANSPORT_UDP && type != PJSIP_TRANSPORT_UDP6) ? pjsip_transport_get_type_name(type) : "");
839
840 return 0;
841}
842
843int ast_sip_set_tpselector_from_transport(const struct ast_sip_transport *transport, pjsip_tpselector *selector)
844{
845 int res = 0;
846 struct ast_sip_transport_state *transport_state;
847
849 if (!transport_state) {
850 ast_log(LOG_ERROR, "Unable to retrieve PJSIP transport state for '%s'\n",
852 return -1;
853 }
854
855 /* Only flows maintain dynamic state which needs protection */
856 if (transport_state->flow) {
857 ao2_lock(transport_state);
858 }
859
860 if (transport_state->transport) {
861 selector->type = PJSIP_TPSELECTOR_TRANSPORT;
862 selector->u.transport = transport_state->transport;
863 pjsip_transport_add_ref(selector->u.transport);
864 } else if (transport_state->factory) {
865 selector->type = PJSIP_TPSELECTOR_LISTENER;
866 selector->u.listener = transport_state->factory;
867 } else if (transport->type == AST_TRANSPORT_WS || transport->type == AST_TRANSPORT_WSS) {
868 /* The WebSocket transport has no factory as it can not create outgoing connections, so
869 * even if an endpoint is locked to a WebSocket transport we let the PJSIP logic
870 * find the existing connection if available and use it.
871 */
872 } else if (transport->flow) {
873 /* This is a child of another transport, so we need to establish a new connection */
874#ifdef HAVE_PJSIP_TRANSPORT_DISABLE_CONNECTION_REUSE
875 selector->disable_connection_reuse = PJ_TRUE;
876#else
877 ast_log(LOG_WARNING, "Connection reuse could not be disabled on transport '%s' as support is not available\n",
879#endif
880 } else {
881 res = -1;
882 }
883
884 if (transport_state->flow) {
885 ao2_unlock(transport_state);
886 }
887
888 ao2_ref(transport_state, -1);
889
890 return res;
891}
892
893int ast_sip_set_tpselector_from_transport_name(const char *transport_name, pjsip_tpselector *selector)
894{
896
897 if (ast_strlen_zero(transport_name)) {
898 return 0;
899 }
900
901 transport = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "transport", transport_name);
902 if (!transport) {
903 ast_log(LOG_ERROR, "Unable to retrieve PJSIP transport '%s'\n",
904 transport_name);
905 return -1;
906 }
907
909}
910
912 pjsip_sip_uri *sip_uri, pjsip_tpselector *selector)
913{
914 char transport_name[128];
915
916 if (ast_sip_get_transport_name(endpoint, sip_uri, transport_name, sizeof(transport_name))) {
917 return 0;
918 }
919
920 return ast_sip_set_tpselector_from_transport_name(transport_name, selector);
921}
922
923void ast_sip_tpselector_unref(pjsip_tpselector *selector)
924{
925 if (selector->type == PJSIP_TPSELECTOR_TRANSPORT && selector->u.transport) {
926 pjsip_transport_dec_ref(selector->u.transport);
927 }
928}
929
930void ast_sip_add_usereqphone(const struct ast_sip_endpoint *endpoint, pj_pool_t *pool, pjsip_uri *uri)
931{
932 pjsip_sip_uri *sip_uri;
933 int i = 0;
934 static const pj_str_t STR_PHONE = { "phone", 5 };
935
936 if (!endpoint || !endpoint->usereqphone || (!PJSIP_URI_SCHEME_IS_SIP(uri) && !PJSIP_URI_SCHEME_IS_SIPS(uri))) {
937 return;
938 }
939
940 sip_uri = pjsip_uri_get_uri(uri);
941
942 if (!pj_strlen(&sip_uri->user)) {
943 return;
944 }
945
946 if (pj_strbuf(&sip_uri->user)[0] == '+') {
947 i = 1;
948 }
949
950 /* Test URI user against allowed characters in AST_DIGIT_ANY */
951 for (; i < pj_strlen(&sip_uri->user); i++) {
952 if (!strchr(AST_DIGIT_ANY, pj_strbuf(&sip_uri->user)[i])) {
953 break;
954 }
955 }
956
957 if (i < pj_strlen(&sip_uri->user)) {
958 return;
959 }
960
961 sip_uri->user_param = STR_PHONE;
962}
963
964pjsip_dialog *ast_sip_create_dialog_uac(const struct ast_sip_endpoint *endpoint,
965 const char *uri, const char *request_user)
966{
967 char enclosed_uri[PJSIP_MAX_URL_SIZE];
968 pj_str_t local_uri = { "sip:temp@temp", 13 }, remote_uri, target_uri;
969 pj_status_t res;
970 pjsip_dialog *dlg = NULL;
971 const char *outbound_proxy = endpoint->outbound_proxy;
972 pjsip_tpselector selector = { .type = PJSIP_TPSELECTOR_NONE, };
973 static const pj_str_t HCONTACT = { "Contact", 7 };
974
975 if (!ast_begins_with(uri, "<")) {
976 snprintf(enclosed_uri, sizeof(enclosed_uri), "<%s>", uri);
977 } else {
978 snprintf(enclosed_uri, sizeof(enclosed_uri), "%s", uri);
979 }
980 pj_cstr(&remote_uri, enclosed_uri);
981
982 pj_cstr(&target_uri, uri);
983
984 res = pjsip_dlg_create_uac(pjsip_ua_instance(), &local_uri, NULL, &remote_uri, &target_uri, &dlg);
985 if (res == PJ_SUCCESS && !(PJSIP_URI_SCHEME_IS_SIP(dlg->target) || PJSIP_URI_SCHEME_IS_SIPS(dlg->target))) {
986 /* dlg->target is a pjsip_other_uri, but it's assumed to be a
987 * pjsip_sip_uri below. Fail fast. */
988 res = PJSIP_EINVALIDURI;
989 pjsip_dlg_terminate(dlg);
990 }
991 if (res != PJ_SUCCESS) {
992 if (res == PJSIP_EINVALIDURI) {
994 "Endpoint '%s': Could not create dialog to invalid URI '%s'. Is endpoint registered and reachable?\n",
995 ast_sorcery_object_get_id(endpoint), uri);
996 }
997 return NULL;
998 }
999
1000 /* We have to temporarily bump up the sess_count here so the dialog is not prematurely destroyed */
1001 dlg->sess_count++;
1002
1003 ast_sip_dlg_set_transport(endpoint, dlg, &selector);
1004
1005 if (sip_dialog_create_from(dlg->pool, &local_uri, endpoint->fromuser, endpoint->fromdomain, &remote_uri, &selector)) {
1006 dlg->sess_count--;
1007 pjsip_dlg_terminate(dlg);
1008 ast_sip_tpselector_unref(&selector);
1009 return NULL;
1010 }
1011
1012 ast_sip_tpselector_unref(&selector);
1013
1014 /* Update the dialog with the new local URI, we do it afterwards so we can use the dialog pool for construction */
1015 pj_strdup_with_null(dlg->pool, &dlg->local.info_str, &local_uri);
1016 dlg->local.info->uri = pjsip_parse_uri(dlg->pool, dlg->local.info_str.ptr, dlg->local.info_str.slen, 0);
1017 if (!dlg->local.info->uri) {
1019 "Could not parse URI '%s' for endpoint '%s'\n",
1020 dlg->local.info_str.ptr, ast_sorcery_object_get_id(endpoint));
1021 dlg->sess_count--;
1022 pjsip_dlg_terminate(dlg);
1023 return NULL;
1024 }
1025
1026 dlg->local.contact = pjsip_parse_hdr(dlg->pool, &HCONTACT, local_uri.ptr, local_uri.slen, NULL);
1027
1028 if (!ast_strlen_zero(endpoint->contact_user)) {
1029 pjsip_sip_uri *sip_uri;
1030
1031 sip_uri = pjsip_uri_get_uri(dlg->local.contact->uri);
1032 pj_strdup2(dlg->pool, &sip_uri->user, endpoint->contact_user);
1033 }
1034
1035 /* If a request user has been specified and we are permitted to change it, do so */
1036 if (!ast_strlen_zero(request_user)) {
1037 pjsip_sip_uri *sip_uri;
1038
1039 if (PJSIP_URI_SCHEME_IS_SIP(dlg->target) || PJSIP_URI_SCHEME_IS_SIPS(dlg->target)) {
1040 sip_uri = pjsip_uri_get_uri(dlg->target);
1041 pj_strdup2(dlg->pool, &sip_uri->user, request_user);
1042 }
1043 if (PJSIP_URI_SCHEME_IS_SIP(dlg->remote.info->uri) || PJSIP_URI_SCHEME_IS_SIPS(dlg->remote.info->uri)) {
1044 sip_uri = pjsip_uri_get_uri(dlg->remote.info->uri);
1045 pj_strdup2(dlg->pool, &sip_uri->user, request_user);
1046 }
1047 }
1048
1049 /* Add the user=phone parameter if applicable */
1050 ast_sip_add_usereqphone(endpoint, dlg->pool, dlg->target);
1051 ast_sip_add_usereqphone(endpoint, dlg->pool, dlg->remote.info->uri);
1052 ast_sip_add_usereqphone(endpoint, dlg->pool, dlg->local.info->uri);
1053
1054 if (!ast_strlen_zero(outbound_proxy)) {
1055 pjsip_route_hdr route_set, *route;
1056 static const pj_str_t ROUTE_HNAME = { "Route", 5 };
1057 pj_str_t tmp;
1058
1059 pj_list_init(&route_set);
1060
1061 pj_strdup2_with_null(dlg->pool, &tmp, outbound_proxy);
1062 if (!(route = pjsip_parse_hdr(dlg->pool, &ROUTE_HNAME, tmp.ptr, tmp.slen, NULL))) {
1063 ast_log(LOG_ERROR, "Could not create dialog to endpoint '%s' as outbound proxy URI '%s' is not valid\n",
1064 ast_sorcery_object_get_id(endpoint), outbound_proxy);
1065 dlg->sess_count--;
1066 pjsip_dlg_terminate(dlg);
1067 return NULL;
1068 }
1069 pj_list_insert_nodes_before(&route_set, route);
1070
1071 pjsip_dlg_set_route_set(dlg, &route_set);
1072 }
1073
1074 dlg->sess_count--;
1075
1076 return dlg;
1077}
1078
1079/*!
1080 * \brief Determine if a SIPS Contact header is required.
1081 *
1082 * This uses the guideline provided in RFC 3261 Section 12.1.1 to
1083 * determine if the Contact header must be a sips: URI.
1084 *
1085 * \param rdata The incoming dialog-starting request
1086 * \retval 0 SIPS not required
1087 * \retval 1 SIPS required
1088 */
1089static int uas_use_sips_contact(pjsip_rx_data *rdata)
1090{
1091 pjsip_rr_hdr *record_route;
1092
1093 if (PJSIP_URI_SCHEME_IS_SIPS(rdata->msg_info.msg->line.req.uri)) {
1094 return 1;
1095 }
1096
1097 record_route = pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_RECORD_ROUTE, NULL);
1098 if (record_route) {
1099 if (PJSIP_URI_SCHEME_IS_SIPS(&record_route->name_addr)) {
1100 return 1;
1101 }
1102 } else {
1103 pjsip_contact_hdr *contact;
1104
1105 contact = pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_CONTACT, NULL);
1106 ast_assert(contact != NULL);
1107 if (PJSIP_URI_SCHEME_IS_SIPS(contact->uri)) {
1108 return 1;
1109 }
1110 }
1111
1112 return 0;
1113}
1114
1115typedef pj_status_t (*create_dlg_uac)(pjsip_user_agent *ua, pjsip_rx_data *rdata,
1116 const pj_str_t *contact, pjsip_dialog **p_dlg);
1117
1118static pjsip_dialog *create_dialog_uas(const struct ast_sip_endpoint *endpoint,
1119 pjsip_rx_data *rdata, pj_status_t *status, create_dlg_uac create_fun)
1120{
1121 pjsip_dialog *dlg;
1122 pj_str_t contact;
1123 pjsip_transport_type_e type = rdata->tp_info.transport->key.type;
1124 pjsip_tpselector selector = { .type = PJSIP_TPSELECTOR_NONE, };
1125 pjsip_transport *transport;
1126 pjsip_contact_hdr *contact_hdr;
1127
1129
1130 contact_hdr = pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_CONTACT, NULL);
1131 if (!contact_hdr || ast_sip_set_tpselector_from_ep_or_uri(endpoint, pjsip_uri_get_uri(contact_hdr->uri),
1132 &selector)) {
1133 return NULL;
1134 }
1135
1136 transport = rdata->tp_info.transport;
1137 if (selector.type == PJSIP_TPSELECTOR_TRANSPORT) {
1138 transport = selector.u.transport;
1139 }
1140 type = transport->key.type;
1141
1142 contact.ptr = pj_pool_alloc(rdata->tp_info.pool, PJSIP_MAX_URL_SIZE);
1143 contact.slen = pj_ansi_snprintf(contact.ptr, PJSIP_MAX_URL_SIZE,
1144 "<%s:%s%s%s%.*s%s:%d%s%s>",
1145 uas_use_sips_contact(rdata) ? "sips" : "sip",
1146 (type & PJSIP_TRANSPORT_IPV6) ? "[" : "",
1147 S_OR(endpoint->contact_user, ""),
1148 (!ast_strlen_zero(endpoint->contact_user)) ? "@" : "",
1149 (int)transport->local_name.host.slen,
1150 transport->local_name.host.ptr,
1151 (type & PJSIP_TRANSPORT_IPV6) ? "]" : "",
1152 transport->local_name.port,
1153 (type != PJSIP_TRANSPORT_UDP && type != PJSIP_TRANSPORT_UDP6) ? ";transport=" : "",
1154 (type != PJSIP_TRANSPORT_UDP && type != PJSIP_TRANSPORT_UDP6) ? pjsip_transport_get_type_name(type) : "");
1155
1156 *status = create_fun(pjsip_ua_instance(), rdata, &contact, &dlg);
1157 if (*status != PJ_SUCCESS) {
1158 char err[PJ_ERR_MSG_SIZE];
1159
1160 pj_strerror(*status, err, sizeof(err));
1161 ast_log(LOG_ERROR, "Could not create dialog with endpoint %s. %s\n",
1162 ast_sorcery_object_get_id(endpoint), err);
1163 ast_sip_tpselector_unref(&selector);
1164 return NULL;
1165 }
1166
1167 dlg->sess_count++;
1168 pjsip_dlg_set_transport(dlg, &selector);
1169 dlg->sess_count--;
1170
1171 ast_sip_tpselector_unref(&selector);
1172
1173 return dlg;
1174}
1175
1176pjsip_dialog *ast_sip_create_dialog_uas(const struct ast_sip_endpoint *endpoint, pjsip_rx_data *rdata, pj_status_t *status)
1177{
1178#ifdef HAVE_PJSIP_DLG_CREATE_UAS_AND_INC_LOCK
1179 pjsip_dialog *dlg;
1180
1181 dlg = create_dialog_uas(endpoint, rdata, status, pjsip_dlg_create_uas_and_inc_lock);
1182 if (dlg) {
1183 pjsip_dlg_dec_lock(dlg);
1184 }
1185
1186 return dlg;
1187#else
1188 return create_dialog_uas(endpoint, rdata, status, pjsip_dlg_create_uas);
1189#endif
1190}
1191
1192pjsip_dialog *ast_sip_create_dialog_uas_locked(const struct ast_sip_endpoint *endpoint,
1193 pjsip_rx_data *rdata, pj_status_t *status)
1194{
1195#ifdef HAVE_PJSIP_DLG_CREATE_UAS_AND_INC_LOCK
1196 return create_dialog_uas(endpoint, rdata, status, pjsip_dlg_create_uas_and_inc_lock);
1197#else
1198 /*
1199 * This is put here in order to be compatible with older versions of pjproject.
1200 * Best we can do in this case is immediately lock after getting the dialog.
1201 * However, that does leave a "gap" between creating and locking.
1202 */
1203 pjsip_dialog *dlg;
1204
1205 dlg = create_dialog_uas(endpoint, rdata, status, pjsip_dlg_create_uas);
1206 if (dlg) {
1207 pjsip_dlg_inc_lock(dlg);
1208 }
1209
1210 return dlg;
1211#endif
1212 }
1213
1214int ast_sip_create_rdata_with_contact(pjsip_rx_data *rdata, char *packet, const char *src_name, int src_port,
1215 char *transport_type, const char *local_name, int local_port, const char *contact)
1216{
1217 pj_str_t tmp;
1218
1219 /*
1220 * Initialize the error list in case there is a parse error
1221 * in the given packet.
1222 */
1223 pj_list_init(&rdata->msg_info.parse_err);
1224
1225 rdata->tp_info.transport = PJ_POOL_ZALLOC_T(rdata->tp_info.pool, pjsip_transport);
1226 if (!rdata->tp_info.transport) {
1227 return -1;
1228 }
1229
1230 ast_copy_string(rdata->pkt_info.packet, packet, sizeof(rdata->pkt_info.packet));
1231 ast_copy_string(rdata->pkt_info.src_name, src_name, sizeof(rdata->pkt_info.src_name));
1232 rdata->pkt_info.src_port = src_port;
1233 pj_sockaddr_parse(pj_AF_UNSPEC(), 0, pj_cstr(&tmp, src_name), &rdata->pkt_info.src_addr);
1234 pj_sockaddr_set_port(&rdata->pkt_info.src_addr, src_port);
1235
1236 pjsip_parse_rdata(packet, strlen(packet), rdata);
1237 if (!rdata->msg_info.msg || !pj_list_empty(&rdata->msg_info.parse_err)) {
1238 return -1;
1239 }
1240
1241 if (!ast_strlen_zero(contact)) {
1242 pjsip_contact_hdr *contact_hdr;
1243
1244 contact_hdr = pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_CONTACT, NULL);
1245 if (contact_hdr) {
1246 contact_hdr->uri = pjsip_parse_uri(rdata->tp_info.pool, (char *)contact,
1247 strlen(contact), PJSIP_PARSE_URI_AS_NAMEADDR);
1248 if (!contact_hdr->uri) {
1249 ast_log(LOG_WARNING, "Unable to parse contact URI from '%s'.\n", contact);
1250 return -1;
1251 }
1252 }
1253 }
1254
1255 pj_strdup2(rdata->tp_info.pool, &rdata->msg_info.via->recvd_param, rdata->pkt_info.src_name);
1256 rdata->msg_info.via->rport_param = -1;
1257
1258 rdata->tp_info.transport->key.type = pjsip_transport_get_type_from_name(pj_cstr(&tmp, transport_type));
1259 rdata->tp_info.transport->type_name = transport_type;
1260 pj_strdup2(rdata->tp_info.pool, &rdata->tp_info.transport->local_name.host, local_name);
1261 rdata->tp_info.transport->local_name.port = local_port;
1262
1263 return 0;
1264}
1265
1266int ast_sip_create_rdata(pjsip_rx_data *rdata, char *packet, const char *src_name, int src_port,
1267 char *transport_type, const char *local_name, int local_port)
1268{
1269 return ast_sip_create_rdata_with_contact(rdata, packet, src_name, src_port, transport_type,
1270 local_name, local_port, NULL);
1271}
1272
1273/* PJSIP doesn't know about the INFO method, so we have to define it ourselves */
1274static const pjsip_method info_method = {PJSIP_OTHER_METHOD, {"INFO", 4} };
1275static const pjsip_method message_method = {PJSIP_OTHER_METHOD, {"MESSAGE", 7} };
1276static const pjsip_method refer_method = {PJSIP_OTHER_METHOD, {"REFER", 5} };
1277
1278static struct {
1279 const char *method;
1280 const pjsip_method *pmethod;
1281} methods [] = {
1282 { "INVITE", &pjsip_invite_method },
1283 { "CANCEL", &pjsip_cancel_method },
1284 { "ACK", &pjsip_ack_method },
1285 { "BYE", &pjsip_bye_method },
1286 { "REGISTER", &pjsip_register_method },
1287 { "OPTIONS", &pjsip_options_method },
1288 { "SUBSCRIBE", &pjsip_subscribe_method },
1289 { "NOTIFY", &pjsip_notify_method },
1290 { "PUBLISH", &pjsip_publish_method },
1291 { "INFO", &info_method },
1292 { "MESSAGE", &message_method },
1293 { "REFER", &refer_method },
1295
1296static const pjsip_method *get_pjsip_method(const char *method)
1297{
1298 int i;
1299 for (i = 0; i < ARRAY_LEN(methods); ++i) {
1300 if (!strcmp(method, methods[i].method)) {
1301 return methods[i].pmethod;
1302 }
1303 }
1304 return NULL;
1305}
1306
1307static int create_in_dialog_request(const pjsip_method *method, struct pjsip_dialog *dlg, pjsip_tx_data **tdata)
1308{
1309 if (pjsip_dlg_create_request(dlg, method, -1, tdata) != PJ_SUCCESS) {
1310 ast_log(LOG_WARNING, "Unable to create in-dialog request.\n");
1311 return -1;
1312 }
1313
1314 return 0;
1315}
1316
1317static pj_bool_t supplement_on_rx_request(pjsip_rx_data *rdata);
1318static pjsip_module supplement_module = {
1319 .name = { "Out of dialog supplement hook", 29 },
1320 .id = -1,
1321 .priority = PJSIP_MOD_PRIORITY_APPLICATION - 1,
1322 .on_rx_request = supplement_on_rx_request,
1323};
1324
1325static int create_out_of_dialog_request(const pjsip_method *method, struct ast_sip_endpoint *endpoint,
1326 const char *uri, struct ast_sip_contact *provided_contact, pjsip_tx_data **tdata)
1327{
1328 RAII_VAR(struct ast_sip_contact *, contact, ao2_bump(provided_contact), ao2_cleanup);
1329 pj_str_t remote_uri;
1330 pj_str_t from;
1331 pj_pool_t *pool;
1332 pjsip_tpselector selector = { .type = PJSIP_TPSELECTOR_NONE, };
1333 pjsip_uri *sip_uri;
1334 const char *fromuser;
1335
1336 if (ast_strlen_zero(uri)) {
1337 if (!endpoint && (!contact || ast_strlen_zero(contact->uri))) {
1338 ast_log(LOG_ERROR, "An endpoint and/or uri must be specified\n");
1339 return -1;
1340 }
1341
1342 if (!contact) {
1344 }
1345 if (!contact || ast_strlen_zero(contact->uri)) {
1346 ast_log(LOG_WARNING, "Unable to retrieve contact for endpoint %s\n",
1347 ast_sorcery_object_get_id(endpoint));
1348 return -1;
1349 }
1350
1351 pj_cstr(&remote_uri, contact->uri);
1352 } else {
1353 pj_cstr(&remote_uri, uri);
1354 }
1355
1356 pool = pjsip_endpt_create_pool(ast_sip_get_pjsip_endpoint(), "Outbound request", 256, 256);
1357
1358 if (!pool) {
1359 ast_log(LOG_ERROR, "Unable to create PJLIB memory pool\n");
1360 return -1;
1361 }
1362
1363 sip_uri = pjsip_parse_uri(pool, remote_uri.ptr, remote_uri.slen, 0);
1364 if (!sip_uri || (!PJSIP_URI_SCHEME_IS_SIP(sip_uri) && !PJSIP_URI_SCHEME_IS_SIPS(sip_uri))) {
1365 ast_log(LOG_ERROR, "Unable to create outbound %.*s request to endpoint %s as URI '%s' is not valid\n",
1366 (int) pj_strlen(&method->name), pj_strbuf(&method->name),
1367 endpoint ? ast_sorcery_object_get_id(endpoint) : "<none>",
1368 pj_strbuf(&remote_uri));
1369 pjsip_endpt_release_pool(ast_sip_get_pjsip_endpoint(), pool);
1370 return -1;
1371 }
1372
1373 ast_sip_set_tpselector_from_ep_or_uri(endpoint, pjsip_uri_get_uri(sip_uri), &selector);
1374
1375 fromuser = endpoint ? (!ast_strlen_zero(endpoint->fromuser) ? endpoint->fromuser : ast_sorcery_object_get_id(endpoint)) : NULL;
1376 if (sip_dialog_create_from(pool, &from, fromuser,
1377 endpoint ? endpoint->fromdomain : NULL, &remote_uri, &selector)) {
1378 ast_log(LOG_ERROR, "Unable to create From header for %.*s request to endpoint %s\n",
1379 (int) pj_strlen(&method->name), pj_strbuf(&method->name),
1380 endpoint ? ast_sorcery_object_get_id(endpoint) : "<none>");
1381 pjsip_endpt_release_pool(ast_sip_get_pjsip_endpoint(), pool);
1382 ast_sip_tpselector_unref(&selector);
1383 return -1;
1384 }
1385
1386 if (pjsip_endpt_create_request(ast_sip_get_pjsip_endpoint(), method, &remote_uri,
1387 &from, &remote_uri, &from, NULL, -1, NULL, tdata) != PJ_SUCCESS) {
1388 ast_log(LOG_ERROR, "Unable to create outbound %.*s request to endpoint %s\n",
1389 (int) pj_strlen(&method->name), pj_strbuf(&method->name),
1390 endpoint ? ast_sorcery_object_get_id(endpoint) : "<none>");
1391 pjsip_endpt_release_pool(ast_sip_get_pjsip_endpoint(), pool);
1392 ast_sip_tpselector_unref(&selector);
1393 return -1;
1394 }
1395
1396 pjsip_tx_data_set_transport(*tdata, &selector);
1397
1398 ast_sip_tpselector_unref(&selector);
1399
1400 if (endpoint && !ast_strlen_zero(endpoint->contact_user)){
1401 pjsip_contact_hdr *contact_hdr;
1402 pjsip_sip_uri *contact_uri;
1403 static const pj_str_t HCONTACT = { "Contact", 7 };
1404 static const pj_str_t HCONTACTSHORT = { "m", 1 };
1405
1406 contact_hdr = pjsip_msg_find_hdr_by_names((*tdata)->msg, &HCONTACT, &HCONTACTSHORT, NULL);
1407 if (contact_hdr) {
1408 contact_uri = pjsip_uri_get_uri(contact_hdr->uri);
1409 pj_strdup2((*tdata)->pool, &contact_uri->user, endpoint->contact_user);
1410 }
1411 }
1412
1413 /* Add the user=phone parameter if applicable */
1414 ast_sip_add_usereqphone(endpoint, (*tdata)->pool, (*tdata)->msg->line.req.uri);
1415
1416 /* If an outbound proxy is specified on the endpoint apply it to this request */
1417 if (endpoint && !ast_strlen_zero(endpoint->outbound_proxy) &&
1418 ast_sip_set_outbound_proxy((*tdata), endpoint->outbound_proxy)) {
1419 ast_log(LOG_ERROR, "Unable to apply outbound proxy on request %.*s to endpoint %s as outbound proxy URI '%s' is not valid\n",
1420 (int) pj_strlen(&method->name), pj_strbuf(&method->name), ast_sorcery_object_get_id(endpoint),
1421 endpoint->outbound_proxy);
1422 pjsip_endpt_release_pool(ast_sip_get_pjsip_endpoint(), pool);
1423 return -1;
1424 }
1425
1426 ast_sip_mod_data_set((*tdata)->pool, (*tdata)->mod_data, supplement_module.id, MOD_DATA_CONTACT, ao2_bump(contact));
1427
1428 /* We can release this pool since request creation copied all the necessary
1429 * data into the outbound request's pool
1430 */
1431 pjsip_endpt_release_pool(ast_sip_get_pjsip_endpoint(), pool);
1432 return 0;
1433}
1434
1435int ast_sip_create_request(const char *method, struct pjsip_dialog *dlg,
1436 struct ast_sip_endpoint *endpoint, const char *uri,
1437 struct ast_sip_contact *contact, pjsip_tx_data **tdata)
1438{
1439 const pjsip_method *pmethod = get_pjsip_method(method);
1440
1441 if (!pmethod) {
1442 ast_log(LOG_WARNING, "Unknown method '%s'. Cannot send request\n", method);
1443 return -1;
1444 }
1445
1446 if (dlg) {
1447 return create_in_dialog_request(pmethod, dlg, tdata);
1448 } else {
1449 ast_assert(endpoint != NULL);
1450 return create_out_of_dialog_request(pmethod, endpoint, uri, contact, tdata);
1451 }
1452}
1453
1455
1457{
1458 struct ast_sip_supplement *iter;
1459 int inserted = 0;
1461
1463 if (iter->priority > supplement->priority) {
1465 inserted = 1;
1466 break;
1467 }
1468 }
1470
1471 if (!inserted) {
1473 }
1474}
1475
1477{
1478 struct ast_sip_supplement *iter;
1480
1482 if (supplement == iter) {
1484 break;
1485 }
1486 }
1488}
1489
1490static int send_in_dialog_request(pjsip_tx_data *tdata, struct pjsip_dialog *dlg)
1491{
1492 if (pjsip_dlg_send_request(dlg, tdata, -1, NULL) != PJ_SUCCESS) {
1493 ast_log(LOG_WARNING, "Unable to send in-dialog request.\n");
1494 return -1;
1495 }
1496 return 0;
1497}
1498
1499static pj_bool_t does_method_match(const pj_str_t *message_method, const char *supplement_method)
1500{
1501 pj_str_t method;
1502
1503 if (ast_strlen_zero(supplement_method)) {
1504 return PJ_TRUE;
1505 }
1506
1507 pj_cstr(&method, supplement_method);
1508
1509 return pj_stristr(&method, message_method) ? PJ_TRUE : PJ_FALSE;
1510}
1511
1512#define TIMER_INACTIVE 0
1513#define TIMEOUT_TIMER2 5
1514
1515/*! \brief Structure to hold information about an outbound request */
1517 /*! The endpoint associated with this request */
1519 /*! Information to be provided to the callback upon receipt of a response */
1520 void *token;
1521 /*! The callback to be called upon receipt of a response */
1522 void (*callback)(void *token, pjsip_event *e);
1523 /*! Number of challenges received. */
1524 unsigned int challenge_count;
1525};
1526
1527static void send_request_data_destroy(void *obj)
1528{
1529 struct send_request_data *req_data = obj;
1530
1531 ao2_cleanup(req_data->endpoint);
1532}
1533
1535 void *token, void (*callback)(void *token, pjsip_event *e))
1536{
1537 struct send_request_data *req_data;
1538
1539 req_data = ao2_alloc_options(sizeof(*req_data), send_request_data_destroy,
1541 if (!req_data) {
1542 return NULL;
1543 }
1544
1545 req_data->endpoint = ao2_bump(endpoint);
1546 req_data->token = token;
1547 req_data->callback = callback;
1548
1549 return req_data;
1550}
1551
1553 /*! Information to be provided to the callback upon receipt of a response */
1554 void *token;
1555 /*! The callback to be called upon receipt of a response */
1556 void (*callback)(void *token, pjsip_event *e);
1557 /*! Non-zero when the callback is called. */
1558 unsigned int cb_called;
1559 /*! Non-zero if endpt_send_request_cb() was called. */
1560 unsigned int send_cb_called;
1561 /*! Timeout timer. */
1562 pj_timer_entry *timeout_timer;
1563 /*! Original timeout. */
1564 pj_int32_t timeout;
1565 /*! The transmit data. */
1566 pjsip_tx_data *tdata;
1567};
1568
1569/*! \internal This function gets called by pjsip when the transaction ends,
1570 * even if it timed out. The lock prevents a race condition if both the pjsip
1571 * transaction timer and our own timer expire simultaneously.
1572 */
1573static void endpt_send_request_cb(void *token, pjsip_event *e)
1574{
1575 struct send_request_wrapper *req_wrapper = token;
1576 unsigned int cb_called;
1577
1578 /*
1579 * Needed because we cannot otherwise tell if this callback was
1580 * called when pjsip_endpt_send_request() returns error.
1581 */
1582 req_wrapper->send_cb_called = 1;
1583
1584 if (e->body.tsx_state.type == PJSIP_EVENT_TIMER) {
1585 ast_debug(2, "%p: PJSIP tsx timer expired\n", req_wrapper);
1586
1587 if (req_wrapper->timeout_timer
1588 && req_wrapper->timeout_timer->id != TIMEOUT_TIMER2) {
1589 ast_debug(3, "%p: Timeout already handled\n", req_wrapper);
1590 ao2_ref(req_wrapper, -1);
1591 return;
1592 }
1593 } else {
1594 ast_debug(2, "%p: PJSIP tsx response received\n", req_wrapper);
1595 }
1596
1597 ao2_lock(req_wrapper);
1598
1599 /* It's possible that our own timer was already processing while
1600 * we were waiting on the lock so check the timer id. If it's
1601 * still TIMER2 then we still need to process.
1602 */
1603 if (req_wrapper->timeout_timer
1604 && req_wrapper->timeout_timer->id == TIMEOUT_TIMER2) {
1605 int timers_cancelled = 0;
1606
1607 ast_debug(3, "%p: Cancelling timer\n", req_wrapper);
1608
1609 timers_cancelled = pj_timer_heap_cancel_if_active(
1610 pjsip_endpt_get_timer_heap(ast_sip_get_pjsip_endpoint()),
1611 req_wrapper->timeout_timer, TIMER_INACTIVE);
1612 if (timers_cancelled > 0) {
1613 /* If the timer was cancelled the callback will never run so
1614 * clean up its reference to the wrapper.
1615 */
1616 ast_debug(3, "%p: Timer cancelled\n", req_wrapper);
1617 ao2_ref(req_wrapper, -1);
1618 } else {
1619 /*
1620 * If it wasn't cancelled, it MAY be in the callback already
1621 * waiting on the lock. When we release the lock, it will
1622 * now know not to proceed.
1623 */
1624 ast_debug(3, "%p: Timer already expired\n", req_wrapper);
1625 }
1626 }
1627
1628 cb_called = req_wrapper->cb_called;
1629 req_wrapper->cb_called = 1;
1630 ao2_unlock(req_wrapper);
1631
1632 /* It's possible that our own timer expired and called the callbacks
1633 * so no need to call them again.
1634 */
1635 if (!cb_called && req_wrapper->callback) {
1636 req_wrapper->callback(req_wrapper->token, e);
1637 ast_debug(2, "%p: Callbacks executed\n", req_wrapper);
1638 }
1639
1640 ao2_ref(req_wrapper, -1);
1641}
1642
1643/*! \internal This function gets called by our own timer when it expires.
1644 * If the timer is cancelled however, the function does NOT get called.
1645 * The lock prevents a race condition if both the pjsip transaction timer
1646 * and our own timer expire simultaneously.
1647 */
1648static void send_request_timer_callback(pj_timer_heap_t *theap, pj_timer_entry *entry)
1649{
1650 struct send_request_wrapper *req_wrapper = entry->user_data;
1651 unsigned int cb_called;
1652
1653 ast_debug(2, "%p: Internal tsx timer expired after %d msec\n",
1654 req_wrapper, req_wrapper->timeout);
1655
1656 ao2_lock(req_wrapper);
1657 /*
1658 * If the id is not TIMEOUT_TIMER2 then the timer was cancelled
1659 * before we got the lock or it was already handled so just clean up.
1660 */
1661 if (entry->id != TIMEOUT_TIMER2) {
1662 ao2_unlock(req_wrapper);
1663 ast_debug(3, "%p: Timeout already handled\n", req_wrapper);
1664 ao2_ref(req_wrapper, -1);
1665 return;
1666 }
1667 entry->id = TIMER_INACTIVE;
1668
1669 ast_debug(3, "%p: Timer handled here\n", req_wrapper);
1670
1671 cb_called = req_wrapper->cb_called;
1672 req_wrapper->cb_called = 1;
1673 ao2_unlock(req_wrapper);
1674
1675 if (!cb_called && req_wrapper->callback) {
1676 pjsip_event event;
1677
1678 PJSIP_EVENT_INIT_TX_MSG(event, req_wrapper->tdata);
1679 event.body.tsx_state.type = PJSIP_EVENT_TIMER;
1680
1681 req_wrapper->callback(req_wrapper->token, &event);
1682 ast_debug(2, "%p: Callbacks executed\n", req_wrapper);
1683 }
1684
1685 ao2_ref(req_wrapper, -1);
1686}
1687
1689{
1690 struct send_request_wrapper *req_wrapper = obj;
1691
1692 pjsip_tx_data_dec_ref(req_wrapper->tdata);
1693 ast_debug(2, "%p: wrapper destroyed\n", req_wrapper);
1694}
1695
1696static pj_status_t endpt_send_request(struct ast_sip_endpoint *endpoint,
1697 pjsip_tx_data *tdata, pj_int32_t timeout, void *token, pjsip_endpt_send_callback cb)
1698{
1699 struct send_request_wrapper *req_wrapper;
1700 pj_status_t ret_val;
1701 pjsip_endpoint *endpt = ast_sip_get_pjsip_endpoint();
1702
1703 if (!cb && token) {
1704 /* Silly. Without a callback we cannot do anything with token. */
1705 pjsip_tx_data_dec_ref(tdata);
1706 return PJ_EINVAL;
1707 }
1708
1709 /* Create wrapper to detect if the callback was actually called on an error. */
1710 req_wrapper = ao2_alloc(sizeof(*req_wrapper), send_request_wrapper_destructor);
1711 if (!req_wrapper) {
1712 pjsip_tx_data_dec_ref(tdata);
1713 return PJ_ENOMEM;
1714 }
1715
1716 ast_debug(2, "%p: Wrapper created\n", req_wrapper);
1717
1718 req_wrapper->token = token;
1719 req_wrapper->callback = cb;
1720 req_wrapper->timeout = timeout;
1721 req_wrapper->timeout_timer = NULL;
1722 req_wrapper->tdata = tdata;
1723 /* Add a reference to tdata. The wrapper destructor cleans it up. */
1724 pjsip_tx_data_add_ref(tdata);
1725
1726 if (timeout > 0) {
1727 pj_time_val timeout_timer_val = { timeout / 1000, timeout % 1000 };
1728
1729 req_wrapper->timeout_timer = PJ_POOL_ALLOC_T(tdata->pool, pj_timer_entry);
1730
1731 ast_debug(2, "%p: Set timer to %d msec\n", req_wrapper, timeout);
1732
1733 pj_timer_entry_init(req_wrapper->timeout_timer, TIMEOUT_TIMER2,
1734 req_wrapper, send_request_timer_callback);
1735
1736 /* We need to insure that the wrapper and tdata are available if/when the
1737 * timer callback is executed.
1738 */
1739 ao2_ref(req_wrapper, +1);
1740 ret_val = pj_timer_heap_schedule(pjsip_endpt_get_timer_heap(endpt),
1741 req_wrapper->timeout_timer, &timeout_timer_val);
1742 if (ret_val != PJ_SUCCESS) {
1744 "Failed to set timer. Not sending %.*s request to endpoint %s.\n",
1745 (int) pj_strlen(&tdata->msg->line.req.method.name),
1746 pj_strbuf(&tdata->msg->line.req.method.name),
1747 endpoint ? ast_sorcery_object_get_id(endpoint) : "<unknown>");
1748 ao2_t_ref(req_wrapper, -2, "Drop timer and routine ref");
1749 pjsip_tx_data_dec_ref(tdata);
1750 return ret_val;
1751 }
1752 }
1753
1754 /* We need to insure that the wrapper and tdata are available when the
1755 * transaction callback is executed.
1756 */
1757 ao2_ref(req_wrapper, +1);
1758 ret_val = pjsip_endpt_send_request(endpt, tdata, -1, req_wrapper, endpt_send_request_cb);
1759 if (ret_val != PJ_SUCCESS) {
1760 char errmsg[PJ_ERR_MSG_SIZE];
1761
1762 if (!req_wrapper->send_cb_called) {
1763 /* endpt_send_request_cb is not expected to ever be called now. */
1764 ao2_ref(req_wrapper, -1);
1765 }
1766
1767 /* Complain of failure to send the request. */
1768 pj_strerror(ret_val, errmsg, sizeof(errmsg));
1769 ast_log(LOG_ERROR, "Error %d '%s' sending %.*s request to endpoint %s\n",
1770 (int) ret_val, errmsg, (int) pj_strlen(&tdata->msg->line.req.method.name),
1771 pj_strbuf(&tdata->msg->line.req.method.name),
1772 endpoint ? ast_sorcery_object_get_id(endpoint) : "<unknown>");
1773
1774 if (timeout > 0) {
1775 int timers_cancelled;
1776
1777 ao2_lock(req_wrapper);
1778 timers_cancelled = pj_timer_heap_cancel_if_active(
1779 pjsip_endpt_get_timer_heap(endpt),
1780 req_wrapper->timeout_timer, TIMER_INACTIVE);
1781 if (timers_cancelled > 0) {
1782 ao2_ref(req_wrapper, -1);
1783 }
1784
1785 /* Was the callback called? */
1786 if (req_wrapper->cb_called) {
1787 /*
1788 * Yes so we cannot report any error. The callback
1789 * has already freed any resources associated with
1790 * token.
1791 */
1792 ret_val = PJ_SUCCESS;
1793 } else {
1794 /*
1795 * No so we claim it is called so our caller can free
1796 * any resources associated with token because of
1797 * failure.
1798 */
1799 req_wrapper->cb_called = 1;
1800 }
1801 ao2_unlock(req_wrapper);
1802 } else if (req_wrapper->cb_called) {
1803 /*
1804 * We cannot report any error. The callback has
1805 * already freed any resources associated with
1806 * token.
1807 */
1808 ret_val = PJ_SUCCESS;
1809 }
1810 }
1811
1812 ao2_ref(req_wrapper, -1);
1813 return ret_val;
1814}
1815
1817{
1818 pjsip_via_hdr *via;
1819
1820 if (!tdata || !tdata->dest_info.addr.count
1821 || (tdata->dest_info.cur_addr == tdata->dest_info.addr.count - 1)) {
1822 /* No more addresses to try */
1823 return 0;
1824 }
1825
1826 /* Try next address */
1827 ++tdata->dest_info.cur_addr;
1828
1829 via = (pjsip_via_hdr*)pjsip_msg_find_hdr(tdata->msg, PJSIP_H_VIA, NULL);
1830 via->branch_param.slen = 0;
1831
1832 pjsip_tx_data_invalidate_msg(tdata);
1833
1834 return 1;
1835}
1836
1837static void send_request_cb(void *token, pjsip_event *e);
1838
1839static int check_request_status(struct send_request_data *req_data, pjsip_event *e)
1840{
1841 struct ast_sip_endpoint *endpoint;
1842 pjsip_transaction *tsx;
1843 pjsip_tx_data *tdata;
1844 int res = 0;
1845
1846 if (!(endpoint = ao2_bump(req_data->endpoint))) {
1847 return 0;
1848 }
1849
1850 tsx = e->body.tsx_state.tsx;
1851
1852 switch (tsx->status_code) {
1853 case 401:
1854 case 407:
1855 /* Resend the request with a challenge response if we are challenged. */
1856 res = ++req_data->challenge_count < MAX_RX_CHALLENGES /* Not in a challenge loop */
1858 e->body.tsx_state.src.rdata, tsx->last_tx, &tdata);
1859 break;
1860 case 408:
1861 case 503:
1862 if ((res = ast_sip_failover_request(tsx->last_tx))) {
1863 tdata = tsx->last_tx;
1864 /*
1865 * Bump the ref since it will be on a new transaction and
1866 * we don't want it to go away along with the old transaction.
1867 */
1868 pjsip_tx_data_add_ref(tdata);
1869 }
1870 break;
1871 }
1872
1873 if (res) {
1874 res = endpt_send_request(endpoint, tdata, -1,
1875 req_data, send_request_cb) == PJ_SUCCESS;
1876 }
1877
1878 ao2_ref(endpoint, -1);
1879 return res;
1880}
1881
1882static void send_request_cb(void *token, pjsip_event *e)
1883{
1884 struct send_request_data *req_data = token;
1885 pjsip_rx_data *challenge;
1886 struct ast_sip_supplement *supplement;
1887
1888 if (e->type == PJSIP_EVENT_TSX_STATE) {
1889 switch(e->body.tsx_state.type) {
1890 case PJSIP_EVENT_TRANSPORT_ERROR:
1891 case PJSIP_EVENT_TIMER:
1892 /*
1893 * Check the request status on transport error or timeout. A transport
1894 * error can occur when a TCP socket closes and that can be the result
1895 * of a 503. Also we may need to failover on a timeout (408).
1896 */
1897 if (check_request_status(req_data, e)) {
1898 return;
1899 }
1900 break;
1901 case PJSIP_EVENT_RX_MSG:
1902 challenge = e->body.tsx_state.src.rdata;
1903
1904 /*
1905 * Call any supplements that want to know about a response
1906 * with any received data.
1907 */
1909 AST_LIST_TRAVERSE(&supplements, supplement, next) {
1910 if (supplement->incoming_response
1911 && does_method_match(&challenge->msg_info.cseq->method.name,
1912 supplement->method)) {
1913 supplement->incoming_response(req_data->endpoint, challenge);
1914 }
1915 }
1917
1918 if (check_request_status(req_data, e)) {
1919 /*
1920 * Request with challenge response or failover sent.
1921 * Passed our req_data ref to the new request.
1922 */
1923 return;
1924 }
1925 break;
1926 default:
1927 ast_log(LOG_ERROR, "Unexpected PJSIP event %u\n", e->body.tsx_state.type);
1928 break;
1929 }
1930 }
1931
1932 if (req_data->callback) {
1933 req_data->callback(req_data->token, e);
1934 }
1935 ao2_ref(req_data, -1);
1936}
1937
1938int ast_sip_send_out_of_dialog_request(pjsip_tx_data *tdata,
1939 struct ast_sip_endpoint *endpoint, int timeout, void *token,
1940 void (*callback)(void *token, pjsip_event *e))
1941{
1942 struct ast_sip_supplement *supplement;
1943 struct send_request_data *req_data;
1944 struct ast_sip_contact *contact;
1945
1946 req_data = send_request_data_alloc(endpoint, token, callback);
1947 if (!req_data) {
1948 pjsip_tx_data_dec_ref(tdata);
1949 return -1;
1950 }
1951
1952 if (endpoint) {
1954 }
1955
1956 contact = ast_sip_mod_data_get(tdata->mod_data, supplement_module.id, MOD_DATA_CONTACT);
1957
1959 AST_LIST_TRAVERSE(&supplements, supplement, next) {
1960 if (supplement->outgoing_request
1961 && does_method_match(&tdata->msg->line.req.method.name, supplement->method)) {
1962 supplement->outgoing_request(endpoint, contact, tdata);
1963 }
1964 }
1966
1967 ast_sip_mod_data_set(tdata->pool, tdata->mod_data, supplement_module.id, MOD_DATA_CONTACT, NULL);
1968 ao2_cleanup(contact);
1969
1970 if (endpt_send_request(endpoint, tdata, timeout, req_data, send_request_cb)
1971 != PJ_SUCCESS) {
1972 ao2_cleanup(req_data);
1973 return -1;
1974 }
1975
1976 return 0;
1977}
1978
1979int ast_sip_send_request(pjsip_tx_data *tdata, struct pjsip_dialog *dlg,
1980 struct ast_sip_endpoint *endpoint, void *token,
1981 void (*callback)(void *token, pjsip_event *e))
1982{
1983 ast_assert(tdata->msg->type == PJSIP_REQUEST_MSG);
1984
1985 if (dlg) {
1986 return send_in_dialog_request(tdata, dlg);
1987 } else {
1988 return ast_sip_send_out_of_dialog_request(tdata, endpoint, -1, token, callback);
1989 }
1990}
1991
1992int ast_sip_set_outbound_proxy(pjsip_tx_data *tdata, const char *proxy)
1993{
1994 pjsip_route_hdr *route;
1995 static const pj_str_t ROUTE_HNAME = { "Route", 5 };
1996 pj_str_t tmp;
1997
1998 pj_strdup2_with_null(tdata->pool, &tmp, proxy);
1999 if (!(route = pjsip_parse_hdr(tdata->pool, &ROUTE_HNAME, tmp.ptr, tmp.slen, NULL))) {
2000 return -1;
2001 }
2002
2003 pj_list_insert_nodes_before(&tdata->msg->hdr, (pjsip_hdr*)route);
2004
2005 return 0;
2006}
2007
2008int ast_sip_add_header(pjsip_tx_data *tdata, const char *name, const char *value)
2009{
2010 pj_str_t hdr_name;
2011 pj_str_t hdr_value;
2012 pjsip_generic_string_hdr *hdr;
2013
2014 pj_cstr(&hdr_name, name);
2015 pj_cstr(&hdr_value, value);
2016
2017 hdr = pjsip_generic_string_hdr_create(tdata->pool, &hdr_name, &hdr_value);
2018
2019 pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr *) hdr);
2020 return 0;
2021}
2022
2023pjsip_generic_string_hdr *ast_sip_add_header2(pjsip_tx_data *tdata,
2024 const char *name, const char *value)
2025{
2026 pj_str_t hdr_name;
2027 pj_str_t hdr_value;
2028 pjsip_generic_string_hdr *hdr;
2029
2030 pj_cstr(&hdr_name, name);
2031 pj_cstr(&hdr_value, value);
2032
2033 hdr = pjsip_generic_string_hdr_create(tdata->pool, &hdr_name, &hdr_value);
2034
2035 pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr *) hdr);
2036 return hdr;
2037}
2038
2039static pjsip_msg_body *ast_body_to_pjsip_body(pj_pool_t *pool, const struct ast_sip_body *body)
2040{
2041 pj_str_t type;
2042 pj_str_t subtype;
2043 pj_str_t body_text;
2044
2045 pj_cstr(&type, body->type);
2046 pj_cstr(&subtype, body->subtype);
2047 pj_cstr(&body_text, body->body_text);
2048
2049 return pjsip_msg_body_create(pool, &type, &subtype, &body_text);
2050}
2051
2052int ast_sip_add_body(pjsip_tx_data *tdata, const struct ast_sip_body *body)
2053{
2054 pjsip_msg_body *pjsip_body = ast_body_to_pjsip_body(tdata->pool, body);
2055 tdata->msg->body = pjsip_body;
2056 return 0;
2057}
2058
2059int ast_sip_add_body_multipart(pjsip_tx_data *tdata, const struct ast_sip_body *bodies[], int num_bodies)
2060{
2061 int i;
2062 /* NULL for type and subtype automatically creates "multipart/mixed" */
2063 pjsip_msg_body *body = pjsip_multipart_create(tdata->pool, NULL, NULL);
2064
2065 for (i = 0; i < num_bodies; ++i) {
2066 pjsip_multipart_part *part = pjsip_multipart_create_part(tdata->pool);
2067 part->body = ast_body_to_pjsip_body(tdata->pool, bodies[i]);
2068 pjsip_multipart_add_part(tdata->pool, body, part);
2069 }
2070
2071 tdata->msg->body = body;
2072 return 0;
2073}
2074
2075int ast_sip_append_body(pjsip_tx_data *tdata, const char *body_text)
2076{
2077 size_t combined_size = strlen(body_text) + tdata->msg->body->len;
2078 struct ast_str *body_buffer = ast_str_alloca(combined_size);
2079
2080 ast_str_set(&body_buffer, 0, "%.*s%s", (int) tdata->msg->body->len, (char *) tdata->msg->body->data, body_text);
2081
2082 tdata->msg->body->data = pj_pool_alloc(tdata->pool, combined_size);
2083 pj_memcpy(tdata->msg->body->data, ast_str_buffer(body_buffer), combined_size);
2084 tdata->msg->body->len = combined_size;
2085
2086 return 0;
2087}
2088
2090{
2092}
2093
2095{
2097}
2098
2099int ast_sip_push_task(struct ast_taskprocessor *serializer, int (*sip_task)(void *), void *task_data)
2100{
2101 if (!serializer) {
2103 }
2104
2105 return ast_taskprocessor_push(serializer, sip_task, task_data);
2106}
2107
2108struct sync_task_data {
2111 int complete;
2112 int fail;
2113 int (*task)(void *);
2114 void *task_data;
2115};
2116
2117static int sync_task(void *data)
2118{
2119 struct sync_task_data *std = data;
2120 int ret;
2121
2122 std->fail = std->task(std->task_data);
2123
2124 /*
2125 * Once we unlock std->lock after signaling, we cannot access
2126 * std again. The thread waiting within ast_sip_push_task_wait()
2127 * is free to continue and release its local variable (std).
2128 */
2129 ast_mutex_lock(&std->lock);
2130 std->complete = 1;
2131 ast_cond_signal(&std->cond);
2132 ret = std->fail;
2133 ast_mutex_unlock(&std->lock);
2134 return ret;
2135}
2136
2137static int ast_sip_push_task_wait(struct ast_taskprocessor *serializer, int (*sip_task)(void *), void *task_data)
2138{
2139 /* This method is an onion */
2140 struct sync_task_data std;
2141
2142 memset(&std, 0, sizeof(std));
2143 ast_mutex_init(&std.lock);
2144 ast_cond_init(&std.cond, NULL);
2145 std.task = sip_task;
2146 std.task_data = task_data;
2147
2149 ast_mutex_destroy(&std.lock);
2150 ast_cond_destroy(&std.cond);
2151 return -1;
2152 }
2153
2154 ast_mutex_lock(&std.lock);
2155 while (!std.complete) {
2156 ast_cond_wait(&std.cond, &std.lock);
2157 }
2158 ast_mutex_unlock(&std.lock);
2159
2160 ast_mutex_destroy(&std.lock);
2161 ast_cond_destroy(&std.cond);
2162 return std.fail;
2163}
2164
2165int ast_sip_push_task_wait_servant(struct ast_taskprocessor *serializer, int (*sip_task)(void *), void *task_data)
2166{
2168 return sip_task(task_data);
2169 }
2170
2171 return ast_sip_push_task_wait(serializer, sip_task, task_data);
2172}
2173
2174int ast_sip_push_task_synchronous(struct ast_taskprocessor *serializer, int (*sip_task)(void *), void *task_data)
2175{
2177}
2178
2180{
2181 if (!serializer) {
2182 /* Caller doesn't care which PJSIP serializer the task executes under. */
2184 if (!serializer) {
2185 /* No serializer picked to execute the task */
2186 return -1;
2187 }
2188 }
2190 /*
2191 * We are the requested serializer so we must execute
2192 * the task now or deadlock waiting on ourself to
2193 * execute it.
2194 */
2195 return sip_task(task_data);
2196 }
2197
2198 return ast_sip_push_task_wait(serializer, sip_task, task_data);
2199}
2200
2201void ast_copy_pj_str(char *dest, const pj_str_t *src, size_t size)
2202{
2203 size_t chars_to_copy = MIN(size - 1, pj_strlen(src));
2204 memcpy(dest, pj_strbuf(src), chars_to_copy);
2205 dest[chars_to_copy] = '\0';
2206}
2207
2208int ast_copy_pj_str2(char **dest, const pj_str_t *src)
2209{
2210 int res = ast_asprintf(dest, "%.*s", (int)pj_strlen(src), pj_strbuf(src));
2211
2212 if (res < 0) {
2213 *dest = NULL;
2214 }
2215
2216 return res;
2217}
2218
2219int ast_sip_are_media_types_equal(pjsip_media_type *a, pjsip_media_type *b)
2220{
2221 int rc = 0;
2222 if (a != NULL && b != NULL) {
2223 rc = pjsip_media_type_cmp(a, b, 0) ? 0 : 1;
2224 }
2225 return rc;
2226}
2227
2228int ast_sip_is_media_type_in(pjsip_media_type *a, ...)
2229{
2230 int rc = 0;
2231 pjsip_media_type *b = NULL;
2232 va_list ap;
2233
2234 ast_assert(a != NULL);
2235 va_start(ap, a);
2236
2237 while ((b = va_arg(ap, pjsip_media_type *)) != (pjsip_media_type *)SENTINEL) {
2238 if (pjsip_media_type_cmp(a, b, 0) == 0) {
2239 rc = 1;
2240 break;
2241 }
2242 }
2243 va_end(ap);
2244
2245 return rc;
2246}
2247
2248int ast_sip_is_content_type(pjsip_media_type *content_type, char *type, char *subtype)
2249{
2250 pjsip_media_type compare;
2251
2252 if (!content_type) {
2253 return 0;
2254 }
2255
2256 pjsip_media_type_init2(&compare, type, subtype);
2257
2258 return pjsip_media_type_cmp(content_type, &compare, 0) ? 0 : -1;
2259}
2260
2261pj_caching_pool caching_pool;
2262pj_pool_t *memory_pool;
2263pj_thread_t *monitor_thread;
2265
2266static void *monitor_thread_exec(void *endpt)
2267{
2268 while (monitor_continue) {
2269 const pj_time_val delay = {0, 10};
2270 pjsip_endpt_handle_events(ast_pjsip_endpoint, &delay);
2271 }
2272 return NULL;
2273}
2274
2275static void stop_monitor_thread(void)
2276{
2277 monitor_continue = 0;
2278 pj_thread_join(monitor_thread);
2279}
2280
2283#define SIP_SERVANT_ID 0x5E2F1D
2284
2285static void sip_thread_start(void)
2286{
2287 pj_thread_desc *desc;
2288 pj_thread_t *thread;
2289 uint32_t *servant_id;
2290
2291 servant_id = ast_threadstorage_get(&servant_id_storage, sizeof(*servant_id));
2292 if (!servant_id) {
2293 ast_log(LOG_ERROR, "Could not set SIP servant ID in thread-local storage.\n");
2294 return;
2295 }
2296 *servant_id = SIP_SERVANT_ID;
2297
2298 desc = ast_threadstorage_get(&pj_thread_storage, sizeof(pj_thread_desc));
2299 if (!desc) {
2300 ast_log(LOG_ERROR, "Could not get thread desc from thread-local storage. Expect awful things to occur\n");
2301 return;
2302 }
2303 pj_bzero(*desc, sizeof(*desc));
2304
2305 if (pj_thread_register("Asterisk Thread", *desc, &thread) != PJ_SUCCESS) {
2306 ast_log(LOG_ERROR, "Couldn't register thread with PJLIB.\n");
2307 }
2308}
2309
2311{
2312 uint32_t *servant_id;
2313
2314 if (monitor_thread &&
2315 pthread_self() == *(pthread_t *)pj_thread_get_os_handle(monitor_thread)) {
2316 return 1;
2317 }
2318
2319 servant_id = ast_threadstorage_get(&servant_id_storage, sizeof(*servant_id));
2320 if (!servant_id) {
2321 return 0;
2322 }
2323
2324 return *servant_id == SIP_SERVANT_ID;
2325}
2326
2327void *ast_sip_dict_get(void *ht, const char *key)
2328{
2329 unsigned int hval = 0;
2330
2331 if (!ht) {
2332 return NULL;
2333 }
2334
2335 return pj_hash_get(ht, key, PJ_HASH_KEY_STRING, &hval);
2336}
2337
2338void *ast_sip_dict_set(pj_pool_t* pool, void *ht,
2339 const char *key, void *val)
2340{
2341 if (!ht) {
2342 ht = pj_hash_create(pool, 11);
2343 }
2344
2345 pj_hash_set(pool, ht, key, PJ_HASH_KEY_STRING, 0, val);
2346
2347 return ht;
2348}
2349
2350static pj_bool_t supplement_on_rx_request(pjsip_rx_data *rdata)
2351{
2352 struct ast_sip_supplement *supplement;
2353
2354 if (pjsip_rdata_get_dlg(rdata)) {
2355 return PJ_FALSE;
2356 }
2357
2359 AST_LIST_TRAVERSE(&supplements, supplement, next) {
2360 if (supplement->incoming_request
2361 && does_method_match(&rdata->msg_info.msg->line.req.method.name, supplement->method)) {
2362 struct ast_sip_endpoint *endpoint;
2363
2364 endpoint = ast_pjsip_rdata_get_endpoint(rdata);
2365 supplement->incoming_request(endpoint, rdata);
2366 ao2_cleanup(endpoint);
2367 }
2368 }
2370
2371 return PJ_FALSE;
2372}
2373
2374static void supplement_outgoing_response(pjsip_tx_data *tdata, struct ast_sip_endpoint *sip_endpoint)
2375{
2376 struct ast_sip_supplement *supplement;
2377 pjsip_cseq_hdr *cseq = pjsip_msg_find_hdr(tdata->msg, PJSIP_H_CSEQ, NULL);
2378 struct ast_sip_contact *contact = ast_sip_mod_data_get(tdata->mod_data, supplement_module.id, MOD_DATA_CONTACT);
2379
2380 if (sip_endpoint) {
2381 ast_sip_message_apply_transport(sip_endpoint->transport, tdata);
2382 }
2383
2385 AST_LIST_TRAVERSE(&supplements, supplement, next) {
2386 if (supplement->outgoing_response && does_method_match(&cseq->method.name, supplement->method)) {
2387 supplement->outgoing_response(sip_endpoint, contact, tdata);
2388 }
2389 }
2391
2392 ast_sip_mod_data_set(tdata->pool, tdata->mod_data, supplement_module.id, MOD_DATA_CONTACT, NULL);
2393 ao2_cleanup(contact);
2394}
2395
2396int ast_sip_send_response(pjsip_response_addr *res_addr, pjsip_tx_data *tdata, struct ast_sip_endpoint *sip_endpoint)
2397{
2398 pj_status_t status;
2399
2400 supplement_outgoing_response(tdata, sip_endpoint);
2401 status = pjsip_endpt_send_response(ast_sip_get_pjsip_endpoint(), res_addr, tdata, NULL, NULL);
2402 if (status != PJ_SUCCESS) {
2403 pjsip_tx_data_dec_ref(tdata);
2404 }
2405
2406 return status == PJ_SUCCESS ? 0 : -1;
2407}
2408
2409static void pool_destroy_callback(void *arg)
2410{
2411 pj_pool_t *pool = (pj_pool_t *)arg;
2412 pjsip_endpt_release_pool(ast_sip_get_pjsip_endpoint(), pool);
2413}
2414
2415static void clean_contact_from_tdata(pjsip_tx_data *tdata)
2416{
2417 struct ast_sip_contact *contact;
2418 contact = ast_sip_mod_data_get(tdata->mod_data, supplement_module.id, MOD_DATA_CONTACT);
2419 ao2_cleanup(contact);
2420 ast_sip_mod_data_set(tdata->pool, tdata->mod_data, supplement_module.id, MOD_DATA_CONTACT, NULL);
2421 pjsip_tx_data_dec_ref(tdata);
2422}
2423
2424int ast_sip_send_stateful_response(pjsip_rx_data *rdata, pjsip_tx_data *tdata, struct ast_sip_endpoint *sip_endpoint)
2425{
2426 pjsip_transaction *tsx;
2427 pj_grp_lock_t *tsx_glock;
2428 pj_pool_t *pool;
2429
2430 /* Create and initialize global lock pool */
2431 pool = pjsip_endpt_create_pool(ast_sip_get_pjsip_endpoint(), "stateful response", PJSIP_POOL_TSX_LEN, PJSIP_POOL_TSX_INC);
2432 if (!pool){
2433 /* ast_sip_create_response bumps the refcount of the contact and adds it to the tdata.
2434 * We'll leak that reference if we don't get rid of it here.
2435 */
2437 return -1;
2438 }
2439 /* Create with handler so that we can release the pool once the glock derefs out */
2440 if(pj_grp_lock_create_w_handler(pool, NULL, pool, &pool_destroy_callback, &tsx_glock) != PJ_SUCCESS) {
2442 pool_destroy_callback((void *) pool);
2443 return -1;
2444 }
2445 /* We need an additional reference as the qualify thread may destroy this out
2446 * from under us. Add it now before it gets added to the tsx. */
2447 pj_grp_lock_add_ref(tsx_glock);
2448
2449 if (pjsip_tsx_create_uas2(NULL, rdata, tsx_glock, &tsx) != PJ_SUCCESS) {
2451 pj_grp_lock_dec_ref(tsx_glock);
2452 return -1;
2453 }
2454
2455 pjsip_tsx_recv_msg(tsx, rdata);
2456 supplement_outgoing_response(tdata, sip_endpoint);
2457
2458 if (pjsip_tsx_send_msg(tsx, tdata) != PJ_SUCCESS) {
2459 pj_grp_lock_dec_ref(tsx_glock);
2460 pjsip_tx_data_dec_ref(tdata);
2461 return -1;
2462 }
2463
2464 pj_grp_lock_dec_ref(tsx_glock);
2465 return 0;
2466}
2467
2468int ast_sip_create_response(const pjsip_rx_data *rdata, int st_code,
2469 struct ast_sip_contact *contact, pjsip_tx_data **tdata)
2470{
2471 int res = pjsip_endpt_create_response(ast_sip_get_pjsip_endpoint(), rdata, st_code, NULL, tdata);
2472
2473 if (!res) {
2474 ast_sip_mod_data_set((*tdata)->pool, (*tdata)->mod_data, supplement_module.id, MOD_DATA_CONTACT, ao2_bump(contact));
2475 }
2476
2477 return res;
2478}
2479
2480int ast_sip_get_host_ip(int af, pj_sockaddr *addr)
2481{
2482 if (af == pj_AF_INET() && !ast_strlen_zero(host_ip_ipv4_string)) {
2483 pj_sockaddr_copy_addr(addr, &host_ip_ipv4);
2484 return 0;
2485 } else if (af == pj_AF_INET6() && !ast_strlen_zero(host_ip_ipv6_string)) {
2486 pj_sockaddr_copy_addr(addr, &host_ip_ipv6);
2487 return 0;
2488 }
2489
2490 return -1;
2491}
2492
2494{
2495 if (af == pj_AF_INET()) {
2496 return host_ip_ipv4_string;
2497 } else if (af == pj_AF_INET6()) {
2498 return host_ip_ipv6_string;
2499 }
2500
2501 return NULL;
2502}
2503
2505 char *buf, size_t buf_len)
2506{
2507 switch (dtmf) {
2508 case AST_SIP_DTMF_NONE:
2509 ast_copy_string(buf, "none", buf_len);
2510 break;
2512 ast_copy_string(buf, "rfc4733", buf_len);
2513 break;
2515 ast_copy_string(buf, "inband", buf_len);
2516 break;
2517 case AST_SIP_DTMF_INFO:
2518 ast_copy_string(buf, "info", buf_len);
2519 break;
2520 case AST_SIP_DTMF_AUTO:
2521 ast_copy_string(buf, "auto", buf_len);
2522 break;
2524 ast_copy_string(buf, "auto_info", buf_len);
2525 break;
2526 default:
2527 buf[0] = '\0';
2528 return -1;
2529 }
2530 return 0;
2531}
2532
2533int ast_sip_str_to_dtmf(const char * dtmf_mode)
2534{
2535 int result = -1;
2536
2537 if (!strcasecmp(dtmf_mode, "info")) {
2539 } else if (!strcasecmp(dtmf_mode, "rfc4733")) {
2541 } else if (!strcasecmp(dtmf_mode, "inband")) {
2543 } else if (!strcasecmp(dtmf_mode, "none")) {
2545 } else if (!strcasecmp(dtmf_mode, "auto")) {
2547 } else if (!strcasecmp(dtmf_mode, "auto_info")) {
2549 }
2550
2551 return result;
2552}
2553
2555{
2556 const char *value;
2557
2558 if (ast_sip_call_codec_pref_test(pref, LOCAL) && ast_sip_call_codec_pref_test(pref, INTERSECT) && ast_sip_call_codec_pref_test(pref, ALL)) {
2559 value = "local";
2560 } else if (ast_sip_call_codec_pref_test(pref, LOCAL) && ast_sip_call_codec_pref_test(pref, UNION) && ast_sip_call_codec_pref_test(pref, ALL)) {
2561 value = "local_merge";
2562 } else if (ast_sip_call_codec_pref_test(pref, LOCAL) && ast_sip_call_codec_pref_test(pref, INTERSECT) && ast_sip_call_codec_pref_test(pref, FIRST)) {
2563 value = "local_first";
2564 } else if (ast_sip_call_codec_pref_test(pref, REMOTE) && ast_sip_call_codec_pref_test(pref, INTERSECT) && ast_sip_call_codec_pref_test(pref, ALL)) {
2565 value = "remote";
2566 } else if (ast_sip_call_codec_pref_test(pref, REMOTE) && ast_sip_call_codec_pref_test(pref, UNION) && ast_sip_call_codec_pref_test(pref, ALL)) {
2567 value = "remote_merge";
2568 } else if (ast_sip_call_codec_pref_test(pref, REMOTE) && ast_sip_call_codec_pref_test(pref, UNION) && ast_sip_call_codec_pref_test(pref, FIRST)) {
2569 value = "remote_first";
2570 } else {
2571 value = "unknown";
2572 }
2573
2574 return value;
2575}
2576
2577int ast_sip_call_codec_str_to_pref(struct ast_flags *pref, const char *pref_str, int is_outgoing)
2578{
2579 pref->flags = 0;
2580
2581 if (strcmp(pref_str, "local") == 0) {
2583 } else if (is_outgoing && strcmp(pref_str, "local_merge") == 0) {
2585 } else if (strcmp(pref_str, "local_first") == 0) {
2587 } else if (strcmp(pref_str, "remote") == 0) {
2589 } else if (is_outgoing && strcmp(pref_str, "remote_merge") == 0) {
2591 } else if (strcmp(pref_str, "remote_first") == 0) {
2593 } else {
2594 return -1;
2595 }
2596
2597 return 0;
2598}
2599
2600/*!
2601 * \internal
2602 * \brief Set an ast_party_id name and number based on an identity header.
2603 * \param hdr From, P-Asserted-Identity, or Remote-Party-ID header on incoming message
2604 * \param[out] id The ID to set data on
2605 */
2606static void set_id_from_hdr(pjsip_fromto_hdr *hdr, struct ast_party_id *id)
2607{
2608 char cid_name[AST_CHANNEL_NAME];
2609 char cid_num[AST_CHANNEL_NAME];
2610 size_t cid_name_size = AST_CHANNEL_NAME;
2611 pjsip_name_addr *id_name_addr = (pjsip_name_addr *) hdr->uri;
2612 char *semi;
2614
2615 ast_copy_pj_str(cid_num, ast_sip_pjsip_uri_get_username(hdr->uri), sizeof(cid_num));
2616 /* Always truncate caller-id number at a semicolon. */
2617 semi = strchr(cid_num, ';');
2618 if (semi) {
2619 /*
2620 * We need to be able to handle URI's looking like
2621 * "sip:1235557890;phone-context=national@x.x.x.x;user=phone"
2622 *
2623 * Where the uri->user field will result in:
2624 * "1235557890;phone-context=national"
2625 *
2626 * People don't care about anything after the semicolon
2627 * showing up on their displays even though the RFC
2628 * allows the semicolon.
2629 */
2630 *semi = '\0';
2631 }
2632
2633 /*
2634 * It's safe to pass a NULL or empty string as the source.
2635 * The result will be an empty string assuming the destination
2636 * size was at least 1.
2637 */
2638 result = ast_utf8_replace_invalid_chars(cid_name, &cid_name_size,
2639 id_name_addr->display.ptr, id_name_addr->display.slen);
2640
2642 ast_log(LOG_WARNING, "CallerID Name '" PJSTR_PRINTF_SPEC
2643 "' for number '%s' has invalid UTF-8 characters which "
2644 "were replaced",
2645 PJSTR_PRINTF_VAR(id_name_addr->display), cid_num);
2646 }
2647
2648 ast_free(id->name.str);
2649 id->name.str = ast_strdup(cid_name);
2650 if (!ast_strlen_zero(cid_name)) {
2651 id->name.valid = 1;
2652 }
2653 ast_free(id->number.str);
2654 id->number.str = ast_strdup(cid_num);
2655 if (!ast_strlen_zero(cid_num)) {
2656 id->number.valid = 1;
2657 }
2658}
2659
2660/*!
2661 * \internal
2662 * \brief Get a P-Asserted-Identity or Remote-Party-ID header from an incoming message
2663 *
2664 * This function will parse the header as if it were a From header. This allows for us
2665 * to easily manipulate the URI, as well as add, modify, or remove parameters from the
2666 * header
2667 *
2668 * \param rdata The incoming message
2669 * \param header_name The name of the ID header to find
2670 * \retval NULL No ID header present or unable to parse ID header
2671 * \retval non-NULL The parsed ID header
2672 */
2673static pjsip_fromto_hdr *get_id_header(pjsip_rx_data *rdata, const pj_str_t *header_name)
2674{
2675 static const pj_str_t from = { "From", 4 };
2676 pj_str_t header_content;
2677 pjsip_fromto_hdr *parsed_hdr;
2678 pjsip_generic_string_hdr *ident = pjsip_msg_find_hdr_by_name(rdata->msg_info.msg,
2679 header_name, NULL);
2680 int parsed_len;
2681
2682 if (!ident) {
2683 return NULL;
2684 }
2685
2686 pj_strdup_with_null(rdata->tp_info.pool, &header_content, &ident->hvalue);
2687
2688 parsed_hdr = pjsip_parse_hdr(rdata->tp_info.pool, &from, header_content.ptr,
2689 pj_strlen(&header_content), &parsed_len);
2690
2691 if (!parsed_hdr) {
2692 return NULL;
2693 }
2694
2695 return parsed_hdr;
2696}
2697
2698/*!
2699 * \internal
2700 * \brief Set an ast_party_id structure based on data in a P-Asserted-Identity header
2701 *
2702 * This makes use of \ref set_id_from_hdr for setting name and number. It uses
2703 * the contents of a Privacy header in order to set presentation information.
2704 *
2705 * \param rdata The incoming message
2706 * \param[out] id The ID to set
2707 * \retval 0 Successfully set the party ID
2708 * \retval non-zero Could not set the party ID
2709 */
2710static int set_id_from_pai(pjsip_rx_data *rdata, struct ast_party_id *id)
2711{
2712 static const pj_str_t pai_str = { "P-Asserted-Identity", 19 };
2713 static const pj_str_t privacy_str = { "Privacy", 7 };
2714 pjsip_fromto_hdr *pai_hdr = get_id_header(rdata, &pai_str);
2715 pjsip_generic_string_hdr *privacy;
2716
2717 if (!pai_hdr) {
2718 return -1;
2719 }
2720
2721 set_id_from_hdr(pai_hdr, id);
2722
2723 if (!id->number.valid) {
2724 return -1;
2725 }
2726
2727 privacy = pjsip_msg_find_hdr_by_name(rdata->msg_info.msg, &privacy_str, NULL);
2728 if (!privacy || !pj_stricmp2(&privacy->hvalue, "none")) {
2729 id->number.presentation = AST_PRES_ALLOWED_USER_NUMBER_NOT_SCREENED;
2730 id->name.presentation = AST_PRES_ALLOWED_USER_NUMBER_NOT_SCREENED;
2731 } else {
2732 id->number.presentation = AST_PRES_PROHIB_USER_NUMBER_NOT_SCREENED;
2733 id->name.presentation = AST_PRES_PROHIB_USER_NUMBER_NOT_SCREENED;
2734 }
2735
2736 return 0;
2737}
2738
2739/*!
2740 * \internal
2741 * \brief Set an ast_party_id structure based on data in a Remote-Party-ID header
2742 *
2743 * This makes use of \ref set_id_from_hdr for setting name and number. It uses
2744 * the privacy and screen parameters in order to set presentation information.
2745 *
2746 * \param rdata The incoming message
2747 * \param[out] id The ID to set
2748 * \retval 0 Succesfully set the party ID
2749 * \retval non-zero Could not set the party ID
2750 */
2751static int set_id_from_rpid(pjsip_rx_data *rdata, struct ast_party_id *id)
2752{
2753 static const pj_str_t rpid_str = { "Remote-Party-ID", 15 };
2754 static const pj_str_t privacy_str = { "privacy", 7 };
2755 static const pj_str_t screen_str = { "screen", 6 };
2756 pjsip_fromto_hdr *rpid_hdr = get_id_header(rdata, &rpid_str);
2757 pjsip_param *screen;
2758 pjsip_param *privacy;
2759
2760 if (!rpid_hdr) {
2761 return -1;
2762 }
2763
2764 set_id_from_hdr(rpid_hdr, id);
2765
2766 if (!id->number.valid) {
2767 return -1;
2768 }
2769
2770 privacy = pjsip_param_find(&rpid_hdr->other_param, &privacy_str);
2771 screen = pjsip_param_find(&rpid_hdr->other_param, &screen_str);
2772 if (privacy && !pj_stricmp2(&privacy->value, "full")) {
2773 id->number.presentation = AST_PRES_RESTRICTED;
2774 id->name.presentation = AST_PRES_RESTRICTED;
2775 } else {
2776 id->number.presentation = AST_PRES_ALLOWED;
2777 id->name.presentation = AST_PRES_ALLOWED;
2778 }
2779 if (screen && !pj_stricmp2(&screen->value, "yes")) {
2780 id->number.presentation |= AST_PRES_USER_NUMBER_PASSED_SCREEN;
2781 id->name.presentation |= AST_PRES_USER_NUMBER_PASSED_SCREEN;
2782 } else {
2783 id->number.presentation |= AST_PRES_USER_NUMBER_UNSCREENED;
2784 id->name.presentation |= AST_PRES_USER_NUMBER_UNSCREENED;
2785 }
2786
2787 return 0;
2788}
2789
2790/*!
2791 * \internal
2792 * \brief Set an ast_party_id structure based on data in a From
2793 *
2794 * This makes use of \ref set_id_from_hdr for setting name and number. It uses
2795 * no information from the message in order to set privacy. It relies on endpoint
2796 * configuration for privacy information.
2797 *
2798 * \param rdata The incoming message
2799 * \param[out] id The ID to set
2800 * \retval 0 Succesfully set the party ID
2801 * \retval non-zero Could not set the party ID
2802 */
2803static int set_id_from_from(struct pjsip_rx_data *rdata, struct ast_party_id *id)
2804{
2805 pjsip_fromto_hdr *from = pjsip_msg_find_hdr(rdata->msg_info.msg,
2806 PJSIP_H_FROM, rdata->msg_info.msg->hdr.next);
2807
2808 if (!from) {
2809 /* This had better not happen */
2810 return -1;
2811 }
2812
2813 set_id_from_hdr(from, id);
2814
2815 if (!id->number.valid) {
2816 return -1;
2817 }
2818
2819 return 0;
2820}
2821
2822int ast_sip_set_id_connected_line(struct pjsip_rx_data *rdata, struct ast_party_id *id)
2823{
2824 return !set_id_from_pai(rdata, id) || !set_id_from_rpid(rdata, id) ? 0 : -1;
2825}
2826
2827int ast_sip_set_id_from_invite(struct pjsip_rx_data *rdata, struct ast_party_id *id, struct ast_party_id *default_id, int trust_inbound)
2828{
2829 if (trust_inbound && (!set_id_from_pai(rdata, id) || !set_id_from_rpid(rdata, id))) {
2830 /* Trusted: Check PAI and RPID */
2831 ast_free(id->tag);
2832 id->tag = ast_strdup(default_id->tag);
2833 return 0;
2834 }
2835 /* Not trusted: check the endpoint config or use From. */
2836 ast_party_id_copy(id, default_id);
2837 if (!default_id->number.valid) {
2838 set_id_from_from(rdata, id);
2839 }
2840 return 0;
2841}
2842
2843/*!
2844 * \brief Set name and number information on an identity header.
2845 *
2846 * \param pool Memory pool to use for string duplication
2847 * \param id_hdr A From, P-Asserted-Identity, or Remote-Party-ID header to modify
2848 * \param id The identity information to apply to the header
2849 */
2850void ast_sip_modify_id_header(pj_pool_t *pool, pjsip_fromto_hdr *id_hdr, const struct ast_party_id *id)
2851{
2852 pjsip_name_addr *id_name_addr;
2853 pjsip_sip_uri *id_uri;
2854
2855 id_name_addr = (pjsip_name_addr *) id_hdr->uri;
2856 id_uri = pjsip_uri_get_uri(id_name_addr->uri);
2857
2858 if (id->name.valid) {
2859 if (!ast_strlen_zero(id->name.str)) {
2860 int name_buf_len = strlen(id->name.str) * 2 + 1;
2861 char *name_buf = ast_alloca(name_buf_len);
2862
2863 ast_escape_quoted(id->name.str, name_buf, name_buf_len);
2864 pj_strdup2(pool, &id_name_addr->display, name_buf);
2865 } else {
2866 pj_strdup2(pool, &id_name_addr->display, NULL);
2867 }
2868 }
2869
2870 if (id->number.valid) {
2871 pj_strdup2(pool, &id_uri->user, id->number.str);
2872 }
2873}
2874
2875/*!
2876 * \brief Find a contact and insert a "user@" into its URI.
2877 *
2878 * \param to Original destination (for error messages only)
2879 * \param endpoint_name Endpoint name (for error messages only)
2880 * \param aors Command separated list of AORs
2881 * \param user The user to insert in the contact URI
2882 * \param uri Pointer to buffer in which to return the URI. Must be freed by caller.
2883 *
2884 * \return 0 Success
2885 * \return -1 Fail
2886 *
2887 * \note If the contact URI found for the endpoint already has a user in
2888 * its URI, it will be replaced by the user passed as an argument to this function.
2889 */
2890static int insert_user_in_contact_uri(const char *to, const char *endpoint_name, const char *aors,
2891 const char *user, char **uri)
2892{
2893 RAII_VAR(struct ast_sip_contact *, contact, NULL, ao2_cleanup);
2894 pj_pool_t *pool;
2895 pjsip_name_addr *name_addr;
2896 pjsip_sip_uri *sip_uri;
2897 int err = 0;
2898
2900 if (!contact) {
2901 ast_log(LOG_WARNING, "Dest: '%s'. Couldn't find contact for endpoint '%s'\n",
2902 to, endpoint_name);
2903 return -1;
2904 }
2905
2906 pool = pjsip_endpt_create_pool(ast_sip_get_pjsip_endpoint(), "uri-user-insert", 128, 128);
2907 if (!pool) {
2908 ast_log(LOG_WARNING, "Failed to allocate ParseUri endpoint pool.\n");
2909 return -1;
2910 }
2911
2912 name_addr = (pjsip_name_addr *) pjsip_parse_uri(pool, (char*)contact->uri, strlen(contact->uri), PJSIP_PARSE_URI_AS_NAMEADDR);
2913 if (!name_addr || (!PJSIP_URI_SCHEME_IS_SIP(name_addr->uri) && !PJSIP_URI_SCHEME_IS_SIPS(name_addr->uri))) {
2914 ast_log(LOG_WARNING, "Failed to parse URI '%s'\n", contact->uri);
2915 err = -1;
2916 goto out;
2917 }
2918
2919 ast_debug(3, "Dest: '%s' User: '%s' Endpoint: '%s' ContactURI: '%s'\n", to, user, endpoint_name, contact->uri);
2920
2921 sip_uri = pjsip_uri_get_uri(name_addr->uri);
2922 pj_strset2(&sip_uri->user, (char*)user);
2923
2924 *uri = ast_malloc(PJSIP_MAX_URL_SIZE);
2925 if (!(*uri)) {
2926 err = -1;
2927 goto out;
2928 }
2929 pjsip_uri_print(PJSIP_URI_IN_REQ_URI, name_addr, *uri, PJSIP_MAX_URL_SIZE);
2930
2931out:
2932 pjsip_endpt_release_pool(ast_sip_get_pjsip_endpoint(), pool);
2933
2934 return err;
2935}
2936
2937/*!
2938 * \internal
2939 * \brief Get endpoint and URI when the destination is only a single token
2940 *
2941 * "destination" could be one of the following:
2942 * \verbatim
2943 endpoint_name
2944 hostname
2945 * \endverbatim
2946 *
2947 * \param to
2948 * \param destination
2949 * \param get_default_outbound If nonzero, try to retrieve the default
2950 * outbound endpoint if no endpoint was found.
2951 * Otherwise, return NULL if no endpoint was found.
2952 * \param uri Pointer to URI variable. Must be freed by caller - even if the return value is NULL!
2953 * \return endpoint
2954 */
2955static struct ast_sip_endpoint *handle_single_token(const char *to, char *destination, int get_default_outbound, char **uri) {
2956 RAII_VAR(struct ast_sip_contact*, contact, NULL, ao2_cleanup);
2957 char *endpoint_name = NULL;
2958 struct ast_sip_endpoint *endpoint = NULL;
2959
2960 /*
2961 * If "destination" is just one token, it could be an endpoint name
2962 * or a hostname without a scheme.
2963 */
2964
2965 endpoint = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "endpoint", destination);
2966 if (!endpoint) {
2967 /*
2968 * We can only assume it's a hostname.
2969 */
2970 char *temp_uri = ast_malloc(strlen(destination) + strlen("sip:") + 1);
2971 if (!temp_uri) {
2972 goto failure;
2973 }
2974 sprintf(temp_uri, "sip:%s", destination);
2975 *uri = temp_uri;
2976 if (get_default_outbound) {
2978 }
2979 ast_debug(3, "Dest: '%s' Didn't find endpoint so adding scheme and using URI '%s'%s\n",
2980 to, *uri, get_default_outbound ? " with default endpoint" : "");
2981 return endpoint;
2982 }
2983
2984 /*
2985 * It's an endpoint
2986 */
2987
2988 endpoint_name = destination;
2990 if (!contact) {
2991 ast_log(LOG_WARNING, "Dest: '%s'. Found endpoint '%s' but didn't find an aor/contact for it\n",
2992 to, endpoint_name);
2993 ao2_cleanup(endpoint);
2994 goto failure;
2995 }
2996
2997 *uri = ast_strdup(contact->uri);
2998 if (!(*uri)) {
2999 ao2_cleanup(endpoint);
3000 goto failure;
3001 }
3002
3003 ast_debug(3, "Dest: '%s' Found endpoint '%s' and found contact with URI '%s'\n",
3004 to, endpoint_name, *uri);
3005 return endpoint;
3006
3007failure:
3008 *uri = NULL;
3009 return NULL;
3010}
3011
3012/*!
3013 * \internal
3014 * \brief Get endpoint and URI when the destination contained a '/'
3015 *
3016 * "to" could be one of the following:
3017 * \verbatim
3018 endpoint/aor
3019 endpoint/<sip[s]:host>
3020 endpoint/<sip[s]:user@host>
3021 endpoint/"Bob" <sip[s]:host>
3022 endpoint/"Bob" <sip[s]:user@host>
3023 endpoint/sip[s]:host
3024 endpoint/sip[s]:user@host
3025 endpoint/host
3026 endpoint/user@host
3027 * \endverbatim
3028 *
3029 * \param to Destination
3030 * \param uri Pointer to URI variable. Must be freed by caller - even if the return value is NULL!
3031 * \param destination, slash, atsign, scheme
3032 * \return endpoint
3033 */
3034static struct ast_sip_endpoint *handle_slash(const char *to, char *destination, char **uri,
3035 char *slash, char *atsign, char *scheme)
3036{
3037 char *endpoint_name = NULL;
3038 struct ast_sip_endpoint *endpoint = NULL;
3039 struct ast_sip_contact *contact = NULL;
3040 char *user = NULL;
3041 char *afterslash = slash + 1;
3042 struct ast_sip_aor *aor;
3043
3044 if (ast_begins_with(destination, "PJSIP/")) {
3045 ast_debug(3, "Dest: '%s' Dialplan format'\n", to);
3046 /*
3047 * This has to be the form PJSIP/user@endpoint
3048 */
3049 if (!atsign || strchr(afterslash, '/')) {
3050 /*
3051 * If there's no "user@" or there's a slash somewhere after
3052 * "PJSIP/" then we go no further.
3053 */
3055 "Dest: '%s'. Destinations beginning with 'PJSIP/' must be in the form of 'PJSIP/user@endpoint'\n",
3056 to);
3057 goto failure;
3058 }
3059 *atsign = '\0';
3060 user = afterslash;
3061 endpoint_name = atsign + 1;
3062 ast_debug(3, "Dest: '%s' User: '%s' Endpoint: '%s'\n", to, user, endpoint_name);
3063 } else {
3064 /*
3065 * Either...
3066 * endpoint/aor
3067 * endpoint/uri
3068 */
3069 *slash = '\0';
3070 endpoint_name = destination;
3071 ast_debug(3, "Dest: '%s' Endpoint: '%s'\n", to, endpoint_name);
3072 }
3073
3074 endpoint = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "endpoint", endpoint_name);
3075 if (!endpoint) {
3076 ast_log(LOG_WARNING, "Dest: '%s'. Didn't find endpoint with name '%s'\n",
3077 to, endpoint_name);
3078 goto failure;
3079 }
3080
3081 if (scheme) {
3082 /*
3083 * If we found a scheme, then everything after the slash MUST be a URI.
3084 * We don't need to do any further modification.
3085 */
3086 *uri = ast_strdup(afterslash);
3087 if (!(*uri)) {
3088 goto failure;
3089 }
3090 ast_debug(3, "Dest: '%s' Found endpoint '%s' and found URI '%s' after '/'\n",
3091 to, endpoint_name, *uri);
3092 return endpoint;
3093 }
3094
3095 if (user) {
3096 /*
3097 * This has to be the form PJSIP/user@endpoint
3098 */
3099 int rc;
3100
3101 /*
3102 * Set the return URI to be the endpoint's contact URI with the user
3103 * portion set to the user that was specified before the endpoint name.
3104 */
3105 rc = insert_user_in_contact_uri(to, endpoint_name, endpoint->aors, user, uri);
3106 if (rc != 0) {
3107 /*
3108 * insert_user_in_contact_uri prints the warning message.
3109 */
3110 goto failure;
3111 }
3112 ast_debug(3, "Dest: '%s' User: '%s' Endpoint: '%s' URI: '%s'\n", to, user,
3113 endpoint_name, *uri);
3114
3115 return endpoint;
3116 }
3117
3118 /*
3119 * We're now left with two possibilities...
3120 * endpoint/aor
3121 * endpoint/uri-without-scheme
3122 */
3123 aor = ast_sip_location_retrieve_aor(afterslash);
3124 if (!aor) {
3125 /*
3126 * It's probably a URI without a scheme but we don't have a way to tell
3127 * for sure. We're going to assume it is and prepend it with a scheme.
3128 */
3129 *uri = ast_malloc(strlen(afterslash) + strlen("sip:") + 1);
3130 if (!(*uri)) {
3131 goto failure;
3132 }
3133 sprintf(*uri, "sip:%s", afterslash);
3134 ast_debug(3, "Dest: '%s' Found endpoint '%s' but didn't find aor after '/' so using URI '%s'\n",
3135 to, endpoint_name, *uri);
3136 return endpoint;
3137 }
3138
3139 /*
3140 * Only one possibility left... There was an aor name after the slash.
3141 */
3142 ast_debug(3, "Dest: '%s' Found endpoint '%s' and found aor '%s' after '/'\n",
3143 to, endpoint_name, ast_sorcery_object_get_id(aor));
3144
3146 if (!contact) {
3147 ast_log(LOG_WARNING, "Dest: '%s'. Found endpoint '%s' but didn't find contact for aor '%s'\n",
3148 to, endpoint_name, ast_sorcery_object_get_id(aor));
3149 ao2_cleanup(aor);
3150 goto failure;
3151 }
3152
3153 *uri = ast_strdup(contact->uri);
3154 ao2_cleanup(contact);
3155 ao2_cleanup(aor);
3156 if (!(*uri)) {
3157 goto failure;
3158 }
3159
3160 ast_debug(3, "Dest: '%s' Found endpoint '%s' and found contact with URI '%s' for aor '%s'\n",
3161 to, endpoint_name, *uri, ast_sorcery_object_get_id(aor));
3162
3163 return endpoint;
3164
3165failure:
3166 ao2_cleanup(endpoint);
3167 *uri = NULL;
3168 return NULL;
3169}
3170
3171/*!
3172 * \internal
3173 * \brief Get endpoint and URI when the destination contained a '@' but no '/' or scheme
3174 *
3175 * "to" could be one of the following:
3176 * \verbatim
3177 <sip[s]:user@host>
3178 "Bob" <sip[s]:user@host>
3179 sip[s]:user@host
3180 user@host
3181 * \endverbatim
3182 *
3183 * \param to Destination
3184 * \param uri Pointer to URI variable. Must be freed by caller - even if the return value is NULL!
3185 * \param destination, slash, atsign, scheme
3186 * \param get_default_outbound If nonzero, try to retrieve the default
3187 * outbound endpoint if no endpoint was found.
3188 * Otherwise, return NULL if no endpoint was found.
3189 * \return endpoint
3190 */
3191static struct ast_sip_endpoint *handle_atsign(const char *to, char *destination, char **uri,
3192 char *slash, char *atsign, char *scheme, int get_default_outbound)
3193{
3194 char *endpoint_name = NULL;
3195 struct ast_sip_endpoint *endpoint = NULL;
3196 struct ast_sip_contact *contact = NULL;
3197 char *afterat = atsign + 1;
3198
3199 *atsign = '\0';
3200 endpoint_name = destination;
3201
3202 /* Apparently there may be ';<user_options>' after the endpoint name ??? */
3205 if (!endpoint) {
3206 /*
3207 * It's probably a uri with a user but without a scheme but we don't have a way to tell.
3208 * We're going to assume it is and prepend it with a scheme.
3209 */
3210 *uri = ast_malloc(strlen(to) + strlen("sip:") + 1);
3211 if (!(*uri)) {
3212 goto failure;
3213 }
3214 sprintf(*uri, "sip:%s", to);
3215 if (get_default_outbound) {
3217 }
3218 ast_debug(3, "Dest: '%s' Didn't find endpoint before the '@' so using URI '%s'%s\n",
3219 to, *uri, get_default_outbound ? " with default endpoint" : "");
3220 return endpoint;
3221 }
3222
3223 /*
3224 * OK, it's an endpoint and a domain (which we ignore)
3225 */
3227 if (!contact) {
3228 ast_log(LOG_WARNING, "Dest: '%s'. Found endpoint '%s' but didn't find contact\n",
3229 to, endpoint_name);
3230 goto failure;
3231 }
3232
3233 *uri = ast_strdup(contact->uri);
3234 ao2_cleanup(contact);
3235 if (!(*uri)) {
3236 goto failure;
3237 }
3238 ast_debug(3, "Dest: '%s' Found endpoint '%s' and found contact with URI '%s' (discarding domain %s)\n",
3239 to, endpoint_name, *uri, afterat);
3240
3241 return endpoint;
3242
3243failure:
3245 *uri = NULL;
3246 return NULL;
3247}
3248
3249struct ast_sip_endpoint *ast_sip_get_endpoint(const char *to, int get_default_outbound, char **uri)
3250{
3251 char *destination;
3252 char *slash = NULL;
3253 char *atsign = NULL;
3254 char *scheme = NULL;
3255 struct ast_sip_endpoint *endpoint = NULL;
3256
3257 destination = ast_strdupa(to);
3258
3259 slash = strchr(destination, '/');
3260 atsign = strchr(destination, '@');
3261 scheme = S_OR(strstr(destination, "sip:"), strstr(destination, "sips:"));
3262
3263 if (!slash && !atsign && !scheme) {
3264 /*
3265 * If there's only a single token, it can be either...
3266 * endpoint
3267 * host
3268 */
3269 return handle_single_token(to, destination, get_default_outbound, uri);
3270 }
3271
3272 if (slash) {
3273 /*
3274 * If there's a '/', then the form must be one of the following...
3275 * PJSIP/user@endpoint
3276 * endpoint/aor
3277 * endpoint/uri
3278 */
3279 return handle_slash(to, destination, uri, slash, atsign, scheme);
3280 }
3281
3282 if (atsign && !scheme) {
3283 /*
3284 * If there's an '@' but no scheme then it's either following an endpoint name
3285 * and being followed by a domain name (which we discard).
3286 * OR is's a user@host uri without a scheme. It's probably the latter but because
3287 * endpoint@domain looks just like user@host, we'll test for endpoint first.
3288 */
3289 return handle_atsign(to, destination, uri, slash, atsign, scheme, get_default_outbound);
3290 }
3291
3292 /*
3293 * If all else fails, we assume it's a URI or just a hostname.
3294 */
3295 if (scheme) {
3296 *uri = ast_strdup(destination);
3297 if (!(*uri)) {
3298 goto failure;
3299 }
3300 ast_debug(3, "Dest: '%s' Didn't find an endpoint but did find a scheme so using URI '%s'%s\n",
3301 to, *uri, get_default_outbound ? " with default endpoint" : "");
3302 } else {
3303 *uri = ast_malloc(strlen(destination) + strlen("sip:") + 1);
3304 if (!(*uri)) {
3305 goto failure;
3306 }
3307 sprintf(*uri, "sip:%s", destination);
3308 ast_debug(3, "Dest: '%s' Didn't find an endpoint and didn't find scheme so adding scheme and using URI '%s'%s\n",
3309 to, *uri, get_default_outbound ? " with default endpoint" : "");
3310 }
3311 if (get_default_outbound) {
3313 }
3314
3315 return endpoint;
3316
3317failure:
3318 ao2_cleanup(endpoint);
3319 *uri = NULL;
3320 return NULL;
3321}
3322
3323int ast_sip_update_to_uri(pjsip_tx_data *tdata, const char *to)
3324{
3325 pjsip_name_addr *parsed_name_addr;
3326 pjsip_sip_uri *sip_uri;
3327 pjsip_name_addr *tdata_name_addr;
3328 pjsip_sip_uri *tdata_sip_uri;
3329 pjsip_to_hdr *to_hdr;
3330 char *buf = NULL;
3331#define DEBUG_BUF_SIZE 256
3332
3333 parsed_name_addr = (pjsip_name_addr *) pjsip_parse_uri(tdata->pool, (char*)to, strlen(to),
3334 PJSIP_PARSE_URI_AS_NAMEADDR);
3335
3336 if (!parsed_name_addr || (!PJSIP_URI_SCHEME_IS_SIP(parsed_name_addr->uri)
3337 && !PJSIP_URI_SCHEME_IS_SIPS(parsed_name_addr->uri))) {
3338 ast_log(LOG_WARNING, "To address '%s' is not a valid SIP/SIPS URI\n", to);
3339 return -1;
3340 }
3341
3342 sip_uri = pjsip_uri_get_uri(parsed_name_addr->uri);
3343 if (DEBUG_ATLEAST(3)) {
3345 pjsip_uri_print(PJSIP_URI_IN_FROMTO_HDR, sip_uri, buf, DEBUG_BUF_SIZE);
3346 ast_debug(3, "Parsed To: %.*s %s\n", (int)parsed_name_addr->display.slen,
3347 parsed_name_addr->display.ptr, buf);
3348 }
3349
3350 to_hdr = PJSIP_MSG_TO_HDR(tdata->msg);
3351 tdata_name_addr = to_hdr ? (pjsip_name_addr *) to_hdr->uri : NULL;
3352 if (!tdata_name_addr || (!PJSIP_URI_SCHEME_IS_SIP(tdata_name_addr->uri)
3353 && !PJSIP_URI_SCHEME_IS_SIPS(tdata_name_addr->uri))) {
3354 /* Highly unlikely but we have to check */
3355 ast_log(LOG_WARNING, "tdata To address '%s' is not a valid SIP/SIPS URI\n", to);
3356 return -1;
3357 }
3358
3359 tdata_sip_uri = pjsip_uri_get_uri(tdata_name_addr->uri);
3360 if (DEBUG_ATLEAST(3)) {
3361 buf[0] = '\0';
3362 pjsip_uri_print(PJSIP_URI_IN_FROMTO_HDR, tdata_sip_uri, buf, DEBUG_BUF_SIZE);
3363 ast_debug(3, "Original tdata To: %.*s %s\n", (int)tdata_name_addr->display.slen,
3364 tdata_name_addr->display.ptr, buf);
3365 }
3366
3367 /* Replace the uri */
3368 pjsip_sip_uri_assign(tdata->pool, tdata_sip_uri, sip_uri);
3369 /* The display name isn't part of the URI so we need to replace it separately */
3370 pj_strdup(tdata->pool, &tdata_name_addr->display, &parsed_name_addr->display);
3371
3372 if (DEBUG_ATLEAST(3)) {
3373 buf[0] = '\0';
3374 pjsip_uri_print(PJSIP_URI_IN_FROMTO_HDR, tdata_sip_uri, buf, 256);
3375 ast_debug(3, "New tdata To: %.*s %s\n", (int)tdata_name_addr->display.slen,
3376 tdata_name_addr->display.ptr, buf);
3377 }
3378
3379 return 0;
3380#undef DEBUG_BUF_SIZE
3381}
3382
3383int ast_sip_update_from(pjsip_tx_data *tdata, char *from)
3384{
3385 pjsip_name_addr *name_addr;
3386 pjsip_sip_uri *uri;
3387 pjsip_name_addr *parsed_name_addr;
3388 pjsip_from_hdr *from_hdr;
3389
3390 if (ast_strlen_zero(from)) {
3391 return 0;
3392 }
3393
3394 from_hdr = PJSIP_MSG_FROM_HDR(tdata->msg);
3395 if (!from_hdr) {
3396 return -1;
3397 }
3398 name_addr = (pjsip_name_addr *) from_hdr->uri;
3399 uri = pjsip_uri_get_uri(name_addr);
3400
3401 parsed_name_addr = (pjsip_name_addr *) pjsip_parse_uri(tdata->pool, from,
3402 strlen(from), PJSIP_PARSE_URI_AS_NAMEADDR);
3403 if (parsed_name_addr) {
3404 pjsip_sip_uri *parsed_uri;
3405
3406 if (!PJSIP_URI_SCHEME_IS_SIP(parsed_name_addr->uri)
3407 && !PJSIP_URI_SCHEME_IS_SIPS(parsed_name_addr->uri)) {
3408 ast_log(LOG_WARNING, "From address '%s' is not a valid SIP/SIPS URI\n", from);
3409 return -1;
3410 }
3411
3412 parsed_uri = pjsip_uri_get_uri(parsed_name_addr->uri);
3413
3414 if (pj_strlen(&parsed_name_addr->display)) {
3415 pj_strdup(tdata->pool, &name_addr->display, &parsed_name_addr->display);
3416 }
3417
3418 /* Unlike the To header, we only want to replace the user, host and port */
3419 pj_strdup(tdata->pool, &uri->user, &parsed_uri->user);
3420 pj_strdup(tdata->pool, &uri->host, &parsed_uri->host);
3421 uri->port = parsed_uri->port;
3422
3423 return 0;
3424 } else {
3425 /* assume it is 'user[@domain]' format */
3426 char *domain = strchr(from, '@');
3427
3428 if (domain) {
3429 pj_str_t pj_from;
3430
3431 pj_strset3(&pj_from, from, domain);
3432 pj_strdup(tdata->pool, &uri->user, &pj_from);
3433
3434 pj_strdup2(tdata->pool, &uri->host, domain + 1);
3435 } else {
3436 pj_strdup2(tdata->pool, &uri->user, from);
3437 }
3438
3439 return 0;
3440 }
3441
3442 return -1;
3443}
3444
3445static void remove_request_headers(pjsip_endpoint *endpt)
3446{
3447 const pjsip_hdr *request_headers = pjsip_endpt_get_request_headers(endpt);
3448 pjsip_hdr *iter = request_headers->next;
3449
3450 while (iter != request_headers) {
3451 pjsip_hdr *to_erase = iter;
3452 iter = iter->next;
3453 pj_list_erase(to_erase);
3454 }
3455}
3456
3458{
3460}
3461
3463{
3464 return sip_threadpool;
3465}
3466
3467int ast_sip_is_uri_sip_sips(pjsip_uri *uri)
3468{
3469 return (PJSIP_URI_SCHEME_IS_SIP(uri) || PJSIP_URI_SCHEME_IS_SIPS(uri));
3470}
3471
3472int ast_sip_is_allowed_uri(pjsip_uri *uri)
3473{
3474 return (ast_sip_is_uri_sip_sips(uri) || PJSIP_URI_SCHEME_IS_TEL(uri));
3475}
3476
3477const pj_str_t *ast_sip_pjsip_uri_get_username(pjsip_uri *uri)
3478{
3479 if (ast_sip_is_uri_sip_sips(uri)) {
3480 pjsip_sip_uri *sip_uri = pjsip_uri_get_uri(uri);
3481 if (!sip_uri) {
3482 return &AST_PJ_STR_EMPTY;
3483 }
3484 return &sip_uri->user;
3485 } else if (PJSIP_URI_SCHEME_IS_TEL(uri)) {
3486 pjsip_tel_uri *tel_uri = pjsip_uri_get_uri(uri);
3487 if (!tel_uri) {
3488 return &AST_PJ_STR_EMPTY;
3489 }
3490 return &tel_uri->number;
3491 }
3492
3493 return &AST_PJ_STR_EMPTY;
3494}
3495
3496const pj_str_t *ast_sip_pjsip_uri_get_hostname(pjsip_uri *uri)
3497{
3498 if (ast_sip_is_uri_sip_sips(uri)) {
3499 pjsip_sip_uri *sip_uri = pjsip_uri_get_uri(uri);
3500 if (!sip_uri) {
3501 return &AST_PJ_STR_EMPTY;
3502 }
3503 return &sip_uri->host;
3504 } else if (PJSIP_URI_SCHEME_IS_TEL(uri)) {
3505 return &AST_PJ_STR_EMPTY;
3506 }
3507
3508 return &AST_PJ_STR_EMPTY;
3509}
3510
3511struct pjsip_param *ast_sip_pjsip_uri_get_other_param(pjsip_uri *uri, const pj_str_t *param_str)
3512{
3513 if (ast_sip_is_uri_sip_sips(uri)) {
3514 pjsip_sip_uri *sip_uri = pjsip_uri_get_uri(uri);
3515 if (!sip_uri) {
3516 return NULL;
3517 }
3518 return pjsip_param_find(&sip_uri->other_param, param_str);
3519 } else if (PJSIP_URI_SCHEME_IS_TEL(uri)) {
3520 pjsip_tel_uri *tel_uri = pjsip_uri_get_uri(uri);
3521 if (!tel_uri) {
3522 return NULL;
3523 }
3524 return pjsip_param_find(&tel_uri->other_param, param_str);
3525 }
3526
3527 return NULL;
3528}
3529
3530/*! \brief Convert SIP hangup causes to Asterisk hangup causes */
3531const int ast_sip_hangup_sip2cause(int cause)
3532{
3533 /* Possible values taken from causes.h */
3534
3535 switch(cause) {
3536 case 401: /* Unauthorized */
3538 case 403: /* Not found */
3540 case 404: /* Not found */
3541 return AST_CAUSE_UNALLOCATED;
3542 case 405: /* Method not allowed */
3544 case 407: /* Proxy authentication required */
3546 case 408: /* No reaction */
3548 case 409: /* Conflict */
3550 case 410: /* Gone */
3552 case 411: /* Length required */
3554 case 413: /* Request entity too large */
3556 case 414: /* Request URI too large */
3558 case 415: /* Unsupported media type */
3560 case 420: /* Bad extension */
3562 case 480: /* No answer */
3563 return AST_CAUSE_NO_ANSWER;
3564 case 481: /* No answer */
3566 case 482: /* Loop detected */
3568 case 483: /* Too many hops */
3569 return AST_CAUSE_NO_ANSWER;
3570 case 484: /* Address incomplete */
3572 case 485: /* Ambiguous */
3573 return AST_CAUSE_UNALLOCATED;
3574 case 486: /* Busy everywhere */
3575 return AST_CAUSE_BUSY;
3576 case 487: /* Request terminated */
3578 case 488: /* No codecs approved */
3580 case 491: /* Request pending */
3582 case 493: /* Undecipherable */
3584 case 500: /* Server internal failure */
3585 return AST_CAUSE_FAILURE;
3586 case 501: /* Call rejected */
3588 case 502:
3590 case 503: /* Service unavailable */
3591 return AST_CAUSE_CONGESTION;
3592 case 504: /* Gateway timeout */
3594 case 505: /* SIP version not supported */
3596 case 600: /* Busy everywhere */
3597 return AST_CAUSE_USER_BUSY;
3598 case 603: /* Decline */
3600 case 604: /* Does not exist anywhere */
3601 return AST_CAUSE_UNALLOCATED;
3602 case 606: /* Not acceptable */
3604 default:
3605 if (cause < 500 && cause >= 400) {
3606 /* 4xx class error that is unknown - someting wrong with our request */
3608 } else if (cause < 600 && cause >= 500) {
3609 /* 5xx class error - problem in the remote end */
3610 return AST_CAUSE_CONGESTION;
3611 } else if (cause < 700 && cause >= 600) {
3612 /* 6xx - global errors in the 4xx class */
3614 }
3615 return AST_CAUSE_NORMAL;
3616 }
3617 /* Never reached */
3618 return 0;
3619}
3620
3622 int code;
3623 const char *long_name;
3624 const char *short_name;
3625};
3626
3627/*
3628 * This map was generated from sip_msg.h with
3629 *
3630 * sed -n -r -e 's/^\s+(PJSIP_SC_([^ =]+))\s*=\s*[0-9]+,/{ \1, "\1", "\2" },/gp' \
3631 * third-party/pjproject/source/pjsip/include/pjsip/sip_msg.h
3632 *
3633 */
3634static const struct response_code_map rc_map[] = {
3635 { PJSIP_SC_NULL, "PJSIP_SC_NULL", "NULL" },
3636 { PJSIP_SC_TRYING, "PJSIP_SC_TRYING", "TRYING" },
3637 { PJSIP_SC_RINGING, "PJSIP_SC_RINGING", "RINGING" },
3638 { PJSIP_SC_CALL_BEING_FORWARDED, "PJSIP_SC_CALL_BEING_FORWARDED", "CALL_BEING_FORWARDED" },
3639 { PJSIP_SC_QUEUED, "PJSIP_SC_QUEUED", "QUEUED" },
3640 { PJSIP_SC_PROGRESS, "PJSIP_SC_PROGRESS", "PROGRESS" },
3641 { PJSIP_SC_EARLY_DIALOG_TERMINATED, "PJSIP_SC_EARLY_DIALOG_TERMINATED", "EARLY_DIALOG_TERMINATED" },
3642 { PJSIP_SC_OK, "PJSIP_SC_OK", "OK" },
3643 { PJSIP_SC_ACCEPTED, "PJSIP_SC_ACCEPTED", "ACCEPTED" },
3644 { PJSIP_SC_NO_NOTIFICATION, "PJSIP_SC_NO_NOTIFICATION", "NO_NOTIFICATION" },
3645 { PJSIP_SC_MULTIPLE_CHOICES, "PJSIP_SC_MULTIPLE_CHOICES", "MULTIPLE_CHOICES" },
3646 { PJSIP_SC_MOVED_PERMANENTLY, "PJSIP_SC_MOVED_PERMANENTLY", "MOVED_PERMANENTLY" },
3647 { PJSIP_SC_MOVED_TEMPORARILY, "PJSIP_SC_MOVED_TEMPORARILY", "MOVED_TEMPORARILY" },
3648 { PJSIP_SC_USE_PROXY, "PJSIP_SC_USE_PROXY", "USE_PROXY" },
3649 { PJSIP_SC_ALTERNATIVE_SERVICE, "PJSIP_SC_ALTERNATIVE_SERVICE", "ALTERNATIVE_SERVICE" },
3650 { PJSIP_SC_BAD_REQUEST, "PJSIP_SC_BAD_REQUEST", "BAD_REQUEST" },
3651 { PJSIP_SC_UNAUTHORIZED, "PJSIP_SC_UNAUTHORIZED", "UNAUTHORIZED" },
3652 { PJSIP_SC_PAYMENT_REQUIRED, "PJSIP_SC_PAYMENT_REQUIRED", "PAYMENT_REQUIRED" },
3653 { PJSIP_SC_FORBIDDEN, "PJSIP_SC_FORBIDDEN", "FORBIDDEN" },
3654 { PJSIP_SC_NOT_FOUND, "PJSIP_SC_NOT_FOUND", "NOT_FOUND" },
3655 { PJSIP_SC_METHOD_NOT_ALLOWED, "PJSIP_SC_METHOD_NOT_ALLOWED", "METHOD_NOT_ALLOWED" },
3656 { PJSIP_SC_NOT_ACCEPTABLE, "PJSIP_SC_NOT_ACCEPTABLE", "NOT_ACCEPTABLE" },
3657 { PJSIP_SC_PROXY_AUTHENTICATION_REQUIRED, "PJSIP_SC_PROXY_AUTHENTICATION_REQUIRED", "PROXY_AUTHENTICATION_REQUIRED" },
3658 { PJSIP_SC_REQUEST_TIMEOUT, "PJSIP_SC_REQUEST_TIMEOUT", "REQUEST_TIMEOUT" },
3659 { PJSIP_SC_CONFLICT, "PJSIP_SC_CONFLICT", "CONFLICT" },
3660 { PJSIP_SC_GONE, "PJSIP_SC_GONE", "GONE" },
3661 { PJSIP_SC_LENGTH_REQUIRED, "PJSIP_SC_LENGTH_REQUIRED", "LENGTH_REQUIRED" },
3662 { PJSIP_SC_CONDITIONAL_REQUEST_FAILED, "PJSIP_SC_CONDITIONAL_REQUEST_FAILED", "CONDITIONAL_REQUEST_FAILED" },
3663 { PJSIP_SC_REQUEST_ENTITY_TOO_LARGE, "PJSIP_SC_REQUEST_ENTITY_TOO_LARGE", "REQUEST_ENTITY_TOO_LARGE" },
3664 { PJSIP_SC_REQUEST_URI_TOO_LONG, "PJSIP_SC_REQUEST_URI_TOO_LONG", "REQUEST_URI_TOO_LONG" },
3665 { PJSIP_SC_UNSUPPORTED_MEDIA_TYPE, "PJSIP_SC_UNSUPPORTED_MEDIA_TYPE", "UNSUPPORTED_MEDIA_TYPE" },
3666 { PJSIP_SC_UNSUPPORTED_URI_SCHEME, "PJSIP_SC_UNSUPPORTED_URI_SCHEME", "UNSUPPORTED_URI_SCHEME" },
3667 { PJSIP_SC_UNKNOWN_RESOURCE_PRIORITY, "PJSIP_SC_UNKNOWN_RESOURCE_PRIORITY", "UNKNOWN_RESOURCE_PRIORITY" },
3668 { PJSIP_SC_BAD_EXTENSION, "PJSIP_SC_BAD_EXTENSION", "BAD_EXTENSION" },
3669 { PJSIP_SC_EXTENSION_REQUIRED, "PJSIP_SC_EXTENSION_REQUIRED", "EXTENSION_REQUIRED" },
3670 { PJSIP_SC_SESSION_TIMER_TOO_SMALL, "PJSIP_SC_SESSION_TIMER_TOO_SMALL", "SESSION_TIMER_TOO_SMALL" },
3671 { PJSIP_SC_INTERVAL_TOO_BRIEF, "PJSIP_SC_INTERVAL_TOO_BRIEF", "INTERVAL_TOO_BRIEF" },
3672 { PJSIP_SC_BAD_LOCATION_INFORMATION, "PJSIP_SC_BAD_LOCATION_INFORMATION", "BAD_LOCATION_INFORMATION" },
3673 { PJSIP_SC_USE_IDENTITY_HEADER, "PJSIP_SC_USE_IDENTITY_HEADER", "USE_IDENTITY_HEADER" },
3674 { PJSIP_SC_PROVIDE_REFERRER_HEADER, "PJSIP_SC_PROVIDE_REFERRER_HEADER", "PROVIDE_REFERRER_HEADER" },
3675 { PJSIP_SC_FLOW_FAILED, "PJSIP_SC_FLOW_FAILED", "FLOW_FAILED" },
3676 { PJSIP_SC_ANONIMITY_DISALLOWED, "PJSIP_SC_ANONIMITY_DISALLOWED", "ANONIMITY_DISALLOWED" },
3677 { PJSIP_SC_BAD_IDENTITY_INFO, "PJSIP_SC_BAD_IDENTITY_INFO", "BAD_IDENTITY_INFO" },
3678 { PJSIP_SC_UNSUPPORTED_CERTIFICATE, "PJSIP_SC_UNSUPPORTED_CERTIFICATE", "UNSUPPORTED_CERTIFICATE" },
3679 { PJSIP_SC_INVALID_IDENTITY_HEADER, "PJSIP_SC_INVALID_IDENTITY_HEADER", "INVALID_IDENTITY_HEADER" },
3680 { PJSIP_SC_FIRST_HOP_LACKS_OUTBOUND_SUPPORT, "PJSIP_SC_FIRST_HOP_LACKS_OUTBOUND_SUPPORT", "FIRST_HOP_LACKS_OUTBOUND_SUPPORT" },
3681 { PJSIP_SC_MAX_BREADTH_EXCEEDED, "PJSIP_SC_MAX_BREADTH_EXCEEDED", "MAX_BREADTH_EXCEEDED" },
3682 { PJSIP_SC_BAD_INFO_PACKAGE, "PJSIP_SC_BAD_INFO_PACKAGE", "BAD_INFO_PACKAGE" },
3683 { PJSIP_SC_CONSENT_NEEDED, "PJSIP_SC_CONSENT_NEEDED", "CONSENT_NEEDED" },
3684 { PJSIP_SC_TEMPORARILY_UNAVAILABLE, "PJSIP_SC_TEMPORARILY_UNAVAILABLE", "TEMPORARILY_UNAVAILABLE" },
3685 { PJSIP_SC_CALL_TSX_DOES_NOT_EXIST, "PJSIP_SC_CALL_TSX_DOES_NOT_EXIST", "CALL_TSX_DOES_NOT_EXIST" },
3686 { PJSIP_SC_LOOP_DETECTED, "PJSIP_SC_LOOP_DETECTED", "LOOP_DETECTED" },
3687 { PJSIP_SC_TOO_MANY_HOPS, "PJSIP_SC_TOO_MANY_HOPS", "TOO_MANY_HOPS" },
3688 { PJSIP_SC_ADDRESS_INCOMPLETE, "PJSIP_SC_ADDRESS_INCOMPLETE", "ADDRESS_INCOMPLETE" },
3689 { PJSIP_SC_BUSY_HERE, "PJSIP_SC_BUSY_HERE", "BUSY_HERE" },
3690 { PJSIP_SC_REQUEST_TERMINATED, "PJSIP_SC_REQUEST_TERMINATED", "REQUEST_TERMINATED" },
3691 { PJSIP_SC_NOT_ACCEPTABLE_HERE, "PJSIP_SC_NOT_ACCEPTABLE_HERE", "NOT_ACCEPTABLE_HERE" },
3692 { PJSIP_SC_BAD_EVENT, "PJSIP_SC_BAD_EVENT", "BAD_EVENT" },
3693 { PJSIP_SC_REQUEST_UPDATED, "PJSIP_SC_REQUEST_UPDATED", "REQUEST_UPDATED" },
3694 { PJSIP_SC_REQUEST_PENDING, "PJSIP_SC_REQUEST_PENDING", "REQUEST_PENDING" },
3695 { PJSIP_SC_UNDECIPHERABLE, "PJSIP_SC_UNDECIPHERABLE", "UNDECIPHERABLE" },
3696 { PJSIP_SC_SECURITY_AGREEMENT_NEEDED, "PJSIP_SC_SECURITY_AGREEMENT_NEEDED", "SECURITY_AGREEMENT_NEEDED" },
3697 { PJSIP_SC_INTERNAL_SERVER_ERROR, "PJSIP_SC_INTERNAL_SERVER_ERROR", "INTERNAL_SERVER_ERROR" },
3698 { PJSIP_SC_NOT_IMPLEMENTED, "PJSIP_SC_NOT_IMPLEMENTED", "NOT_IMPLEMENTED" },
3699 { PJSIP_SC_BAD_GATEWAY, "PJSIP_SC_BAD_GATEWAY", "BAD_GATEWAY" },
3700 { PJSIP_SC_SERVICE_UNAVAILABLE, "PJSIP_SC_SERVICE_UNAVAILABLE", "SERVICE_UNAVAILABLE" },
3701 { PJSIP_SC_SERVER_TIMEOUT, "PJSIP_SC_SERVER_TIMEOUT", "SERVER_TIMEOUT" },
3702 { PJSIP_SC_VERSION_NOT_SUPPORTED, "PJSIP_SC_VERSION_NOT_SUPPORTED", "VERSION_NOT_SUPPORTED" },
3703 { PJSIP_SC_MESSAGE_TOO_LARGE, "PJSIP_SC_MESSAGE_TOO_LARGE", "MESSAGE_TOO_LARGE" },
3704 { PJSIP_SC_PUSH_NOTIFICATION_SERVICE_NOT_SUPPORTED, "PJSIP_SC_PUSH_NOTIFICATION_SERVICE_NOT_SUPPORTED", "PUSH_NOTIFICATION_SERVICE_NOT_SUPPORTED" },
3705 { PJSIP_SC_PRECONDITION_FAILURE, "PJSIP_SC_PRECONDITION_FAILURE", "PRECONDITION_FAILURE" },
3706 { PJSIP_SC_BUSY_EVERYWHERE, "PJSIP_SC_BUSY_EVERYWHERE", "BUSY_EVERYWHERE" },
3707 { PJSIP_SC_DECLINE, "PJSIP_SC_DECLINE", "DECLINE" },
3708 { PJSIP_SC_DOES_NOT_EXIST_ANYWHERE, "PJSIP_SC_DOES_NOT_EXIST_ANYWHERE", "DOES_NOT_EXIST_ANYWHERE" },
3709 { PJSIP_SC_NOT_ACCEPTABLE_ANYWHERE, "PJSIP_SC_NOT_ACCEPTABLE_ANYWHERE", "NOT_ACCEPTABLE_ANYWHERE" },
3710 { PJSIP_SC_UNWANTED, "PJSIP_SC_UNWANTED", "UNWANTED" },
3711 { PJSIP_SC_REJECTED, "PJSIP_SC_REJECTED", "REJECTED" },
3712};
3713
3714int ast_sip_str2rc(const char *name)
3715{
3716 int i;
3717
3718 if (ast_strlen_zero(name)) {
3719 return -1;
3720 }
3721
3722 for (i = 0; i < ARRAY_LEN(rc_map); i++) {
3723 if (strcasecmp(rc_map[i].short_name, name) == 0 ||
3724 strcasecmp(rc_map[i].long_name, name) == 0) {
3725 return rc_map[i].code;
3726 }
3727 }
3728
3729 return -1;
3730}
3731
3732
3733#ifdef TEST_FRAMEWORK
3734AST_TEST_DEFINE(xml_sanitization_end_null)
3735{
3736 char sanitized[8];
3737
3738 switch (cmd) {
3739 case TEST_INIT:
3740 info->name = "xml_sanitization_end_null";
3741 info->category = "/res/res_pjsip/";
3742 info->summary = "Ensure XML sanitization works as expected with a long string";
3743 info->description = "This test sanitizes a string which exceeds the output\n"
3744 "buffer size. Once done the string is confirmed to be NULL terminated.";
3745 return AST_TEST_NOT_RUN;
3746 case TEST_EXECUTE:
3747 break;
3748 }
3749
3750 ast_sip_sanitize_xml("aaaaaaaaaaaa", sanitized, sizeof(sanitized));
3751 if (sanitized[7] != '\0') {
3752 ast_test_status_update(test, "Sanitized XML string is not null-terminated when it should be\n");
3753 return AST_TEST_FAIL;
3754 }
3755
3756 return AST_TEST_PASS;
3757}
3758
3759AST_TEST_DEFINE(xml_sanitization_exceeds_buffer)
3760{
3761 char sanitized[8];
3762
3763 switch (cmd) {
3764 case TEST_INIT:
3765 info->name = "xml_sanitization_exceeds_buffer";
3766 info->category = "/res/res_pjsip/";
3767 info->summary = "Ensure XML sanitization does not exceed buffer when output won't fit";
3768 info->description = "This test sanitizes a string which before sanitization would\n"
3769 "fit within the output buffer. After sanitization, however, the string would\n"
3770 "exceed the buffer. Once done the string is confirmed to be NULL terminated.";
3771 return AST_TEST_NOT_RUN;
3772 case TEST_EXECUTE:
3773 break;
3774 }
3775
3776 ast_sip_sanitize_xml("<><><>&", sanitized, sizeof(sanitized));
3777 if (sanitized[7] != '\0') {
3778 ast_test_status_update(test, "Sanitized XML string is not null-terminated when it should be\n");
3779 return AST_TEST_FAIL;
3780 }
3781
3782 return AST_TEST_PASS;
3783}
3784#endif
3785
3786/*!
3787 * \internal
3788 * \brief Reload configuration within a PJSIP thread
3789 */
3790static int reload_configuration_task(void *obj)
3791{
3795 return 0;
3796}
3797
3798static int unload_pjsip(void *data)
3799{
3800 /*
3801 * These calls need the pjsip endpoint and serializer to clean up.
3802 * If they're not set, then there's nothing to clean up anyway.
3803 */
3814 }
3815
3816 if (monitor_thread) {
3819 }
3820
3821 if (memory_pool) {
3822 /* This mimics the behavior of pj_pool_safe_release
3823 * which was introduced in pjproject 2.6.
3824 */
3825 pj_pool_t *temp_pool = memory_pool;
3826
3827 memory_pool = NULL;
3828 pj_pool_release(temp_pool);
3829 }
3830
3832
3833 if (caching_pool.lock) {
3835 }
3836
3837 pj_shutdown();
3838
3839 return 0;
3840}
3841
3842static int load_pjsip(void)
3843{
3844 const unsigned int flags = 0; /* no port, no brackets */
3845 pj_status_t status;
3846
3847 /* The third parameter is just copied from
3848 * example code from PJLIB. This can be adjusted
3849 * if necessary.
3850 */
3852 if (pjsip_endpt_create(&caching_pool.factory, "SIP", &ast_pjsip_endpoint) != PJ_SUCCESS) {
3853 ast_log(LOG_ERROR, "Failed to create PJSIP endpoint structure. Aborting load\n");
3854 goto error;
3855 }
3856
3857 /* PJSIP will automatically try to add a Max-Forwards header. Since we want to control that,
3858 * we need to stop PJSIP from doing it automatically
3859 */
3861
3862 memory_pool = pj_pool_create(&caching_pool.factory, "SIP", 1024, 1024, NULL);
3863 if (!memory_pool) {
3864 ast_log(LOG_ERROR, "Failed to create memory pool for SIP. Aborting load\n");
3865 goto error;
3866 }
3867
3868 if (!pj_gethostip(pj_AF_INET(), &host_ip_ipv4)) {
3869 pj_sockaddr_print(&host_ip_ipv4, host_ip_ipv4_string, sizeof(host_ip_ipv4_string), flags);
3870 ast_verb(3, "Local IPv4 address determined to be: %s\n", host_ip_ipv4_string);
3871 }
3872
3873 if (!pj_gethostip(pj_AF_INET6(), &host_ip_ipv6)) {
3874 pj_sockaddr_print(&host_ip_ipv6, host_ip_ipv6_string, sizeof(host_ip_ipv6_string), flags);
3875 ast_verb(3, "Local IPv6 address determined to be: %s\n", host_ip_ipv6_string);
3876 }
3877
3878 pjsip_tsx_layer_init_module(ast_pjsip_endpoint);
3879 pjsip_ua_init_module(ast_pjsip_endpoint, NULL);
3880
3881 monitor_continue = 1;
3882 status = pj_thread_create(memory_pool, "SIP", (pj_thread_proc *) &monitor_thread_exec,
3883 NULL, PJ_THREAD_DEFAULT_STACK_SIZE * 2, 0, &monitor_thread);
3884 if (status != PJ_SUCCESS) {
3885 ast_log(LOG_ERROR, "Failed to start SIP monitor thread. Aborting load\n");
3886 goto error;
3887 }
3888
3890
3891error:
3893}
3894
3895/*
3896 * This is a place holder function to ensure that pjmedia_strerr() is at
3897 * least directly referenced by this module to ensure that the loader
3898 * linker will link to the function. If a module only indirectly
3899 * references a function from another module, such as a callback parameter
3900 * to a function, the loader linker has been known to miss the link.
3901 */
3902void never_called_res_pjsip(void);
3904{
3905 pjmedia_strerror(0, NULL, 0);
3906}
3907
3908/* Definitions of media types declared "extern" in res_pjsip.h */
3921
3922static int load_module(void)
3923{
3925
3926 /* pjproject and config_system need to be initialized before all else */
3927 if (pj_init() != PJ_SUCCESS) {
3929 }
3930
3931 if (pjlib_util_init() != PJ_SUCCESS) {
3932 goto error;
3933 }
3934
3935 /* Register PJMEDIA error codes for SDP parsing errors */
3936 if (pj_register_strerror(PJMEDIA_ERRNO_START, PJ_ERRNO_SPACE_SIZE, pjmedia_strerror)
3937 != PJ_SUCCESS) {
3938 ast_log(LOG_WARNING, "Failed to register pjmedia error codes. Codes will not be decoded.\n");
3939 }
3940
3941 /* Initialize common media types */
3942 pjsip_media_type_init2(&pjsip_media_type_application_json, "application", "json");
3943 pjsip_media_type_init2(&pjsip_media_type_application_media_control_xml, "application", "media_control+xml");
3944 pjsip_media_type_init2(&pjsip_media_type_application_pidf_xml, "application", "pidf+xml");
3945 pjsip_media_type_init2(&pjsip_media_type_application_xpidf_xml, "application", "xpidf+xml");
3946 pjsip_media_type_init2(&pjsip_media_type_application_cpim_xpidf_xml, "application", "cpim-xpidf+xml");
3947 pjsip_media_type_init2(&pjsip_media_type_application_rlmi_xml, "application", "rlmi+xml");
3948 pjsip_media_type_init2(&pjsip_media_type_application_sdp, "application", "sdp");
3949 pjsip_media_type_init2(&pjsip_media_type_application_simple_message_summary, "application", "simple-message-summary");
3950 pjsip_media_type_init2(&pjsip_media_type_multipart_alternative, "multipart", "alternative");
3951 pjsip_media_type_init2(&pjsip_media_type_multipart_mixed, "multipart", "mixed");
3952 pjsip_media_type_init2(&pjsip_media_type_multipart_related, "multipart", "related");
3953 pjsip_media_type_init2(&pjsip_media_type_text_plain, "text", "plain");
3954
3955
3957 ast_log(LOG_ERROR, "Failed to initialize SIP 'system' configuration section. Aborting load\n");
3958 goto error;
3959 }
3960
3961 /* The serializer needs threadpool and threadpool needs pjproject to be initialized so it's next */
3963 options.thread_start = sip_thread_start;
3965 if (!sip_threadpool) {
3966 goto error;
3967 }
3968
3970 "pjsip/default", SERIALIZER_POOL_SIZE, sip_threadpool, -1);
3971 if (!sip_serializer_pool) {
3972 ast_log(LOG_ERROR, "Failed to create SIP serializer pool. Aborting load\n");
3973 goto error;
3974 }
3975
3977 ast_log(LOG_ERROR, "Failed to start scheduler. Aborting load\n");
3978 goto error;
3979 }
3980
3981 /* Now load all the pjproject infrastructure. */
3982 if (load_pjsip()) {
3983 goto error;
3984 }
3985
3987 ast_log(LOG_ERROR, "Failed to initialize SIP transport monitor. Aborting load\n");
3988 goto error;
3989 }
3990
3993
3995 ast_log(LOG_ERROR, "Failed to pre-initialize OPTIONS handling. Aborting load\n");
3996 goto error;
3997 }
3998
4000 ast_log(LOG_ERROR, "Failed to initialize SIP configuration. Aborting load\n");
4001 goto error;
4002 }
4003
4006
4008 ast_log(LOG_ERROR, "Failed to initialize SIP transport management. Aborting load\n");
4009 goto error;
4010 }
4011
4013 ast_log(LOG_ERROR, "Failed to register distributor module. Aborting load\n");
4014 goto error;
4015 }
4016
4018 ast_log(LOG_ERROR, "Failed to initialize supplement hooks. Aborting load\n");
4019 goto error;
4020 }
4021
4023 ast_log(LOG_ERROR, "Failed to initialize OPTIONS handling. Aborting load\n");
4024 goto error;
4025 }
4026
4027 /*
4028 * It is OK to prune the contacts now that
4029 * ast_res_pjsip_init_options_handling() has added the contact observer
4030 * of res/res_pjsip/pjsip_options.c to sorcery (to ensure that any
4031 * pruned contacts are removed from this module's data structure).
4032 */
4034
4036 ast_log(LOG_ERROR, "Failed to initialize message IP updating. Aborting load\n");
4037 goto error;
4038 }
4039
4041
4042 AST_TEST_REGISTER(xml_sanitization_end_null);
4043 AST_TEST_REGISTER(xml_sanitization_exceeds_buffer);
4044
4046
4047error:
4049
4050 /* These functions all check for NULLs and are safe to call at any time */
4054
4056}
4057
4058static int reload_module(void)
4059{
4060 /*
4061 * We must wait for the reload to complete so multiple
4062 * reloads cannot happen at the same time.
4063 */
4065 ast_log(LOG_WARNING, "Failed to reload PJSIP\n");
4066 return -1;
4067 }
4068
4069 return 0;
4070}
4071
4072static int unload_module(void)
4073{
4074 AST_TEST_UNREGISTER(xml_sanitization_end_null);
4075 AST_TEST_UNREGISTER(xml_sanitization_exceeds_buffer);
4077
4078 /* The thread this is called from cannot call PJSIP/PJLIB functions,
4079 * so we have to push the work to the threadpool to handle
4080 */
4085
4086 return 0;
4087}
4088
4090 .support_level = AST_MODULE_SUPPORT_CORE,
4091 .load = load_module,
4092 .unload = unload_module,
4094 .load_pri = AST_MODPRI_CHANNEL_DEPEND - 5,
4095 .requires = "dnsmgr,res_pjproject,res_sorcery_config,res_sorcery_memory,res_sorcery_astdb",
4096 .optional_modules = "res_geolocation,res_statsd",
Access Control of various sorts.
static int compare(const char *text, const char *template)
jack_status_t status
Definition: app_jack.c:146
const char * str
Definition: app_jack.c:147
enum queue_result id
Definition: app_queue.c:1638
pthread_t thread
Definition: app_sla.c:329
ast_mutex_t lock
Definition: app_sla.c:331
if(!yyg->yy_init)
Definition: ast_expr2f.c:854
Asterisk main include file. File version handling, generic pbx functions.
#define ast_alloca(size)
call __builtin_alloca to ensure we get gcc builtin semantics
Definition: astmm.h:288
#define ast_free(a)
Definition: astmm.h:180
#define ast_strdup(str)
A wrapper for strdup()
Definition: astmm.h:241
#define ast_strdupa(s)
duplicate a string in memory from the stack
Definition: astmm.h:298
#define ast_asprintf(ret, fmt,...)
A wrapper for asprintf()
Definition: astmm.h:267
#define ast_calloc(num, len)
A wrapper for calloc()
Definition: astmm.h:202
#define ast_malloc(len)
A wrapper for malloc()
Definition: astmm.h:191
#define ast_log
Definition: astobj2.c:42
#define ao2_t_ref(o, delta, tag)
Definition: astobj2.h:460
@ CMP_MATCH
Definition: astobj2.h:1027
@ CMP_STOP
Definition: astobj2.h:1028
@ AO2_ALLOC_OPT_LOCK_NOLOCK
Definition: astobj2.h:367
#define ao2_callback(c, flags, cb_fn, arg)
ao2_callback() is a generic function that applies cb_fn() to all objects in a container,...
Definition: astobj2.h:1693
#define ao2_cleanup(obj)
Definition: astobj2.h:1934
#define ao2_unlock(a)
Definition: astobj2.h:729
#define ao2_lock(a)
Definition: astobj2.h:717
#define ao2_ref(o, delta)
Reference/unreference an object and return the old refcount.
Definition: astobj2.h:459
#define ao2_alloc_options(data_size, destructor_fn, options)
Definition: astobj2.h:404
#define ao2_bump(obj)
Bump refcount on an AO2 object by one, returning the object.
Definition: astobj2.h:480
#define ao2_alloc(data_size, destructor_fn)
Definition: astobj2.h:409
static int tmp()
Definition: bt_open.c:389
CallerID (and other GR30) management and generation Includes code and algorithms from the Zapata libr...
#define AST_PRES_PROHIB_USER_NUMBER_NOT_SCREENED
Definition: callerid.h:449
#define AST_PRES_USER_NUMBER_UNSCREENED
Definition: callerid.h:426
#define AST_PRES_USER_NUMBER_PASSED_SCREEN
Definition: callerid.h:427
#define AST_PRES_RESTRICTED
Definition: callerid.h:433
#define AST_PRES_ALLOWED
Definition: callerid.h:432
#define AST_PRES_ALLOWED_USER_NUMBER_NOT_SCREENED
Definition: callerid.h:437
Internal Asterisk hangup causes.
#define AST_CAUSE_CONGESTION
Definition: causes.h:153
#define AST_CAUSE_UNALLOCATED
Definition: causes.h:98
#define AST_CAUSE_INTERWORKING
Definition: causes.h:146
#define AST_CAUSE_NUMBER_CHANGED
Definition: causes.h:112
#define AST_CAUSE_BEARERCAPABILITY_NOTAVAIL
Definition: causes.h:130
#define AST_CAUSE_INVALID_NUMBER_FORMAT
Definition: causes.h:116
#define AST_CAUSE_FAILURE
Definition: causes.h:150
#define AST_CAUSE_DESTINATION_OUT_OF_ORDER
Definition: causes.h:115
#define AST_CAUSE_NO_USER_RESPONSE
Definition: causes.h:108
#define AST_CAUSE_NORMAL_TEMPORARY_FAILURE
Definition: causes.h:122
#define AST_CAUSE_NORMAL
Definition: causes.h:151
#define AST_CAUSE_CALL_REJECTED
Definition: causes.h:111
#define AST_CAUSE_FACILITY_REJECTED
Definition: causes.h:117
#define AST_CAUSE_RECOVERY_ON_TIMER_EXPIRE
Definition: causes.h:143
#define AST_CAUSE_NO_ROUTE_DESTINATION
Definition: causes.h:100
#define AST_CAUSE_BUSY
Definition: causes.h:149
#define AST_CAUSE_NO_ANSWER
Definition: causes.h:109
#define AST_CAUSE_USER_BUSY
Definition: causes.h:107
static const char desc[]
Definition: cdr_radius.c:84
static PGresult * result
Definition: cel_pgsql.c:84
static const char type[]
Definition: chan_ooh323.c:109
#define AST_CHANNEL_NAME
Definition: channel.h:171
void ast_party_id_copy(struct ast_party_id *dest, const struct ast_party_id *src)
Copy the source party id information to the destination party id.
Definition: channel.c:1765
Standard Command Line Interface.
#define CLI_SHOWUSAGE
Definition: cli.h:45
#define CLI_SUCCESS
Definition: cli.h:44
int ast_cli_unregister_multiple(struct ast_cli_entry *e, int len)
Unregister multiple commands.
Definition: clicompat.c:30
#define AST_CLI_DEFINE(fn, txt,...)
Definition: cli.h:197
void ast_cli(int fd, const char *fmt,...)
Definition: clicompat.c:6
@ CLI_INIT
Definition: cli.h:152
@ CLI_GENERATE
Definition: cli.h:153
#define CLI_FAILURE
Definition: cli.h:46
#define ast_cli_register_multiple(e, len)
Register multiple commands.
Definition: cli.h:265
#define SENTINEL
Definition: compiler.h:87
int sip_cli_print_global(struct ast_sip_cli_context *context)
void ast_sip_destroy_system(void)
int sip_cli_print_system(struct ast_sip_cli_context *context)
int ast_sip_initialize_system(void)
void ast_sip_initialize_dns(void)
void sip_get_threadpool_options(struct ast_threadpool_options *threadpool_options)
Definition: config_system.c:70
static struct ao2_container * transport_states
char buf[BUFSIZE]
Definition: eagi_proxy.c:66
Generic File Format Support. Should be included by clients of the file handling routines....
#define AST_DIGIT_ANY
Definition: file.h:48
static const char name[]
Definition: format_mp3.c:68
int ast_sip_push_task(struct ast_taskprocessor *serializer, int(*sip_task)(void *), void *task_data)
Pushes a task to SIP servants.
Definition: res_pjsip.c:2099
struct ast_taskprocessor * ast_sip_create_serializer(const char *name)
Create a new serializer for SIP tasks.
Definition: res_pjsip.c:2094
struct ast_taskprocessor * ast_sip_create_serializer_group(const char *name, struct ast_serializer_shutdown_group *shutdown_group)
Create a new serializer for SIP tasks.
Definition: res_pjsip.c:2089
int ast_sip_thread_is_servant(void)
Determine if the current thread is a SIP servant thread.
Definition: res_pjsip.c:2310
int ast_sip_push_task_synchronous(struct ast_taskprocessor *serializer, int(*sip_task)(void *), void *task_data)
Push a task to SIP servants and wait for it to complete.
Definition: res_pjsip.c:2174
int ast_sip_push_task_wait_servant(struct ast_taskprocessor *serializer, int(*sip_task)(void *), void *task_data)
Push a task to SIP servants and wait for it to complete.
Definition: res_pjsip.c:2165
int ast_sip_push_task_wait_serializer(struct ast_taskprocessor *serializer, int(*sip_task)(void *), void *task_data)
Push a task to the serializer and wait for it to complete.
Definition: res_pjsip.c:2179
Support for logging to various files, console and syslog Configuration in file logger....
#define DEBUG_ATLEAST(level)
#define ast_debug(level,...)
Log a DEBUG message.
#define LOG_ERROR
#define ast_verb(level,...)
#define LOG_WARNING
A set of macros to manage forward-linked lists.
#define AST_RWLIST_EMPTY
Definition: linkedlists.h:452
#define AST_RWLIST_REMOVE_CURRENT
Definition: linkedlists.h:570
#define AST_RWLIST_RDLOCK(head)
Read locks a list.
Definition: linkedlists.h:78
#define AST_RWLIST_TRAVERSE_SAFE_BEGIN
Definition: linkedlists.h:545
#define AST_RWLIST_WRLOCK(head)
Write locks a list.
Definition: linkedlists.h:52
#define AST_RWLIST_UNLOCK(head)
Attempts to unlock a read/write based list.
Definition: linkedlists.h:151
#define AST_LIST_TRAVERSE(head, var, field)
Loops over (traverses) the entries in a list.
Definition: linkedlists.h:491
#define AST_RWLIST_HEAD_STATIC(name, type)
Defines a structure to be used to hold a read/write list of specified type, statically initialized.
Definition: linkedlists.h:333
#define AST_RWLIST_INSERT_AFTER
Definition: linkedlists.h:702
#define AST_RWLIST_NEXT
Definition: linkedlists.h:441
#define AST_RWLIST_TRAVERSE_SAFE_END
Definition: linkedlists.h:617
#define AST_RWLIST_TRAVERSE
Definition: linkedlists.h:494
#define AST_RWLIST_INSERT_HEAD
Definition: linkedlists.h:718
#define AST_RWLIST_INSERT_TAIL
Definition: linkedlists.h:741
#define AST_RWLIST_ENTRY
Definition: linkedlists.h:415
#define AST_RWLIST_INSERT_BEFORE_CURRENT
Definition: linkedlists.h:610
Asterisk locking-related definitions:
#define ast_cond_destroy(cond)
Definition: lock.h:202
#define ast_cond_wait(cond, mutex)
Definition: lock.h:205
#define ast_cond_init(cond, attr)
Definition: lock.h:201
#define ast_mutex_init(pmutex)
Definition: lock.h:186
#define ast_mutex_unlock(a)
Definition: lock.h:190
#define SCOPED_LOCK(varname, lock, lockfunc, unlockfunc)
Scoped Locks.
Definition: lock.h:583
pthread_cond_t ast_cond_t
Definition: lock.h:178
#define ast_mutex_destroy(a)
Definition: lock.h:188
#define ast_mutex_lock(a)
Definition: lock.h:189
#define ast_cond_signal(cond)
Definition: lock.h:203
size_t current
Definition: main/cli.c:113
Asterisk module definitions.
@ AST_MODFLAG_LOAD_ORDER
Definition: module.h:331
@ AST_MODFLAG_GLOBAL_SYMBOLS
Definition: module.h:330
#define AST_MODULE_INFO(keystr, flags_to_set, desc, fields...)
Definition: module.h:557
@ AST_MODPRI_CHANNEL_DEPEND
Definition: module.h:340
@ AST_MODULE_SUPPORT_CORE
Definition: module.h:121
#define ASTERISK_GPL_KEY
The text the key() function should return.
Definition: module.h:46
@ AST_MODULE_LOAD_SUCCESS
Definition: module.h:70
@ AST_MODULE_LOAD_DECLINE
Module has failed to load, may be in an inconsistent state.
Definition: module.h:78
def info(msg)
static char * ast_sockaddr_stringify_host(const struct ast_sockaddr *addr)
Wrapper around ast_sockaddr_stringify_fmt() to return an address only, suitable for a URL (with brack...
Definition: netsock2.h:327
@ AST_TRANSPORT_WSS
Definition: netsock2.h:64
@ AST_TRANSPORT_WS
Definition: netsock2.h:63
@ AST_TRANSPORT_UDP
Definition: netsock2.h:60
@ AST_TRANSPORT_TLS
Definition: netsock2.h:62
@ AST_TRANSPORT_TCP
Definition: netsock2.h:61
int ast_sockaddr_parse(struct ast_sockaddr *addr, const char *str, int flags)
Parse an IPv4 or IPv6 address string.
Definition: netsock2.c:230
static int ast_sockaddr_isnull(const struct ast_sockaddr *addr)
Checks if the ast_sockaddr is null. "null" in this sense essentially means uninitialized,...
Definition: netsock2.h:127
#define ast_sockaddr_set_port(addr, port)
Sets the port number of a socket address.
Definition: netsock2.h:532
static struct header_list request_headers
static struct ast_serializer_shutdown_group * shutdown_group
Shutdown group for options serializers.
static int reload(void)
void ast_pjproject_log_intercept_begin(int fd)
Begin PJPROJECT log interception for CLI output.
void ast_pjproject_log_intercept_end(void)
End PJPROJECT log interception for CLI output.
void ast_pjproject_caching_pool_destroy(pj_caching_pool *cp)
Destroy caching pool factory and all cached pools.
void ast_pjproject_caching_pool_init(pj_caching_pool *cp, const pj_pool_factory_policy *policy, pj_size_t max_capacity)
Initialize the caching pool factory.
static const pjsip_method refer_method
Definition: res_pjsip.c:1276
static pjsip_endpoint * ast_pjsip_endpoint
Definition: res_pjsip.c:74
void ast_sip_unregister_supplement(struct ast_sip_supplement *supplement)
Unregister a an supplement to SIP out of dialog processing.
Definition: res_pjsip.c:1476
static pj_sockaddr host_ip_ipv4
Definition: res_pjsip.c:79
int ast_sip_is_media_type_in(pjsip_media_type *a,...)
Check if a media type is in a list of others.
Definition: res_pjsip.c:2228
struct ast_sip_endpoint * ast_sip_get_endpoint(const char *to, int get_default_outbound, char **uri)
Retrieves an endpoint and URI from the "to" string.
Definition: res_pjsip.c:3249
void ast_sip_add_usereqphone(const struct ast_sip_endpoint *endpoint, pj_pool_t *pool, pjsip_uri *uri)
Add 'user=phone' parameter to URI if enabled and user is a phone number.
Definition: res_pjsip.c:930
static int unload_pjsip(void *data)
Definition: res_pjsip.c:3798
static void supplement_outgoing_response(pjsip_tx_data *tdata, struct ast_sip_endpoint *sip_endpoint)
Definition: res_pjsip.c:2374
struct pjsip_param * ast_sip_pjsip_uri_get_other_param(pjsip_uri *uri, const pj_str_t *param_str)
Find an 'other' SIP/SIPS URI parameter by name.
Definition: res_pjsip.c:3511
const pj_str_t * ast_sip_pjsip_uri_get_username(pjsip_uri *uri)
Get the user portion of the pjsip_uri.
Definition: res_pjsip.c:3477
static const pjsip_method info_method
Definition: res_pjsip.c:1274
void ast_sip_unregister_service(pjsip_module *module)
Definition: res_pjsip.c:133
const char * ast_sip_get_host_ip_string(int af)
Retrieve the local host address in string form.
Definition: res_pjsip.c:2493
pj_status_t(* create_dlg_uac)(pjsip_user_agent *ua, pjsip_rx_data *rdata, const pj_str_t *contact, pjsip_dialog **p_dlg)
Definition: res_pjsip.c:1115
static struct ast_sip_outbound_authenticator * registered_outbound_authenticator
Definition: res_pjsip.c:189
pjsip_media_type pjsip_media_type_application_media_control_xml
Definition: res_pjsip.c:3910
static struct ast_cli_entry cli_commands[]
Definition: res_pjsip.c:473
static int create_in_dialog_request(const pjsip_method *method, struct pjsip_dialog *dlg, pjsip_tx_data **tdata)
Definition: res_pjsip.c:1307
int ast_sip_call_codec_str_to_pref(struct ast_flags *pref, const char *pref_str, int is_outgoing)
Convert a call codec preference string to preference flags.
Definition: res_pjsip.c:2577
char * ast_sip_rdata_get_header_value(pjsip_rx_data *rdata, const pj_str_t str)
Get a specific header value from rdata.
Definition: res_pjsip.c:345
pjsip_dialog * ast_sip_create_dialog_uas(const struct ast_sip_endpoint *endpoint, pjsip_rx_data *rdata, pj_status_t *status)
General purpose method for creating a UAS dialog with an endpoint.
Definition: res_pjsip.c:1176
pjsip_media_type pjsip_media_type_application_json
Definition: res_pjsip.c:3909
static char * cli_dump_endpt(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition: res_pjsip.c:371
int ast_sip_requires_authentication(struct ast_sip_endpoint *endpoint, pjsip_rx_data *rdata)
Determine if an incoming request requires authentication.
Definition: res_pjsip.c:163
static struct send_request_data * send_request_data_alloc(struct ast_sip_endpoint *endpoint, void *token, void(*callback)(void *token, pjsip_event *e))
Definition: res_pjsip.c:1534
int ast_sip_send_response(pjsip_response_addr *res_addr, pjsip_tx_data *tdata, struct ast_sip_endpoint *sip_endpoint)
Send a response to an out of dialog request.
Definition: res_pjsip.c:2396
pjsip_generic_string_hdr * ast_sip_add_header2(pjsip_tx_data *tdata, const char *name, const char *value)
Add a header to an outbound SIP message, returning a pointer to the header.
Definition: res_pjsip.c:2023
int ast_copy_pj_str2(char **dest, const pj_str_t *src)
Create and copy a pj_str_t into a standard character buffer.
Definition: res_pjsip.c:2208
int ast_sip_get_host_ip(int af, pj_sockaddr *addr)
Retrieve the local host address in IP form.
Definition: res_pjsip.c:2480
int ast_sip_register_service(pjsip_module *module)
Register a SIP service in Asterisk.
Definition: res_pjsip.c:117
static const pjsip_method * get_pjsip_method(const char *method)
Definition: res_pjsip.c:1296
static int create_out_of_dialog_request(const pjsip_method *method, struct ast_sip_endpoint *endpoint, const char *uri, struct ast_sip_contact *provided_contact, pjsip_tx_data **tdata)
Definition: res_pjsip.c:1325
static void send_request_timer_callback(pj_timer_heap_t *theap, pj_timer_entry *entry)
Definition: res_pjsip.c:1648
static int reload_configuration_task(void *obj)
Definition: res_pjsip.c:3790
int ast_sip_is_allowed_uri(pjsip_uri *uri)
Check whether a pjsip_uri is allowed or not.
Definition: res_pjsip.c:3472
#define MOD_DATA_CONTACT
Definition: res_pjsip.c:66
int ast_sip_register_outbound_authenticator(struct ast_sip_outbound_authenticator *auth)
Register an outbound SIP authenticator.
Definition: res_pjsip.c:191
static struct ast_sip_endpoint * handle_slash(const char *to, char *destination, char **uri, char *slash, char *atsign, char *scheme)
Definition: res_pjsip.c:3034
static struct ast_sip_endpoint * handle_single_token(const char *to, char *destination, int get_default_outbound, char **uri)
Definition: res_pjsip.c:2955
static int ast_sip_push_task_wait(struct ast_taskprocessor *serializer, int(*sip_task)(void *), void *task_data)
Definition: res_pjsip.c:2137
static void send_request_wrapper_destructor(void *obj)
Definition: res_pjsip.c:1688
static pjsip_fromto_hdr * get_id_header(pjsip_rx_data *rdata, const pj_str_t *header_name)
Definition: res_pjsip.c:2673
static int unregister_service(void *data)
Definition: res_pjsip.c:122
static void send_request_data_destroy(void *obj)
Definition: res_pjsip.c:1527
static int uas_use_sips_contact(pjsip_rx_data *rdata)
Determine if a SIPS Contact header is required.
Definition: res_pjsip.c:1089
const int ast_sip_hangup_sip2cause(int cause)
Convert SIP hangup causes to Asterisk hangup causes.
Definition: res_pjsip.c:3531
pj_pool_t * memory_pool
Definition: res_pjsip.c:2262
int ast_sip_rewrite_uri_to_local(pjsip_sip_uri *uri, pjsip_tx_data *tdata)
Replace domain and port of SIP URI to point to (external) signaling address of this Asterisk instance...
Definition: res_pjsip.c:605
int ast_sip_set_id_connected_line(struct pjsip_rx_data *rdata, struct ast_party_id *id)
Set the ID for a connected line update.
Definition: res_pjsip.c:2822
pjsip_media_type pjsip_media_type_application_sdp
Definition: res_pjsip.c:3916
void ast_sip_register_supplement(struct ast_sip_supplement *supplement)
Register a supplement to SIP out of dialog processing.
Definition: res_pjsip.c:1456
void ast_sip_add_date_header(pjsip_tx_data *tdata)
Adds a Date header to the tdata, formatted like: Date: Wed, 01 Jan 2021 14:53:01 GMT.
Definition: res_pjsip.c:90
pjsip_media_type pjsip_media_type_text_plain
Definition: res_pjsip.c:3920
pj_thread_t * monitor_thread
Definition: res_pjsip.c:2263
void ast_sip_unregister_outbound_authenticator(struct ast_sip_outbound_authenticator *auth)
Unregister an outbound SIP authenticator.
Definition: res_pjsip.c:203
int ast_sip_set_id_from_invite(struct pjsip_rx_data *rdata, struct ast_party_id *id, struct ast_party_id *default_id, int trust_inbound)
Set the ID from an INVITE.
Definition: res_pjsip.c:2827
pjsip_media_type pjsip_media_type_application_pidf_xml
Definition: res_pjsip.c:3911
int ast_sip_create_rdata(pjsip_rx_data *rdata, char *packet, const char *src_name, int src_port, char *transport_type, const char *local_name, int local_port)
General purpose method for creating an rdata structure using specific information.
Definition: res_pjsip.c:1266
enum ast_sip_check_auth_result ast_sip_check_authentication(struct ast_sip_endpoint *endpoint, pjsip_rx_data *rdata, pjsip_tx_data *tdata)
Method to determine authentication status of an incoming request.
Definition: res_pjsip.c:179
#define SIP_SERVANT_ID
Definition: res_pjsip.c:2283
pjsip_endpoint * ast_sip_get_pjsip_endpoint(void)
Get a pointer to the PJSIP endpoint.
Definition: res_pjsip.c:520
int ast_sip_register_endpoint_identifier(struct ast_sip_endpoint_identifier *identifier)
Register a SIP endpoint identifier.
Definition: res_pjsip.c:310
static void send_request_cb(void *token, pjsip_event *e)
Definition: res_pjsip.c:1882
void * ast_sip_dict_get(void *ht, const char *key)
Retrieves the value associated with the given key.
Definition: res_pjsip.c:2327
int ast_sip_update_from(pjsip_tx_data *tdata, char *from)
Overwrite fields in the outbound 'From' header.
Definition: res_pjsip.c:3383
static const pjsip_method message_method
Definition: res_pjsip.c:1275
int ast_sip_format_endpoint_ami(struct ast_sip_endpoint *endpoint, struct ast_sip_ami *ami, int *count)
Formats the endpoint and sends over AMI.
Definition: res_pjsip.c:501
int ast_sip_dtmf_to_str(const enum ast_sip_dtmf_mode dtmf, char *buf, size_t buf_len)
Convert the DTMF mode enum value into a string.
Definition: res_pjsip.c:2504
int ast_sip_str2rc(const char *name)
Convert name to SIP response code.
Definition: res_pjsip.c:3714
static struct ast_threadpool * sip_threadpool
Definition: res_pjsip.c:76
int ast_sip_set_tpselector_from_transport(const struct ast_sip_transport *transport, pjsip_tpselector *selector)
Sets pjsip_tpselector from ast_sip_transport.
Definition: res_pjsip.c:843
int ast_sip_is_uri_sip_sips(pjsip_uri *uri)
Check whether a pjsip_uri is SIP/SIPS or not.
Definition: res_pjsip.c:3467
int ast_sip_set_tpselector_from_ep_or_uri(const struct ast_sip_endpoint *endpoint, pjsip_sip_uri *sip_uri, pjsip_tpselector *selector)
Sets pjsip_tpselector from an endpoint or uri.
Definition: res_pjsip.c:911
#define DEBUG_BUF_SIZE
static int check_request_status(struct send_request_data *req_data, pjsip_event *e)
Definition: res_pjsip.c:1839
static void sip_thread_start(void)
Definition: res_pjsip.c:2285
static char * cli_show_endpoint_identifiers(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition: res_pjsip.c:411
static struct @450 methods[]
static void clean_contact_from_tdata(pjsip_tx_data *tdata)
Definition: res_pjsip.c:2415
void ast_sip_unregister_endpoint_identifier(struct ast_sip_endpoint_identifier *identifier)
Unregister a SIP endpoint identifier.
Definition: res_pjsip.c:315
static int reload_module(void)
Definition: res_pjsip.c:4058
void ast_copy_pj_str(char *dest, const pj_str_t *src, size_t size)
Copy a pj_str_t into a standard character buffer.
Definition: res_pjsip.c:2201
static int send_in_dialog_request(pjsip_tx_data *tdata, struct pjsip_dialog *dlg)
Definition: res_pjsip.c:1490
static int insert_user_in_contact_uri(const char *to, const char *endpoint_name, const char *aors, const char *user, char **uri)
Find a contact and insert a "user@" into its URI.
Definition: res_pjsip.c:2890
#define SERIALIZER_POOL_SIZE
Definition: res_pjsip.c:69
const char * ast_sip_call_codec_pref_to_str(struct ast_flags pref)
Convert the call codec preference flags to a string.
Definition: res_pjsip.c:2554
struct ast_sip_endpoint * ast_sip_identify_endpoint(pjsip_rx_data *rdata)
Determine the endpoint that has sent a SIP message.
Definition: res_pjsip.c:330
int ast_sip_send_out_of_dialog_request(pjsip_tx_data *tdata, struct ast_sip_endpoint *endpoint, int timeout, void *token, void(*callback)(void *token, pjsip_event *e))
General purpose method for sending an Out-Of-Dialog SIP request.
Definition: res_pjsip.c:1938
static struct ast_sip_endpoint * handle_atsign(const char *to, char *destination, char **uri, char *slash, char *atsign, char *scheme, int get_default_outbound)
Definition: res_pjsip.c:3191
pjsip_dialog * ast_sip_create_dialog_uas_locked(const struct ast_sip_endpoint *endpoint, pjsip_rx_data *rdata, pj_status_t *status)
General purpose method for creating a UAS dialog with an endpoint.
Definition: res_pjsip.c:1192
pjsip_media_type pjsip_media_type_application_simple_message_summary
Definition: res_pjsip.c:3915
struct ast_sip_transport_state * ast_sip_find_transport_state_in_use(struct ast_sip_request_transport_details *details)
Returns the transport state currently in use based on request transport details.
Definition: res_pjsip.c:595
static char host_ip_ipv6_string[PJ_INET6_ADDRSTRLEN]
Definition: res_pjsip.c:88
static struct ast_threadstorage pj_thread_storage
Definition: res_pjsip.c:2281
int ast_sip_dlg_set_transport(const struct ast_sip_endpoint *endpoint, pjsip_dialog *dlg, pjsip_tpselector *selector)
Set the transport on a dialog.
Definition: res_pjsip.c:727
static pj_sockaddr host_ip_ipv6
Definition: res_pjsip.c:85
pjsip_dialog * ast_sip_create_dialog_uac(const struct ast_sip_endpoint *endpoint, const char *uri, const char *request_user)
General purpose method for creating a UAC dialog with an endpoint.
Definition: res_pjsip.c:964
const char * method
Definition: res_pjsip.c:1279
static pj_status_t endpt_send_request(struct ast_sip_endpoint *endpoint, pjsip_tx_data *tdata, pj_int32_t timeout, void *token, pjsip_endpt_send_callback cb)
Definition: res_pjsip.c:1696
void ast_sip_unregister_authenticator(struct ast_sip_authenticator *auth)
Unregister a SIP authenticator.
Definition: res_pjsip.c:152
int ast_sip_send_request(pjsip_tx_data *tdata, struct pjsip_dialog *dlg, struct ast_sip_endpoint *endpoint, void *token, void(*callback)(void *token, pjsip_event *e))
General purpose method for sending a SIP request.
Definition: res_pjsip.c:1979
long ast_sip_threadpool_queue_size(void)
Return the size of the SIP threadpool's task queue.
Definition: res_pjsip.c:3457
int ast_sip_set_request_transport_details(struct ast_sip_request_transport_details *details, pjsip_tx_data *tdata, int use_ipv6)
Sets request transport details based on tdata.
Definition: res_pjsip.c:648
static pj_bool_t supplement_on_rx_request(pjsip_rx_data *rdata)
Definition: res_pjsip.c:2350
static pjsip_msg_body * ast_body_to_pjsip_body(pj_pool_t *pool, const struct ast_sip_body *body)
Definition: res_pjsip.c:2039
void ast_sip_register_endpoint_formatter(struct ast_sip_endpoint_formatter *obj)
Register an endpoint formatter.
Definition: res_pjsip.c:481
int ast_sip_add_body(pjsip_tx_data *tdata, const struct ast_sip_body *body)
Add a body to an outbound SIP message.
Definition: res_pjsip.c:2052
void * ast_sip_dict_set(pj_pool_t *pool, void *ht, const char *key, void *val)
Set the value for the given key.
Definition: res_pjsip.c:2338
int ast_sip_are_media_types_equal(pjsip_media_type *a, pjsip_media_type *b)
Compare pjsip media types.
Definition: res_pjsip.c:2219
void ast_sip_tpselector_unref(pjsip_tpselector *selector)
Unreference a pjsip_tpselector.
Definition: res_pjsip.c:923
void never_called_res_pjsip(void)
Definition: res_pjsip.c:3903
int ast_sip_get_transport_name(const struct ast_sip_endpoint *endpoint, pjsip_sip_uri *sip_uri, char *buf, size_t buf_len)
Get the transport name from an endpoint or request uri.
Definition: res_pjsip.c:698
static int set_id_from_from(struct pjsip_rx_data *rdata, struct ast_party_id *id)
Definition: res_pjsip.c:2803
void ast_sip_unregister_endpoint_formatter(struct ast_sip_endpoint_formatter *obj)
Unregister an endpoint formatter.
Definition: res_pjsip.c:487
static void * monitor_thread_exec(void *endpt)
Definition: res_pjsip.c:2266
static char * cli_show_settings(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition: res_pjsip.c:442
int ast_sip_register_authenticator(struct ast_sip_authenticator *auth)
Register a SIP authenticator.
Definition: res_pjsip.c:140
int ast_sip_create_rdata_with_contact(pjsip_rx_data *rdata, char *packet, const char *src_name, int src_port, char *transport_type, const char *local_name, int local_port, const char *contact)
General purpose method for creating an rdata structure using specific information.
Definition: res_pjsip.c:1214
int ast_sip_add_body_multipart(pjsip_tx_data *tdata, const struct ast_sip_body *bodies[], int num_bodies)
Add a multipart body to an outbound SIP message.
Definition: res_pjsip.c:2059
static pjsip_dialog * create_dialog_uas(const struct ast_sip_endpoint *endpoint, pjsip_rx_data *rdata, pj_status_t *status, create_dlg_uac create_fun)
Definition: res_pjsip.c:1118
pjsip_media_type pjsip_media_type_application_rlmi_xml
Definition: res_pjsip.c:3914
static int monitor_continue
Definition: res_pjsip.c:2264
static const struct response_code_map rc_map[]
Definition: res_pjsip.c:3634
static void remove_request_headers(pjsip_endpoint *endpt)
Definition: res_pjsip.c:3445
int ast_sip_update_to_uri(pjsip_tx_data *tdata, const char *to)
Replace the To URI in the tdata with the supplied one.
Definition: res_pjsip.c:3323
pjsip_media_type pjsip_media_type_multipart_mixed
Definition: res_pjsip.c:3918
static int register_service(void *data)
Definition: res_pjsip.c:102
pjsip_media_type pjsip_media_type_application_xpidf_xml
Definition: res_pjsip.c:3912
static int load_module(void)
Definition: res_pjsip.c:3922
int ast_sip_set_outbound_proxy(pjsip_tx_data *tdata, const char *proxy)
Set the outbound proxy for an outbound SIP message.
Definition: res_pjsip.c:1992
static struct ast_sip_authenticator * registered_authenticator
Definition: res_pjsip.c:138
struct ast_threadpool * ast_sip_threadpool(void)
Retrieve the SIP threadpool object.
Definition: res_pjsip.c:3462
int ast_sip_will_uri_survive_restart(pjsip_sip_uri *uri, struct ast_sip_endpoint *endpoint, pjsip_rx_data *rdata)
Definition: res_pjsip.c:525
int ast_sip_register_endpoint_identifier_with_name(struct ast_sip_endpoint_identifier *identifier, const char *name)
Register a SIP endpoint identifier with a name.
Definition: res_pjsip.c:233
pjsip_media_type pjsip_media_type_multipart_alternative
Definition: res_pjsip.c:3917
int ast_sip_set_tpselector_from_transport_name(const char *transport_name, pjsip_tpselector *selector)
Sets pjsip_tpselector from ast_sip_transport.
Definition: res_pjsip.c:893
int ast_sip_create_request(const char *method, struct pjsip_dialog *dlg, struct ast_sip_endpoint *endpoint, const char *uri, struct ast_sip_contact *contact, pjsip_tx_data **tdata)
General purpose method for creating a SIP request.
Definition: res_pjsip.c:1435
pj_caching_pool caching_pool
Definition: res_pjsip.c:2261
static int find_transport_state_in_use(void *obj, void *arg, int flags)
Callback function for finding the transport the request is going out on.
Definition: res_pjsip.c:576
static void endpt_send_request_cb(void *token, pjsip_event *e)
Definition: res_pjsip.c:1573
const pjsip_method * pmethod
Definition: res_pjsip.c:1280
int ast_sip_str_to_dtmf(const char *dtmf_mode)
Convert the DTMF mode name into an enum.
Definition: res_pjsip.c:2533
static int do_cli_dump_endpt(void *v_a)
Definition: res_pjsip.c:360
int ast_sip_add_header(pjsip_tx_data *tdata, const char *name, const char *value)
Add a header to an outbound SIP message.
Definition: res_pjsip.c:2008
static int unload_module(void)
Definition: res_pjsip.c:4072
const pj_str_t * ast_sip_pjsip_uri_get_hostname(pjsip_uri *uri)
Get the host portion of the pjsip_uri.
Definition: res_pjsip.c:3496
static pjsip_module supplement_module
Definition: res_pjsip.c:1318
static void pool_destroy_callback(void *arg)
Definition: res_pjsip.c:2409
static char host_ip_ipv4_string[PJ_INET6_ADDRSTRLEN]
Definition: res_pjsip.c:82
static int load_pjsip(void)
Definition: res_pjsip.c:3842
static pj_bool_t does_method_match(const pj_str_t *message_method, const char *supplement_method)
Definition: res_pjsip.c:1499
static struct ast_threadstorage servant_id_storage
Definition: res_pjsip.c:2282
int ast_sip_send_stateful_response(pjsip_rx_data *rdata, pjsip_tx_data *tdata, struct ast_sip_endpoint *sip_endpoint)
Send a stateful response to an out of dialog request.
Definition: res_pjsip.c:2424
int ast_sip_is_content_type(pjsip_media_type *content_type, char *type, char *subtype)
Checks if the given content type matches type/subtype.
Definition: res_pjsip.c:2248
#define TIMER_INACTIVE
Definition: res_pjsip.c:1512
int ast_sip_append_body(pjsip_tx_data *tdata, const char *body_text)
Append body data to a SIP message.
Definition: res_pjsip.c:2075
static int set_id_from_pai(pjsip_rx_data *rdata, struct ast_party_id *id)
Definition: res_pjsip.c:2710
#define TIMEOUT_TIMER2
Definition: res_pjsip.c:1513
#define ENDPOINT_IDENTIFIER_FORMAT
int ast_sip_create_request_with_auth(const struct ast_sip_auth_vector *auths, pjsip_rx_data *challenge, pjsip_tx_data *old_request, pjsip_tx_data **new_request)
Create a response to an authentication challenge.
Definition: res_pjsip.c:214
pjsip_media_type pjsip_media_type_application_cpim_xpidf_xml
Definition: res_pjsip.c:3913
static void set_id_from_hdr(pjsip_fromto_hdr *hdr, struct ast_party_id *id)
Definition: res_pjsip.c:2606
static int set_id_from_rpid(pjsip_rx_data *rdata, struct ast_party_id *id)
Definition: res_pjsip.c:2751
static void stop_monitor_thread(void)
Definition: res_pjsip.c:2275
pjsip_sip_uri * ast_sip_get_contact_sip_uri(pjsip_tx_data *tdata)
Return the SIP URI of the Contact header.
Definition: res_pjsip.c:564
static int sync_task(void *data)
Definition: res_pjsip.c:2117
pjsip_media_type pjsip_media_type_multipart_related
Definition: res_pjsip.c:3919
static struct ast_serializer_pool * sip_serializer_pool
Definition: res_pjsip.c:72
int ast_sip_failover_request(pjsip_tx_data *tdata)
Set a request to use the next value in the list of resolved addresses.
Definition: res_pjsip.c:1816
static int sip_dialog_create_from(pj_pool_t *pool, pj_str_t *from, const char *user, const char *domain, const pj_str_t *target, pjsip_tpselector *selector)
Definition: res_pjsip.c:749
void ast_sip_modify_id_header(pj_pool_t *pool, pjsip_fromto_hdr *id_hdr, const struct ast_party_id *id)
Set name and number information on an identity header.
Definition: res_pjsip.c:2850
int ast_sip_create_response(const pjsip_rx_data *rdata, int st_code, struct ast_sip_contact *contact, pjsip_tx_data **tdata)
General purpose method for creating a SIP response.
Definition: res_pjsip.c:2468
char * ast_sip_get_endpoint_identifier_order(void)
Retrieve the global endpoint_identifier_order setting.
struct ast_sip_contact * ast_sip_location_retrieve_contact_from_aor_list(const char *aor_list)
Retrieve the first bound contact from a list of AORs.
Definition: location.c:304
struct ao2_container * ast_sip_get_transport_states(void)
Retrieves all transport states.
struct ast_sip_aor * ast_sip_location_retrieve_aor(const char *aor_name)
Retrieve a named AOR.
Definition: location.c:147
#define ast_sip_call_codec_pref_test(__param, __codec_pref)
Returns true if the preference is set in the parameter.
Definition: res_pjsip.h:697
void ast_sip_message_apply_transport(const char *transport_name, pjsip_tx_data *tdata)
Apply the configuration for a transport to an outgoing message.
#define AST_SIP_X_AST_TXP
Definition: res_pjsip.h:1076
#define AST_SIP_USER_OPTIONS_TRUNCATE_CHECK(str)
Truncate the URI user field options string if enabled.
Definition: res_pjsip.h:3349
struct ast_sip_endpoint * ast_pjsip_rdata_get_endpoint(pjsip_rx_data *rdata)
Get the looked-up endpoint on an out-of dialog request or response.
struct ast_sip_endpoint * ast_sip_default_outbound_endpoint(void)
Retrieve the default outbound endpoint.
#define ast_sip_mod_data_set(pool, mod_data, id, key, val)
Utilizing a mod_data array for a given id, set the value associated with the given key.
Definition: res_pjsip.h:2978
unsigned int ast_sip_get_disable_multi_domain(void)
Retrieve the system setting 'disable multi domain'.
ast_sip_dtmf_mode
DTMF modes for SIP endpoints.
Definition: res_pjsip.h:543
@ AST_SIP_DTMF_NONE
Definition: res_pjsip.h:545
@ AST_SIP_DTMF_AUTO_INFO
Definition: res_pjsip.h:556
@ AST_SIP_DTMF_AUTO
Definition: res_pjsip.h:554
@ AST_SIP_DTMF_INBAND
Definition: res_pjsip.h:550
@ AST_SIP_DTMF_INFO
Definition: res_pjsip.h:552
@ AST_SIP_DTMF_RFC_4733
Definition: res_pjsip.h:548
static const pj_str_t AST_PJ_STR_EMPTY
Definition: res_pjsip.h:114
#define ast_sip_mod_data_get(mod_data, id, key)
Using the dictionary stored in mod_data array at a given id, retrieve the value associated with the g...
Definition: res_pjsip.h:2946
struct ast_sip_transport_state * ast_sip_get_transport_state(const char *transport_id)
Retrieve transport state.
struct ast_sorcery * ast_sip_get_sorcery(void)
Get a pointer to the SIP sorcery structure.
#define MAX_RX_CHALLENGES
Definition: res_pjsip.h:110
ast_sip_check_auth_result
Possible returns from ast_sip_check_authentication.
Definition: res_pjsip.h:1227
@ AST_SIP_AUTHENTICATION_SUCCESS
Definition: res_pjsip.h:1231
@ AST_SIP_CALL_CODEC_PREF_ALL
Definition: res_pjsip.h:677
@ AST_SIP_CALL_CODEC_PREF_LOCAL
Definition: res_pjsip.h:683
@ AST_SIP_CALL_CODEC_PREF_REMOTE
Definition: res_pjsip.h:685
@ AST_SIP_CALL_CODEC_PREF_UNION
Definition: res_pjsip.h:673
@ AST_SIP_CALL_CODEC_PREF_FIRST
Definition: res_pjsip.h:679
@ AST_SIP_CALL_CODEC_PREF_INTERSECT
Definition: res_pjsip.h:671
#define AST_SIP_X_AST_TXP_LEN
Definition: res_pjsip.h:1077
#define PJSTR_PRINTF_VAR(_v)
Definition: res_pjsip.h:72
void ast_sip_get_default_from_user(char *from_user, size_t size)
Retrieve the global default from user.
struct ast_sip_contact * ast_sip_location_retrieve_first_aor_contact(const struct ast_sip_aor *aor)
Retrieve the first bound contact for an AOR.
Definition: location.c:194
void ast_sip_location_prune_boot_contacts(void)
Prune the prune_on_boot contacts.
Definition: location.c:469
#define ast_sip_transport_is_local(transport_state, addr)
Definition: res_pjsip.h:215
#define PJSTR_PRINTF_SPEC
Definition: res_pjsip.h:71
static void challenge(const char *realm, pjsip_tx_data *tdata, const pjsip_rx_data *rdata, int is_stale)
astobj2 callback for adding digest challenges to responses
void ast_sip_sanitize_xml(const char *input, char *output, size_t len)
Replace offensive XML characters with XML entities.
Definition: presence_xml.c:29
int ast_sip_initialize_scheduler(void)
Initialize scheduler.
int ast_res_pjsip_preinit_options_handling(void)
int ast_sip_initialize_transport_management(void)
void ast_sip_initialize_resolver(void)
int ast_res_pjsip_init_options_handling(int reload)
int ast_sip_initialize_distributor(void)
int ast_res_pjsip_reload_configuration(void)
int ast_sip_destroy_scheduler(void)
void ast_sip_initialize_global_headers(void)
void ast_res_pjsip_cleanup_options_handling(void)
void ast_sip_destroy_transport_management(void)
int ast_sip_initialize_transport_events(void)
void ast_sip_destroy_distributor(void)
int ast_res_pjsip_initialize_configuration(void)
void ast_sip_destroy_global_headers(void)
void ast_res_pjsip_destroy_configuration(void)
int ast_res_pjsip_init_message_filter(void)
void ast_sip_destroy_transport_events(void)
void ast_res_pjsip_cleanup_message_filter(void)
const pjsip_method pjsip_publish_method
Defined method for PUBLISH.
#define NULL
Definition: resample.c:96
struct ast_taskprocessor * ast_serializer_pool_get(struct ast_serializer_pool *pool)
Retrieve a serializer from the pool.
Definition: serializer.c:127
struct ast_serializer_pool * ast_serializer_pool_create(const char *name, unsigned int size, struct ast_threadpool *threadpool, int timeout)
Create a serializer pool.
Definition: serializer.c:76
int ast_serializer_pool_destroy(struct ast_serializer_pool *pool)
Destroy the serializer pool.
Definition: serializer.c:39
Sorcery Data Access Layer API.
const char * ast_sorcery_object_get_id(const void *object)
Get the unique identifier of a sorcery object.
Definition: sorcery.c:2317
void * ast_sorcery_retrieve_by_id(const struct ast_sorcery *sorcery, const char *type, const char *id)
Retrieve an object using its unique identifier.
Definition: sorcery.c:1853
String manipulation functions.
char * ast_str_buffer(const struct ast_str *buf)
Returns the string buffer within the ast_str buf.
Definition: strings.h:761
#define S_OR(a, b)
returns the equivalent of logic or for strings: first one if not empty, otherwise second one.
Definition: strings.h:80
static force_inline int attribute_pure ast_strlen_zero(const char *s)
Definition: strings.h:65
#define ast_str_alloca(init_len)
Definition: strings.h:848
#define ast_str_create(init_len)
Create a malloc'ed dynamic length string.
Definition: strings.h:659
int ast_str_set(struct ast_str **buf, ssize_t max_len, const char *fmt,...)
Set a dynamic string using variable arguments.
Definition: strings.h:1113
void ast_copy_string(char *dst, const char *src, size_t size)
Size-limited null-terminating string copy.
Definition: strings.h:425
static int force_inline attribute_pure ast_begins_with(const char *str, const char *prefix)
Checks whether a string begins with another.
Definition: strings.h:97
Generic container type.
descriptor for a cli entry.
Definition: cli.h:171
struct ast_cli_entry * next
Definition: cli.h:189
char * command
Definition: cli.h:186
const char * usage
Definition: cli.h:177
Structure used to handle boolean flags.
Definition: utils.h:199
unsigned int flags
Definition: utils.h:200
Structure for mutex and tracking information.
Definition: lock.h:135
Information needed to identify an endpoint in a call.
Definition: channel.h:338
char * tag
User-set "tag".
Definition: channel.h:354
struct ast_party_number number
Subscriber phone number.
Definition: channel.h:342
unsigned char valid
TRUE if the number information is valid/present.
Definition: channel.h:297
AMI variable container.
Definition: res_pjsip.h:3045
A SIP address of record.
Definition: res_pjsip.h:478
An interchangeable way of handling digest authentication for SIP.
Definition: res_pjsip.h:1245
enum ast_sip_check_auth_result(* check_authentication)(struct ast_sip_endpoint *endpoint, pjsip_rx_data *rdata, pjsip_tx_data *tdata)
Check that an incoming request passes authentication.
Definition: res_pjsip.h:1260
int(* requires_authentication)(struct ast_sip_endpoint *endpoint, pjsip_rx_data *rdata)
Check if a request requires authentication See ast_sip_requires_authentication for more details.
Definition: res_pjsip.h:1250
SIP body description.
Definition: res_pjsip.h:2323
const char * type
Definition: res_pjsip.h:2325
const char * body_text
Definition: res_pjsip.h:2329
const char * subtype
Definition: res_pjsip.h:2327
CLI Formatter Context passed to all formatters.
Definition: res_pjsip_cli.h:34
Contact associated with an address of record.
Definition: res_pjsip.h:392
const ast_string_field uri
Definition: res_pjsip.h:414
struct ast_sip_endpoint * endpoint
Definition: res_pjsip.h:424
const ast_string_field endpoint_name
Definition: res_pjsip.h:414
An entity responsible formatting endpoint information.
Definition: res_pjsip.h:3071
int(* format_ami)(const struct ast_sip_endpoint *endpoint, struct ast_sip_ami *ami)
Callback used to format endpoint information over AMI.
Definition: res_pjsip.h:3075
An entity responsible for identifying the source of a SIP message.
Definition: res_pjsip.h:1288
struct ast_sip_endpoint *(* identify_endpoint)(pjsip_rx_data *rdata)
Callback used to identify the source of a message. See ast_sip_identify_endpoint for more details.
Definition: res_pjsip.h:1293
An entity with which Asterisk communicates.
Definition: res_pjsip.h:961
struct ast_sip_auth_vector outbound_auths
Definition: res_pjsip.h:1008
char * contact_user
Definition: