Improve initial INVITE handling and fix crash due to rapidly arriving CANCEL.
[asterisk/asterisk.git] / res / res_sip / sip_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_sip.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 pj_bool_t distributor(pjsip_rx_data *rdata)
96 {
97         pjsip_dialog *dlg = pjsip_ua_find_dialog(&rdata->msg_info.cid->id, &rdata->msg_info.to->tag, &rdata->msg_info.from->tag, PJ_TRUE);
98         struct distributor_dialog_data *dist = NULL;
99         struct ast_taskprocessor *serializer = NULL;
100         pjsip_rx_data *clone;
101
102         if (dlg) {
103                 dist = pjsip_dlg_get_mod_data(dlg, distributor_mod.id);
104                 if (dist) {
105                         serializer = dist->serializer;
106                 }
107         }
108
109         if (rdata->msg_info.msg->type == PJSIP_REQUEST_MSG && (
110                 !pjsip_method_cmp(&rdata->msg_info.msg->line.req.method, &pjsip_cancel_method) || 
111                 !pjsip_method_cmp(&rdata->msg_info.msg->line.req.method, &pjsip_bye_method)) &&
112                 !serializer) {
113                 pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 481, NULL, NULL, NULL);
114                 goto end;
115         }
116
117         pjsip_rx_data_clone(rdata, 0, &clone);
118
119         if (dist) {
120                 clone->endpt_info.mod_data[distributor_mod.id] = dist->endpoint;
121         }
122
123         ast_sip_push_task(serializer, distribute, clone);
124
125 end:
126         if (dlg) {
127                 pjsip_dlg_dec_lock(dlg);
128         }
129
130         return PJ_TRUE;
131 }
132
133 static pj_bool_t endpoint_lookup(pjsip_rx_data *rdata);
134
135 static pjsip_module endpoint_mod = {
136         .name = {"Endpoint Identifier", 19},
137         .priority = PJSIP_MOD_PRIORITY_TSX_LAYER - 3,
138         .on_rx_request = endpoint_lookup,
139 };
140
141 static struct ast_sip_auth *artificial_auth;
142
143 static int create_artificial_auth(void)
144 {
145         if (!(artificial_auth = ast_sorcery_alloc(
146                       ast_sip_get_sorcery(), SIP_SORCERY_AUTH_TYPE, "artificial"))) {
147                 ast_log(LOG_ERROR, "Unable to create artificial auth\n");
148                 return -1;
149         }
150
151         ast_string_field_set(artificial_auth, realm, "asterisk");
152         ast_string_field_set(artificial_auth, auth_user, "");
153         ast_string_field_set(artificial_auth, auth_pass, "");
154         artificial_auth->type = AST_SIP_AUTH_TYPE_ARTIFICIAL;
155         return 0;
156 }
157
158 struct ast_sip_auth *ast_sip_get_artificial_auth(void)
159 {
160         ao2_ref(artificial_auth, +1);
161         return artificial_auth;
162 }
163
164 static struct ast_sip_endpoint *artificial_endpoint;
165
166 static int create_artificial_endpoint(void)
167 {
168         if (!(artificial_endpoint = ast_sorcery_alloc(
169                       ast_sip_get_sorcery(), "endpoint", NULL))) {
170                 return -1;
171         }
172
173         artificial_endpoint->num_inbound_auths = 1;
174         return 0;
175 }
176
177 struct ast_sip_endpoint *ast_sip_get_artificial_endpoint(void)
178 {
179         ao2_ref(artificial_endpoint, +1);
180         return artificial_endpoint;
181 }
182
183 static pj_bool_t endpoint_lookup(pjsip_rx_data *rdata)
184 {
185         struct ast_sip_endpoint *endpoint;
186         int is_ack = rdata->msg_info.msg->line.req.method.id == PJSIP_ACK_METHOD;
187
188         endpoint = rdata->endpt_info.mod_data[distributor_mod.id];
189         if (endpoint) {
190                 /* Bumping the refcount makes refcounting consistent whether an endpoint
191                  * is looked up or not */
192                 ao2_ref(endpoint, +1);
193         } else {
194                 endpoint = ast_sip_identify_endpoint(rdata);
195         }
196
197         if (!endpoint && !is_ack) {
198                 char name[AST_UUID_STR_LEN] = "";
199                 pjsip_uri *from = rdata->msg_info.from->uri;
200
201                 /* always use an artificial endpoint - per discussion no reason
202                    to have "alwaysauthreject" as an option.  It is felt using it
203                    was a bug fix and it is not needed since we are not worried about
204                    breaking old stuff and we really don't want to enable the discovery
205                    of SIP accounts */
206                 endpoint = ast_sip_get_artificial_endpoint();
207
208                 if (PJSIP_URI_SCHEME_IS_SIP(from) || PJSIP_URI_SCHEME_IS_SIPS(from)) {
209                         pjsip_sip_uri *sip_from = pjsip_uri_get_uri(from);
210                         ast_copy_pj_str(name, &sip_from->user, sizeof(name));
211                 }
212
213                 ast_sip_report_invalid_endpoint(name, rdata);
214         }
215         rdata->endpt_info.mod_data[endpoint_mod.id] = endpoint;
216         return PJ_FALSE;
217 }
218
219 static pj_bool_t authenticate(pjsip_rx_data *rdata)
220 {
221         RAII_VAR(struct ast_sip_endpoint *, endpoint, ast_pjsip_rdata_get_endpoint(rdata), ao2_cleanup);
222         int is_ack = rdata->msg_info.msg->line.req.method.id == PJSIP_ACK_METHOD;
223
224         ast_assert(endpoint != NULL);
225
226         if (!is_ack && ast_sip_requires_authentication(endpoint, rdata)) {
227                 pjsip_tx_data *tdata;
228                 pjsip_endpt_create_response(ast_sip_get_pjsip_endpoint(), rdata, 401, NULL, &tdata);
229                 switch (ast_sip_check_authentication(endpoint, rdata, tdata)) {
230                 case AST_SIP_AUTHENTICATION_CHALLENGE:
231                         /* Send the 401 we created for them */
232                         ast_sip_report_auth_challenge_sent(endpoint, rdata, tdata);
233                         pjsip_endpt_send_response2(ast_sip_get_pjsip_endpoint(), rdata, tdata, NULL, NULL);
234                         return PJ_TRUE;
235                 case AST_SIP_AUTHENTICATION_SUCCESS:
236                         ast_sip_report_auth_success(endpoint, rdata);
237                         pjsip_tx_data_dec_ref(tdata);
238                         return PJ_FALSE;
239                 case AST_SIP_AUTHENTICATION_FAILED:
240                         ast_sip_report_auth_failed_challenge_response(endpoint, rdata);
241                         pjsip_endpt_send_response2(ast_sip_get_pjsip_endpoint(), rdata, tdata, NULL, NULL);
242                         return PJ_TRUE;
243                 case AST_SIP_AUTHENTICATION_ERROR:
244                         ast_sip_report_auth_failed_challenge_response(endpoint, rdata);
245                         pjsip_tx_data_dec_ref(tdata);
246                         pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 500, NULL, NULL, NULL);
247                         return PJ_TRUE;
248                 }
249         }
250
251         return PJ_FALSE;
252 }
253
254 static pjsip_module auth_mod = {
255         .name = {"Request Authenticator", 21},
256         .priority = PJSIP_MOD_PRIORITY_APPLICATION - 1,
257         .on_rx_request = authenticate,
258 };
259
260 static int distribute(void *data)
261 {
262         static pjsip_process_rdata_param param = {
263                 .start_mod = &distributor_mod,
264                 .idx_after_start = 1,
265         };
266         pj_bool_t handled;
267         pjsip_rx_data *rdata = data;
268         int is_request = rdata->msg_info.msg->type == PJSIP_REQUEST_MSG;
269         int is_ack = is_request ? rdata->msg_info.msg->line.req.method.id == PJSIP_ACK_METHOD : 0;
270         struct ast_sip_endpoint *endpoint;
271
272         pjsip_endpt_process_rx_data(ast_sip_get_pjsip_endpoint(), rdata, &param, &handled);
273         if (!handled && is_request && !is_ack) {
274                 pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 501, NULL, NULL, NULL);
275         }
276
277         /* The endpoint_mod stores an endpoint reference in the mod_data of rdata. This
278          * is the only appropriate spot to actually decrement the reference.
279          */
280         endpoint = rdata->endpt_info.mod_data[endpoint_mod.id];
281         ao2_cleanup(endpoint);
282         pjsip_rx_data_free_cloned(rdata);
283         return 0;
284 }
285
286 struct ast_sip_endpoint *ast_pjsip_rdata_get_endpoint(pjsip_rx_data *rdata)
287 {
288         struct ast_sip_endpoint *endpoint = rdata->endpt_info.mod_data[endpoint_mod.id];
289         if (endpoint) {
290                 ao2_ref(endpoint, +1);
291         }
292         return endpoint;
293 }
294
295 int ast_sip_initialize_distributor(void)
296 {
297         if (create_artificial_endpoint() || create_artificial_auth()) {
298                 return -1;
299         }
300
301         if (ast_sip_register_service(&distributor_mod)) {
302                 return -1;
303         }
304         if (ast_sip_register_service(&endpoint_mod)) {
305                 return -1;
306         }
307         if (ast_sip_register_service(&auth_mod)) {
308                 return -1;
309         }
310
311         return 0;
312 }
313
314 void ast_sip_destroy_distributor(void)
315 {
316         ast_sip_unregister_service(&distributor_mod);
317         ast_sip_unregister_service(&endpoint_mod);
318         ast_sip_unregister_service(&auth_mod);
319
320         ao2_cleanup(artificial_auth);
321         ao2_cleanup(artificial_endpoint);
322 }