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