9c7298b981c920ab9489673fee6567360c638fba
[asterisk/asterisk.git] / res / res_pjsip / config_transport.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2013, Digium, Inc.
5  *
6  * Joshua Colp <jcolp@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 #include <pjlib.h>
23
24 #include "asterisk/res_pjsip.h"
25 #include "asterisk/res_pjsip_cli.h"
26 #include "asterisk/logger.h"
27 #include "asterisk/astobj2.h"
28 #include "asterisk/sorcery.h"
29 #include "asterisk/acl.h"
30 #include "include/res_pjsip_private.h"
31 #include "asterisk/http_websocket.h"
32
33 static int sip_transport_to_ami(const struct ast_sip_transport *transport,
34                                 struct ast_str **buf)
35 {
36         return ast_sip_sorcery_object_to_ami(transport, buf);
37 }
38
39 static int format_ami_endpoint_transport(const struct ast_sip_endpoint *endpoint,
40                                          struct ast_sip_ami *ami)
41 {
42         RAII_VAR(struct ast_str *, buf, NULL, ast_free);
43         RAII_VAR(struct ast_sip_transport *, transport, NULL, ao2_cleanup);
44
45         if (ast_strlen_zero(endpoint->transport)) {
46                 return 0;
47         }
48
49         buf = ast_sip_create_ami_event("TransportDetail", ami);
50         if (!buf) {
51                 return -1;
52         }
53
54         transport = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "transport",
55                 endpoint->transport);
56         if (!transport) {
57                 astman_send_error_va(ami->s, ami->m, "Unable to retrieve "
58                                      "transport %s\n", endpoint->transport);
59                 return -1;
60         }
61
62         sip_transport_to_ami(transport, &buf);
63
64         ast_str_append(&buf, 0, "EndpointName: %s\r\n",
65                        ast_sorcery_object_get_id(endpoint));
66
67         astman_append(ami->s, "%s\r\n", ast_str_buffer(buf));
68         ami->count++;
69
70         return 0;
71 }
72
73 struct ast_sip_endpoint_formatter endpoint_transport_formatter = {
74         .format_ami = format_ami_endpoint_transport
75 };
76
77 static int destroy_transport_state(void *data)
78 {
79         pjsip_transport *transport = data;
80         pjsip_transport_shutdown(transport);
81         return 0;
82 }
83
84 /*! \brief Destructor for transport state information */
85 static void transport_state_destroy(void *obj)
86 {
87         struct ast_sip_transport_state *state = obj;
88
89         if (state->transport) {
90                 ast_sip_push_task_synchronous(NULL, destroy_transport_state, state->transport);
91         }
92 }
93
94 /*! \brief Destructor for transport */
95 static void transport_destroy(void *obj)
96 {
97         struct ast_sip_transport *transport = obj;
98
99         ast_string_field_free_memory(transport);
100         ast_free_ha(transport->localnet);
101
102         if (transport->external_address_refresher) {
103                 ast_dnsmgr_release(transport->external_address_refresher);
104         }
105
106         ao2_cleanup(transport->state);
107 }
108
109 /*! \brief Allocator for transport */
110 static void *transport_alloc(const char *name)
111 {
112         struct ast_sip_transport *transport = ast_sorcery_generic_alloc(sizeof(*transport), transport_destroy);
113
114         if (!transport) {
115                 return NULL;
116         }
117
118         if (ast_string_field_init(transport, 256)) {
119                 ao2_cleanup(transport);
120                 return NULL;
121         }
122
123         pjsip_tls_setting_default(&transport->tls);
124         transport->tls.ciphers = transport->ciphers;
125
126         return transport;
127 }
128
129 static void set_qos(struct ast_sip_transport *transport, pj_qos_params *qos)
130 {
131         int tos_as_dscp = transport->tos >> 2;
132
133         if (transport->tos) {
134                 qos->flags |= PJ_QOS_PARAM_HAS_DSCP;
135                 qos->dscp_val = tos_as_dscp;
136         }
137         if (transport->cos) {
138                 qos->flags |= PJ_QOS_PARAM_HAS_SO_PRIO;
139                 qos->so_prio = transport->cos;
140         }
141 }
142
143 /*! \brief Apply handler for transports */
144 static int transport_apply(const struct ast_sorcery *sorcery, void *obj)
145 {
146         struct ast_sip_transport *transport = obj;
147         RAII_VAR(struct ast_sip_transport *, existing, ast_sorcery_retrieve_by_id(sorcery, "transport", ast_sorcery_object_get_id(obj)), ao2_cleanup);
148         pj_status_t res = -1;
149
150         if (!existing || !existing->state) {
151                 if (!(transport->state = ao2_alloc(sizeof(*transport->state), transport_state_destroy))) {
152                         ast_log(LOG_ERROR, "Transport state for '%s' could not be allocated\n", ast_sorcery_object_get_id(obj));
153                         return -1;
154                 }
155         } else {
156                 transport->state = existing->state;
157                 ao2_ref(transport->state, +1);
158         }
159
160         /* Once active a transport can not be reconfigured */
161         if (transport->state->transport || transport->state->factory) {
162                 return -1;
163         }
164
165         if (transport->host.addr.sa_family != PJ_AF_INET && transport->host.addr.sa_family != PJ_AF_INET6) {
166                 ast_log(LOG_ERROR, "Transport '%s' could not be started as binding not specified\n", ast_sorcery_object_get_id(obj));
167                 return -1;
168         }
169
170         /* Set default port if not present */
171         if (!pj_sockaddr_get_port(&transport->host)) {
172                 pj_sockaddr_set_port(&transport->host, (transport->type == AST_TRANSPORT_TLS) ? 5061 : 5060);
173         }
174
175         /* Now that we know what address family we can set up a dnsmgr refresh for the external media address if present */
176         if (!ast_strlen_zero(transport->external_signaling_address)) {
177                 if (transport->host.addr.sa_family == pj_AF_INET()) {
178                         transport->external_address.ss.ss_family = AF_INET;
179                 } else if (transport->host.addr.sa_family == pj_AF_INET6()) {
180                         transport->external_address.ss.ss_family = AF_INET6;
181                 } else {
182                         ast_log(LOG_ERROR, "Unknown address family for transport '%s', could not get external signaling address\n",
183                                         ast_sorcery_object_get_id(obj));
184                         return -1;
185                 }
186
187                 if (ast_dnsmgr_lookup(transport->external_signaling_address, &transport->external_address, &transport->external_address_refresher, NULL) < 0) {
188                         ast_log(LOG_ERROR, "Could not create dnsmgr for external signaling address on '%s'\n", ast_sorcery_object_get_id(obj));
189                         return -1;
190                 }
191         }
192
193         if (transport->type == AST_TRANSPORT_UDP) {
194                 if (transport->host.addr.sa_family == pj_AF_INET()) {
195                         res = pjsip_udp_transport_start(ast_sip_get_pjsip_endpoint(), &transport->host.ipv4, NULL, transport->async_operations, &transport->state->transport);
196                 } else if (transport->host.addr.sa_family == pj_AF_INET6()) {
197                         res = pjsip_udp_transport_start6(ast_sip_get_pjsip_endpoint(), &transport->host.ipv6, NULL, transport->async_operations, &transport->state->transport);
198                 }
199
200                 if (res == PJ_SUCCESS && (transport->tos || transport->cos)) {
201                         pj_sock_t sock;
202                         pj_qos_params qos_params;
203
204                         sock = pjsip_udp_transport_get_socket(transport->state->transport);
205                         pj_sock_get_qos_params(sock, &qos_params);
206                         set_qos(transport, &qos_params);
207                         pj_sock_set_qos_params(sock, &qos_params);
208                 }
209         } else if (transport->type == AST_TRANSPORT_TCP) {
210                 pjsip_tcp_transport_cfg cfg;
211
212                 pjsip_tcp_transport_cfg_default(&cfg, transport->host.addr.sa_family);
213                 cfg.bind_addr = transport->host;
214                 cfg.async_cnt = transport->async_operations;
215                 set_qos(transport, &cfg.qos_params);
216
217                 res = pjsip_tcp_transport_start3(ast_sip_get_pjsip_endpoint(), &cfg, &transport->state->factory);
218         } else if (transport->type == AST_TRANSPORT_TLS) {
219                 transport->tls.ca_list_file = pj_str((char*)transport->ca_list_file);
220 #ifdef HAVE_PJ_SSL_CERT_LOAD_FROM_FILES2
221                 transport->tls.ca_list_path = pj_str((char*)transport->ca_list_path);
222 #else
223                 if (!ast_strlen_zero(transport->ca_list_path)) {
224                         ast_log(LOG_WARNING, "Asterisk has been built against a version of pjproject that does not "
225                                         "support the 'ca_list_path' option. Please upgrade to version 2.4 or later.\n");
226                 }
227 #endif
228                 transport->tls.cert_file = pj_str((char*)transport->cert_file);
229                 transport->tls.privkey_file = pj_str((char*)transport->privkey_file);
230                 transport->tls.password = pj_str((char*)transport->password);
231                 set_qos(transport, &transport->tls.qos_params);
232
233                 res = pjsip_tls_transport_start2(ast_sip_get_pjsip_endpoint(), &transport->tls, &transport->host, NULL, transport->async_operations, &transport->state->factory);
234         } else if ((transport->type == AST_TRANSPORT_WS) || (transport->type == AST_TRANSPORT_WSS)) {
235                 if (transport->cos || transport->tos) {
236                         ast_log(LOG_WARNING, "TOS and COS values ignored for websocket transport\n");
237                 }
238                 res = PJ_SUCCESS;
239         }
240
241         if (res != PJ_SUCCESS) {
242                 char msg[PJ_ERR_MSG_SIZE];
243
244                 pj_strerror(res, msg, sizeof(msg));
245                 ast_log(LOG_ERROR, "Transport '%s' could not be started: %s\n", ast_sorcery_object_get_id(obj), msg);
246                 return -1;
247         }
248         return 0;
249 }
250
251 /*! \brief Custom handler for turning a string protocol into an enum */
252 static int transport_protocol_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
253 {
254         struct ast_sip_transport *transport = obj;
255
256         if (!strcasecmp(var->value, "udp")) {
257                 transport->type = AST_TRANSPORT_UDP;
258         } else if (!strcasecmp(var->value, "tcp")) {
259                 transport->type = AST_TRANSPORT_TCP;
260         } else if (!strcasecmp(var->value, "tls")) {
261                 transport->type = AST_TRANSPORT_TLS;
262         } else if (!strcasecmp(var->value, "ws")) {
263                 transport->type = AST_TRANSPORT_WS;
264         } else if (!strcasecmp(var->value, "wss")) {
265                 transport->type = AST_TRANSPORT_WSS;
266         } else {
267                 return -1;
268         }
269
270         return 0;
271 }
272
273 static const char *transport_types[] = {
274         [AST_TRANSPORT_UDP] = "udp",
275         [AST_TRANSPORT_TCP] = "tcp",
276         [AST_TRANSPORT_TLS] = "tls",
277         [AST_TRANSPORT_WS] = "ws",
278         [AST_TRANSPORT_WSS] = "wss"
279 };
280
281 static int transport_protocol_to_str(const void *obj, const intptr_t *args, char **buf)
282 {
283         const struct ast_sip_transport *transport = obj;
284
285         if (ARRAY_IN_BOUNDS(transport->type, transport_types)) {
286                 *buf = ast_strdup(transport_types[transport->type]);
287         }
288
289         return 0;
290 }
291
292 /*! \brief Custom handler for turning a string bind into a pj_sockaddr */
293 static int transport_bind_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
294 {
295         struct ast_sip_transport *transport = obj;
296         pj_str_t buf;
297         int rc = pj_sockaddr_parse(pj_AF_UNSPEC(), 0, pj_cstr(&buf, var->value), &transport->host);
298
299         return rc != PJ_SUCCESS ? -1 : 0;
300 }
301
302 static int transport_bind_to_str(const void *obj, const intptr_t *args, char **buf)
303 {
304         const struct ast_sip_transport *transport = obj;
305
306         if (!(*buf = ast_calloc(MAX_OBJECT_FIELD, sizeof(char)))) {
307                 return -1;
308         }
309
310         /* include port as well as brackets if IPv6 */
311         pj_sockaddr_print(&transport->host, *buf, MAX_OBJECT_FIELD, 1 | 2);
312
313         return 0;
314 }
315
316 /*! \brief Custom handler for TLS boolean settings */
317 static int transport_tls_bool_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
318 {
319         struct ast_sip_transport *transport = obj;
320
321         if (!strcasecmp(var->name, "verify_server")) {
322                 transport->tls.verify_server = ast_true(var->value) ? PJ_TRUE : PJ_FALSE;
323         } else if (!strcasecmp(var->name, "verify_client")) {
324                 transport->tls.verify_client = ast_true(var->value) ? PJ_TRUE : PJ_FALSE;
325         } else if (!strcasecmp(var->name, "require_client_cert")) {
326                 transport->tls.require_client_cert = ast_true(var->value) ? PJ_TRUE : PJ_FALSE;
327         } else {
328                 return -1;
329         }
330
331         return 0;
332 }
333
334 static int verify_server_to_str(const void *obj, const intptr_t *args, char **buf)
335 {
336         const struct ast_sip_transport *transport = obj;
337         *buf = ast_strdup(AST_YESNO(transport->tls.verify_server));
338         return 0;
339 }
340
341 static int verify_client_to_str(const void *obj, const intptr_t *args, char **buf)
342 {
343         const struct ast_sip_transport *transport = obj;
344         *buf = ast_strdup(AST_YESNO(transport->tls.verify_client));
345         return 0;
346 }
347
348 static int require_client_cert_to_str(const void *obj, const intptr_t *args, char **buf)
349 {
350         const struct ast_sip_transport *transport = obj;
351         *buf = ast_strdup(AST_YESNO(transport->tls.require_client_cert));
352         return 0;
353 }
354
355 /*! \brief Custom handler for TLS method setting */
356 static int transport_tls_method_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
357 {
358         struct ast_sip_transport *transport = obj;
359
360         if (ast_strlen_zero(var->value) || !strcasecmp(var->value, "default")) {
361                 transport->tls.method = PJSIP_SSL_DEFAULT_METHOD;
362         } else if (!strcasecmp(var->value, "unspecified")) {
363                 transport->tls.method = PJSIP_SSL_UNSPECIFIED_METHOD;
364         } else if (!strcasecmp(var->value, "tlsv1")) {
365                 transport->tls.method = PJSIP_TLSV1_METHOD;
366         } else if (!strcasecmp(var->value, "sslv2")) {
367                 transport->tls.method = PJSIP_SSLV2_METHOD;
368         } else if (!strcasecmp(var->value, "sslv3")) {
369                 transport->tls.method = PJSIP_SSLV3_METHOD;
370         } else if (!strcasecmp(var->value, "sslv23")) {
371                 transport->tls.method = PJSIP_SSLV23_METHOD;
372         } else {
373                 return -1;
374         }
375
376         return 0;
377 }
378
379 static const char *tls_method_map[] = {
380         [PJSIP_SSL_DEFAULT_METHOD] = "default",
381         [PJSIP_SSL_UNSPECIFIED_METHOD] = "unspecified",
382         [PJSIP_TLSV1_METHOD] = "tlsv1",
383         [PJSIP_SSLV2_METHOD] = "sslv2",
384         [PJSIP_SSLV3_METHOD] = "sslv3",
385         [PJSIP_SSLV23_METHOD] = "sslv23",
386 };
387
388 static int tls_method_to_str(const void *obj, const intptr_t *args, char **buf)
389 {
390         const struct ast_sip_transport *transport = obj;
391         if (ARRAY_IN_BOUNDS(transport->tls.method, tls_method_map)) {
392                 *buf = ast_strdup(tls_method_map[transport->tls.method]);
393         }
394         return 0;
395 }
396
397 /*! \brief Helper function which turns a cipher name into an identifier */
398 static pj_ssl_cipher cipher_name_to_id(const char *name)
399 {
400         pj_ssl_cipher ciphers[100];
401         pj_ssl_cipher id = 0;
402         unsigned int cipher_num = PJ_ARRAY_SIZE(ciphers);
403         int pos;
404         const char *pos_name;
405
406         if (pj_ssl_cipher_get_availables(ciphers, &cipher_num)) {
407                 return 0;
408         }
409
410         for (pos = 0; pos < cipher_num; ++pos) {
411                 pos_name = pj_ssl_cipher_name(ciphers[pos]);
412                 if (!pos_name || strcmp(pos_name, name)) {
413                         continue;
414                 }
415
416                 id = ciphers[pos];
417                 break;
418         }
419
420         return id;
421 }
422
423 /*!
424  * \internal
425  * \brief Add a new cipher to the transport's cipher list array.
426  *
427  * \param transport Which transport to add the cipher to.
428  * \param name Cipher identifier name.
429  *
430  * \retval 0 on success.
431  * \retval -1 on error.
432  */
433 static int transport_cipher_add(struct ast_sip_transport *transport, const char *name)
434 {
435         pj_ssl_cipher cipher;
436         int idx;
437
438         cipher = cipher_name_to_id(name);
439         if (!cipher) {
440                 /* TODO: Check this over/tweak - it's taken from pjsua for now */
441                 if (!strnicmp(name, "0x", 2)) {
442                         pj_str_t cipher_st = pj_str((char *) name + 2);
443                         cipher = pj_strtoul2(&cipher_st, NULL, 16);
444                 } else {
445                         cipher = atoi(name);
446                 }
447         }
448
449         if (pj_ssl_cipher_is_supported(cipher)) {
450                 for (idx = transport->tls.ciphers_num; idx--;) {
451                         if (transport->ciphers[idx] == cipher) {
452                                 /* The cipher is already in the list. */
453                                 return 0;
454                         }
455                 }
456                 transport->ciphers[transport->tls.ciphers_num++] = cipher;
457                 return 0;
458         } else {
459                 ast_log(LOG_ERROR, "Cipher '%s' is unsupported\n", name);
460                 return -1;
461         }
462 }
463
464 /*! \brief Custom handler for TLS cipher setting */
465 static int transport_tls_cipher_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
466 {
467         struct ast_sip_transport *transport = obj;
468         char *parse;
469         char *name;
470         int res = 0;
471
472         parse = ast_strdupa(S_OR(var->value, ""));
473         while ((name = strsep(&parse, ","))) {
474                 name = ast_strip(name);
475                 if (ast_strlen_zero(name)) {
476                         continue;
477                 }
478                 if (ARRAY_LEN(transport->ciphers) <= transport->tls.ciphers_num) {
479                         ast_log(LOG_ERROR, "Too many ciphers specified\n");
480                         res = -1;
481                         break;
482                 }
483                 res |= transport_cipher_add(transport, name);
484         }
485         return res ? -1 : 0;
486 }
487
488 static void cipher_to_str(char **buf, const pj_ssl_cipher *ciphers, unsigned int cipher_num)
489 {
490         struct ast_str *str;
491         int idx;
492
493         str = ast_str_create(128);
494         if (!str) {
495                 *buf = NULL;
496                 return;
497         }
498
499         for (idx = 0; idx < cipher_num; ++idx) {
500                 ast_str_append(&str, 0, "%s", pj_ssl_cipher_name(ciphers[idx]));
501                 if (idx < cipher_num - 1) {
502                         ast_str_append(&str, 0, ", ");
503                 }
504         }
505
506         *buf = ast_strdup(ast_str_buffer(str));
507         ast_free(str);
508 }
509
510 static int transport_tls_cipher_to_str(const void *obj, const intptr_t *args, char **buf)
511 {
512         const struct ast_sip_transport *transport = obj;
513
514         cipher_to_str(buf, transport->ciphers, transport->tls.ciphers_num);
515         return *buf ? 0 : -1;
516 }
517
518 static char *handle_pjsip_list_ciphers(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
519 {
520         pj_ssl_cipher ciphers[100];
521         unsigned int cipher_num = PJ_ARRAY_SIZE(ciphers);
522         char *buf;
523
524         switch (cmd) {
525         case CLI_INIT:
526                 e->command = "pjsip list ciphers";
527                 e->usage = "Usage: pjsip list ciphers\n"
528                         "       List available OpenSSL cipher names.\n";
529                 return NULL;
530         case CLI_GENERATE:
531                 return NULL;
532         }
533
534         if (pj_ssl_cipher_get_availables(ciphers, &cipher_num) || !cipher_num) {
535                 buf = NULL;
536         } else {
537                 cipher_to_str(&buf, ciphers, cipher_num);
538         }
539
540         if (!ast_strlen_zero(buf)) {
541                 ast_cli(a->fd, "Available ciphers: '%s'\n", buf);
542         } else {
543                 ast_cli(a->fd, "No available ciphers\n");
544         }
545         ast_free(buf);
546         return CLI_SUCCESS;
547 }
548
549 /*! \brief Custom handler for localnet setting */
550 static int transport_localnet_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
551 {
552         struct ast_sip_transport *transport = obj;
553         int error = 0;
554
555         if (ast_strlen_zero(var->value)) {
556                 ast_free_ha(transport->localnet);
557                 transport->localnet = NULL;
558                 return 0;
559         }
560
561         if (!(transport->localnet = ast_append_ha("d", var->value, transport->localnet, &error))) {
562                 return -1;
563         }
564
565         return error;
566 }
567
568 static int localnet_to_vl(const void *obj, struct ast_variable **fields)
569 {
570         const struct ast_sip_transport *transport = obj;
571
572         char str[MAX_OBJECT_FIELD];
573         struct ast_variable *head = NULL;
574         struct ast_ha *ha = transport->localnet;
575
576         for (; ha; ha = ha->next) {
577                 const char *addr = ast_strdupa(ast_sockaddr_stringify_addr(&ha->addr));
578                 snprintf(str, MAX_OBJECT_FIELD, "%s%s/%s", ha->sense == AST_SENSE_ALLOW ? "!" : "",
579                         addr, ast_sockaddr_stringify_addr(&ha->netmask));
580
581                 ast_variable_list_append(&head, ast_variable_new("local_net", str, ""));
582         }
583
584         if (head) {
585                 *fields = head;
586         }
587
588         return 0;
589 }
590
591 static int localnet_to_str(const void *obj, const intptr_t *args, char **buf)
592 {
593         RAII_VAR(struct ast_str *, str, ast_str_create(MAX_OBJECT_FIELD), ast_free);
594         const struct ast_sip_transport *transport = obj;
595
596         ast_ha_join(transport->localnet, &str);
597         *buf = ast_strdup(ast_str_buffer(str));
598         return 0;
599 }
600
601 /*! \brief Custom handler for TOS setting */
602 static int transport_tos_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
603 {
604         struct ast_sip_transport *transport = obj;
605         unsigned int value;
606
607         if (ast_str2tos(var->value, &value)) {
608                 ast_log(LOG_ERROR, "Error configuring transport '%s' - Could not "
609                         "interpret 'tos' value '%s'\n",
610                         ast_sorcery_object_get_id(transport), var->value);
611                 return -1;
612         }
613
614         if (value % 4) {
615                 value = value >> 2;
616                 value = value << 2;
617                 ast_log(LOG_WARNING,
618                         "transport '%s' - 'tos' value '%s' uses bits that are "
619                         "discarded when converted to DSCP. Using equivalent %u instead.\n",
620                         ast_sorcery_object_get_id(transport), var->value, value);
621         }
622
623         transport->tos = value;
624         return 0;
625 }
626
627 static int tos_to_str(const void *obj, const intptr_t *args, char **buf)
628 {
629         const struct ast_sip_transport *transport = obj;
630
631         if (ast_asprintf(buf, "%u", transport->tos) == -1) {
632                 return -1;
633         }
634         return 0;
635 }
636
637 static struct ao2_container *cli_get_container(void)
638 {
639         RAII_VAR(struct ao2_container *, container, NULL, ao2_cleanup);
640         struct ao2_container *s_container;
641
642         container = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "transport",
643                 AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL);
644         if (!container) {
645                 return NULL;
646         }
647
648         s_container = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_NOLOCK, 0,
649                 ast_sorcery_object_id_sort, ast_sorcery_object_id_compare);
650         if (!s_container) {
651                 return NULL;
652         }
653
654         if (ao2_container_dup(s_container, container, 0)) {
655                 ao2_ref(s_container, -1);
656                 return NULL;
657         }
658
659         return s_container;
660 }
661
662 static int cli_iterate(void *container, ao2_callback_fn callback, void *args)
663 {
664         const struct ast_sip_endpoint *endpoint = container;
665         struct ast_sip_transport *transport = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(),
666                 "transport", endpoint->transport);
667
668         if (!transport) {
669                 return -1;
670         }
671
672         return callback(transport, args, 0);
673 }
674
675 static void *cli_retrieve_by_id(const char *id)
676 {
677         return ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "transport", id);
678 }
679
680 static int cli_print_header(void *obj, void *arg, int flags)
681 {
682         struct ast_sip_cli_context *context = arg;
683         int indent = CLI_INDENT_TO_SPACES(context->indent_level);
684         int filler = CLI_MAX_WIDTH - indent - 61;
685
686         ast_assert(context->output_buffer != NULL);
687
688         ast_str_append(&context->output_buffer, 0,
689                 "%*s:  <TransportId........>  <Type>  <cos>  <tos>  <BindAddress%*.*s>\n",
690                 indent, "Transport", filler, filler, CLI_HEADER_FILLER);
691
692         return 0;
693 }
694
695 static int cli_print_body(void *obj, void *arg, int flags)
696 {
697         struct ast_sip_transport *transport = obj;
698         struct ast_sip_cli_context *context = arg;
699         char hoststr[PJ_INET6_ADDRSTRLEN];
700
701         ast_assert(context->output_buffer != NULL);
702
703         pj_sockaddr_print(&transport->host, hoststr, sizeof(hoststr), 3);
704
705         ast_str_append(&context->output_buffer, 0, "%*s:  %-21s  %6s  %5u  %5u  %s\n",
706                 CLI_INDENT_TO_SPACES(context->indent_level), "Transport",
707                 ast_sorcery_object_get_id(transport),
708                 ARRAY_IN_BOUNDS(transport->type, transport_types) ? transport_types[transport->type] : "Unknown",
709                 transport->cos, transport->tos, hoststr);
710
711         if (context->show_details
712                 || (context->show_details_only_level_0 && context->indent_level == 0)) {
713                 ast_str_append(&context->output_buffer, 0, "\n");
714                 ast_sip_cli_print_sorcery_objectset(transport, context, 0);
715         }
716
717         return 0;
718 }
719
720 static struct ast_cli_entry cli_commands[] = {
721         AST_CLI_DEFINE(handle_pjsip_list_ciphers, "List available OpenSSL cipher names"),
722         AST_CLI_DEFINE(ast_sip_cli_traverse_objects, "List PJSIP Transports",
723                 .command = "pjsip list transports",
724                 .usage = "Usage: pjsip list transports\n"
725                                  "       List the configured PJSIP Transports\n"),
726         AST_CLI_DEFINE(ast_sip_cli_traverse_objects, "Show PJSIP Transports",
727                 .command = "pjsip show transports",
728                 .usage = "Usage: pjsip show transports\n"
729                                  "       Show the configured PJSIP Transport\n"),
730         AST_CLI_DEFINE(ast_sip_cli_traverse_objects, "Show PJSIP Transport",
731                 .command = "pjsip show transport",
732                 .usage = "Usage: pjsip show transport <id>\n"
733                                  "       Show the configured PJSIP Transport\n"),
734 };
735
736 static struct ast_sip_cli_formatter_entry *cli_formatter;
737
738 /*! \brief Initialize sorcery with transport support */
739 int ast_sip_initialize_sorcery_transport(void)
740 {
741         struct ast_sorcery *sorcery = ast_sip_get_sorcery();
742
743         ast_sorcery_apply_default(sorcery, "transport", "config", "pjsip.conf,criteria=type=transport");
744
745         if (ast_sorcery_object_register_no_reload(sorcery, "transport", transport_alloc, NULL, transport_apply)) {
746                 return -1;
747         }
748
749         ast_sorcery_object_field_register(sorcery, "transport", "type", "", OPT_NOOP_T, 0, 0);
750         ast_sorcery_object_field_register_custom(sorcery, "transport", "protocol", "udp", transport_protocol_handler, transport_protocol_to_str, NULL, 0, 0);
751         ast_sorcery_object_field_register_custom(sorcery, "transport", "bind", "", transport_bind_handler, transport_bind_to_str, NULL, 0, 0);
752         ast_sorcery_object_field_register(sorcery, "transport", "async_operations", "1", OPT_UINT_T, 0, FLDSET(struct ast_sip_transport, async_operations));
753         ast_sorcery_object_field_register(sorcery, "transport", "ca_list_file", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_transport, ca_list_file));
754         ast_sorcery_object_field_register(sorcery, "transport", "ca_list_path", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_transport, ca_list_path));
755         ast_sorcery_object_field_register(sorcery, "transport", "cert_file", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_transport, cert_file));
756         ast_sorcery_object_field_register(sorcery, "transport", "priv_key_file", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_transport, privkey_file));
757         ast_sorcery_object_field_register(sorcery, "transport", "password", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_transport, password));
758         ast_sorcery_object_field_register(sorcery, "transport", "external_signaling_address", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_transport, external_signaling_address));
759         ast_sorcery_object_field_register(sorcery, "transport", "external_signaling_port", "0", OPT_UINT_T, PARSE_IN_RANGE, FLDSET(struct ast_sip_transport, external_signaling_port), 0, 65535);
760         ast_sorcery_object_field_register(sorcery, "transport", "external_media_address", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_transport, external_media_address));
761         ast_sorcery_object_field_register(sorcery, "transport", "domain", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_transport, domain));
762         ast_sorcery_object_field_register_custom(sorcery, "transport", "verify_server", "", transport_tls_bool_handler, verify_server_to_str, NULL, 0, 0);
763         ast_sorcery_object_field_register_custom(sorcery, "transport", "verify_client", "", transport_tls_bool_handler, verify_client_to_str, NULL, 0, 0);
764         ast_sorcery_object_field_register_custom(sorcery, "transport", "require_client_cert", "", transport_tls_bool_handler, require_client_cert_to_str, NULL, 0, 0);
765         ast_sorcery_object_field_register_custom(sorcery, "transport", "method", "", transport_tls_method_handler, tls_method_to_str, NULL, 0, 0);
766         ast_sorcery_object_field_register_custom(sorcery, "transport", "cipher", "", transport_tls_cipher_handler, transport_tls_cipher_to_str, NULL, 0, 0);
767         ast_sorcery_object_field_register_custom(sorcery, "transport", "local_net", "", transport_localnet_handler, localnet_to_str, localnet_to_vl, 0, 0);
768         ast_sorcery_object_field_register_custom(sorcery, "transport", "tos", "0", transport_tos_handler, tos_to_str, NULL, 0, 0);
769         ast_sorcery_object_field_register(sorcery, "transport", "cos", "0", OPT_UINT_T, 0, FLDSET(struct ast_sip_transport, cos));
770         ast_sorcery_object_field_register(sorcery, "transport", "websocket_write_timeout", AST_DEFAULT_WEBSOCKET_WRITE_TIMEOUT_STR, OPT_INT_T, PARSE_IN_RANGE, FLDSET(struct ast_sip_transport, write_timeout), 1, INT_MAX);
771
772         internal_sip_register_endpoint_formatter(&endpoint_transport_formatter);
773
774         cli_formatter = ao2_alloc(sizeof(struct ast_sip_cli_formatter_entry), NULL);
775         if (!cli_formatter) {
776                 ast_log(LOG_ERROR, "Unable to allocate memory for cli formatter\n");
777                 return -1;
778         }
779         cli_formatter->name = "transport";
780         cli_formatter->print_header = cli_print_header;
781         cli_formatter->print_body = cli_print_body;
782         cli_formatter->get_container = cli_get_container;
783         cli_formatter->iterate = cli_iterate;
784         cli_formatter->get_id = ast_sorcery_object_get_id;
785         cli_formatter->retrieve_by_id = cli_retrieve_by_id;
786
787         ast_sip_register_cli_formatter(cli_formatter);
788         ast_cli_register_multiple(cli_commands, ARRAY_LEN(cli_commands));
789
790         return 0;
791 }
792
793 int ast_sip_destroy_sorcery_transport(void)
794 {
795         ast_cli_unregister_multiple(cli_commands, ARRAY_LEN(cli_commands));
796         ast_sip_unregister_cli_formatter(cli_formatter);
797
798         internal_sip_unregister_endpoint_formatter(&endpoint_transport_formatter);
799
800         return 0;
801 }