clang compiler warnings: Fix -Winitializer-overrides
[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_UNSPECIFIED_METHOD] = "unspecified",
381         [PJSIP_TLSV1_METHOD] = "tlsv1",
382         [PJSIP_SSLV2_METHOD] = "sslv2",
383         [PJSIP_SSLV3_METHOD] = "sslv3",
384         [PJSIP_SSLV23_METHOD] = "sslv23",
385 };
386
387 static int tls_method_to_str(const void *obj, const intptr_t *args, char **buf)
388 {
389         const struct ast_sip_transport *transport = obj;
390         if (ARRAY_IN_BOUNDS(transport->tls.method, tls_method_map)) {
391                 *buf = ast_strdup(tls_method_map[transport->tls.method]);
392         }
393         return 0;
394 }
395
396 /*! \brief Helper function which turns a cipher name into an identifier */
397 static pj_ssl_cipher cipher_name_to_id(const char *name)
398 {
399         pj_ssl_cipher ciphers[100];
400         pj_ssl_cipher id = 0;
401         unsigned int cipher_num = PJ_ARRAY_SIZE(ciphers);
402         int pos;
403         const char *pos_name;
404
405         if (pj_ssl_cipher_get_availables(ciphers, &cipher_num)) {
406                 return 0;
407         }
408
409         for (pos = 0; pos < cipher_num; ++pos) {
410                 pos_name = pj_ssl_cipher_name(ciphers[pos]);
411                 if (!pos_name || strcmp(pos_name, name)) {
412                         continue;
413                 }
414
415                 id = ciphers[pos];
416                 break;
417         }
418
419         return id;
420 }
421
422 /*!
423  * \internal
424  * \brief Add a new cipher to the transport's cipher list array.
425  *
426  * \param transport Which transport to add the cipher to.
427  * \param name Cipher identifier name.
428  *
429  * \retval 0 on success.
430  * \retval -1 on error.
431  */
432 static int transport_cipher_add(struct ast_sip_transport *transport, const char *name)
433 {
434         pj_ssl_cipher cipher;
435         int idx;
436
437         cipher = cipher_name_to_id(name);
438         if (!cipher) {
439                 /* TODO: Check this over/tweak - it's taken from pjsua for now */
440                 if (!strnicmp(name, "0x", 2)) {
441                         pj_str_t cipher_st = pj_str((char *) name + 2);
442                         cipher = pj_strtoul2(&cipher_st, NULL, 16);
443                 } else {
444                         cipher = atoi(name);
445                 }
446         }
447
448         if (pj_ssl_cipher_is_supported(cipher)) {
449                 for (idx = transport->tls.ciphers_num; idx--;) {
450                         if (transport->ciphers[idx] == cipher) {
451                                 /* The cipher is already in the list. */
452                                 return 0;
453                         }
454                 }
455                 transport->ciphers[transport->tls.ciphers_num++] = cipher;
456                 return 0;
457         } else {
458                 ast_log(LOG_ERROR, "Cipher '%s' is unsupported\n", name);
459                 return -1;
460         }
461 }
462
463 /*! \brief Custom handler for TLS cipher setting */
464 static int transport_tls_cipher_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
465 {
466         struct ast_sip_transport *transport = obj;
467         char *parse;
468         char *name;
469         int res = 0;
470
471         parse = ast_strdupa(S_OR(var->value, ""));
472         while ((name = strsep(&parse, ","))) {
473                 name = ast_strip(name);
474                 if (ast_strlen_zero(name)) {
475                         continue;
476                 }
477                 if (ARRAY_LEN(transport->ciphers) <= transport->tls.ciphers_num) {
478                         ast_log(LOG_ERROR, "Too many ciphers specified\n");
479                         res = -1;
480                         break;
481                 }
482                 res |= transport_cipher_add(transport, name);
483         }
484         return res ? -1 : 0;
485 }
486
487 static void cipher_to_str(char **buf, const pj_ssl_cipher *ciphers, unsigned int cipher_num)
488 {
489         struct ast_str *str;
490         int idx;
491
492         str = ast_str_create(128);
493         if (!str) {
494                 *buf = NULL;
495                 return;
496         }
497
498         for (idx = 0; idx < cipher_num; ++idx) {
499                 ast_str_append(&str, 0, "%s", pj_ssl_cipher_name(ciphers[idx]));
500                 if (idx < cipher_num - 1) {
501                         ast_str_append(&str, 0, ", ");
502                 }
503         }
504
505         *buf = ast_strdup(ast_str_buffer(str));
506         ast_free(str);
507 }
508
509 static int transport_tls_cipher_to_str(const void *obj, const intptr_t *args, char **buf)
510 {
511         const struct ast_sip_transport *transport = obj;
512
513         cipher_to_str(buf, transport->ciphers, transport->tls.ciphers_num);
514         return *buf ? 0 : -1;
515 }
516
517 static char *handle_pjsip_list_ciphers(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
518 {
519         pj_ssl_cipher ciphers[100];
520         unsigned int cipher_num = PJ_ARRAY_SIZE(ciphers);
521         char *buf;
522
523         switch (cmd) {
524         case CLI_INIT:
525                 e->command = "pjsip list ciphers";
526                 e->usage = "Usage: pjsip list ciphers\n"
527                         "       List available OpenSSL cipher names.\n";
528                 return NULL;
529         case CLI_GENERATE:
530                 return NULL;
531         }
532
533         if (pj_ssl_cipher_get_availables(ciphers, &cipher_num) || !cipher_num) {
534                 buf = NULL;
535         } else {
536                 cipher_to_str(&buf, ciphers, cipher_num);
537         }
538
539         if (!ast_strlen_zero(buf)) {
540                 ast_cli(a->fd, "Available ciphers: '%s'\n", buf);
541         } else {
542                 ast_cli(a->fd, "No available ciphers\n");
543         }
544         ast_free(buf);
545         return CLI_SUCCESS;
546 }
547
548 /*! \brief Custom handler for localnet setting */
549 static int transport_localnet_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
550 {
551         struct ast_sip_transport *transport = obj;
552         int error = 0;
553
554         if (ast_strlen_zero(var->value)) {
555                 ast_free_ha(transport->localnet);
556                 transport->localnet = NULL;
557                 return 0;
558         }
559
560         if (!(transport->localnet = ast_append_ha("d", var->value, transport->localnet, &error))) {
561                 return -1;
562         }
563
564         return error;
565 }
566
567 static int localnet_to_vl(const void *obj, struct ast_variable **fields)
568 {
569         const struct ast_sip_transport *transport = obj;
570
571         char str[MAX_OBJECT_FIELD];
572         struct ast_variable *head = NULL;
573         struct ast_ha *ha = transport->localnet;
574
575         for (; ha; ha = ha->next) {
576                 const char *addr = ast_strdupa(ast_sockaddr_stringify_addr(&ha->addr));
577                 snprintf(str, MAX_OBJECT_FIELD, "%s%s/%s", ha->sense == AST_SENSE_ALLOW ? "!" : "",
578                         addr, ast_sockaddr_stringify_addr(&ha->netmask));
579
580                 ast_variable_list_append(&head, ast_variable_new("local_net", str, ""));
581         }
582
583         if (head) {
584                 *fields = head;
585         }
586
587         return 0;
588 }
589
590 static int localnet_to_str(const void *obj, const intptr_t *args, char **buf)
591 {
592         RAII_VAR(struct ast_str *, str, ast_str_create(MAX_OBJECT_FIELD), ast_free);
593         const struct ast_sip_transport *transport = obj;
594
595         ast_ha_join(transport->localnet, &str);
596         *buf = ast_strdup(ast_str_buffer(str));
597         return 0;
598 }
599
600 /*! \brief Custom handler for TOS setting */
601 static int transport_tos_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
602 {
603         struct ast_sip_transport *transport = obj;
604         unsigned int value;
605
606         if (ast_str2tos(var->value, &value)) {
607                 ast_log(LOG_ERROR, "Error configuring transport '%s' - Could not "
608                         "interpret 'tos' value '%s'\n",
609                         ast_sorcery_object_get_id(transport), var->value);
610                 return -1;
611         }
612
613         if (value % 4) {
614                 value = value >> 2;
615                 value = value << 2;
616                 ast_log(LOG_WARNING,
617                         "transport '%s' - 'tos' value '%s' uses bits that are "
618                         "discarded when converted to DSCP. Using equivalent %u instead.\n",
619                         ast_sorcery_object_get_id(transport), var->value, value);
620         }
621
622         transport->tos = value;
623         return 0;
624 }
625
626 static int tos_to_str(const void *obj, const intptr_t *args, char **buf)
627 {
628         const struct ast_sip_transport *transport = obj;
629
630         if (ast_asprintf(buf, "%u", transport->tos) == -1) {
631                 return -1;
632         }
633         return 0;
634 }
635
636 static struct ao2_container *cli_get_container(void)
637 {
638         RAII_VAR(struct ao2_container *, container, NULL, ao2_cleanup);
639         struct ao2_container *s_container;
640
641         container = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "transport",
642                 AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL);
643         if (!container) {
644                 return NULL;
645         }
646
647         s_container = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_NOLOCK, 0,
648                 ast_sorcery_object_id_sort, ast_sorcery_object_id_compare);
649         if (!s_container) {
650                 return NULL;
651         }
652
653         if (ao2_container_dup(s_container, container, 0)) {
654                 ao2_ref(s_container, -1);
655                 return NULL;
656         }
657
658         return s_container;
659 }
660
661 static int cli_iterate(void *container, ao2_callback_fn callback, void *args)
662 {
663         const struct ast_sip_endpoint *endpoint = container;
664         struct ast_sip_transport *transport = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(),
665                 "transport", endpoint->transport);
666
667         if (!transport) {
668                 return -1;
669         }
670
671         return callback(transport, args, 0);
672 }
673
674 static void *cli_retrieve_by_id(const char *id)
675 {
676         return ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "transport", id);
677 }
678
679 static int cli_print_header(void *obj, void *arg, int flags)
680 {
681         struct ast_sip_cli_context *context = arg;
682         int indent = CLI_INDENT_TO_SPACES(context->indent_level);
683         int filler = CLI_MAX_WIDTH - indent - 61;
684
685         ast_assert(context->output_buffer != NULL);
686
687         ast_str_append(&context->output_buffer, 0,
688                 "%*s:  <TransportId........>  <Type>  <cos>  <tos>  <BindAddress%*.*s>\n",
689                 indent, "Transport", filler, filler, CLI_HEADER_FILLER);
690
691         return 0;
692 }
693
694 static int cli_print_body(void *obj, void *arg, int flags)
695 {
696         struct ast_sip_transport *transport = obj;
697         struct ast_sip_cli_context *context = arg;
698         char hoststr[PJ_INET6_ADDRSTRLEN];
699
700         ast_assert(context->output_buffer != NULL);
701
702         pj_sockaddr_print(&transport->host, hoststr, sizeof(hoststr), 3);
703
704         ast_str_append(&context->output_buffer, 0, "%*s:  %-21s  %6s  %5u  %5u  %s\n",
705                 CLI_INDENT_TO_SPACES(context->indent_level), "Transport",
706                 ast_sorcery_object_get_id(transport),
707                 ARRAY_IN_BOUNDS(transport->type, transport_types) ? transport_types[transport->type] : "Unknown",
708                 transport->cos, transport->tos, hoststr);
709
710         if (context->show_details
711                 || (context->show_details_only_level_0 && context->indent_level == 0)) {
712                 ast_str_append(&context->output_buffer, 0, "\n");
713                 ast_sip_cli_print_sorcery_objectset(transport, context, 0);
714         }
715
716         return 0;
717 }
718
719 static struct ast_cli_entry cli_commands[] = {
720         AST_CLI_DEFINE(handle_pjsip_list_ciphers, "List available OpenSSL cipher names"),
721         AST_CLI_DEFINE(ast_sip_cli_traverse_objects, "List PJSIP Transports",
722                 .command = "pjsip list transports",
723                 .usage = "Usage: pjsip list transports\n"
724                                  "       List the configured PJSIP Transports\n"),
725         AST_CLI_DEFINE(ast_sip_cli_traverse_objects, "Show PJSIP Transports",
726                 .command = "pjsip show transports",
727                 .usage = "Usage: pjsip show transports\n"
728                                  "       Show the configured PJSIP Transport\n"),
729         AST_CLI_DEFINE(ast_sip_cli_traverse_objects, "Show PJSIP Transport",
730                 .command = "pjsip show transport",
731                 .usage = "Usage: pjsip show transport <id>\n"
732                                  "       Show the configured PJSIP Transport\n"),
733 };
734
735 static struct ast_sip_cli_formatter_entry *cli_formatter;
736
737 /*! \brief Initialize sorcery with transport support */
738 int ast_sip_initialize_sorcery_transport(void)
739 {
740         struct ast_sorcery *sorcery = ast_sip_get_sorcery();
741
742         ast_sorcery_apply_default(sorcery, "transport", "config", "pjsip.conf,criteria=type=transport");
743
744         if (ast_sorcery_object_register_no_reload(sorcery, "transport", transport_alloc, NULL, transport_apply)) {
745                 return -1;
746         }
747
748         ast_sorcery_object_field_register(sorcery, "transport", "type", "", OPT_NOOP_T, 0, 0);
749         ast_sorcery_object_field_register_custom(sorcery, "transport", "protocol", "udp", transport_protocol_handler, transport_protocol_to_str, NULL, 0, 0);
750         ast_sorcery_object_field_register_custom(sorcery, "transport", "bind", "", transport_bind_handler, transport_bind_to_str, NULL, 0, 0);
751         ast_sorcery_object_field_register(sorcery, "transport", "async_operations", "1", OPT_UINT_T, 0, FLDSET(struct ast_sip_transport, async_operations));
752         ast_sorcery_object_field_register(sorcery, "transport", "ca_list_file", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_transport, ca_list_file));
753         ast_sorcery_object_field_register(sorcery, "transport", "ca_list_path", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_transport, ca_list_path));
754         ast_sorcery_object_field_register(sorcery, "transport", "cert_file", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_transport, cert_file));
755         ast_sorcery_object_field_register(sorcery, "transport", "priv_key_file", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_transport, privkey_file));
756         ast_sorcery_object_field_register(sorcery, "transport", "password", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_transport, password));
757         ast_sorcery_object_field_register(sorcery, "transport", "external_signaling_address", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_transport, external_signaling_address));
758         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);
759         ast_sorcery_object_field_register(sorcery, "transport", "external_media_address", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_transport, external_media_address));
760         ast_sorcery_object_field_register(sorcery, "transport", "domain", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_transport, domain));
761         ast_sorcery_object_field_register_custom(sorcery, "transport", "verify_server", "", transport_tls_bool_handler, verify_server_to_str, NULL, 0, 0);
762         ast_sorcery_object_field_register_custom(sorcery, "transport", "verify_client", "", transport_tls_bool_handler, verify_client_to_str, NULL, 0, 0);
763         ast_sorcery_object_field_register_custom(sorcery, "transport", "require_client_cert", "", transport_tls_bool_handler, require_client_cert_to_str, NULL, 0, 0);
764         ast_sorcery_object_field_register_custom(sorcery, "transport", "method", "", transport_tls_method_handler, tls_method_to_str, NULL, 0, 0);
765         ast_sorcery_object_field_register_custom(sorcery, "transport", "cipher", "", transport_tls_cipher_handler, transport_tls_cipher_to_str, NULL, 0, 0);
766         ast_sorcery_object_field_register_custom(sorcery, "transport", "local_net", "", transport_localnet_handler, localnet_to_str, localnet_to_vl, 0, 0);
767         ast_sorcery_object_field_register_custom(sorcery, "transport", "tos", "0", transport_tos_handler, tos_to_str, NULL, 0, 0);
768         ast_sorcery_object_field_register(sorcery, "transport", "cos", "0", OPT_UINT_T, 0, FLDSET(struct ast_sip_transport, cos));
769         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);
770
771         internal_sip_register_endpoint_formatter(&endpoint_transport_formatter);
772
773         cli_formatter = ao2_alloc(sizeof(struct ast_sip_cli_formatter_entry), NULL);
774         if (!cli_formatter) {
775                 ast_log(LOG_ERROR, "Unable to allocate memory for cli formatter\n");
776                 return -1;
777         }
778         cli_formatter->name = "transport";
779         cli_formatter->print_header = cli_print_header;
780         cli_formatter->print_body = cli_print_body;
781         cli_formatter->get_container = cli_get_container;
782         cli_formatter->iterate = cli_iterate;
783         cli_formatter->get_id = ast_sorcery_object_get_id;
784         cli_formatter->retrieve_by_id = cli_retrieve_by_id;
785
786         ast_sip_register_cli_formatter(cli_formatter);
787         ast_cli_register_multiple(cli_commands, ARRAY_LEN(cli_commands));
788
789         return 0;
790 }
791
792 int ast_sip_destroy_sorcery_transport(void)
793 {
794         ast_cli_unregister_multiple(cli_commands, ARRAY_LEN(cli_commands));
795         ast_sip_unregister_cli_formatter(cli_formatter);
796
797         internal_sip_unregister_endpoint_formatter(&endpoint_transport_formatter);
798
799         return 0;
800 }