Audit ast_pjsip_rdata_get_endpoint() usage for ref leaks.
[asterisk/asterisk.git] / res / res_pjsip_nat.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 /*** MODULEINFO
20         <depend>pjproject</depend>
21         <depend>res_pjsip</depend>
22         <support_level>core</support_level>
23  ***/
24
25 #include "asterisk.h"
26
27 #include <pjsip.h>
28 #include <pjsip_ua.h>
29
30 #include "asterisk/res_pjsip.h"
31 #include "asterisk/res_pjsip_session.h"
32 #include "asterisk/module.h"
33 #include "asterisk/acl.h"
34
35 static pj_bool_t handle_rx_message(struct ast_sip_endpoint *endpoint, pjsip_rx_data *rdata)
36 {
37         pjsip_contact_hdr *contact;
38
39         if (!endpoint) {
40                 return PJ_FALSE;
41         }
42
43         if (endpoint->nat.rewrite_contact && (contact = pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_CONTACT, NULL)) &&
44                 !contact->star && (PJSIP_URI_SCHEME_IS_SIP(contact->uri) || PJSIP_URI_SCHEME_IS_SIPS(contact->uri))) {
45                 pjsip_sip_uri *uri = pjsip_uri_get_uri(contact->uri);
46                 pjsip_dialog *dlg = pjsip_rdata_get_dlg(rdata);
47
48                 pj_cstr(&uri->host, rdata->pkt_info.src_name);
49                 if (strcasecmp("udp", rdata->tp_info.transport->type_name)) {
50                         uri->transport_param = pj_str(rdata->tp_info.transport->type_name);
51                 } else {
52                         uri->transport_param.slen = 0;
53                 }
54                 uri->port = rdata->pkt_info.src_port;
55                 ast_debug(4, "Re-wrote Contact URI host/port to %.*s:%d\n",
56                         (int)pj_strlen(&uri->host), pj_strbuf(&uri->host), uri->port);
57
58                 /* rewrite the session target since it may have already been pulled from the contact header */
59                 if (dlg && (!dlg->remote.contact
60                         || pjsip_uri_cmp(PJSIP_URI_IN_REQ_URI, dlg->remote.contact->uri, contact->uri))) {
61                         dlg->remote.contact = (pjsip_contact_hdr*)pjsip_hdr_clone(dlg->pool, contact);
62                         dlg->target = dlg->remote.contact->uri;
63                 }
64         }
65
66         if (endpoint->nat.force_rport) {
67                 rdata->msg_info.via->rport_param = rdata->pkt_info.src_port;
68         }
69
70         return PJ_FALSE;
71 }
72
73 static pj_bool_t nat_on_rx_message(pjsip_rx_data *rdata)
74 {
75         pj_bool_t res;
76         struct ast_sip_endpoint *endpoint;
77
78         endpoint = ast_pjsip_rdata_get_endpoint(rdata);
79         res = handle_rx_message(endpoint, rdata);
80         ao2_cleanup(endpoint);
81         return res;
82 }
83
84 /*! \brief Structure which contains information about a transport */
85 struct request_transport_details {
86         /*! \brief Type of transport */
87         enum ast_transport type;
88         /*! \brief Potential pointer to the transport itself, if UDP */
89         pjsip_transport *transport;
90         /*! \brief Potential pointer to the transport factory itself, if TCP/TLS */
91         pjsip_tpfactory *factory;
92         /*! \brief Local address for transport */
93         pj_str_t local_address;
94         /*! \brief Local port for transport */
95         int local_port;
96 };
97
98 /*! \brief Callback function for finding the transport the request is going out on */
99 static int find_transport_in_use(void *obj, void *arg, int flags)
100 {
101         struct ast_sip_transport *transport = obj;
102         struct request_transport_details *details = arg;
103
104         /* If an explicit transport or factory matches then this is what is in use, if we are unavailable
105          * to compare based on that we make sure that the type is the same and the source IP address/port are the same
106          */
107         if ((details->transport && details->transport == transport->state->transport) ||
108                 (details->factory && details->factory == transport->state->factory) ||
109                 ((details->type == transport->type) && (transport->state->factory) &&
110                         !pj_strcmp(&transport->state->factory->addr_name.host, &details->local_address) &&
111                         transport->state->factory->addr_name.port == details->local_port)) {
112                 return CMP_MATCH | CMP_STOP;
113         }
114
115         return 0;
116 }
117
118 /*! \brief Helper function which returns the SIP URI of a Contact header */
119 static pjsip_sip_uri *nat_get_contact_sip_uri(pjsip_tx_data *tdata)
120 {
121         pjsip_contact_hdr *contact = pjsip_msg_find_hdr(tdata->msg, PJSIP_H_CONTACT, NULL);
122
123         if (!contact || (!PJSIP_URI_SCHEME_IS_SIP(contact->uri) && !PJSIP_URI_SCHEME_IS_SIPS(contact->uri))) {
124                 return NULL;
125         }
126
127         return pjsip_uri_get_uri(contact->uri);
128 }
129
130 /*! \brief Structure which contains hook details */
131 struct nat_hook_details {
132         /*! \brief Outgoing message itself */
133         pjsip_tx_data *tdata;
134         /*! \brief Chosen transport */
135         struct ast_sip_transport *transport;
136 };
137
138 /*! \brief Callback function for invoking hooks */
139 static int nat_invoke_hook(void *obj, void *arg, int flags)
140 {
141         struct ast_sip_nat_hook *hook = obj;
142         struct nat_hook_details *details = arg;
143
144         if (hook->outgoing_external_message) {
145                 hook->outgoing_external_message(details->tdata, details->transport);
146         }
147
148         return 0;
149 }
150
151 static pj_status_t nat_on_tx_message(pjsip_tx_data *tdata)
152 {
153         RAII_VAR(struct ao2_container *, transports, NULL, ao2_cleanup);
154         RAII_VAR(struct ast_sip_transport *, transport, NULL, ao2_cleanup);
155         struct request_transport_details details = { 0, };
156         pjsip_via_hdr *via = NULL;
157         struct ast_sockaddr addr = { { 0, } };
158         pjsip_sip_uri *uri = NULL;
159         RAII_VAR(struct ao2_container *, hooks, NULL, ao2_cleanup);
160
161         /* If a transport selector is in use we know the transport or factory, so explicitly find it */
162         if (tdata->tp_sel.type == PJSIP_TPSELECTOR_TRANSPORT) {
163                 details.transport = tdata->tp_sel.u.transport;
164         } else if (tdata->tp_sel.type == PJSIP_TPSELECTOR_LISTENER) {
165                 details.factory = tdata->tp_sel.u.listener;
166         } else if (tdata->tp_info.transport->key.type == PJSIP_TRANSPORT_UDP || tdata->tp_info.transport->key.type == PJSIP_TRANSPORT_UDP6) {
167                 /* Connectionless uses the same transport for all requests */
168                 details.type = AST_TRANSPORT_UDP;
169                 details.transport = tdata->tp_info.transport;
170         } else {
171                 if (tdata->tp_info.transport->key.type == PJSIP_TRANSPORT_TCP) {
172                         details.type = AST_TRANSPORT_TCP;
173                 } else if (tdata->tp_info.transport->key.type == PJSIP_TRANSPORT_TLS) {
174                         details.type = AST_TRANSPORT_TLS;
175                 } else {
176                         /* Unknown transport type, we can't map and thus can't apply NAT changes */
177                         return PJ_SUCCESS;
178                 }
179
180                 if ((uri = nat_get_contact_sip_uri(tdata))) {
181                         details.local_address = uri->host;
182                         details.local_port = uri->port;
183                 } else if ((tdata->msg->type == PJSIP_REQUEST_MSG) &&
184                         (via = pjsip_msg_find_hdr(tdata->msg, PJSIP_H_VIA, NULL))) {
185                         details.local_address = via->sent_by.host;
186                         details.local_port = via->sent_by.port;
187                 } else {
188                         return PJ_SUCCESS;
189                 }
190
191                 if (!details.local_port) {
192                         details.local_port = (details.type == AST_TRANSPORT_TLS) ? 5061 : 5060;
193                 }
194         }
195
196         if (!(transports = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "transport", AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL)) ||
197                 !(transport = ao2_callback(transports, 0, find_transport_in_use, &details)) || !transport->localnet ||
198                 ast_sockaddr_isnull(&transport->external_address)) {
199                 return PJ_SUCCESS;
200         }
201
202         ast_sockaddr_parse(&addr, tdata->tp_info.dst_name, PARSE_PORT_FORBID);
203         ast_sockaddr_set_port(&addr, tdata->tp_info.dst_port);
204
205         /* See if where we are sending this request is local or not, and if not that we can get a Contact URI to modify */
206         if (ast_apply_ha(transport->localnet, &addr) != AST_SENSE_ALLOW) {
207                 return PJ_SUCCESS;
208         }
209
210         /* Update the contact header with the external address */
211         if (uri || (uri = nat_get_contact_sip_uri(tdata))) {
212                 pj_strdup2(tdata->pool, &uri->host, ast_sockaddr_stringify_host(&transport->external_address));
213                 if (transport->external_signaling_port) {
214                         uri->port = transport->external_signaling_port;
215                         ast_debug(4, "Re-wrote Contact URI port to %d\n", uri->port);
216                 }
217         }
218
219         /* Update the via header if relevant */
220         if ((tdata->msg->type == PJSIP_REQUEST_MSG) && (via || (via = pjsip_msg_find_hdr(tdata->msg, PJSIP_H_VIA, NULL)))) {
221                 pj_strdup2(tdata->pool, &via->sent_by.host, ast_sockaddr_stringify_host(&transport->external_address));
222                 if (transport->external_signaling_port) {
223                         via->sent_by.port = transport->external_signaling_port;
224                 }
225         }
226
227         /* Invoke any additional hooks that may be registered */
228         if ((hooks = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "nat_hook", AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL))) {
229                 struct nat_hook_details hook_details = {
230                         .tdata = tdata,
231                         .transport = transport,
232                 };
233                 ao2_callback(hooks, 0, nat_invoke_hook, &hook_details);
234         }
235
236         return PJ_SUCCESS;
237 }
238
239 static pjsip_module nat_module = {
240         .name = { "NAT", 3 },
241         .id = -1,
242         .priority = PJSIP_MOD_PRIORITY_TSX_LAYER - 2,
243         .on_rx_request = nat_on_rx_message,
244         .on_rx_response = nat_on_rx_message,
245         .on_tx_request = nat_on_tx_message,
246         .on_tx_response = nat_on_tx_message,
247 };
248
249 /*! \brief Function called when an INVITE goes out */
250 static int nat_incoming_invite_request(struct ast_sip_session *session, struct pjsip_rx_data *rdata)
251 {
252         if (session->inv_session->state == PJSIP_INV_STATE_INCOMING) {
253                 pjsip_dlg_add_usage(session->inv_session->dlg, &nat_module, NULL);
254         }
255
256         return 0;
257 }
258
259 /*! \brief Function called when an INVITE response comes in */
260 static void nat_incoming_invite_response(struct ast_sip_session *session, struct pjsip_rx_data *rdata)
261 {
262         handle_rx_message(session->endpoint, rdata);
263 }
264
265 /*! \brief Function called when an INVITE comes in */
266 static void nat_outgoing_invite_request(struct ast_sip_session *session, struct pjsip_tx_data *tdata)
267 {
268         if (session->inv_session->state == PJSIP_INV_STATE_NULL) {
269                 pjsip_dlg_add_usage(session->inv_session->dlg, &nat_module, NULL);
270         }
271 }
272
273 /*! \brief Supplement for adding NAT functionality to dialog */
274 static struct ast_sip_session_supplement nat_supplement = {
275         .method = "INVITE",
276         .priority = AST_SIP_SUPPLEMENT_PRIORITY_FIRST + 1,
277         .incoming_request = nat_incoming_invite_request,
278         .outgoing_request = nat_outgoing_invite_request,
279         .incoming_response = nat_incoming_invite_response,
280 };
281
282
283 static int unload_module(void)
284 {
285         ast_sip_session_unregister_supplement(&nat_supplement);
286         ast_sip_unregister_service(&nat_module);
287         return 0;
288 }
289
290 static int load_module(void)
291 {
292         CHECK_PJSIP_SESSION_MODULE_LOADED();
293
294         if (ast_sip_register_service(&nat_module)) {
295                 ast_log(LOG_ERROR, "Could not register NAT module for incoming and outgoing requests\n");
296                 return AST_MODULE_LOAD_FAILURE;
297         }
298
299         if (ast_sip_session_register_supplement(&nat_supplement)) {
300                 ast_log(LOG_ERROR, "Could not register NAT session supplement for incoming and outgoing INVITE requests\n");
301                 unload_module();
302                 return AST_MODULE_LOAD_FAILURE;
303         }
304
305         return AST_MODULE_LOAD_SUCCESS;
306 }
307
308 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "PJSIP NAT Support",
309                 .support_level = AST_MODULE_SUPPORT_CORE,
310                 .load = load_module,
311                 .unload = unload_module,
312                 .load_pri = AST_MODPRI_APP_DEPEND,
313                );