res_pjsip: Add ignore_uri_user_options option.
[asterisk/asterisk.git] / res / res_pjsip_messaging.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2013, Digium, Inc.
5  *
6  * Kevin Harwell <kharwell@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         <depend>res_pjsip_session</depend>
23         <support_level>core</support_level>
24  ***/
25
26 /*** DOCUMENTATION
27         <info name="MessageFromInfo" language="en_US" tech="PJSIP">
28                 <para>The <literal>from</literal> parameter can be a configured endpoint
29                 or in the form of "display-name" &lt;URI&gt;.</para>
30         </info>
31         <info name="MessageToInfo" language="en_US" tech="PJSIP">
32                 <para>Specifying a prefix of <literal>pjsip:</literal> will send the
33                 message as a SIP MESSAGE request.</para>
34         </info>
35  ***/
36 #include "asterisk.h"
37
38 #include "pjsua-lib/pjsua.h"
39
40 #include "asterisk/message.h"
41 #include "asterisk/module.h"
42 #include "asterisk/pbx.h"
43 #include "asterisk/res_pjsip.h"
44 #include "asterisk/res_pjsip_session.h"
45 #include "asterisk/taskprocessor.h"
46
47 const pjsip_method pjsip_message_method = {PJSIP_OTHER_METHOD, {"MESSAGE", 7} };
48
49 #define MAX_HDR_SIZE 512
50 #define MAX_BODY_SIZE 1024
51 #define MAX_USER_SIZE 128
52
53 static struct ast_taskprocessor *message_serializer;
54
55 /*!
56  * \internal
57  * \brief Checks to make sure the request has the correct content type.
58  *
59  * \details This module supports the following media types: "text/plain".
60  * Return unsupported otherwise.
61  *
62  * \param rdata The SIP request
63  */
64 static enum pjsip_status_code check_content_type(const pjsip_rx_data *rdata)
65 {
66         int res;
67         if (rdata->msg_info.msg->body && rdata->msg_info.msg->body->len) {
68                 res = ast_sip_is_content_type(
69                         &rdata->msg_info.msg->body->content_type, "text", "plain");
70         } else {
71                 res = rdata->msg_info.ctype &&
72                         !pj_strcmp2(&rdata->msg_info.ctype->media.type, "text") &&
73                         !pj_strcmp2(&rdata->msg_info.ctype->media.subtype, "plain");
74         }
75
76         return res ? PJSIP_SC_OK : PJSIP_SC_UNSUPPORTED_MEDIA_TYPE;
77 }
78
79 /*!
80  * \internal
81  * \brief Puts pointer past 'sip[s]:' string that should be at the
82  * front of the given 'fromto' parameter
83  *
84  * \param fromto 'From' or 'To' field containing 'sip:'
85  */
86 static const char *skip_sip(const char *fromto)
87 {
88         const char *p;
89
90         /* need to be one past 'sip:' or 'sips:' */
91         if (!(p = strstr(fromto, "sip"))) {
92                 return fromto;
93         }
94
95         p += 3;
96         if (*p == 's') {
97                 ++p;
98         }
99
100         return ++p;
101 }
102
103 /*!
104  * \internal
105  * \brief Retrieves an endpoint if specified in the given 'to'
106  *
107  * Expects the given 'to' to be in one of the following formats:
108  *      sip[s]:endpoint[/aor]
109  *      sip[s]:endpoint[/uri]
110  *      sip[s]:uri <-- will use default outbound endpoint
111  *
112  * If an optional aor is given it will try to find an associated uri
113  * to return.  If an optional uri is given then that will be returned,
114  * otherwise uri will be NULL.
115  *
116  * \param to 'From' or 'To' field with possible endpoint
117  * \param uri Optional uri to return
118  */
119 static struct ast_sip_endpoint* get_outbound_endpoint(
120         const char *to, char **uri)
121 {
122         char *name, *aor_uri;
123         struct ast_sip_endpoint* endpoint;
124         RAII_VAR(struct ast_sip_aor *, aor, NULL, ao2_cleanup);
125         RAII_VAR(struct ast_sip_contact *, contact, NULL, ao2_cleanup);
126
127         name = ast_strdupa(skip_sip(to));
128
129         /* attempt to extract the endpoint name */
130         if ((aor_uri = strchr(name, '/'))) {
131                 /* format was 'endpoint/' */
132                 *aor_uri++ = '\0';
133         } else if ((aor_uri = strchr(name, '@'))) {
134                 /* format was 'endpoint@' - don't use the rest */
135                 *aor_uri = '\0';
136
137                 /*
138                  * We may want to match without any user options getting
139                  * in the way.
140                  */
141                 AST_SIP_USER_OPTIONS_TRUNCATE_CHECK(name);
142         }
143
144         /* at this point, if name is not empty then it
145            might be an endpoint, so try to retrieve it */
146         if (ast_strlen_zero(name) || !(endpoint = ast_sorcery_retrieve_by_id(
147                       ast_sip_get_sorcery(), "endpoint", name))) {
148                 /* an endpoint was not found, so assume sending directly
149                    to a uri and use the default outbound endpoint */
150                 *uri = ast_strdup(to);
151                 return ast_sip_default_outbound_endpoint();
152         }
153
154         *uri = aor_uri;
155         if (*uri) {
156                 char *end = strchr(*uri, '>');
157                 if (end) {
158                         *end++ = '\0';
159                 }
160
161                 /* if what's in 'uri' is a retrievable aor use the uri on it
162                    instead, otherwise assume what's there is already a uri*/
163                 if ((aor = ast_sip_location_retrieve_aor(*uri)) &&
164                         (contact = ast_sip_location_retrieve_first_aor_contact(aor))) {
165                         *uri = (char*)contact->uri;
166                 }
167                 /* need to copy because underlying uri goes away */
168                 *uri = ast_strdup(*uri);
169         }
170
171         return endpoint;
172 }
173
174 /*!
175  * \internal
176  * \brief Overwrite fields in the outbound 'To' header
177  *
178  * Updates display name in an outgoing To header.
179  *
180  * \param tdata the outbound message data structure
181  * \param to info to copy into the header
182  */
183 static void update_to(pjsip_tx_data *tdata, char *to)
184 {
185         pjsip_name_addr *name_addr = (pjsip_name_addr *)
186                 PJSIP_MSG_TO_HDR(tdata->msg)->uri;
187         pjsip_uri *parsed;
188
189         if ((parsed = pjsip_parse_uri(tdata->pool, to, strlen(to),
190                                       PJSIP_PARSE_URI_AS_NAMEADDR))) {
191                 pjsip_name_addr *parsed_name_addr = (pjsip_name_addr *)parsed;
192                 if (pj_strlen(&parsed_name_addr->display)) {
193                         pj_strdup(tdata->pool, &name_addr->display,
194                                   &parsed_name_addr->display);
195                 }
196         }
197 }
198
199 /*!
200  * \internal
201  * \brief Overwrite fields in the outbound 'From' header
202  *
203  * The outbound 'From' header is created/added in ast_sip_create_request with
204  * default data.  If available that data may be info specified in the 'from_user'
205  * and 'from_domain' options found on the endpoint.  That information will be
206  * overwritten with data in the given 'from' parameter.
207  *
208  * \param tdata the outbound message data structure
209  * \param from info to copy into the header
210  */
211 static void update_from(pjsip_tx_data *tdata, char *from)
212 {
213         pjsip_name_addr *name_addr = (pjsip_name_addr *)
214                 PJSIP_MSG_FROM_HDR(tdata->msg)->uri;
215         pjsip_sip_uri *uri = pjsip_uri_get_uri(name_addr);
216         pjsip_uri *parsed;
217
218         if (ast_strlen_zero(from)) {
219                 return;
220         }
221
222         if ((parsed = pjsip_parse_uri(tdata->pool, from, strlen(from),
223                                       PJSIP_PARSE_URI_AS_NAMEADDR))) {
224                 pjsip_name_addr *parsed_name_addr = (pjsip_name_addr *)parsed;
225                 pjsip_sip_uri *parsed_uri = pjsip_uri_get_uri(parsed_name_addr->uri);
226                 if (pj_strlen(&parsed_name_addr->display)) {
227                         pj_strdup(tdata->pool, &name_addr->display,
228                                   &parsed_name_addr->display);
229                 }
230
231                 pj_strdup(tdata->pool, &uri->user, &parsed_uri->user);
232                 pj_strdup(tdata->pool, &uri->host, &parsed_uri->host);
233                 uri->port = parsed_uri->port;
234         } else {
235                 /* assume it is 'user[@domain]' format */
236                 char *domain = strchr(from, '@');
237                 if (domain) {
238                         *domain++ = '\0';
239                         pj_strdup2(tdata->pool, &uri->host, domain);
240                 }
241                 pj_strdup2(tdata->pool, &uri->user, from);
242         }
243 }
244
245 /*!
246  * \internal
247  * \brief Checks if the given msg var name should be blocked.
248  *
249  * \details Some headers are not allowed to be overriden by the user.
250  *  Determine if the given var header name from the user is blocked for
251  *  an outgoing MESSAGE.
252  *
253  * \param name name of header to see if it is blocked.
254  *
255  * \retval TRUE if the given header is blocked.
256  */
257 static int is_msg_var_blocked(const char *name)
258 {
259         int i;
260
261         /*
262          * Don't block Content-Type or Max-Forwards headers because the
263          * user can override them.
264          */
265         static const char *hdr[] = {
266                 "To",
267                 "From",
268                 "Via",
269                 "Route",
270                 "Contact",
271                 "Call-ID",
272                 "CSeq",
273                 "Allow",
274                 "Content-Length",
275                 "Request-URI",
276         };
277
278         for (i = 0; i < ARRAY_LEN(hdr); ++i) {
279                 if (!strcasecmp(name, hdr[i])) {
280                         /* Block addition of this header. */
281                         return 1;
282                 }
283         }
284         return 0;
285 }
286
287 /*!
288  * \internal
289  * \brief Copies any other msg vars over to the request headers.
290  *
291  * \param msg The msg structure to copy headers from
292  * \param tdata The SIP transmission data
293  */
294 static enum pjsip_status_code vars_to_headers(const struct ast_msg *msg, pjsip_tx_data *tdata)
295 {
296         const char *name;
297         const char *value;
298         int max_forwards;
299         struct ast_msg_var_iterator *iter;
300
301         for (iter = ast_msg_var_iterator_init(msg);
302                 ast_msg_var_iterator_next(msg, iter, &name, &value);
303                 ast_msg_var_unref_current(iter)) {
304                 if (!strcasecmp(name, "Max-Forwards")) {
305                         /* Decrement Max-Forwards for SIP loop prevention. */
306                         if (sscanf(value, "%30d", &max_forwards) != 1 || --max_forwards == 0) {
307                                 ast_msg_var_iterator_destroy(iter);
308                                 ast_log(LOG_NOTICE, "MESSAGE(Max-Forwards) reached zero.  MESSAGE not sent.\n");
309                                 return -1;
310                         }
311                         sprintf((char *) value, "%d", max_forwards);
312                         ast_sip_add_header(tdata, name, value);
313                 } else if (!is_msg_var_blocked(name)) {
314                         ast_sip_add_header(tdata, name, value);
315                 }
316         }
317         ast_msg_var_iterator_destroy(iter);
318
319         return PJSIP_SC_OK;
320 }
321
322 /*!
323  * \internal
324  * \brief Copies any other request header data over to ast_msg structure.
325  *
326  * \param rdata The SIP request
327  * \param msg The msg structure to copy headers into
328  */
329 static int headers_to_vars(const pjsip_rx_data *rdata, struct ast_msg *msg)
330 {
331         char *c;
332         char name[MAX_HDR_SIZE];
333         char buf[MAX_HDR_SIZE];
334         int res = 0;
335         pjsip_hdr *h = rdata->msg_info.msg->hdr.next;
336         pjsip_hdr *end= &rdata->msg_info.msg->hdr;
337
338         while (h != end) {
339                 if ((res = pjsip_hdr_print_on(h, buf, sizeof(buf)-1)) > 0) {
340                         buf[res] = '\0';
341                         if ((c = strchr(buf, ':'))) {
342                                 ast_copy_string(buf, ast_skip_blanks(c + 1), sizeof(buf));
343                         }
344
345                         ast_copy_pj_str(name, &h->name, sizeof(name));
346                         if ((res = ast_msg_set_var(msg, name, buf)) != 0) {
347                                 break;
348                         }
349                 }
350                 h = h->next;
351         }
352         return 0;
353 }
354
355 /*!
356  * \internal
357  * \brief Prints the message body into the given char buffer.
358  *
359  * \details Copies body content from the received data into the given
360  * character buffer removing any extra carriage return/line feeds.
361  *
362  * \param rdata The SIP request
363  * \param buf Buffer to fill
364  * \param len The length of the buffer
365  */
366 static int print_body(pjsip_rx_data *rdata, char *buf, int len)
367 {
368         int res;
369
370         if (!rdata->msg_info.msg->body || !rdata->msg_info.msg->body->len) {
371                 return 0;
372         }
373
374         if ((res = rdata->msg_info.msg->body->print_body(
375                      rdata->msg_info.msg->body, buf, len)) < 0) {
376                 return res;
377         }
378
379         /* remove any trailing carriage return/line feeds */
380         while (res > 0 && ((buf[--res] == '\r') || (buf[res] == '\n')));
381
382         buf[++res] = '\0';
383
384         return res;
385 }
386
387 /*!
388  * \internal
389  * \brief Converts a 'sip:' uri to a 'pjsip:' so it can be found by
390  * the message tech.
391  *
392  * \param buf uri to insert 'pjsip' into
393  * \param size length of the uri in buf
394  * \param capacity total size of buf
395  */
396 static char *sip_to_pjsip(char *buf, int size, int capacity)
397 {
398         int count;
399         const char *scheme;
400         char *res = buf;
401
402         /* remove any wrapping brackets */
403         if (*buf == '<') {
404                 ++buf;
405                 --size;
406         }
407
408         scheme = strncmp(buf, "sip", 3) ? "pjsip:" : "pj";
409         count = strlen(scheme);
410         if (count + size >= capacity) {
411                 ast_log(LOG_WARNING, "Unable to handle MESSAGE- incoming uri "
412                         "too large for given buffer\n");
413                 return NULL;
414         }
415
416         memmove(res + count, buf, size);
417         memcpy(res, scheme, count);
418
419         buf += size - 1;
420         if (*buf == '>') {
421                 *buf = '\0';
422         }
423
424         return res;
425 }
426
427 /*!
428  * \internal
429  * \brief Converts a pjsip_rx_data structure to an ast_msg structure.
430  *
431  * \details Attempts to fill in as much information as possible into the given
432  * msg structure copied from the given request data.
433  *
434  * \param rdata The SIP request
435  * \param msg The asterisk message structure to fill in.
436  */
437 static enum pjsip_status_code rx_data_to_ast_msg(pjsip_rx_data *rdata, struct ast_msg *msg)
438 {
439         RAII_VAR(struct ast_sip_endpoint *, endpt, NULL, ao2_cleanup);
440         pjsip_uri *ruri = rdata->msg_info.msg->line.req.uri;
441         pjsip_sip_uri *sip_ruri;
442         pjsip_name_addr *name_addr;
443         char buf[MAX_BODY_SIZE];
444         const char *field;
445         const char *context;
446         char exten[AST_MAX_EXTENSION];
447         int res = 0;
448         int size;
449
450         if (!PJSIP_URI_SCHEME_IS_SIP(ruri) && !PJSIP_URI_SCHEME_IS_SIPS(ruri)) {
451                 return PJSIP_SC_UNSUPPORTED_URI_SCHEME;
452         }
453
454         sip_ruri = pjsip_uri_get_uri(ruri);
455         ast_copy_pj_str(exten, &sip_ruri->user, AST_MAX_EXTENSION);
456
457         /*
458          * We may want to match in the dialplan without any user
459          * options getting in the way.
460          */
461         AST_SIP_USER_OPTIONS_TRUNCATE_CHECK(exten);
462
463         endpt = ast_pjsip_rdata_get_endpoint(rdata);
464         ast_assert(endpt != NULL);
465
466         context = S_OR(endpt->message_context, endpt->context);
467         res |= ast_msg_set_context(msg, "%s", context);
468         res |= ast_msg_set_exten(msg, "%s", exten);
469
470         /* to header */
471         name_addr = (pjsip_name_addr *)rdata->msg_info.to->uri;
472         size = pjsip_uri_print(PJSIP_URI_IN_FROMTO_HDR, name_addr, buf, sizeof(buf) - 1);
473         if (size <= 0) {
474                 return PJSIP_SC_INTERNAL_SERVER_ERROR;
475         }
476         buf[size] = '\0';
477         res |= ast_msg_set_to(msg, "%s", sip_to_pjsip(buf, ++size, sizeof(buf) - 1));
478
479         /* from header */
480         name_addr = (pjsip_name_addr *)rdata->msg_info.from->uri;
481         size = pjsip_uri_print(PJSIP_URI_IN_FROMTO_HDR, name_addr, buf, sizeof(buf) - 1);
482         if (size <= 0) {
483                 return PJSIP_SC_INTERNAL_SERVER_ERROR;
484         }
485         buf[size] = '\0';
486         res |= ast_msg_set_from(msg, "%s", buf);
487
488         field = pj_sockaddr_print(&rdata->pkt_info.src_addr, buf, sizeof(buf) - 1, 1);
489         res |= ast_msg_set_var(msg, "PJSIP_RECVADDR", field);
490
491         switch (rdata->tp_info.transport->key.type) {
492         case PJSIP_TRANSPORT_UDP:
493         case PJSIP_TRANSPORT_UDP6:
494                 field = "udp";
495                 break;
496         case PJSIP_TRANSPORT_TCP:
497         case PJSIP_TRANSPORT_TCP6:
498                 field = "tcp";
499                 break;
500         case PJSIP_TRANSPORT_TLS:
501         case PJSIP_TRANSPORT_TLS6:
502                 field = "tls";
503                 break;
504         default:
505                 field = rdata->tp_info.transport->type_name;
506         }
507         ast_msg_set_var(msg, "PJSIP_TRANSPORT", field);
508
509         if (print_body(rdata, buf, sizeof(buf) - 1) > 0) {
510                 res |= ast_msg_set_body(msg, "%s", buf);
511         }
512
513         /* endpoint name */
514         res |= ast_msg_set_tech(msg, "%s", "PJSIP");
515         res |= ast_msg_set_endpoint(msg, "%s", ast_sorcery_object_get_id(endpt));
516         if (endpt->id.self.name.valid) {
517                 res |= ast_msg_set_var(msg, "PJSIP_ENDPOINT", endpt->id.self.name.str);
518         }
519
520         res |= headers_to_vars(rdata, msg);
521
522         return !res ? PJSIP_SC_OK : PJSIP_SC_INTERNAL_SERVER_ERROR;
523 }
524
525 struct msg_data {
526         struct ast_msg *msg;
527         char *to;
528         char *from;
529 };
530
531 static void msg_data_destroy(void *obj)
532 {
533         struct msg_data *mdata = obj;
534
535         ast_free(mdata->from);
536         ast_free(mdata->to);
537
538         ast_msg_destroy(mdata->msg);
539 }
540
541 static struct msg_data* msg_data_create(const struct ast_msg *msg, const char *to, const char *from)
542 {
543         char *uri_params;
544         struct msg_data *mdata = ao2_alloc(sizeof(*mdata), msg_data_destroy);
545
546         if (!mdata) {
547                 return NULL;
548         }
549
550         /* typecast to suppress const warning */
551         mdata->msg = ast_msg_ref((struct ast_msg*)msg);
552
553         /* starts with 'pjsip:' the 'pj' needs to be removed and maybe even
554            the entire string. */
555         if (!(to = strchr(to, ':'))) {
556                 ao2_ref(mdata, -1);
557                 return NULL;
558         }
559
560         /* Make sure we start with sip: */
561         mdata->to = ast_begins_with(to, "sip:") ? ast_strdup(++to) : ast_strdup(to - 3);
562         mdata->from = ast_strdup(from);
563         if (!mdata->to || !mdata->from) {
564                 ao2_ref(mdata, -1);
565                 return NULL;
566         }
567
568         /*
569          * Sometimes from URI can contain URI parameters, so remove them.
570          *
571          * sip:user;user-options@domain;uri-parameters
572          */
573         uri_params = strchr(mdata->from, '@');
574         if (uri_params && (uri_params = strchr(mdata->from, ';'))) {
575                 *uri_params = '\0';
576         }
577         return mdata;
578 }
579
580 static int msg_send(void *data)
581 {
582         RAII_VAR(struct msg_data *, mdata, data, ao2_cleanup);
583
584         const struct ast_sip_body body = {
585                 .type = "text",
586                 .subtype = "plain",
587                 .body_text = ast_msg_get_body(mdata->msg)
588         };
589
590         pjsip_tx_data *tdata;
591         RAII_VAR(char *, uri, NULL, ast_free);
592         RAII_VAR(struct ast_sip_endpoint *, endpoint, get_outbound_endpoint(
593                          mdata->to, &uri), ao2_cleanup);
594
595         if (!endpoint) {
596                 ast_log(LOG_ERROR, "PJSIP MESSAGE - Could not find endpoint '%s' and "
597                         "no default outbound endpoint configured\n", mdata->to);
598                 return -1;
599         }
600
601         if (ast_sip_create_request("MESSAGE", NULL, endpoint, uri, NULL, &tdata)) {
602                 ast_log(LOG_ERROR, "PJSIP MESSAGE - Could not create request\n");
603                 return -1;
604         }
605
606         update_to(tdata, mdata->to);
607         update_from(tdata, mdata->from);
608
609         if (ast_sip_add_body(tdata, &body)) {
610                 pjsip_tx_data_dec_ref(tdata);
611                 ast_log(LOG_ERROR, "PJSIP MESSAGE - Could not add body to request\n");
612                 return -1;
613         }
614
615         vars_to_headers(mdata->msg, tdata);
616
617         ast_debug(1, "Sending message to '%s' (via endpoint %s) from '%s'\n",
618                 mdata->to, ast_sorcery_object_get_id(endpoint), mdata->from);
619
620         if (ast_sip_send_request(tdata, NULL, endpoint, NULL, NULL)) {
621                 ast_log(LOG_ERROR, "PJSIP MESSAGE - Could not send request\n");
622                 return -1;
623         }
624
625         return PJ_SUCCESS;
626 }
627
628 static int sip_msg_send(const struct ast_msg *msg, const char *to, const char *from)
629 {
630         struct msg_data *mdata;
631
632         if (ast_strlen_zero(to)) {
633                 ast_log(LOG_ERROR, "SIP MESSAGE - a 'To' URI  must be specified\n");
634                 return -1;
635         }
636
637         if (!(mdata = msg_data_create(msg, to, from)) ||
638             ast_sip_push_task(message_serializer, msg_send, mdata)) {
639                 ao2_cleanup(mdata);
640                 return -1;
641         }
642         return 0;
643 }
644
645 static const struct ast_msg_tech msg_tech = {
646         .name = "pjsip",
647         .msg_send = sip_msg_send,
648 };
649
650 static pj_status_t send_response(pjsip_rx_data *rdata, enum pjsip_status_code code,
651                                  pjsip_dialog *dlg, pjsip_transaction *tsx)
652 {
653         pjsip_tx_data *tdata;
654         pj_status_t status;
655
656         status = ast_sip_create_response(rdata, code, NULL, &tdata);
657         if (status != PJ_SUCCESS) {
658                 ast_log(LOG_ERROR, "Unable to create response (%d)\n", status);
659                 return status;
660         }
661
662         if (dlg && tsx) {
663                 status = pjsip_dlg_send_response(dlg, tsx, tdata);
664         } else {
665                 struct ast_sip_endpoint *endpoint;
666
667                 endpoint = ast_pjsip_rdata_get_endpoint(rdata);
668                 status = ast_sip_send_stateful_response(rdata, tdata, endpoint);
669                 ao2_cleanup(endpoint);
670         }
671
672         if (status != PJ_SUCCESS) {
673                 ast_log(LOG_ERROR, "Unable to send response (%d)\n", status);
674         }
675
676         return status;
677 }
678
679 static pj_bool_t module_on_rx_request(pjsip_rx_data *rdata)
680 {
681         enum pjsip_status_code code;
682         struct ast_msg *msg;
683
684         /* if not a MESSAGE, don't handle */
685         if (pjsip_method_cmp(&rdata->msg_info.msg->line.req.method, &pjsip_message_method)) {
686                 return PJ_FALSE;
687         }
688
689         code = check_content_type(rdata);
690         if (code != PJSIP_SC_OK) {
691                 send_response(rdata, code, NULL, NULL);
692                 return PJ_TRUE;
693         }
694
695         msg = ast_msg_alloc();
696         if (!msg) {
697                 send_response(rdata, PJSIP_SC_INTERNAL_SERVER_ERROR, NULL, NULL);
698                 return PJ_TRUE;
699         }
700
701         code = rx_data_to_ast_msg(rdata, msg);
702         if (code != PJSIP_SC_OK) {
703                 send_response(rdata, code, NULL, NULL);
704                 ast_msg_destroy(msg);
705                 return PJ_TRUE;
706         }
707
708         if (!ast_msg_has_destination(msg)) {
709                 ast_debug(1, "MESSAGE request received, but no handler wanted it\n");
710                 send_response(rdata, PJSIP_SC_NOT_FOUND, NULL, NULL);
711                 ast_msg_destroy(msg);
712                 return PJ_TRUE;
713         }
714
715         /* Send it to the messaging core.
716          *
717          * If we are unable to send a response, the most likely reason is that we
718          * are handling a retransmission of an incoming MESSAGE and were unable to
719          * create a transaction due to a duplicate key. If we are unable to send
720          * a response, we should not queue the message to the dialplan
721          */
722         if (!send_response(rdata, PJSIP_SC_ACCEPTED, NULL, NULL)) {
723                 ast_msg_queue(msg);
724         }
725
726         return PJ_TRUE;
727 }
728
729 static int incoming_in_dialog_request(struct ast_sip_session *session, struct pjsip_rx_data *rdata)
730 {
731         char buf[MAX_BODY_SIZE];
732         enum pjsip_status_code code;
733         struct ast_frame f;
734         pjsip_dialog *dlg = session->inv_session->dlg;
735         pjsip_transaction *tsx = pjsip_rdata_get_tsx(rdata);
736
737         if (!session->channel) {
738                 send_response(rdata, PJSIP_SC_NOT_FOUND, dlg, tsx);
739                 return 0;
740         }
741
742         if ((code = check_content_type(rdata)) != PJSIP_SC_OK) {
743                 send_response(rdata, code, dlg, tsx);
744                 return 0;
745         }
746
747         if (print_body(rdata, buf, sizeof(buf)-1) < 1) {
748                 /* invalid body size */
749                 send_response(rdata, PJSIP_SC_REQUEST_ENTITY_TOO_LARGE, dlg, tsx);
750                 return 0;
751         }
752
753         ast_debug(3, "Received in dialog SIP message\n");
754
755         memset(&f, 0, sizeof(f));
756         f.frametype = AST_FRAME_TEXT;
757         f.subclass.integer = 0;
758         f.offset = 0;
759         f.data.ptr = buf;
760         f.datalen = strlen(buf) + 1;
761         ast_queue_frame(session->channel, &f);
762
763         send_response(rdata, PJSIP_SC_ACCEPTED, dlg, tsx);
764         return 0;
765 }
766
767 static struct ast_sip_session_supplement messaging_supplement = {
768         .method = "MESSAGE",
769         .incoming_request = incoming_in_dialog_request
770 };
771
772 static pjsip_module messaging_module = {
773         .name = {"Messaging Module", 16},
774         .id = -1,
775         .priority = PJSIP_MOD_PRIORITY_APPLICATION,
776         .on_rx_request = module_on_rx_request,
777 };
778
779 static int load_module(void)
780 {
781         CHECK_PJSIP_SESSION_MODULE_LOADED();
782
783         if (ast_sip_register_service(&messaging_module) != PJ_SUCCESS) {
784                 return AST_MODULE_LOAD_DECLINE;
785         }
786
787         if (pjsip_endpt_add_capability(ast_sip_get_pjsip_endpoint(),
788                                        NULL, PJSIP_H_ALLOW, NULL, 1,
789                                        &pjsip_message_method.name) != PJ_SUCCESS) {
790
791                 ast_sip_unregister_service(&messaging_module);
792                 return AST_MODULE_LOAD_DECLINE;
793         }
794
795         if (ast_msg_tech_register(&msg_tech)) {
796                 ast_sip_unregister_service(&messaging_module);
797                 return AST_MODULE_LOAD_DECLINE;
798         }
799
800         message_serializer = ast_sip_create_serializer("pjsip/messaging");
801         if (!message_serializer) {
802                 ast_sip_unregister_service(&messaging_module);
803                 ast_msg_tech_unregister(&msg_tech);
804                 return AST_MODULE_LOAD_DECLINE;
805         }
806
807         ast_sip_session_register_supplement(&messaging_supplement);
808         return AST_MODULE_LOAD_SUCCESS;
809 }
810
811 static int unload_module(void)
812 {
813         ast_sip_session_unregister_supplement(&messaging_supplement);
814         ast_msg_tech_unregister(&msg_tech);
815         ast_sip_unregister_service(&messaging_module);
816         ast_taskprocessor_unreference(message_serializer);
817         return 0;
818 }
819
820 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "PJSIP Messaging Support",
821         .support_level = AST_MODULE_SUPPORT_CORE,
822         .load = load_module,
823         .unload = unload_module,
824         .load_pri = AST_MODPRI_APP_DEPEND,
825 );