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