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