Asterisk - The Open Source Telephony Project  21.4.1
res_pjsip.c
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"
32 #include "res_pjsip/include/res_pjsip_private.h"
33 #include "asterisk/linkedlists.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"
41 #include "asterisk/taskprocessor.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"
48 #include "asterisk/res_pjsip_cli.h"
49 #include "asterisk/test.h"
50 #include "asterisk/res_pjsip_presence_xml.h"
51 #include "asterisk/res_pjproject.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. */
72 static struct ast_serializer_pool *sip_serializer_pool;
73 
74 static pjsip_endpoint *ast_pjsip_endpoint;
75 
76 static struct ast_threadpool *sip_threadpool;
77 
78 /*! Local host address for IPv4 */
79 static pj_sockaddr host_ip_ipv4;
80 
81 /*! Local host address for IPv4 (string form) */
82 static char host_ip_ipv4_string[PJ_INET6_ADDRSTRLEN];
83 
84 /*! Local host address for IPv6 */
85 static pj_sockaddr host_ip_ipv6;
86 
87 /*! Local host address for IPv6 (string form) */
88 static char host_ip_ipv6_string[PJ_INET6_ADDRSTRLEN];
89 
90 void 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 
102 static 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 
117 int ast_sip_register_service(pjsip_module *module)
118 {
119  return ast_sip_push_task_wait_servant(NULL, register_service, &module);
120 }
121 
122 static 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 
133 void ast_sip_unregister_service(pjsip_module *module)
134 {
135  ast_sip_push_task_wait_servant(NULL, unregister_service, &module);
136 }
137 
138 static struct ast_sip_authenticator *registered_authenticator;
139 
140 int ast_sip_register_authenticator(struct ast_sip_authenticator *auth)
141 {
142  if (registered_authenticator) {
143  ast_log(LOG_WARNING, "Authenticator %p is already registered. Cannot register a new one\n", registered_authenticator);
144  return -1;
145  }
146  registered_authenticator = auth;
147  ast_debug(1, "Registered SIP authenticator module %p\n", auth);
148 
149  return 0;
150 }
151 
152 void ast_sip_unregister_authenticator(struct ast_sip_authenticator *auth)
153 {
154  if (registered_authenticator != auth) {
155  ast_log(LOG_WARNING, "Trying to unregister authenticator %p but authenticator %p registered\n",
156  auth, registered_authenticator);
157  return;
158  }
159  registered_authenticator = NULL;
160  ast_debug(1, "Unregistered SIP authenticator %p\n", auth);
161 }
162 
163 int ast_sip_requires_authentication(struct ast_sip_endpoint *endpoint, pjsip_rx_data *rdata)
164 {
165  if (endpoint->allow_unauthenticated_options
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 
171  if (!registered_authenticator) {
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 
179 enum ast_sip_check_auth_result ast_sip_check_authentication(struct ast_sip_endpoint *endpoint,
180  pjsip_rx_data *rdata, pjsip_tx_data *tdata)
181 {
182  if (!registered_authenticator) {
183  ast_log(LOG_WARNING, "No SIP authenticator registered. Assuming authentication is successful\n");
184  return AST_SIP_AUTHENTICATION_SUCCESS;
185  }
186  return registered_authenticator->check_authentication(endpoint, rdata, tdata);
187 }
188 
189 static struct ast_sip_outbound_authenticator *registered_outbound_authenticator;
190 
191 int ast_sip_register_outbound_authenticator(struct ast_sip_outbound_authenticator *auth)
192 {
193  if (registered_outbound_authenticator) {
194  ast_log(LOG_WARNING, "Outbound authenticator %p is already registered. Cannot register a new one\n", registered_outbound_authenticator);
195  return -1;
196  }
197  registered_outbound_authenticator = auth;
198  ast_debug(1, "Registered SIP outbound authenticator module %p\n", auth);
199 
200  return 0;
201 }
202 
203 void ast_sip_unregister_outbound_authenticator(struct ast_sip_outbound_authenticator *auth)
204 {
205  if (registered_outbound_authenticator != auth) {
206  ast_log(LOG_WARNING, "Trying to unregister outbound authenticator %p but outbound authenticator %p registered\n",
207  auth, registered_outbound_authenticator);
208  return;
209  }
210  registered_outbound_authenticator = NULL;
211  ast_debug(1, "Unregistered SIP outbound authenticator %p\n", auth);
212 }
213 
214 int 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 {
217  if (!registered_outbound_authenticator) {
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;
227  struct ast_sip_endpoint_identifier *identifier;
228  AST_RWLIST_ENTRY(endpoint_identifier_list) list;
229 };
230 
232 
233 int ast_sip_register_endpoint_identifier_with_name(struct ast_sip_endpoint_identifier *identifier,
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 
293  AST_RWLIST_TRAVERSE_SAFE_BEGIN(&endpoint_identifiers, iter, list) {
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  }
304  AST_RWLIST_TRAVERSE_SAFE_END;
305 
306  ast_free(identifier_order);
307  return 0;
308 }
309 
310 int ast_sip_register_endpoint_identifier(struct ast_sip_endpoint_identifier *identifier)
311 {
312  return ast_sip_register_endpoint_identifier_with_name(identifier, NULL);
313 }
314 
315 void ast_sip_unregister_endpoint_identifier(struct ast_sip_endpoint_identifier *identifier)
316 {
317  struct endpoint_identifier_list *iter;
319  AST_RWLIST_TRAVERSE_SAFE_BEGIN(&endpoint_identifiers, iter, list) {
320  if (iter->identifier == identifier) {
321  AST_RWLIST_REMOVE_CURRENT(list);
322  ast_free(iter);
323  ast_debug(1, "Unregistered endpoint identifier %p\n", identifier);
324  break;
325  }
326  }
327  AST_RWLIST_TRAVERSE_SAFE_END;
328 }
329 
330 struct 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;
335  AST_RWLIST_TRAVERSE(&endpoint_identifiers, iter, list) {
336  ast_assert(iter->identifier->identify_endpoint != NULL);
337  endpoint = iter->identifier->identify_endpoint(rdata);
338  if (endpoint) {
339  break;
340  }
341  }
342  return endpoint;
343 }
344 
345 char *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 
360 static 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 
371 static 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 
406  ast_sip_push_task_wait_servant(NULL, do_cli_dump_endpt, a);
407 
408  return CLI_SUCCESS;
409 }
410 
411 static 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  {
433  AST_RWLIST_TRAVERSE(&endpoint_identifiers, iter, list) {
434  ast_cli(a->fd, ENDPOINT_IDENTIFIER_FORMAT,
435  iter->name ? iter->name : "name not specified");
436  }
437  }
438  return CLI_SUCCESS;
439 #undef ENDPOINT_IDENTIFIER_FORMAT
440 }
441 
442 static char *cli_show_settings(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
443 {
444  struct ast_sip_cli_context context;
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 
462  if (sip_cli_print_global(&context) || sip_cli_print_system(&context)) {
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 
473 static 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 
481 void ast_sip_register_endpoint_formatter(struct ast_sip_endpoint_formatter *obj)
482 {
484  AST_RWLIST_INSERT_TAIL(&endpoint_formatters, obj, next);
485 }
486 
487 void ast_sip_unregister_endpoint_formatter(struct ast_sip_endpoint_formatter *obj)
488 {
489  struct ast_sip_endpoint_formatter *i;
491 
492  AST_RWLIST_TRAVERSE_SAFE_BEGIN(&endpoint_formatters, i, next) {
493  if (i == obj) {
494  AST_RWLIST_REMOVE_CURRENT(next);
495  break;
496  }
497  }
498  AST_RWLIST_TRAVERSE_SAFE_END;
499 }
500 
501 int ast_sip_format_endpoint_ami(struct ast_sip_endpoint *endpoint,
502  struct ast_sip_ami *ami, int *count)
503 {
504  int res = 0;
505  struct ast_sip_endpoint_formatter *i;
507  *count = 0;
508  AST_RWLIST_TRAVERSE(&endpoint_formatters, i, next) {
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 
520 pjsip_endpoint *ast_sip_get_pjsip_endpoint(void)
521 {
522  return ast_pjsip_endpoint;
523 }
524 
525 int 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 
564 pjsip_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 */
576 static 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 
595 struct ast_sip_transport_state *ast_sip_find_transport_state_in_use(struct ast_sip_request_transport_details *details) {
596  RAII_VAR(struct ao2_container *, transport_states, NULL, ao2_cleanup);
597 
598  if (!(transport_states = ast_sip_get_transport_states())) {
599  return NULL;
600  }
601 
602  return ao2_callback(transport_states, 0, find_transport_state_in_use, details);
603 }
604 
605 int ast_sip_rewrite_uri_to_local(pjsip_sip_uri *uri, pjsip_tx_data *tdata) {
606  RAII_VAR(struct ast_sip_transport *, transport, NULL, ao2_cleanup);
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 
648 int ast_sip_set_request_transport_details(struct ast_sip_request_transport_details *details, pjsip_tx_data *tdata,
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 
698 int ast_sip_get_transport_name(const struct ast_sip_endpoint *endpoint,
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);
718  if (!ast_sockaddr_parse(NULL, host, PARSE_PORT_FORBID)) {
719  return -1;
720  }
721 
722  ast_copy_pj_str(buf, &x_transport->value, buf_len);
723 
724  return 0;
725 }
726 
727 int 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) {
743  ast_sip_tpselector_unref(&sel);
744  }
745 
746  return 0;
747 }
748 
749 static 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 
843 int 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 
848  transport_state = ast_sip_get_transport_state(ast_sorcery_object_get_id(transport));
849  if (!transport_state) {
850  ast_log(LOG_ERROR, "Unable to retrieve PJSIP transport state for '%s'\n",
851  ast_sorcery_object_get_id(transport));
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",
878  ast_sorcery_object_get_id(transport));
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 
893 int ast_sip_set_tpselector_from_transport_name(const char *transport_name, pjsip_tpselector *selector)
894 {
895  RAII_VAR(struct ast_sip_transport *, transport, NULL, ao2_cleanup);
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 
908  return ast_sip_set_tpselector_from_transport(transport, selector);
909 }
910 
911 int ast_sip_set_tpselector_from_ep_or_uri(const struct ast_sip_endpoint *endpoint,
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 
923 void 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 
930 void 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 
964 pjsip_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) {
993  ast_log(LOG_ERROR,
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) {
1018  ast_log(LOG_ERROR,
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  */
1089 static 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 
1115 typedef 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 
1118 static 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 
1128  ast_assert(status != NULL);
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 
1176 pjsip_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 
1192 pjsip_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 
1214 int 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 
1266 int 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 */
1274 static const pjsip_method info_method = {PJSIP_OTHER_METHOD, {"INFO", 4} };
1275 static const pjsip_method message_method = {PJSIP_OTHER_METHOD, {"MESSAGE", 7} };
1276 static const pjsip_method refer_method = {PJSIP_OTHER_METHOD, {"REFER", 5} };
1277 
1278 static 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 },
1294 };
1295 
1296 static 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 
1307 static 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 
1317 static pj_bool_t supplement_on_rx_request(pjsip_rx_data *rdata);
1318 static 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 
1325 static 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) {
1343  contact = ast_sip_location_retrieve_contact_from_aor_list(endpoint->aors);
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 
1435 int 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 
1456 void ast_sip_register_supplement(struct ast_sip_supplement *supplement)
1457 {
1458  struct ast_sip_supplement *iter;
1459  int inserted = 0;
1461 
1462  AST_RWLIST_TRAVERSE_SAFE_BEGIN(&supplements, iter, next) {
1463  if (iter->priority > supplement->priority) {
1464  AST_RWLIST_INSERT_BEFORE_CURRENT(supplement, next);
1465  inserted = 1;
1466  break;
1467  }
1468  }
1469  AST_RWLIST_TRAVERSE_SAFE_END;
1470 
1471  if (!inserted) {
1472  AST_RWLIST_INSERT_TAIL(&supplements, supplement, next);
1473  }
1474 }
1475 
1476 void ast_sip_unregister_supplement(struct ast_sip_supplement *supplement)
1477 {
1478  struct ast_sip_supplement *iter;
1480 
1481  AST_RWLIST_TRAVERSE_SAFE_BEGIN(&supplements, iter, next) {
1482  if (supplement == iter) {
1483  AST_RWLIST_REMOVE_CURRENT(next);
1484  break;
1485  }
1486  }
1487  AST_RWLIST_TRAVERSE_SAFE_END;
1488 }
1489 
1490 static 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 
1499 static 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 
1527 static 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 
1534 static struct send_request_data *send_request_data_alloc(struct ast_sip_endpoint *endpoint,
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  */
1573 static 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  */
1648 static 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 
1688 static void send_request_wrapper_destructor(void *obj)
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 
1696 static 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) {
1743  ast_log(LOG_ERROR,
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 
1816 int ast_sip_failover_request(pjsip_tx_data *tdata)
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 
1837 static void send_request_cb(void *token, pjsip_event *e);
1838 
1839 static 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 */
1857  && !ast_sip_create_request_with_auth(&endpoint->outbound_auths,
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 
1882 static 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 
1938 int 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) {
1953  ast_sip_message_apply_transport(endpoint->transport, tdata);
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 
1979 int 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 
1992 int 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 
2008 int 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 
2023 pjsip_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 
2039 static 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 
2052 int 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 
2059 int 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 
2075 int 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 {
2091  return ast_threadpool_serializer_group(name, sip_threadpool, shutdown_group);
2092 }
2093 
2095 {
2096  return ast_sip_create_serializer_group(name, NULL);
2097 }
2098 
2099 int ast_sip_push_task(struct ast_taskprocessor *serializer, int (*sip_task)(void *), void *task_data)
2100 {
2101  if (!serializer) {
2102  serializer = ast_serializer_pool_get(sip_serializer_pool);
2103  }
2104 
2105  return ast_taskprocessor_push(serializer, sip_task, task_data);
2106 }
2107 
2108 struct sync_task_data {
2109  ast_mutex_t lock;
2110  ast_cond_t cond;
2111  int complete;
2112  int fail;
2113  int (*task)(void *);
2114  void *task_data;
2115 };
2116 
2117 static 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 
2137 static 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 
2148  if (ast_sip_push_task(serializer, sync_task, &std)) {
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 
2165 int ast_sip_push_task_wait_servant(struct ast_taskprocessor *serializer, int (*sip_task)(void *), void *task_data)
2166 {
2167  if (ast_sip_thread_is_servant()) {
2168  return sip_task(task_data);
2169  }
2170 
2171  return ast_sip_push_task_wait(serializer, sip_task, task_data);
2172 }
2173 
2174 int ast_sip_push_task_synchronous(struct ast_taskprocessor *serializer, int (*sip_task)(void *), void *task_data)
2175 {
2176  return ast_sip_push_task_wait_servant(serializer, sip_task, task_data);
2177 }
2178 
2179 int ast_sip_push_task_wait_serializer(struct ast_taskprocessor *serializer, int (*sip_task)(void *), void *task_data)
2180 {
2181  if (!serializer) {
2182  /* Caller doesn't care which PJSIP serializer the task executes under. */
2183  serializer = ast_serializer_pool_get(sip_serializer_pool);
2184  if (!serializer) {
2185  /* No serializer picked to execute the task */
2186  return -1;
2187  }
2188  }
2189  if (ast_taskprocessor_is_task(serializer)) {
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 
2201 void 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 
2208 int 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 
2219 int 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 
2228 int 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 
2248 int 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 
2261 pj_caching_pool caching_pool;
2262 pj_pool_t *memory_pool;
2263 pj_thread_t *monitor_thread;
2264 static int monitor_continue;
2265 
2266 static 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 
2275 static void stop_monitor_thread(void)
2276 {
2277  monitor_continue = 0;
2278  pj_thread_join(monitor_thread);
2279 }
2280 
2281 AST_THREADSTORAGE(pj_thread_storage);
2282 AST_THREADSTORAGE(servant_id_storage);
2283 #define SIP_SERVANT_ID 0x5E2F1D
2284 
2285 static 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 
2327 void *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 
2338 void *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 
2350 static 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 
2374 static 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 
2396 int 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 
2409 static 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 
2415 static 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 
2424 int 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  */
2436  clean_contact_from_tdata(tdata);
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) {
2441  clean_contact_from_tdata(tdata);
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) {
2450  clean_contact_from_tdata(tdata);
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 
2468 int 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 
2480 int 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 
2493 const char *ast_sip_get_host_ip_string(int af)
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 
2504 int ast_sip_dtmf_to_str(const enum ast_sip_dtmf_mode dtmf,
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;
2511  case AST_SIP_DTMF_RFC_4733:
2512  ast_copy_string(buf, "rfc4733", buf_len);
2513  break;
2514  case AST_SIP_DTMF_INBAND:
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;
2523  case AST_SIP_DTMF_AUTO_INFO:
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 
2533 int ast_sip_str_to_dtmf(const char * dtmf_mode)
2534 {
2535  int result = -1;
2536 
2537  if (!strcasecmp(dtmf_mode, "info")) {
2538  result = AST_SIP_DTMF_INFO;
2539  } else if (!strcasecmp(dtmf_mode, "rfc4733")) {
2540  result = AST_SIP_DTMF_RFC_4733;
2541  } else if (!strcasecmp(dtmf_mode, "inband")) {
2542  result = AST_SIP_DTMF_INBAND;
2543  } else if (!strcasecmp(dtmf_mode, "none")) {
2544  result = AST_SIP_DTMF_NONE;
2545  } else if (!strcasecmp(dtmf_mode, "auto")) {
2546  result = AST_SIP_DTMF_AUTO;
2547  } else if (!strcasecmp(dtmf_mode, "auto_info")) {
2548  result = AST_SIP_DTMF_AUTO_INFO;
2549  }
2550 
2551  return result;
2552 }
2553 
2554 const char *ast_sip_call_codec_pref_to_str(struct ast_flags pref)
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 
2577 int 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) {
2582  ast_set_flag(pref, AST_SIP_CALL_CODEC_PREF_LOCAL | AST_SIP_CALL_CODEC_PREF_INTERSECT | AST_SIP_CALL_CODEC_PREF_ALL);
2583  } else if (is_outgoing && strcmp(pref_str, "local_merge") == 0) {
2584  ast_set_flag(pref, AST_SIP_CALL_CODEC_PREF_LOCAL | AST_SIP_CALL_CODEC_PREF_UNION | AST_SIP_CALL_CODEC_PREF_ALL);
2585  } else if (strcmp(pref_str, "local_first") == 0) {
2586  ast_set_flag(pref, AST_SIP_CALL_CODEC_PREF_LOCAL | AST_SIP_CALL_CODEC_PREF_INTERSECT | AST_SIP_CALL_CODEC_PREF_FIRST);
2587  } else if (strcmp(pref_str, "remote") == 0) {
2588  ast_set_flag(pref, AST_SIP_CALL_CODEC_PREF_REMOTE | AST_SIP_CALL_CODEC_PREF_INTERSECT | AST_SIP_CALL_CODEC_PREF_ALL);
2589  } else if (is_outgoing && strcmp(pref_str, "remote_merge") == 0) {
2590  ast_set_flag(pref, AST_SIP_CALL_CODEC_PREF_REMOTE | AST_SIP_CALL_CODEC_PREF_UNION | AST_SIP_CALL_CODEC_PREF_ALL);
2591  } else if (strcmp(pref_str, "remote_first") == 0) {
2592  ast_set_flag(pref, AST_SIP_CALL_CODEC_PREF_REMOTE | AST_SIP_CALL_CODEC_PREF_UNION | AST_SIP_CALL_CODEC_PREF_FIRST);
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  */
2606 static 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;
2613  enum ast_utf8_replace_result result;
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 
2641  if (result != AST_UTF8_REPLACE_VALID) {
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  */
2673 static 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  */
2710 static 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  */
2751 static 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  */
2803 static 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 
2822 int 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 
2827 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)
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  */
2850 void 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  */
2890 static 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 
2899  contact = ast_sip_location_retrieve_contact_from_aor_list(aors);
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 
2931 out:
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  */
2955 static 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) {
2977  endpoint = ast_sip_default_outbound_endpoint();
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;
2989  contact = ast_sip_location_retrieve_contact_from_aor_list(endpoint->aors);
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 
3007 failure:
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  */
3034 static 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  */
3054  ast_log(LOG_WARNING,
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 
3145  contact = ast_sip_location_retrieve_first_aor_contact(aor);
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 
3165 failure:
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  */
3191 static 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 ??? */
3203  AST_SIP_USER_OPTIONS_TRUNCATE_CHECK(endpoint_name);
3204  endpoint = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "endpoint", 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) {
3216  endpoint = ast_sip_default_outbound_endpoint();
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  */
3226  contact = ast_sip_location_retrieve_contact_from_aor_list(endpoint->aors);
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 
3243 failure:
3244  ao2_cleanup(endpoint);
3245  *uri = NULL;
3246  return NULL;
3247 }
3248 
3249 struct 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) {
3312  endpoint = ast_sip_default_outbound_endpoint();
3313  }
3314 
3315  return endpoint;
3316 
3317 failure:
3318  ao2_cleanup(endpoint);
3319  *uri = NULL;
3320  return NULL;
3321 }
3322 
3323 int 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)) {
3344  buf = ast_alloca(DEBUG_BUF_SIZE);
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 
3383 int 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 
3445 static 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 
3457 long ast_sip_threadpool_queue_size(void)
3458 {
3459  return ast_threadpool_queue_size(sip_threadpool);
3460 }
3461 
3462 struct ast_threadpool *ast_sip_threadpool(void)
3463 {
3464  return sip_threadpool;
3465 }
3466 
3467 int 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 
3472 int 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 
3477 const 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 
3496 const 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 
3511 struct 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 */
3531 const int ast_sip_hangup_sip2cause(int cause)
3532 {
3533  /* Possible values taken from causes.h */
3534 
3535  switch(cause) {
3536  case 401: /* Unauthorized */
3537  return AST_CAUSE_CALL_REJECTED;
3538  case 403: /* Not found */
3539  return AST_CAUSE_CALL_REJECTED;
3540  case 404: /* Not found */
3541  return AST_CAUSE_UNALLOCATED;
3542  case 405: /* Method not allowed */
3543  return AST_CAUSE_INTERWORKING;
3544  case 407: /* Proxy authentication required */
3545  return AST_CAUSE_CALL_REJECTED;
3546  case 408: /* No reaction */
3547  return AST_CAUSE_NO_USER_RESPONSE;
3548  case 409: /* Conflict */
3549  return AST_CAUSE_NORMAL_TEMPORARY_FAILURE;
3550  case 410: /* Gone */
3551  return AST_CAUSE_NUMBER_CHANGED;
3552  case 411: /* Length required */
3553  return AST_CAUSE_INTERWORKING;
3554  case 413: /* Request entity too large */
3555  return AST_CAUSE_INTERWORKING;
3556  case 414: /* Request URI too large */
3557  return AST_CAUSE_INTERWORKING;
3558  case 415: /* Unsupported media type */
3559  return AST_CAUSE_INTERWORKING;
3560  case 420: /* Bad extension */
3561  return AST_CAUSE_NO_ROUTE_DESTINATION;
3562  case 480: /* No answer */
3563  return AST_CAUSE_NO_ANSWER;
3564  case 481: /* No answer */
3565  return AST_CAUSE_INTERWORKING;
3566  case 482: /* Loop detected */
3567  return AST_CAUSE_INTERWORKING;
3568  case 483: /* Too many hops */
3569  return AST_CAUSE_NO_ANSWER;
3570  case 484: /* Address incomplete */
3571  return AST_CAUSE_INVALID_NUMBER_FORMAT;
3572  case 485: /* Ambiguous */
3573  return AST_CAUSE_UNALLOCATED;
3574  case 486: /* Busy everywhere */
3575  return AST_CAUSE_BUSY;
3576  case 487: /* Request terminated */
3577  return AST_CAUSE_INTERWORKING;
3578  case 488: /* No codecs approved */
3579  return AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
3580  case 491: /* Request pending */
3581  return AST_CAUSE_INTERWORKING;
3582  case 493: /* Undecipherable */
3583  return AST_CAUSE_INTERWORKING;
3584  case 500: /* Server internal failure */
3585  return AST_CAUSE_FAILURE;
3586  case 501: /* Call rejected */
3587  return AST_CAUSE_FACILITY_REJECTED;
3588  case 502:
3589  return AST_CAUSE_DESTINATION_OUT_OF_ORDER;
3590  case 503: /* Service unavailable */
3591  return AST_CAUSE_CONGESTION;
3592  case 504: /* Gateway timeout */
3593  return AST_CAUSE_RECOVERY_ON_TIMER_EXPIRE;
3594  case 505: /* SIP version not supported */
3595  return AST_CAUSE_INTERWORKING;
3596  case 600: /* Busy everywhere */
3597  return AST_CAUSE_USER_BUSY;
3598  case 603: /* Decline */
3599  return AST_CAUSE_CALL_REJECTED;
3600  case 604: /* Does not exist anywhere */
3601  return AST_CAUSE_UNALLOCATED;
3602  case 606: /* Not acceptable */
3603  return AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
3604  default:
3605  if (cause < 500 && cause >= 400) {
3606  /* 4xx class error that is unknown - someting wrong with our request */
3607  return AST_CAUSE_INTERWORKING;
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 */
3613  return AST_CAUSE_INTERWORKING;
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  */
3634 static 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 
3714 int 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
3734 AST_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 
3759 AST_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  */
3790 static int reload_configuration_task(void *obj)
3791 {
3792  ast_res_pjsip_reload_configuration();
3793  ast_res_pjsip_init_options_handling(1);
3794  ast_sip_initialize_dns();
3795  return 0;
3796 }
3797 
3798 static 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  */
3804  if (ast_pjsip_endpoint && sip_serializer_pool) {
3805  ast_res_pjsip_cleanup_options_handling();
3806  ast_res_pjsip_cleanup_message_filter();
3807  ast_sip_destroy_distributor();
3808  ast_sip_destroy_transport_management();
3809  ast_res_pjsip_destroy_configuration();
3810  ast_sip_destroy_system();
3811  ast_sip_destroy_global_headers();
3812  ast_sip_unregister_service(&supplement_module);
3813  ast_sip_destroy_transport_events();
3814  }
3815 
3816  if (monitor_thread) {
3817  stop_monitor_thread();
3818  monitor_thread = NULL;
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 
3831  ast_pjsip_endpoint = NULL;
3832 
3833  if (caching_pool.lock) {
3834  ast_pjproject_caching_pool_destroy(&caching_pool);
3835  }
3836 
3837  pj_shutdown();
3838 
3839  return 0;
3840 }
3841 
3842 static 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  */
3851  ast_pjproject_caching_pool_init(&caching_pool, NULL, 1024 * 1024);
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  */
3860  remove_request_headers(ast_pjsip_endpoint);
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 
3889  return AST_MODULE_LOAD_SUCCESS;
3890 
3891 error:
3892  return AST_MODULE_LOAD_DECLINE;
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  */
3902 void never_called_res_pjsip(void);
3903 void 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 */
3909 pjsip_media_type pjsip_media_type_application_json;
3910 pjsip_media_type pjsip_media_type_application_media_control_xml;
3911 pjsip_media_type pjsip_media_type_application_pidf_xml;
3912 pjsip_media_type pjsip_media_type_application_xpidf_xml;
3913 pjsip_media_type pjsip_media_type_application_cpim_xpidf_xml;
3914 pjsip_media_type pjsip_media_type_application_rlmi_xml;
3915 pjsip_media_type pjsip_media_type_application_simple_message_summary;
3916 pjsip_media_type pjsip_media_type_application_sdp;
3917 pjsip_media_type pjsip_media_type_multipart_alternative;
3918 pjsip_media_type pjsip_media_type_multipart_mixed;
3919 pjsip_media_type pjsip_media_type_multipart_related;
3920 pjsip_media_type pjsip_media_type_text_plain;
3921 
3922 static int load_module(void)
3923 {
3924  struct ast_threadpool_options options;
3925 
3926  /* pjproject and config_system need to be initialized before all else */
3927  if (pj_init() != PJ_SUCCESS) {
3928  return AST_MODULE_LOAD_DECLINE;
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 
3956  if (ast_sip_initialize_system()) {
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 */
3962  sip_get_threadpool_options(&options);
3963  options.thread_start = sip_thread_start;
3964  sip_threadpool = ast_threadpool_create("pjsip", NULL, &options);
3965  if (!sip_threadpool) {
3966  goto error;
3967  }
3968 
3969  sip_serializer_pool = ast_serializer_pool_create(
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 
3986  if (ast_sip_initialize_transport_events()) {
3987  ast_log(LOG_ERROR, "Failed to initialize SIP transport monitor. Aborting load\n");
3988  goto error;
3989  }
3990 
3991  ast_sip_initialize_dns();
3992  ast_sip_initialize_global_headers();
3993 
3994  if (ast_res_pjsip_preinit_options_handling()) {
3995  ast_log(LOG_ERROR, "Failed to pre-initialize OPTIONS handling. Aborting load\n");
3996  goto error;
3997  }
3998 
3999  if (ast_res_pjsip_initialize_configuration()) {
4000  ast_log(LOG_ERROR, "Failed to initialize SIP configuration. Aborting load\n");
4001  goto error;
4002  }
4003 
4004  ast_sip_initialize_resolver();
4005  ast_sip_initialize_dns();
4006 
4007  if (ast_sip_initialize_transport_management()) {
4008  ast_log(LOG_ERROR, "Failed to initialize SIP transport management. Aborting load\n");
4009  goto error;
4010  }
4011 
4012  if (ast_sip_initialize_distributor()) {
4013  ast_log(LOG_ERROR, "Failed to register distributor module. Aborting load\n");
4014  goto error;
4015  }
4016 
4017  if (ast_sip_register_service(&supplement_module)) {
4018  ast_log(LOG_ERROR, "Failed to initialize supplement hooks. Aborting load\n");
4019  goto error;
4020  }
4021 
4022  if (ast_res_pjsip_init_options_handling(0)) {
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  */
4033  ast_sip_location_prune_boot_contacts();
4034 
4035  if (ast_res_pjsip_init_message_filter()) {
4036  ast_log(LOG_ERROR, "Failed to initialize message IP updating. Aborting load\n");
4037  goto error;
4038  }
4039 
4040  ast_cli_register_multiple(cli_commands, ARRAY_LEN(cli_commands));
4041 
4042  AST_TEST_REGISTER(xml_sanitization_end_null);
4043  AST_TEST_REGISTER(xml_sanitization_exceeds_buffer);
4044 
4045  return AST_MODULE_LOAD_SUCCESS;
4046 
4047 error:
4048  unload_pjsip(NULL);
4049 
4050  /* These functions all check for NULLs and are safe to call at any time */
4051  ast_sip_destroy_scheduler();
4052  ast_serializer_pool_destroy(sip_serializer_pool);
4053  ast_threadpool_shutdown(sip_threadpool);
4054 
4055  return AST_MODULE_LOAD_DECLINE;
4056 }
4057 
4058 static 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  */
4064  if (ast_sip_push_task_wait_servant(NULL, reload_configuration_task, NULL)) {
4065  ast_log(LOG_WARNING, "Failed to reload PJSIP\n");
4066  return -1;
4067  }
4068 
4069  return 0;
4070 }
4071 
4072 static int unload_module(void)
4073 {
4074  AST_TEST_UNREGISTER(xml_sanitization_end_null);
4075  AST_TEST_UNREGISTER(xml_sanitization_exceeds_buffer);
4076  ast_cli_unregister_multiple(cli_commands, ARRAY_LEN(cli_commands));
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  */
4081  ast_sip_push_task_wait_servant(NULL, unload_pjsip, NULL);
4082  ast_sip_destroy_scheduler();
4083  ast_serializer_pool_destroy(sip_serializer_pool);
4084  ast_threadpool_shutdown(sip_threadpool);
4085 
4086  return 0;
4087 }
4088 
4089 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER, "Basic SIP resource",
4090  .support_level = AST_MODULE_SUPPORT_CORE,
4091  .load = load_module,
4092  .unload = unload_module,
4093  .reload = reload_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",
4097 );
enum ast_transport type
Definition: res_pjsip.h:133
#define AST_THREADSTORAGE(name)
Define a thread storage variable.
Definition: threadstorage.h:86
Information needed to identify an endpoint in a call.
Definition: channel.h:338
const char * body_text
Definition: res_pjsip.h:2315
struct ast_ha * localnet
Definition: res_pjsip.h:156
char * str
Subscriber phone number (Malloced)
Definition: channel.h:291
Asterisk locking-related definitions:
Asterisk main include file. File version handling, generic pbx functions.
const ast_string_field fromuser
Definition: res_pjsip.h:966
A SIP address of record.
Definition: res_pjsip.h:478
An entity responsible formatting endpoint information.
Definition: res_pjsip.h:3057
void(* outgoing_response)(struct ast_sip_endpoint *endpoint, struct ast_sip_contact *contact, struct pjsip_tx_data *tdata)
Called on an outgoing SIP response This method is always called from a SIP servant thread...
Definition: res_pjsip.h:3230
void * ast_threadstorage_get(struct ast_threadstorage *ts, size_t init_size)
Retrieve thread storage.
String manipulation functions.
CallerID (and other GR30) management and generation Includes code and algorithms from the Zapata libr...
int ast_sockaddr_parse(struct ast_sockaddr *addr, const char *str, int flags)
Parse an IPv4 or IPv6 address string.
Definition: netsock2.c:230
int ast_cli_unregister_multiple(struct ast_cli_entry *e, int len)
Unregister multiple commands.
Definition: clicompat.c:30
void(* callback)(void *token, pjsip_event *e)
Definition: res_pjsip.c:1556
const ast_string_field transport
Definition: res_pjsip.h:954
struct ast_party_name name
Subscriber name.
Definition: channel.h:340
struct ast_sip_endpoint_nat_configuration nat
Definition: res_pjsip.h:984
pj_int32_t timeout
Definition: res_pjsip.c:1564
descriptor for a cli entry.
Definition: cli.h:171
char * ast_str_buffer(const struct ast_str *buf)
Returns the string buffer within the ast_str buf.
Definition: strings.h:761
char * contact_user
Definition: res_pjsip.h:1026
#define ao2_callback(c, flags, cb_fn, arg)
ao2_callback() is a generic function that applies cb_fn() to all objects in a container, as described below.
Definition: astobj2.h:1693
pj_timer_entry * timeout_timer
Definition: res_pjsip.c:1562
#define AST_RWLIST_RDLOCK(head)
Read locks a list.
Definition: linkedlists.h:78
AMI variable container.
Definition: res_pjsip.h:3031
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
static pj_pool_t * pool
Global memory pool for configuration and timers.
pthread_t thread
Definition: app_sla.c:329
struct ast_sip_auth_vector outbound_auths
Definition: res_pjsip.h:994
const char * method
Definition: res_pjsip.h:3184
Universally unique identifier support.
Test Framework API.
pjsip_tpfactory * factory
Potential pointer to the transport factory itself, if TCP/TLS.
Definition: res_pjsip.h:343
#define AST_RWLIST_WRLOCK(head)
Write locks a list.
Definition: linkedlists.h:52
char * str
Subscriber name (Malloced)
Definition: channel.h:264
Definition: astman.c:222
#define ast_cli_register_multiple(e, len)
Register multiple commands.
Definition: cli.h:265
int(* create_request_with_auth)(const struct ast_sip_auth_vector *auths, struct pjsip_rx_data *challenge, struct pjsip_tx_data *old_request, struct pjsip_tx_data **new_request)
Create a new request with authentication credentials.
Definition: res_pjsip.h:1267
Source contained fully valid UTF-8.
Definition: utf8.h:76
#define ast_strdup(str)
A wrapper for strdup()
Definition: astmm.h:241
Generic File Format Support. Should be included by clients of the file handling routines. File service providers should instead include mod_format.h.
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:1246
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:1279
CLI Formatter Context passed to all formatters.
Definition: res_pjsip_cli.h:34
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
enum ast_transport type
Definition: res_pjsip.h:243
UTF-8 information and validation functions.
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.
Socket address structure.
Definition: netsock2.h:97
Utility functions.
#define ast_asprintf(ret, fmt,...)
A wrapper for asprintf()
Definition: astmm.h:267
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
struct ast_sip_endpoint * endpoint
Definition: res_pjsip.h:424
#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
static int ast_sockaddr_isnull(const struct ast_sockaddr *addr)
Checks if the ast_sockaddr is null. "null" in this sense essentially means uninitialized, or having a 0 length.
Definition: netsock2.h:127
#define ao2_bump(obj)
Bump refcount on an AO2 object by one, returning the object.
Definition: astobj2.h:480
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_pjproject_log_intercept_end(void)
End PJPROJECT log interception for CLI output.
const ast_string_field endpoint_name
Definition: res_pjsip.h:414
int local_port
Local port for transport.
Definition: res_pjsip.h:347
Structure for SIP transport information.
Definition: res_pjsip.h:119
ast_mutex_t lock
static pthread_t monitor_thread
This is the thread for the monitor which checks for input on the channels which are not currently in ...
Definition: chan_dahdi.c:761
void(* incoming_response)(struct ast_sip_endpoint *endpoint, struct pjsip_rx_data *rdata)
Called on an incoming SIP response This method is always called from a SIP servant thread...
Definition: res_pjsip.h:3220
const char * type
Definition: res_pjsip.h:2311
struct pjsip_transport * transport
Transport itself.
Definition: res_pjsip.h:121
#define ast_strdupa(s)
duplicate a string in memory from the stack
Definition: astmm.h:298
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
Access Control of various sorts.
#define ao2_ref(o, delta)
Reference/unreference an object and return the old refcount.
Definition: astobj2.h:459
const char * ast_sorcery_object_get_id(const void *object)
Get the unique identifier of a sorcery object.
Definition: sorcery.c:2317
void ast_pjproject_log_intercept_begin(int fd)
Begin PJPROJECT log interception for CLI output.
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:1236
#define SCOPED_LOCK(varname, lock, lockfunc, unlockfunc)
Scoped Locks.
Definition: lock.h:583
A set of macros to manage forward-linked lists.
#define ast_malloc(len)
A wrapper for malloc()
Definition: astmm.h:191
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
#define ast_debug(level,...)
Log a DEBUG message.
An entity with which Asterisk communicates.
Definition: res_pjsip.h:949
unsigned int cb_called
Definition: res_pjsip.c:1558
pjsip_transport * transport
Potential pointer to the transport itself, if UDP.
Definition: res_pjsip.h:341
enum ast_transport type
Type of transport.
Definition: res_pjsip.h:339
const ast_string_field outbound_proxy
Definition: res_pjsip.h:956
#define ast_alloca(size)
call __builtin_alloca to ensure we get gcc builtin semantics
Definition: astmm.h:288
struct ast_sip_endpoint_info_configuration info
Definition: res_pjsip.h:988
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(* incoming_request)(struct ast_sip_endpoint *endpoint, struct pjsip_rx_data *rdata)
Called on incoming SIP request This method can indicate a failure in processing in its return...
Definition: res_pjsip.h:3204
Support for dynamic strings.
Definition: strings.h:623
#define ast_sockaddr_set_port(addr, port)
Sets the port number of a socket address.
Definition: netsock2.h:532
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(struct ast_taskprocessor *serializer, int(*sip_task)(void *), void *task_data)
Pushes a task to SIP servants.
Definition: res_pjsip.c:2099
void(* callback)(void *token, pjsip_event *e)
Definition: res_pjsip.c:1522
Transport to bind to.
Definition: res_pjsip.h:221
Contact associated with an address of record.
Definition: res_pjsip.h:392
const char * subtype
Definition: res_pjsip.h:2313
struct ast_taskprocessor * ast_sip_create_serializer(const char *name)
Create a new serializer for SIP tasks.
Definition: res_pjsip.c:2094
userdata associated with baseline taskprocessor test
int ast_sip_initialize_scheduler(void)
Initialize scheduler.
void ast_pjproject_caching_pool_destroy(pj_caching_pool *cp)
Destroy caching pool factory and all cached pools.
#define AST_LIST_TRAVERSE(head, var, field)
Loops over (traverses) the entries in a list.
Definition: linkedlists.h:491
int ast_taskprocessor_is_task(struct ast_taskprocessor *tps)
Am I the given taskprocessor's current task.
struct pjsip_tpfactory * factory
Transport factory.
Definition: res_pjsip.h:123
char * command
Definition: cli.h:186
#define ast_calloc(num, len)
A wrapper for calloc()
Definition: astmm.h:202
char * ast_escape_quoted(const char *string, char *outbuf, int buflen)
Escape characters found in a quoted string.
Definition: utils.c:781
#define AST_CHANNEL_NAME
Definition: channel.h:171
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:3061
Support for logging to various files, console and syslog Configuration in file logger.conf.
Module has failed to load, may be in an inconsistent state.
Definition: module.h:78
An API for managing task processing threads that can be shared across modules.
pj_str_t local_address
Local address for transport.
Definition: res_pjsip.h:345
An entity responsible for identifying the source of a SIP message.
Definition: res_pjsip.h:1274
structure to hold users read from users.conf
Structure used to handle boolean flags.
Definition: utils.h:199
pjsip_tx_data * tdata
Definition: res_pjsip.c:1566
struct ast_sockaddr external_signaling_address
Definition: res_pjsip.h:166
const char * usage
Definition: cli.h:177
char * tag
User-set "tag".
Definition: channel.h:354
ast_utf8_replace_result
Definition: utf8.h:70
An interchangeable way of handling digest authentication for SIP.
Definition: res_pjsip.h:1231
A ast_taskprocessor structure is a singleton by name.
Definition: taskprocessor.c:69
int ast_taskprocessor_push(struct ast_taskprocessor *tps, int(*task_exe)(void *datap), void *datap) attribute_warn_unused_result
Push a task into the specified taskprocessor queue and signal the taskprocessor thread.
Standard Command Line Interface.
A supplement to SIP message processing.
Definition: res_pjsip.h:3182
An opaque threadpool structure.
Definition: threadpool.c:36
void ast_copy_string(char *dst, const char *src, size_t size)
Size-limited null-terminating string copy.
Definition: strings.h:425
Structure to hold information about an outbound request.
Definition: res_pjsip.c:1516
#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
unsigned int challenge_count
Definition: res_pjsip.c:1524
unsigned int usereqphone
Definition: res_pjsip.h:1016
Internal Asterisk hangup causes.
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
#define AST_TEST_DEFINE(hdr)
Definition: test.h:126
unsigned int allow_unauthenticated_options
Definition: res_pjsip.h:1048
Definition: search.h:40
#define AST_RWLIST_UNLOCK(head)
Attempts to unlock a read/write based list.
Definition: linkedlists.h:151
Generic container type.
Structure which contains information about a transport.
Definition: res_pjsip.h:337
unsigned char valid
TRUE if the name information is valid/present.
Definition: channel.h:279
enum ast_utf8_replace_result ast_utf8_replace_invalid_chars(char *dst, size_t *dst_size, const char *src, size_t src_len)
Copy a string safely replacing any invalid UTF-8 sequences.
Definition: utf8.c:173
an interchangeable way of responding to authentication challenges
Definition: res_pjsip.h:1256
const ast_string_field aors
Definition: res_pjsip.h:958
#define ASTERISK_GPL_KEY
The text the key() function should return.
Definition: module.h:46
const ast_string_field uri
Definition: res_pjsip.h:414
void(* outgoing_request)(struct ast_sip_endpoint *endpoint, struct ast_sip_contact *contact, struct pjsip_tx_data *tdata)
Called on an outgoing SIP request This method is always called from a SIP servant thread...
Definition: res_pjsip.h:3225
Asterisk module definitions.
#define RAII_VAR(vartype, varname, initval, dtor)
Declare a variable that will call a destructor function when it goes out of scope.
Definition: utils.h:941
unsigned int send_cb_called
Definition: res_pjsip.c:1560
unsigned char valid
TRUE if the number information is valid/present.
Definition: channel.h:297
SIP body description.
Definition: res_pjsip.h:2309
Structure for mutex and tracking information.
Definition: lock.h:135
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
#define ast_str_create(init_len)
Create a malloc'ed dynamic length string.
Definition: strings.h:659
Sorcery Data Access Layer API.
const ast_string_field fromdomain
Definition: res_pjsip.h:968
struct ast_sip_endpoint * endpoint
Definition: res_pjsip.c:1518
struct ast_party_number number
Subscriber phone number.
Definition: channel.h:342
enum ast_sip_supplement_priority priority
Definition: res_pjsip.h:3186