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