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