build: Update config.guess and config.sub
[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 void rewrite_uri(pjsip_rx_data *rdata, pjsip_sip_uri *uri)
36 {
37         pj_cstr(&uri->host, rdata->pkt_info.src_name);
38         uri->port = rdata->pkt_info.src_port;
39         if (!strcasecmp("WSS", rdata->tp_info.transport->type_name)) {
40                 /* WSS is special, we don't want to overwrite the URI at all as it needs to be ws */
41         } else if (strcasecmp("udp", rdata->tp_info.transport->type_name)) {
42                 uri->transport_param = pj_str(rdata->tp_info.transport->type_name);
43         } else {
44                 uri->transport_param.slen = 0;
45         }
46 }
47
48 /*
49  * Update the Record-Route headers in the request or response and in the dialog
50  * object if exists.
51  *
52  * When NAT is in use, the address of the next hop in the SIP may be incorrect.
53  * To address this  asterisk uses two strategies in parallel:
54  *  1. intercept the messages at the transaction level and rewrite the
55  *     messages before arriving at the dialog layer
56  *  2. after the application processing, update the dialog object with the
57  *     correct information
58  *
59  * The first strategy has a limitation that the SIP message may not have all
60  * the information required to determine if the next hop is in the route set
61  * or in the contact. Causing risk that asterisk will update the Contact on
62  * receipt of an in-dialog message despite there being a route set saved in
63  * the dialog.
64  *
65  * The second strategy has a limitation that not all UAC layers have interfaces
66  * available to invoke this module after dialog creation.  (pjsip_sesion does
67  * but pjsip_pubsub does not), thus this strategy can't update the dialog in
68  * all cases needed.
69  *
70  * The ideal solution would be to implement an "incomming_request" event
71  * in pubsub module that can then pass the dialog object to this module
72  * on SUBSCRIBE, this module then should add itself as a listener to the dialog
73  * for the subsequent requests and responses & then be able to properly update
74  * the dialog object for all required events.
75  */
76
77 static int rewrite_route_set(pjsip_rx_data *rdata, pjsip_dialog *dlg)
78 {
79         pjsip_rr_hdr *rr = NULL;
80         pjsip_sip_uri *uri;
81         int res = -1;
82         int ignore_rr = 0;
83         int pubsub = 0;
84
85         if (rdata->msg_info.msg->type == PJSIP_RESPONSE_MSG) {
86                 pjsip_hdr *iter;
87                 for (iter = rdata->msg_info.msg->hdr.prev; iter != &rdata->msg_info.msg->hdr; iter = iter->prev) {
88                         if (iter->type == PJSIP_H_RECORD_ROUTE) {
89                                 rr = (pjsip_rr_hdr *)iter;
90                                 break;
91                         }
92                 }
93         } else if (pjsip_method_cmp(&rdata->msg_info.msg->line.req.method, &pjsip_register_method)) {
94                 rr = pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_RECORD_ROUTE, NULL);
95         } else {
96                 /**
97                  * Record-Route header has no meaning in REGISTER requests
98                  * and should be ignored
99                  */
100                 ignore_rr = 1;
101         }
102
103         if (!pjsip_method_cmp(&rdata->msg_info.cseq->method, &pjsip_subscribe_method) ||
104                 !pjsip_method_cmp(&rdata->msg_info.cseq->method, &pjsip_notify_method)) {
105                 /**
106                  * There is currently no good way to get the dlg object for a pubsub dialog
107                  * so we will just look at the rr & contact of the current message and
108                  * hope for the best
109                  */
110                 pubsub = 1;
111         }
112
113         if (rr) {
114                 uri = pjsip_uri_get_uri(&rr->name_addr);
115                 rewrite_uri(rdata, uri);
116                 res = 0;
117         }
118
119         if (dlg && !pj_list_empty(&dlg->route_set) && !dlg->route_set_frozen) {
120                 pjsip_routing_hdr *route = dlg->route_set.next;
121                 uri = pjsip_uri_get_uri(&route->name_addr);
122                 rewrite_uri(rdata, uri);
123                 res = 0;
124         }
125
126         if (!dlg && !rr && !ignore_rr  && !pubsub && rdata->msg_info.to->tag.slen){
127                 /**
128                  * Even if this message doesn't have any route headers
129                  * the dialog may, so wait until a later invocation that
130                  * has a dialog reference to make sure there isn't a
131                  * previously saved routset in the dialog before deciding
132                  * the contact needs to be modified
133                  */
134                 res = 0;
135         }
136
137         return res;
138 }
139
140 static int rewrite_contact(pjsip_rx_data *rdata, pjsip_dialog *dlg)
141 {
142         pjsip_contact_hdr *contact;
143
144         contact = pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_CONTACT, NULL);
145         if (contact && !contact->star && (PJSIP_URI_SCHEME_IS_SIP(contact->uri) || PJSIP_URI_SCHEME_IS_SIPS(contact->uri))) {
146                 pjsip_sip_uri *uri = pjsip_uri_get_uri(contact->uri);
147
148                 rewrite_uri(rdata, uri);
149
150                 if (dlg && pj_list_empty(&dlg->route_set) && (!dlg->remote.contact
151                         || pjsip_uri_cmp(PJSIP_URI_IN_REQ_URI, dlg->remote.contact->uri, contact->uri))) {
152                         dlg->remote.contact = (pjsip_contact_hdr*)pjsip_hdr_clone(dlg->pool, contact);
153                         dlg->target = dlg->remote.contact->uri;
154                 }
155                 return 0;
156         }
157
158         return -1;
159 }
160
161 static pj_bool_t handle_rx_message(struct ast_sip_endpoint *endpoint, pjsip_rx_data *rdata)
162 {
163         pjsip_dialog *dlg = pjsip_rdata_get_dlg(rdata);
164
165         if (!endpoint) {
166                 return PJ_FALSE;
167         }
168
169         if (endpoint->nat.rewrite_contact) {
170                 /* rewrite_contact is intended to ensure we send requests/responses to
171                  * a routeable address when NAT is involved. The URI that dictates where
172                  * we send requests/responses can be determined either by Record-Route
173                  * headers or by the Contact header if no Record-Route headers are present.
174                  * We therefore will attempt to rewrite a Record-Route header first, and if
175                  * none are present, we fall back to rewriting the Contact header instead.
176                  */
177                 if (rewrite_route_set(rdata, dlg)) {
178                         rewrite_contact(rdata, dlg);
179                 }
180         }
181
182         if (endpoint->nat.force_rport) {
183                 rdata->msg_info.via->rport_param = rdata->pkt_info.src_port;
184         }
185
186         return PJ_FALSE;
187 }
188
189 static pj_bool_t nat_on_rx_message(pjsip_rx_data *rdata)
190 {
191         pj_bool_t res;
192         struct ast_sip_endpoint *endpoint;
193
194         endpoint = ast_pjsip_rdata_get_endpoint(rdata);
195         res = handle_rx_message(endpoint, rdata);
196         ao2_cleanup(endpoint);
197         return res;
198 }
199
200 /*! \brief Structure which contains information about a transport */
201 struct request_transport_details {
202         /*! \brief Type of transport */
203         enum ast_transport type;
204         /*! \brief Potential pointer to the transport itself, if UDP */
205         pjsip_transport *transport;
206         /*! \brief Potential pointer to the transport factory itself, if TCP/TLS */
207         pjsip_tpfactory *factory;
208         /*! \brief Local address for transport */
209         pj_str_t local_address;
210         /*! \brief Local port for transport */
211         int local_port;
212 };
213
214 /*! \brief Callback function for finding the transport the request is going out on */
215 static int find_transport_state_in_use(void *obj, void *arg, int flags)
216 {
217         struct ast_sip_transport_state *transport_state = obj;
218         struct request_transport_details *details = arg;
219
220         /* If an explicit transport or factory matches then this is what is in use, if we are unavailable
221          * to compare based on that we make sure that the type is the same and the source IP address/port are the same
222          */
223         if (transport_state && ((details->transport && details->transport == transport_state->transport) ||
224                 (details->factory && details->factory == transport_state->factory) ||
225                 ((details->type == transport_state->type) && (transport_state->factory) &&
226                         !pj_strcmp(&transport_state->factory->addr_name.host, &details->local_address) &&
227                         transport_state->factory->addr_name.port == details->local_port))) {
228                 return CMP_MATCH;
229         }
230
231         return 0;
232 }
233
234 /*! \brief Helper function which returns the SIP URI of a Contact header */
235 static pjsip_sip_uri *nat_get_contact_sip_uri(pjsip_tx_data *tdata)
236 {
237         pjsip_contact_hdr *contact = pjsip_msg_find_hdr(tdata->msg, PJSIP_H_CONTACT, NULL);
238
239         if (!contact || (!PJSIP_URI_SCHEME_IS_SIP(contact->uri) && !PJSIP_URI_SCHEME_IS_SIPS(contact->uri))) {
240                 return NULL;
241         }
242
243         return pjsip_uri_get_uri(contact->uri);
244 }
245
246 /*! \brief Structure which contains hook details */
247 struct nat_hook_details {
248         /*! \brief Outgoing message itself */
249         pjsip_tx_data *tdata;
250         /*! \brief Chosen transport */
251         struct ast_sip_transport *transport;
252 };
253
254 /*! \brief Callback function for invoking hooks */
255 static int nat_invoke_hook(void *obj, void *arg, int flags)
256 {
257         struct ast_sip_nat_hook *hook = obj;
258         struct nat_hook_details *details = arg;
259
260         if (hook->outgoing_external_message) {
261                 hook->outgoing_external_message(details->tdata, details->transport);
262         }
263
264         return 0;
265 }
266
267 static pj_status_t nat_on_tx_message(pjsip_tx_data *tdata)
268 {
269         RAII_VAR(struct ao2_container *, transport_states, NULL, ao2_cleanup);
270         RAII_VAR(struct ast_sip_transport *, transport, NULL, ao2_cleanup);
271         RAII_VAR(struct ast_sip_transport_state *, transport_state, NULL, ao2_cleanup);
272         struct request_transport_details details = { 0, };
273         pjsip_via_hdr *via = NULL;
274         struct ast_sockaddr addr = { { 0, } };
275         pjsip_sip_uri *uri = NULL;
276         RAII_VAR(struct ao2_container *, hooks, NULL, ao2_cleanup);
277
278         /* If a transport selector is in use we know the transport or factory, so explicitly find it */
279         if (tdata->tp_sel.type == PJSIP_TPSELECTOR_TRANSPORT) {
280                 details.transport = tdata->tp_sel.u.transport;
281         } else if (tdata->tp_sel.type == PJSIP_TPSELECTOR_LISTENER) {
282                 details.factory = tdata->tp_sel.u.listener;
283         } else if (tdata->tp_info.transport->key.type == PJSIP_TRANSPORT_UDP || tdata->tp_info.transport->key.type == PJSIP_TRANSPORT_UDP6) {
284                 /* Connectionless uses the same transport for all requests */
285                 details.type = AST_TRANSPORT_UDP;
286                 details.transport = tdata->tp_info.transport;
287         } else {
288                 if (tdata->tp_info.transport->key.type == PJSIP_TRANSPORT_TCP) {
289                         details.type = AST_TRANSPORT_TCP;
290                 } else if (tdata->tp_info.transport->key.type == PJSIP_TRANSPORT_TLS) {
291                         details.type = AST_TRANSPORT_TLS;
292                 } else {
293                         /* Unknown transport type, we can't map and thus can't apply NAT changes */
294                         return PJ_SUCCESS;
295                 }
296
297                 if ((uri = nat_get_contact_sip_uri(tdata))) {
298                         details.local_address = uri->host;
299                         details.local_port = uri->port;
300                 } else if ((tdata->msg->type == PJSIP_REQUEST_MSG) &&
301                         (via = pjsip_msg_find_hdr(tdata->msg, PJSIP_H_VIA, NULL))) {
302                         details.local_address = via->sent_by.host;
303                         details.local_port = via->sent_by.port;
304                 } else {
305                         return PJ_SUCCESS;
306                 }
307
308                 if (!details.local_port) {
309                         details.local_port = (details.type == AST_TRANSPORT_TLS) ? 5061 : 5060;
310                 }
311         }
312
313         if (!(transport_states = ast_sip_get_transport_states())) {
314                 return PJ_SUCCESS;
315         }
316
317         if (!(transport_state = ao2_callback(transport_states, 0, find_transport_state_in_use, &details))) {
318                 return PJ_SUCCESS;
319         }
320
321         if (!(transport = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "transport", transport_state->id))) {
322                 return PJ_SUCCESS;
323         }
324
325         if (transport_state->localnet) {
326                 ast_sockaddr_parse(&addr, tdata->tp_info.dst_name, PARSE_PORT_FORBID);
327                 ast_sockaddr_set_port(&addr, tdata->tp_info.dst_port);
328
329                 /* See if where we are sending this request is local or not, and if not that we can get a Contact URI to modify */
330                 if (ast_sip_transport_is_local(transport_state, &addr)) {
331                         ast_debug(5, "Request is being sent to local address, skipping NAT manipulation\n");
332                         return PJ_SUCCESS;
333                 }
334         }
335
336         if (!ast_sockaddr_isnull(&transport_state->external_signaling_address)) {
337                 /* Update the contact header with the external address */
338                 if (uri || (uri = nat_get_contact_sip_uri(tdata))) {
339                         pj_strdup2(tdata->pool, &uri->host, ast_sockaddr_stringify_host(&transport_state->external_signaling_address));
340                         if (transport->external_signaling_port) {
341                                 uri->port = transport->external_signaling_port;
342                                 ast_debug(4, "Re-wrote Contact URI port to %d\n", uri->port);
343                         }
344                 }
345
346                 /* Update the via header if relevant */
347                 if ((tdata->msg->type == PJSIP_REQUEST_MSG) && (via || (via = pjsip_msg_find_hdr(tdata->msg, PJSIP_H_VIA, NULL)))) {
348                         pj_strdup2(tdata->pool, &via->sent_by.host, ast_sockaddr_stringify_host(&transport_state->external_signaling_address));
349                         if (transport->external_signaling_port) {
350                                 via->sent_by.port = transport->external_signaling_port;
351                         }
352                 }
353         }
354
355         /* Invoke any additional hooks that may be registered */
356         if ((hooks = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "nat_hook", AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL))) {
357                 struct nat_hook_details hook_details = {
358                         .tdata = tdata,
359                         .transport = transport,
360                 };
361                 ao2_callback(hooks, 0, nat_invoke_hook, &hook_details);
362         }
363
364         return PJ_SUCCESS;
365 }
366
367 static pjsip_module nat_module = {
368         .name = { "NAT", 3 },
369         .id = -1,
370         .priority = PJSIP_MOD_PRIORITY_TSX_LAYER - 2,
371         .on_rx_request = nat_on_rx_message,
372         .on_rx_response = nat_on_rx_message,
373         .on_tx_request = nat_on_tx_message,
374         .on_tx_response = nat_on_tx_message,
375 };
376
377 /*! \brief Function called when an INVITE goes out */
378 static int nat_incoming_invite_request(struct ast_sip_session *session, struct pjsip_rx_data *rdata)
379 {
380         if (session->inv_session->state == PJSIP_INV_STATE_INCOMING) {
381                 pjsip_dlg_add_usage(session->inv_session->dlg, &nat_module, NULL);
382         }
383
384         return 0;
385 }
386
387 /*! \brief Function called when an INVITE response comes in */
388 static void nat_incoming_invite_response(struct ast_sip_session *session, struct pjsip_rx_data *rdata)
389 {
390         handle_rx_message(session->endpoint, rdata);
391 }
392
393 /*! \brief Function called when an INVITE comes in */
394 static void nat_outgoing_invite_request(struct ast_sip_session *session, struct pjsip_tx_data *tdata)
395 {
396         if (session->inv_session->state == PJSIP_INV_STATE_NULL) {
397                 pjsip_dlg_add_usage(session->inv_session->dlg, &nat_module, NULL);
398         }
399 }
400
401 /*! \brief Supplement for adding NAT functionality to dialog */
402 static struct ast_sip_session_supplement nat_supplement = {
403         .method = "INVITE",
404         .priority = AST_SIP_SUPPLEMENT_PRIORITY_FIRST + 1,
405         .incoming_request = nat_incoming_invite_request,
406         .outgoing_request = nat_outgoing_invite_request,
407         .incoming_response = nat_incoming_invite_response,
408 };
409
410
411 static int unload_module(void)
412 {
413         ast_sip_session_unregister_supplement(&nat_supplement);
414         ast_sip_unregister_service(&nat_module);
415         return 0;
416 }
417
418 static int load_module(void)
419 {
420         if (ast_sip_register_service(&nat_module)) {
421                 ast_log(LOG_ERROR, "Could not register NAT module for incoming and outgoing requests\n");
422                 return AST_MODULE_LOAD_DECLINE;
423         }
424
425         ast_sip_session_register_supplement(&nat_supplement);
426
427         return AST_MODULE_LOAD_SUCCESS;
428 }
429
430 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "PJSIP NAT Support",
431         .support_level = AST_MODULE_SUPPORT_CORE,
432         .load = load_module,
433         .unload = unload_module,
434         .load_pri = AST_MODPRI_APP_DEPEND,
435         .requires = "res_pjsip,res_pjsip_session",
436 );