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