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