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