e32f02833f7dc94561c556e58fa1430a07ad6d31
[asterisk/asterisk.git] / res / res_pjsip / pjsip_distributor.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2013, Digium, Inc.
5  *
6  * Mark Michelson <mmichelson@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
23 #include "asterisk/res_pjsip.h"
24 #include "include/res_pjsip_private.h"
25
26 static int distribute(void *data);
27 static pj_bool_t distributor(pjsip_rx_data *rdata);
28
29 static pjsip_module distributor_mod = {
30         .name = {"Request Distributor", 19},
31         .priority = PJSIP_MOD_PRIORITY_TSX_LAYER - 6,
32         .on_rx_request = distributor,
33         .on_rx_response = distributor,
34 };
35
36 /*! Dialog-specific information the distributor uses */
37 struct distributor_dialog_data {
38         /* Serializer to distribute tasks to for this dialog */
39         struct ast_taskprocessor *serializer;
40         /* Endpoint associated with this dialog */
41         struct ast_sip_endpoint *endpoint;
42 };
43
44 /*!
45  * \internal
46  *
47  * \note Call this with the dialog locked
48  */
49 static struct distributor_dialog_data *distributor_dialog_data_alloc(pjsip_dialog *dlg)
50 {
51         struct distributor_dialog_data *dist;
52
53         dist = PJ_POOL_ZALLOC_T(dlg->pool, struct distributor_dialog_data);
54         pjsip_dlg_set_mod_data(dlg, distributor_mod.id, dist);
55
56         return dist;
57 }
58
59 void ast_sip_dialog_set_serializer(pjsip_dialog *dlg, struct ast_taskprocessor *serializer)
60 {
61         struct distributor_dialog_data *dist;
62         SCOPED_LOCK(lock, dlg, pjsip_dlg_inc_lock, pjsip_dlg_dec_lock);
63
64         dist = pjsip_dlg_get_mod_data(dlg, distributor_mod.id);
65         if (!dist) {
66                 dist = distributor_dialog_data_alloc(dlg);
67         }
68         dist->serializer = serializer;
69 }
70
71 void ast_sip_dialog_set_endpoint(pjsip_dialog *dlg, struct ast_sip_endpoint *endpoint)
72 {
73         struct distributor_dialog_data *dist;
74         SCOPED_LOCK(lock, dlg, pjsip_dlg_inc_lock, pjsip_dlg_dec_lock);
75
76         dist = pjsip_dlg_get_mod_data(dlg, distributor_mod.id);
77         if (!dist) {
78                 dist = distributor_dialog_data_alloc(dlg);
79         }
80         dist->endpoint = endpoint;
81 }
82
83 struct ast_sip_endpoint *ast_sip_dialog_get_endpoint(pjsip_dialog *dlg)
84 {
85         struct distributor_dialog_data *dist;
86         SCOPED_LOCK(lock, dlg, pjsip_dlg_inc_lock, pjsip_dlg_dec_lock);
87
88         dist = pjsip_dlg_get_mod_data(dlg, distributor_mod.id);
89         if (!dist || !dist->endpoint) {
90                 return NULL;
91         }
92         ao2_ref(dist->endpoint, +1);
93         return dist->endpoint;
94 }
95
96 static pjsip_dialog *find_dialog(pjsip_rx_data *rdata)
97 {
98         pj_str_t tsx_key;
99         pjsip_transaction *tsx;
100         pjsip_dialog *dlg;
101         pj_str_t *local_tag;
102         pj_str_t *remote_tag;
103
104         if (!rdata->msg_info.msg) {
105                 return NULL;
106         }
107
108         if (rdata->msg_info.msg->type == PJSIP_REQUEST_MSG) {
109                 local_tag = &rdata->msg_info.to->tag;
110                 remote_tag = &rdata->msg_info.from->tag;
111         } else {
112                 local_tag = &rdata->msg_info.from->tag;
113                 remote_tag = &rdata->msg_info.to->tag;
114         }
115
116         /* We can only call the convenient method for
117          *  1) responses
118          *  2) non-CANCEL requests
119          *  3) CANCEL requests with a to-tag
120          */
121         if (rdata->msg_info.msg->type == PJSIP_RESPONSE_MSG ||
122                         pjsip_method_cmp(&rdata->msg_info.msg->line.req.method, &pjsip_cancel_method) ||
123                         rdata->msg_info.to->tag.slen != 0) {
124                 return pjsip_ua_find_dialog(&rdata->msg_info.cid->id, local_tag,
125                                 remote_tag, PJ_TRUE);
126         }
127
128         /* Incoming CANCEL without a to-tag can't use same method for finding the
129          * dialog. Instead, we have to find the matching INVITE transaction and
130          * then get the dialog from the transaction
131          */
132         pjsip_tsx_create_key(rdata->tp_info.pool, &tsx_key, PJSIP_ROLE_UAS,
133                         pjsip_get_invite_method(), rdata);
134
135         tsx = pjsip_tsx_layer_find_tsx(&tsx_key, PJ_TRUE);
136         if (!tsx) {
137                 ast_log(LOG_ERROR, "Could not find matching INVITE transaction for CANCEL request\n");
138                 return NULL;
139         }
140
141         dlg = pjsip_tsx_get_dlg(tsx);
142
143 #ifdef HAVE_PJ_TRANSACTION_GRP_LOCK
144         pj_grp_lock_release(tsx->grp_lock);
145 #else
146         pj_mutex_unlock(tsx->mutex);
147 #endif
148
149         if (!dlg) {
150                 return NULL;
151         }
152
153         pjsip_dlg_inc_lock(dlg);
154         return dlg;
155 }
156
157 static pj_bool_t endpoint_lookup(pjsip_rx_data *rdata);
158
159 static pjsip_module endpoint_mod = {
160         .name = {"Endpoint Identifier", 19},
161         .priority = PJSIP_MOD_PRIORITY_TSX_LAYER - 3,
162         .on_rx_request = endpoint_lookup,
163 };
164
165 static pj_bool_t distributor(pjsip_rx_data *rdata)
166 {
167         pjsip_dialog *dlg = find_dialog(rdata);
168         struct distributor_dialog_data *dist = NULL;
169         struct ast_taskprocessor *serializer = NULL;
170         pjsip_rx_data *clone;
171
172         if (dlg) {
173                 dist = pjsip_dlg_get_mod_data(dlg, distributor_mod.id);
174                 if (dist) {
175                         serializer = dist->serializer;
176                 }
177         }
178
179         if (rdata->msg_info.msg->type == PJSIP_REQUEST_MSG && (
180                 !pjsip_method_cmp(&rdata->msg_info.msg->line.req.method, &pjsip_cancel_method) || 
181                 !pjsip_method_cmp(&rdata->msg_info.msg->line.req.method, &pjsip_bye_method)) &&
182                 !serializer) {
183                 pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 481, NULL, NULL, NULL);
184                 goto end;
185         }
186
187         pjsip_rx_data_clone(rdata, 0, &clone);
188
189         if (dist) {
190                 clone->endpt_info.mod_data[endpoint_mod.id] = ao2_bump(dist->endpoint);
191         }
192
193         ast_sip_push_task(serializer, distribute, clone);
194
195 end:
196         if (dlg) {
197                 pjsip_dlg_dec_lock(dlg);
198         }
199
200         return PJ_TRUE;
201 }
202
203 static struct ast_sip_auth *artificial_auth;
204
205 static int create_artificial_auth(void)
206 {
207         if (!(artificial_auth = ast_sorcery_alloc(
208                       ast_sip_get_sorcery(), SIP_SORCERY_AUTH_TYPE, "artificial"))) {
209                 ast_log(LOG_ERROR, "Unable to create artificial auth\n");
210                 return -1;
211         }
212
213         ast_string_field_set(artificial_auth, realm, "asterisk");
214         ast_string_field_set(artificial_auth, auth_user, "");
215         ast_string_field_set(artificial_auth, auth_pass, "");
216         artificial_auth->type = AST_SIP_AUTH_TYPE_ARTIFICIAL;
217         return 0;
218 }
219
220 struct ast_sip_auth *ast_sip_get_artificial_auth(void)
221 {
222         ao2_ref(artificial_auth, +1);
223         return artificial_auth;
224 }
225
226 static struct ast_sip_endpoint *artificial_endpoint = NULL;
227
228 static int create_artificial_endpoint(void)
229 {
230         if (!(artificial_endpoint = ast_sorcery_alloc(
231                       ast_sip_get_sorcery(), "endpoint", NULL))) {
232                 return -1;
233         }
234
235         AST_VECTOR_INIT(&artificial_endpoint->inbound_auths, 1);
236         /* Pushing a bogus value into the vector will ensure that
237          * the proper size of the vector is returned. This value is
238          * not actually used anywhere
239          */
240         AST_VECTOR_APPEND(&artificial_endpoint->inbound_auths, ast_strdup("artificial-auth"));
241         return 0;
242 }
243
244 struct ast_sip_endpoint *ast_sip_get_artificial_endpoint(void)
245 {
246         ao2_ref(artificial_endpoint, +1);
247         return artificial_endpoint;
248 }
249
250 static void log_unidentified_request(pjsip_rx_data *rdata)
251 {
252         char from_buf[PJSIP_MAX_URL_SIZE];
253         char callid_buf[PJSIP_MAX_URL_SIZE];
254         pjsip_uri_print(PJSIP_URI_IN_FROMTO_HDR, rdata->msg_info.from->uri, from_buf, PJSIP_MAX_URL_SIZE);
255         ast_copy_pj_str(callid_buf, &rdata->msg_info.cid->id, PJSIP_MAX_URL_SIZE);
256         ast_log(LOG_NOTICE, "Request from '%s' failed for '%s:%d' (callid: %s) - No matching endpoint found\n",
257                 from_buf, rdata->pkt_info.src_name, rdata->pkt_info.src_port, callid_buf);
258 }
259
260 static pj_bool_t endpoint_lookup(pjsip_rx_data *rdata)
261 {
262         struct ast_sip_endpoint *endpoint;
263         int is_ack = rdata->msg_info.msg->line.req.method.id == PJSIP_ACK_METHOD;
264
265         endpoint = rdata->endpt_info.mod_data[endpoint_mod.id];
266         if (endpoint) {
267                 return PJ_FALSE;
268         }
269
270         endpoint = ast_sip_identify_endpoint(rdata);
271
272         if (!endpoint && !is_ack) {
273                 char name[AST_UUID_STR_LEN] = "";
274                 pjsip_uri *from = rdata->msg_info.from->uri;
275
276                 /* always use an artificial endpoint - per discussion no reason
277                    to have "alwaysauthreject" as an option.  It is felt using it
278                    was a bug fix and it is not needed since we are not worried about
279                    breaking old stuff and we really don't want to enable the discovery
280                    of SIP accounts */
281                 endpoint = ast_sip_get_artificial_endpoint();
282
283                 if (PJSIP_URI_SCHEME_IS_SIP(from) || PJSIP_URI_SCHEME_IS_SIPS(from)) {
284                         pjsip_sip_uri *sip_from = pjsip_uri_get_uri(from);
285                         ast_copy_pj_str(name, &sip_from->user, sizeof(name));
286                 }
287
288                 log_unidentified_request(rdata);
289                 ast_sip_report_invalid_endpoint(name, rdata);
290         }
291         rdata->endpt_info.mod_data[endpoint_mod.id] = endpoint;
292         return PJ_FALSE;
293 }
294
295 static pj_bool_t authenticate(pjsip_rx_data *rdata)
296 {
297         RAII_VAR(struct ast_sip_endpoint *, endpoint, ast_pjsip_rdata_get_endpoint(rdata), ao2_cleanup);
298         int is_ack = rdata->msg_info.msg->line.req.method.id == PJSIP_ACK_METHOD;
299
300         ast_assert(endpoint != NULL);
301
302         if (!is_ack && ast_sip_requires_authentication(endpoint, rdata)) {
303                 pjsip_tx_data *tdata;
304                 pjsip_endpt_create_response(ast_sip_get_pjsip_endpoint(), rdata, 401, NULL, &tdata);
305                 switch (ast_sip_check_authentication(endpoint, rdata, tdata)) {
306                 case AST_SIP_AUTHENTICATION_CHALLENGE:
307                         /* Send the 401 we created for them */
308                         ast_sip_report_auth_challenge_sent(endpoint, rdata, tdata);
309                         pjsip_endpt_send_response2(ast_sip_get_pjsip_endpoint(), rdata, tdata, NULL, NULL);
310                         return PJ_TRUE;
311                 case AST_SIP_AUTHENTICATION_SUCCESS:
312                         ast_sip_report_auth_success(endpoint, rdata);
313                         pjsip_tx_data_dec_ref(tdata);
314                         return PJ_FALSE;
315                 case AST_SIP_AUTHENTICATION_FAILED:
316                         ast_sip_report_auth_failed_challenge_response(endpoint, rdata);
317                         pjsip_endpt_send_response2(ast_sip_get_pjsip_endpoint(), rdata, tdata, NULL, NULL);
318                         return PJ_TRUE;
319                 case AST_SIP_AUTHENTICATION_ERROR:
320                         ast_sip_report_auth_failed_challenge_response(endpoint, rdata);
321                         pjsip_tx_data_dec_ref(tdata);
322                         pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 500, NULL, NULL, NULL);
323                         return PJ_TRUE;
324                 }
325         }
326
327         return PJ_FALSE;
328 }
329
330 static pjsip_module auth_mod = {
331         .name = {"Request Authenticator", 21},
332         .priority = PJSIP_MOD_PRIORITY_APPLICATION - 2,
333         .on_rx_request = authenticate,
334 };
335
336 static int distribute(void *data)
337 {
338         static pjsip_process_rdata_param param = {
339                 .start_mod = &distributor_mod,
340                 .idx_after_start = 1,
341         };
342         pj_bool_t handled;
343         pjsip_rx_data *rdata = data;
344         int is_request = rdata->msg_info.msg->type == PJSIP_REQUEST_MSG;
345         int is_ack = is_request ? rdata->msg_info.msg->line.req.method.id == PJSIP_ACK_METHOD : 0;
346         struct ast_sip_endpoint *endpoint;
347
348         pjsip_endpt_process_rx_data(ast_sip_get_pjsip_endpoint(), rdata, &param, &handled);
349         if (!handled && is_request && !is_ack) {
350                 pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 501, NULL, NULL, NULL);
351         }
352
353         /* The endpoint_mod stores an endpoint reference in the mod_data of rdata. This
354          * is the only appropriate spot to actually decrement the reference.
355          */
356         endpoint = rdata->endpt_info.mod_data[endpoint_mod.id];
357         ao2_cleanup(endpoint);
358         pjsip_rx_data_free_cloned(rdata);
359         return 0;
360 }
361
362 struct ast_sip_endpoint *ast_pjsip_rdata_get_endpoint(pjsip_rx_data *rdata)
363 {
364         struct ast_sip_endpoint *endpoint = rdata->endpt_info.mod_data[endpoint_mod.id];
365         if (endpoint) {
366                 ao2_ref(endpoint, +1);
367         }
368         return endpoint;
369 }
370
371 int ast_sip_initialize_distributor(void)
372 {
373         if (create_artificial_endpoint() || create_artificial_auth()) {
374                 return -1;
375         }
376
377         if (internal_sip_register_service(&distributor_mod)) {
378                 return -1;
379         }
380         if (internal_sip_register_service(&endpoint_mod)) {
381                 return -1;
382         }
383         if (internal_sip_register_service(&auth_mod)) {
384                 return -1;
385         }
386
387         return 0;
388 }
389
390 void ast_sip_destroy_distributor(void)
391 {
392         internal_sip_unregister_service(&distributor_mod);
393         internal_sip_unregister_service(&endpoint_mod);
394         internal_sip_unregister_service(&auth_mod);
395
396         ao2_cleanup(artificial_auth);
397         ao2_cleanup(artificial_endpoint);
398 }