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