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