5a0e2ba81be29aec57fee4df08072ce63ef7742c
[asterisk/asterisk.git] / res / res_pjsip_pubsub.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2013, Digium, Inc.
5  *
6  * Mark Michelson <mmichelson@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  * \brief Opaque structure representing an RFC 3265 SIP subscription
20  */
21
22 /*** MODULEINFO
23         <depend>pjproject</depend>
24         <depend>res_pjsip</depend>
25         <support_level>core</support_level>
26  ***/
27
28 #include "asterisk.h"
29
30 #include <pjsip.h>
31 #include <pjsip_simple.h>
32 #include <pjlib.h>
33
34 #include "asterisk/res_pjsip_pubsub.h"
35 #include "asterisk/module.h"
36 #include "asterisk/linkedlists.h"
37 #include "asterisk/astobj2.h"
38 #include "asterisk/datastore.h"
39 #include "asterisk/uuid.h"
40 #include "asterisk/taskprocessor.h"
41 #include "asterisk/sched.h"
42 #include "asterisk/res_pjsip.h"
43 #include "asterisk/callerid.h"
44 #include "asterisk/manager.h"
45 #include "asterisk/test.h"
46 #include "res_pjsip/include/res_pjsip_private.h"
47 #include "asterisk/res_pjsip_presence_xml.h"
48
49 /*** DOCUMENTATION
50         <manager name="PJSIPShowSubscriptionsInbound" language="en_US">
51                 <synopsis>
52                         Lists subscriptions.
53                 </synopsis>
54                 <syntax />
55                 <description>
56                         <para>
57                         Provides a listing of all inbound subscriptions.  An event <literal>InboundSubscriptionDetail</literal>
58                         is issued for each subscription object.  Once all detail events are completed an
59                         <literal>InboundSubscriptionDetailComplete</literal> event is issued.
60                         </para>
61                 </description>
62         </manager>
63         <manager name="PJSIPShowSubscriptionsOutbound" language="en_US">
64                 <synopsis>
65                         Lists subscriptions.
66                 </synopsis>
67                 <syntax />
68                 <description>
69                         <para>
70                         Provides a listing of all outbound subscriptions.  An event <literal>OutboundSubscriptionDetail</literal>
71                         is issued for each subscription object.  Once all detail events are completed an
72                         <literal>OutboundSubscriptionDetailComplete</literal> event is issued.
73                         </para>
74                 </description>
75         </manager>
76         <manager name="PJSIPShowResourceLists" language="en_US">
77                 <synopsis>
78                         Displays settings for configured resource lists.
79                 </synopsis>
80                 <syntax />
81                 <description>
82                         <para>
83                         Provides a listing of all resource lists.  An event <literal>ResourceListDetail</literal>
84                         is issued for each resource list object.  Once all detail events are completed a
85                         <literal>ResourceListDetailComplete</literal> event is issued.
86                         </para>
87                 </description>
88         </manager>
89
90         <configInfo name="res_pjsip_pubsub" language="en_US">
91                 <synopsis>Module that implements publish and subscribe support.</synopsis>
92                 <configFile name="pjsip.conf">
93                         <configObject name="subscription_persistence">
94                                 <synopsis>Persists SIP subscriptions so they survive restarts.</synopsis>
95                                 <configOption name="packet">
96                                         <synopsis>Entire SIP SUBSCRIBE packet that created the subscription</synopsis>
97                                 </configOption>
98                                 <configOption name="src_name">
99                                         <synopsis>The source address of the subscription</synopsis>
100                                 </configOption>
101                                 <configOption name="src_port">
102                                         <synopsis>The source port of the subscription</synopsis>
103                                 </configOption>
104                                 <configOption name="transport_key">
105                                         <synopsis>The type of transport the subscription was received on</synopsis>
106                                 </configOption>
107                                 <configOption name="local_name">
108                                         <synopsis>The local address the subscription was received on</synopsis>
109                                 </configOption>
110                                 <configOption name="local_port">
111                                         <synopsis>The local port the subscription was received on</synopsis>
112                                 </configOption>
113                                 <configOption name="cseq">
114                                         <synopsis>The sequence number of the next NOTIFY to be sent</synopsis>
115                                 </configOption>
116                                 <configOption name="tag">
117                                         <synopsis>The local tag of the dialog for the subscription</synopsis>
118                                 </configOption>
119                                 <configOption name="endpoint">
120                                         <synopsis>The name of the endpoint that subscribed</synopsis>
121                                 </configOption>
122                                 <configOption name="expires">
123                                         <synopsis>The time at which the subscription expires</synopsis>
124                                 </configOption>
125                         </configObject>
126                         <configObject name="resource_list">
127                                 <synopsis>Resource list configuration parameters.</synopsis>
128                                 <description>
129                                         <para>This configuration object allows for RFC 4662 resource list subscriptions
130                                         to be specified. This can be useful to decrease the amount of subscription traffic
131                                         that a server has to process.</para>
132                                         <note>
133                                                 <para>Current limitations limit the size of SIP NOTIFY requests that Asterisk sends
134                                                 to 64000 bytes. If your resource list notifications are larger than this maximum, you
135                                                 will need to make adjustments.</para>
136                                         </note>
137                                 </description>
138                                 <configOption name="type">
139                                         <synopsis>Must be of type 'resource_list'</synopsis>
140                                 </configOption>
141                                 <configOption name="event">
142                                         <synopsis>The SIP event package that the list resource belong to.</synopsis>
143                                         <description><para>
144                                                 The SIP event package describes the types of resources that Asterisk reports
145                                                 the state of.
146                                         </para>
147                                                 <enumlist>
148                                                         <enum name="presence"><para>
149                                                                 Device state and presence reporting.
150                                                         </para></enum>
151                                                         <enum name="message-summary"><para>
152                                                                 Message-waiting indication (MWI) reporting.
153                                                         </para></enum>
154                                                 </enumlist>
155                                         </description>
156                                 </configOption>
157                                 <configOption name="list_item">
158                                         <synopsis>The name of a resource to report state on</synopsis>
159                                         <description>
160                                                 <para>In general Asterisk looks up list items in the following way:</para>
161                                                 <para>1. Check if the list item refers to another configured resource list.</para>
162                                                 <para>2. Pass the name of the resource off to event-package-specific handlers
163                                                    to find the specified resource.</para>
164                                                 <para>The second part means that the way the list item is specified depends
165                                                 on what type of list this is. For instance, if you have the <replaceable>event</replaceable>
166                                                 set to <literal>presence</literal>, then list items should be in the form of
167                                                 dialplan_extension@dialplan_context. For <literal>message-summary</literal> mailbox
168                                                 names should be listed.</para>
169                                         </description>
170                                 </configOption>
171                                 <configOption name="full_state" default="no">
172                                         <synopsis>Indicates if the entire list's state should be sent out.</synopsis>
173                                         <description>
174                                                 <para>If this option is enabled, and a resource changes state, then Asterisk will construct
175                                                 a notification that contains the state of all resources in the list. If the option is
176                                                 disabled, Asterisk will construct a notification that only contains the states of
177                                                 resources that have changed.</para>
178                                                 <note>
179                                                         <para>Even with this option disabled, there are certain situations where Asterisk is forced
180                                                         to send a notification with the states of all resources in the list. When a subscriber
181                                                         renews or terminates its subscription to the list, Asterisk MUST send a full state
182                                                         notification.</para>
183                                                 </note>
184                                         </description>
185                                 </configOption>
186                                 <configOption name="notification_batch_interval" default="0">
187                                         <synopsis>Time Asterisk should wait, in milliseconds, before sending notifications.</synopsis>
188                                         <description>
189                                                 <para>When a resource's state changes, it may be desired to wait a certain amount before Asterisk
190                                                 sends a notification to subscribers. This allows for other state changes to accumulate, so that
191                                                 Asterisk can communicate multiple state changes in a single notification instead of rapidly sending
192                                                 many notifications.</para>
193                                         </description>
194                                 </configOption>
195                         </configObject>
196                         <configObject name="inbound-publication">
197                                 <synopsis>The configuration for inbound publications</synopsis>
198                                 <configOption name="endpoint" default="">
199                                         <synopsis>Optional name of an endpoint that is only allowed to publish to this resource</synopsis>
200                                 </configOption>
201                                 <configOption name="type">
202                                         <synopsis>Must be of type 'inbound-publication'.</synopsis>
203                                 </configOption>
204                         </configObject>
205                 </configFile>
206         </configInfo>
207  ***/
208
209 static pj_bool_t pubsub_on_rx_request(pjsip_rx_data *rdata);
210
211 static struct pjsip_module pubsub_module = {
212         .name = { "PubSub Module", 13 },
213         .priority = PJSIP_MOD_PRIORITY_APPLICATION,
214         .on_rx_request = pubsub_on_rx_request,
215 };
216
217 #define MOD_DATA_PERSISTENCE "sub_persistence"
218 #define MOD_DATA_MSG "sub_msg"
219
220 static const pj_str_t str_event_name = { "Event", 5 };
221
222 /*! \brief Scheduler used for automatically expiring publications */
223 static struct ast_sched_context *sched;
224
225 /*! \brief Number of buckets for publications (on a per handler) */
226 #define PUBLICATIONS_BUCKETS 37
227
228 /*! \brief Default expiration time for PUBLISH if one is not specified */
229 #define DEFAULT_PUBLISH_EXPIRES 3600
230
231 /*! \brief Number of buckets for subscription datastore */
232 #define DATASTORE_BUCKETS 53
233
234 /*! \brief Default expiration for subscriptions */
235 #define DEFAULT_EXPIRES 3600
236
237 /*! \brief Defined method for PUBLISH */
238 const pjsip_method pjsip_publish_method =
239 {
240         PJSIP_OTHER_METHOD,
241         { "PUBLISH", 7 }
242 };
243
244 /*!
245  * \brief The types of PUBLISH messages defined in RFC 3903
246  */
247 enum sip_publish_type {
248         /*!
249          * \brief Unknown
250          *
251          * \details
252          * This actually is not defined in RFC 3903. We use this as a constant
253          * to indicate that an incoming PUBLISH does not fit into any of the
254          * other categories and is thus invalid.
255          */
256         SIP_PUBLISH_UNKNOWN,
257
258         /*!
259          * \brief Initial
260          *
261          * \details
262          * The first PUBLISH sent. This will contain a non-zero Expires header
263          * as well as a body that indicates the current state of the endpoint
264          * that has sent the message. The initial PUBLISH is the only type
265          * of PUBLISH to not contain a Sip-If-Match header in it.
266          */
267         SIP_PUBLISH_INITIAL,
268
269         /*!
270          * \brief Refresh
271          *
272          * \details
273          * Used to keep a published state from expiring. This will contain a
274          * non-zero Expires header but no body since its purpose is not to
275          * update state.
276          */
277         SIP_PUBLISH_REFRESH,
278
279         /*!
280          * \brief Modify
281          *
282          * \details
283          * Used to change state from its previous value. This will contain
284          * a body updating the published state. May or may not contain an
285          * Expires header.
286          */
287         SIP_PUBLISH_MODIFY,
288
289         /*!
290          * \brief Remove
291          *
292          * \details
293          * Used to remove published state from an ESC. This will contain
294          * an Expires header set to 0 and likely no body.
295          */
296         SIP_PUBLISH_REMOVE,
297 };
298
299 /*!
300  * \brief A vector of strings commonly used throughout this module
301  */
302 AST_VECTOR(resources, const char *);
303
304 /*!
305  * \brief Resource list configuration item
306  */
307 struct resource_list {
308         SORCERY_OBJECT(details);
309         /*! SIP event package the list uses. */
310         char event[32];
311         /*! Strings representing resources in the list. */
312         struct resources items;
313         /*! Indicates if Asterisk sends full or partial state on notifications. */
314         unsigned int full_state;
315         /*! Time, in milliseconds Asterisk waits before sending a batched notification.*/
316         unsigned int notification_batch_interval;
317 };
318
319 /*!
320  * Used to create new entity IDs by ESCs.
321  */
322 static int esc_etag_counter;
323
324 /*!
325  * \brief Structure representing a SIP publication
326  */
327 struct ast_sip_publication {
328         /*! Publication datastores set up by handlers */
329         struct ao2_container *datastores;
330         /*! \brief Entity tag for the publication */
331         int entity_tag;
332         /*! \brief Handler for this publication */
333         struct ast_sip_publish_handler *handler;
334         /*! \brief The endpoint with which the subscription is communicating */
335         struct ast_sip_endpoint *endpoint;
336         /*! \brief Expiration time of the publication */
337         int expires;
338         /*! \brief Scheduled item for expiration of publication */
339         int sched_id;
340         /*! \brief The resource the publication is to */
341         char *resource;
342         /*! \brief The name of the event type configuration */
343         char *event_configuration_name;
344         /*! \brief Data containing the above */
345         char data[0];
346 };
347
348
349 /*!
350  * \brief Structure used for persisting an inbound subscription
351  */
352 struct subscription_persistence {
353         /*! Sorcery object details */
354         SORCERY_OBJECT(details);
355         /*! The name of the endpoint involved in the subscrption */
356         char *endpoint;
357         /*! SIP message that creates the subscription */
358         char packet[PJSIP_MAX_PKT_LEN];
359         /*! Source address of the message */
360         char src_name[PJ_INET6_ADDRSTRLEN];
361         /*! Source port of the message */
362         int src_port;
363         /*! Local transport key type */
364         char transport_key[32];
365         /*! Local transport address */
366         char local_name[PJ_INET6_ADDRSTRLEN];
367         /*! Local transport port */
368         int local_port;
369         /*! Next CSeq to use for message */
370         unsigned int cseq;
371         /*! Local tag of the dialog */
372         char *tag;
373         /*! When this subscription expires */
374         struct timeval expires;
375 };
376
377 /*!
378  * \brief A tree of SIP subscriptions
379  *
380  * Because of the ability to subscribe to resource lists, a SIP
381  * subscription can result in a tree of subscriptions being created.
382  * This structure represents the information relevant to the subscription
383  * as a whole, to include the underlying PJSIP structure for the
384  * subscription.
385  */
386 struct sip_subscription_tree {
387         /*! The endpoint with which the subscription is communicating */
388         struct ast_sip_endpoint *endpoint;
389         /*! Serializer on which to place operations for this subscription */
390         struct ast_taskprocessor *serializer;
391         /*! The role for this subscription */
392         enum ast_sip_subscription_role role;
393         /*! Persistence information */
394         struct subscription_persistence *persistence;
395         /*! The underlying PJSIP event subscription structure */
396         pjsip_evsub *evsub;
397         /*! The underlying PJSIP dialog */
398         pjsip_dialog *dlg;
399         /*! Interval to use for batching notifications */
400         unsigned int notification_batch_interval;
401         /*! Scheduler ID for batched notification */
402         int notify_sched_id;
403         /*! Indicator if scheduled batched notification should be sent */
404         unsigned int send_scheduled_notify;
405         /*! The root of the subscription tree */
406         struct ast_sip_subscription *root;
407         /*! Is this subscription to a list? */
408         int is_list;
409         /*! Next item in the list */
410         AST_LIST_ENTRY(sip_subscription_tree) next;
411 };
412
413 /*!
414  * \brief Structure representing a "virtual" SIP subscription.
415  *
416  * This structure serves a dual purpose. Structurally, it is
417  * the constructed tree of subscriptions based on the resources
418  * being subscribed to. API-wise, this serves as the handle that
419  * subscription handlers use in order to interact with the pubsub API.
420  */
421 struct ast_sip_subscription {
422         /*! Subscription datastores set up by handlers */
423         struct ao2_container *datastores;
424         /*! The handler for this subscription */
425         const struct ast_sip_subscription_handler *handler;
426         /*! Pointer to the base of the tree */
427         struct sip_subscription_tree *tree;
428         /*! Body generaator for NOTIFYs */
429         struct ast_sip_pubsub_body_generator *body_generator;
430         /*! Vector of child subscriptions */
431         AST_VECTOR(, struct ast_sip_subscription *) children;
432         /*! Saved NOTIFY body text for this subscription */
433         struct ast_str *body_text;
434         /*! Indicator that the body text has changed since the last notification */
435         int body_changed;
436         /*! The current state of the subscription */
437         pjsip_evsub_state subscription_state;
438         /*! For lists, the current version to place in the RLMI body */
439         unsigned int version;
440         /*! For lists, indicates if full state should always be communicated. */
441         unsigned int full_state;
442         /*! URI associated with the subscription */
443         pjsip_sip_uri *uri;
444         /*! Name of resource being subscribed to */
445         char resource[0];
446 };
447
448 /*!
449  * \brief Structure representing a publication resource
450  */
451 struct ast_sip_publication_resource {
452         /*! \brief Sorcery object details */
453         SORCERY_OBJECT(details);
454         /*! \brief Optional name of an endpoint that is only allowed to publish to this resource */
455         char *endpoint;
456         /*! \brief Mapping for event types to configuration */
457         struct ast_variable *events;
458 };
459
460 static const char *sip_subscription_roles_map[] = {
461         [AST_SIP_SUBSCRIBER] = "Subscriber",
462         [AST_SIP_NOTIFIER] = "Notifier"
463 };
464
465 AST_RWLIST_HEAD_STATIC(subscriptions, sip_subscription_tree);
466
467 AST_RWLIST_HEAD_STATIC(body_generators, ast_sip_pubsub_body_generator);
468 AST_RWLIST_HEAD_STATIC(body_supplements, ast_sip_pubsub_body_supplement);
469
470 static void pubsub_on_evsub_state(pjsip_evsub *sub, pjsip_event *event);
471 static void pubsub_on_rx_refresh(pjsip_evsub *sub, pjsip_rx_data *rdata,
472                 int *p_st_code, pj_str_t **p_st_text, pjsip_hdr *res_hdr, pjsip_msg_body **p_body);
473 static void pubsub_on_rx_notify(pjsip_evsub *sub, pjsip_rx_data *rdata, int *p_st_code,
474                 pj_str_t **p_st_text, pjsip_hdr *res_hdr, pjsip_msg_body **p_body);
475 static void pubsub_on_client_refresh(pjsip_evsub *sub);
476 static void pubsub_on_server_timeout(pjsip_evsub *sub);
477  
478 static pjsip_evsub_user pubsub_cb = {
479         .on_evsub_state = pubsub_on_evsub_state,
480         .on_rx_refresh = pubsub_on_rx_refresh,
481         .on_rx_notify = pubsub_on_rx_notify,
482         .on_client_refresh = pubsub_on_client_refresh,
483         .on_server_timeout = pubsub_on_server_timeout,
484 };
485
486 /*! \brief Destructor for publication resource */
487 static void publication_resource_destroy(void *obj)
488 {
489         struct ast_sip_publication_resource *resource = obj;
490
491         ast_free(resource->endpoint);
492         ast_variables_destroy(resource->events);
493 }
494
495 /*! \brief Allocator for publication resource */
496 static void *publication_resource_alloc(const char *name)
497 {
498         return ast_sorcery_generic_alloc(sizeof(struct ast_sip_publication_resource), publication_resource_destroy);
499 }
500
501 /*! \brief Destructor for subscription persistence */
502 static void subscription_persistence_destroy(void *obj)
503 {
504         struct subscription_persistence *persistence = obj;
505
506         ast_free(persistence->endpoint);
507         ast_free(persistence->tag);
508 }
509
510 /*! \brief Allocator for subscription persistence */
511 static void *subscription_persistence_alloc(const char *name)
512 {
513         return ast_sorcery_generic_alloc(sizeof(struct subscription_persistence), subscription_persistence_destroy);
514 }
515
516 /*! \brief Function which creates initial persistence information of a subscription in sorcery */
517 static struct subscription_persistence *subscription_persistence_create(struct sip_subscription_tree *sub_tree)
518 {
519         char tag[PJ_GUID_STRING_LENGTH + 1];
520
521         /* The id of this persistence object doesn't matter as we keep it on the subscription and don't need to
522          * look it up by id at all.
523          */
524         struct subscription_persistence *persistence = ast_sorcery_alloc(ast_sip_get_sorcery(),
525                 "subscription_persistence", NULL);
526
527         pjsip_dialog *dlg = sub_tree->dlg;
528
529         if (!persistence) {
530                 return NULL;
531         }
532
533         persistence->endpoint = ast_strdup(ast_sorcery_object_get_id(sub_tree->endpoint));
534         ast_copy_pj_str(tag, &dlg->local.info->tag, sizeof(tag));
535         persistence->tag = ast_strdup(tag);
536
537         ast_sorcery_create(ast_sip_get_sorcery(), persistence);
538         return persistence;
539 }
540
541 /*! \brief Function which updates persistence information of a subscription in sorcery */
542 static void subscription_persistence_update(struct sip_subscription_tree *sub_tree,
543         pjsip_rx_data *rdata)
544 {
545         pjsip_dialog *dlg;
546
547         if (!sub_tree->persistence) {
548                 return;
549         }
550
551         dlg = sub_tree->dlg;
552         sub_tree->persistence->cseq = dlg->local.cseq;
553
554         if (rdata) {
555                 int expires;
556                 pjsip_expires_hdr *expires_hdr = pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_EXPIRES, NULL);
557
558                 expires = expires_hdr ? expires_hdr->ivalue : DEFAULT_PUBLISH_EXPIRES;
559                 sub_tree->persistence->expires = ast_tvadd(ast_tvnow(), ast_samp2tv(expires, 1));
560
561                 ast_copy_string(sub_tree->persistence->packet, rdata->pkt_info.packet,
562                                 sizeof(sub_tree->persistence->packet));
563                 ast_copy_string(sub_tree->persistence->src_name, rdata->pkt_info.src_name,
564                                 sizeof(sub_tree->persistence->src_name));
565                 sub_tree->persistence->src_port = rdata->pkt_info.src_port;
566                 ast_copy_string(sub_tree->persistence->transport_key, rdata->tp_info.transport->type_name,
567                         sizeof(sub_tree->persistence->transport_key));
568                 ast_copy_pj_str(sub_tree->persistence->local_name, &rdata->tp_info.transport->local_name.host,
569                         sizeof(sub_tree->persistence->local_name));
570                 sub_tree->persistence->local_port = rdata->tp_info.transport->local_name.port;
571         }
572
573         ast_sorcery_update(ast_sip_get_sorcery(), sub_tree->persistence);
574 }
575
576 /*! \brief Function which removes persistence of a subscription from sorcery */
577 static void subscription_persistence_remove(struct sip_subscription_tree *sub_tree)
578 {
579         if (!sub_tree->persistence) {
580                 return;
581         }
582
583         ast_sorcery_delete(ast_sip_get_sorcery(), sub_tree->persistence);
584         ao2_ref(sub_tree->persistence, -1);
585 }
586
587
588 static struct ast_sip_subscription_handler *find_sub_handler_for_event_name(const char *event_name);
589 static struct ast_sip_pubsub_body_generator *find_body_generator(char accept[AST_SIP_MAX_ACCEPT][64],
590                 size_t num_accept, const char *body_type);
591
592 /*! \brief Retrieve a handler using the Event header of an rdata message */
593 static struct ast_sip_subscription_handler *subscription_get_handler_from_rdata(pjsip_rx_data *rdata)
594 {
595         pjsip_event_hdr *event_header;
596         char event[32];
597         struct ast_sip_subscription_handler *handler;
598
599         event_header = pjsip_msg_find_hdr_by_name(rdata->msg_info.msg, &str_event_name, rdata->msg_info.msg->hdr.next);
600         if (!event_header) {
601                 ast_log(LOG_WARNING, "Incoming SUBSCRIBE request with no Event header\n");
602                 return NULL;
603         }
604         ast_copy_pj_str(event, &event_header->event_type, sizeof(event));
605
606         handler = find_sub_handler_for_event_name(event);
607         if (!handler) {
608                 ast_log(LOG_WARNING, "No registered subscribe handler for event %s\n", event);
609         }
610
611         return handler;
612 }
613
614 /*!
615  * \brief Accept headers that are exceptions to the rule
616  *
617  * Typically, when a SUBSCRIBE arrives, we attempt to find a
618  * body generator that matches one of the Accept headers in
619  * the request. When subscribing to a single resource, this works
620  * great. However, when subscribing to a list, things work
621  * differently. Most Accept header values are fine, but there
622  * are a couple that are endemic to resource lists that need
623  * to be ignored when searching for a body generator to use
624  * for the individual resources of the subscription.
625  */
626 const char *accept_exceptions[] =  {
627         "multipart/related",
628         "application/rlmi+xml",
629 };
630
631 /*!
632  * \brief Is the Accept header from the SUBSCRIBE in the list of exceptions?
633  *
634  * \retval 1 This Accept header value is an exception to the rule.
635  * \retval 0 This Accept header is not an exception to the rule.
636  */
637 static int exceptional_accept(const pj_str_t *accept)
638 {
639         int i;
640
641         for (i = 0; i < ARRAY_LEN(accept_exceptions); ++i) {
642                 if (!pj_strcmp2(accept, accept_exceptions[i])) {
643                         return 1;
644                 }
645         }
646
647         return 0;
648 }
649
650 /*! \brief Retrieve a body generator using the Accept header of an rdata message */
651 static struct ast_sip_pubsub_body_generator *subscription_get_generator_from_rdata(pjsip_rx_data *rdata,
652         const struct ast_sip_subscription_handler *handler)
653 {
654         pjsip_accept_hdr *accept_header = (pjsip_accept_hdr *) &rdata->msg_info.msg->hdr;
655         char accept[AST_SIP_MAX_ACCEPT][64];
656         size_t num_accept_headers = 0;
657
658         while ((accept_header = pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_ACCEPT, accept_header->next))) {
659                 int i;
660
661                 for (i = 0; i < accept_header->count; ++i) {
662                         if (!exceptional_accept(&accept_header->values[i])) {
663                                 ast_copy_pj_str(accept[num_accept_headers], &accept_header->values[i], sizeof(accept[num_accept_headers]));
664                                 ++num_accept_headers;
665                         }
666                 }
667         }
668
669         if (num_accept_headers == 0) {
670                 /* If a SUBSCRIBE contains no Accept headers, then we must assume that
671                  * the default accept type for the event package is to be used.
672                  */
673                 ast_copy_string(accept[0], handler->notifier->default_accept, sizeof(accept[0]));
674                 num_accept_headers = 1;
675         }
676
677         return find_body_generator(accept, num_accept_headers, handler->body_type);
678 }
679
680 /*! \brief Check if the rdata has a Supported header containing 'eventlist'
681  *
682  *  \retval 1 rdata has an eventlist containing supported header
683  *  \retval 0 rdata doesn't have an eventlist containing supported header
684  */
685 static int ast_sip_pubsub_has_eventlist_support(pjsip_rx_data *rdata)
686 {
687         pjsip_supported_hdr *supported_header = (pjsip_supported_hdr *) &rdata->msg_info.msg->hdr;
688
689         while ((supported_header = pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_SUPPORTED, supported_header->next))) {
690                 int i;
691
692                 for (i = 0; i < supported_header->count; i++) {
693                         if (!pj_stricmp2(&supported_header->values[i], "eventlist")) {
694                                 return 1;
695                         }
696                 }
697         }
698
699         return 0;
700 }
701
702 struct resource_tree;
703
704 /*!
705  * \brief A node for a resource tree.
706  */
707 struct tree_node {
708         AST_VECTOR(, struct tree_node *) children;
709         unsigned int full_state;
710         char resource[0];
711 };
712
713 /*!
714  * \brief Helper function for retrieving a resource list for a given event.
715  *
716  * This will retrieve a resource list that corresponds to the resource and event provided.
717  *
718  * \param resource The name of the resource list to retrieve
719  * \param event The expected event name on the resource list
720  */
721 static struct resource_list *retrieve_resource_list(const char *resource, const char *event)
722 {
723         struct resource_list *list;
724
725         list = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "resource_list", resource);
726         if (!list) {
727                 return NULL;
728         }
729
730         if (strcmp(list->event, event)) {
731                 ast_log(LOG_WARNING, "Found resource list %s, but its event type (%s) does not match SUBSCRIBE's (%s)\n",
732                                 resource, list->event, event);
733                 ao2_cleanup(list);
734                 return NULL;
735         }
736
737         return list;
738 }
739
740 /*!
741  * \brief Allocate a tree node
742  *
743  * In addition to allocating and initializing the tree node, the node is also added
744  * to the vector of visited resources. See \ref build_resource_tree for more information
745  * on the visited resources.
746  *
747  * \param resource The name of the resource for this tree node.
748  * \param visited The vector of resources that have been visited.
749  * \param if allocating a list, indicate whether full state is requested in notifications.
750  * \retval NULL Allocation failure.
751  * \retval non-NULL The newly-allocated tree_node
752  */
753 static struct tree_node *tree_node_alloc(const char *resource, struct resources *visited, unsigned int full_state)
754 {
755         struct tree_node *node;
756
757         node = ast_calloc(1, sizeof(*node) + strlen(resource) + 1);
758         if (!node) {
759                 return NULL;
760         }
761
762         strcpy(node->resource, resource);
763         if (AST_VECTOR_INIT(&node->children, 4)) {
764                 ast_free(node);
765                 return NULL;
766         }
767         node->full_state = full_state;
768
769         if (visited) {
770                 AST_VECTOR_APPEND(visited, resource);
771         }
772         return node;
773 }
774
775 /*!
776  * \brief Destructor for a tree node
777  *
778  * This function calls recursively in order to destroy
779  * all nodes lower in the tree from the given node in
780  * addition to the node itself.
781  *
782  * \param node The node to destroy.
783  */
784 static void tree_node_destroy(struct tree_node *node)
785 {
786         int i;
787         if (!node) {
788                 return;
789         }
790
791         for (i = 0; i < AST_VECTOR_SIZE(&node->children); ++i) {
792                 tree_node_destroy(AST_VECTOR_GET(&node->children, i));
793         }
794         AST_VECTOR_FREE(&node->children);
795         ast_free(node);
796 }
797
798 /*!
799  * \brief Determine if this resource has been visited already
800  *
801  * See \ref build_resource_tree for more information
802  *
803  * \param resource The resource currently being visited
804  * \param visited The resources that have previously been visited
805  */
806 static int have_visited(const char *resource, struct resources *visited)
807 {
808         int i;
809
810         for (i = 0; i < AST_VECTOR_SIZE(visited); ++i) {
811                 if (!strcmp(resource, AST_VECTOR_GET(visited, i))) {
812                         return 1;
813                 }
814         }
815
816         return 0;
817 }
818
819 /*!
820  * \brief Build child nodes for a given parent.
821  *
822  * This iterates through the items on a resource list and creates tree nodes for each one. The
823  * tree nodes created are children of the supplied parent node. If an item in the resource
824  * list is itself a list, then this function is called recursively to provide children for
825  * the the new node.
826  *
827  * If an item in a resource list is not a list, then the supplied subscription handler is
828  * called into as if a new SUBSCRIBE for the list item were presented. The handler's response
829  * is used to determine if the node can be added to the tree or not.
830  *
831  * If a parent node ends up having no child nodes added under it, then the parent node is
832  * pruned from the tree.
833  *
834  * \param endpoint The endpoint that sent the inbound SUBSCRIBE.
835  * \param handler The subscription handler for leaf nodes in the tree.
836  * \param list The configured resource list from which the child node is being built.
837  * \param parent The parent node for these children.
838  * \param visited The resources that have already been visited.
839  */
840 static void build_node_children(struct ast_sip_endpoint *endpoint, const struct ast_sip_subscription_handler *handler,
841                 struct resource_list *list, struct tree_node *parent, struct resources *visited)
842 {
843         int i;
844
845         for (i = 0; i < AST_VECTOR_SIZE(&list->items); ++i) {
846                 struct tree_node *current;
847                 struct resource_list *child_list;
848                 const char *resource = AST_VECTOR_GET(&list->items, i);
849
850                 if (have_visited(resource, visited)) {
851                         ast_debug(1, "Already visited resource %s. Avoiding duplicate resource or potential loop.\n", resource);
852                         continue;
853                 }
854
855                 child_list = retrieve_resource_list(resource, list->event);
856                 if (!child_list) {
857                         int resp = handler->notifier->new_subscribe(endpoint, resource);
858                         if (PJSIP_IS_STATUS_IN_CLASS(resp, 200)) {
859                                 current = tree_node_alloc(resource, visited, 0);
860                                 if (!current) {
861                                         ast_debug(1, "Subscription to leaf resource %s was successful, but encountered"
862                                                         "allocation error afterwards\n", resource);
863                                         continue;
864                                 }
865                                 ast_debug(1, "Subscription to leaf resource %s resulted in success. Adding to parent %s\n",
866                                                 resource, parent->resource);
867                                 AST_VECTOR_APPEND(&parent->children, current);
868                         } else {
869                                 ast_debug(1, "Subscription to leaf resource %s resulted in error response %d\n",
870                                                 resource, resp);
871                         }
872                 } else {
873                         ast_debug(1, "Resource %s (child of %s) is a list\n", resource, parent->resource);
874                         current = tree_node_alloc(resource, visited, child_list->full_state);
875                         if (!current) {
876                                 ast_debug(1, "Cannot build children of resource %s due to allocation failure\n", resource);
877                                 continue;
878                         }
879                         build_node_children(endpoint, handler, child_list, current, visited);
880                         if (AST_VECTOR_SIZE(&current->children) > 0) {
881                                 ast_debug(1, "List %s had no successful children.\n", resource);
882                                 AST_VECTOR_APPEND(&parent->children, current);
883                         } else {
884                                 ast_debug(1, "List %s had successful children. Adding to parent %s\n",
885                                                 resource, parent->resource);
886                                 tree_node_destroy(current);
887                         }
888                         ao2_cleanup(child_list);
889                 }
890         }
891 }
892
893 /*!
894  * \brief A resource tree
895  *
896  * When an inbound SUBSCRIBE arrives, the resource being subscribed to may
897  * be a resource list. If this is the case, the resource list may contain resources
898  * that are themselves lists. The structure needed to hold the resources is
899  * a tree.
900  *
901  * Upon receipt of the SUBSCRIBE, the tree is built by determining if subscriptions
902  * to the individual resources in the tree would be successful or not. Any successful
903  * subscriptions result in a node in the tree being created. Any unsuccessful subscriptions
904  * result in no node being created.
905  *
906  * This tree can be seen as a bare-bones analog of the tree of ast_sip_subscriptions that
907  * will end up being created to actually carry out the duties of a SIP SUBSCRIBE dialog.
908  */
909 struct resource_tree {
910         struct tree_node *root;
911         unsigned int notification_batch_interval;
912 };
913
914 /*!
915  * \brief Destroy a resource tree.
916  *
917  * This function makes no assumptions about how the tree itself was
918  * allocated and does not attempt to free the tree itself. Callers
919  * of this function are responsible for freeing the tree.
920  *
921  * \param tree The tree to destroy.
922  */
923 static void resource_tree_destroy(struct resource_tree *tree)
924 {
925         if (tree) {
926                 tree_node_destroy(tree->root);
927         }
928 }
929
930 /*!
931  * \brief Build a resource tree
932  *
933  * This function builds a resource tree based on the requested resource in a SUBSCRIBE request.
934  *
935  * This function also creates a container that has all resources that have been visited during
936  * creation of the tree, whether those resources resulted in a tree node being created or not.
937  * Keeping this container of visited resources allows for misconfigurations such as loops in
938  * the tree or duplicated resources to be detected.
939  *
940  * \param endpoint The endpoint that sent the SUBSCRIBE request.
941  * \param handler The subscription handler for leaf nodes in the tree.
942  * \param resource The resource requested in the SUBSCRIBE request.
943  * \param tree The tree that is to be built.
944  * \param has_eventlist_support
945  *
946  * \retval 200-299 Successfully subscribed to at least one resource.
947  * \retval 300-699 Failure to subscribe to requested resource.
948  */
949 static int build_resource_tree(struct ast_sip_endpoint *endpoint, const struct ast_sip_subscription_handler *handler,
950                 const char *resource, struct resource_tree *tree, int has_eventlist_support)
951 {
952         RAII_VAR(struct resource_list *, list, NULL, ao2_cleanup);
953         struct resources visited;
954
955         if (!has_eventlist_support || !(list = retrieve_resource_list(resource, handler->event_name))) {
956                 ast_debug(1, "Subscription to resource %s is not to a list\n", resource);
957                 tree->root = tree_node_alloc(resource, NULL, 0);
958                 if (!tree->root) {
959                         return 500;
960                 }
961                 return handler->notifier->new_subscribe(endpoint, resource);
962         }
963
964         ast_debug(1, "Subscription to resource %s is a list\n", resource);
965         if (AST_VECTOR_INIT(&visited, AST_VECTOR_SIZE(&list->items))) {
966                 return 500;
967         }
968
969         tree->root = tree_node_alloc(resource, &visited, list->full_state);
970         if (!tree->root) {
971                 return 500;
972         }
973
974         tree->notification_batch_interval = list->notification_batch_interval;
975
976         build_node_children(endpoint, handler, list, tree->root, &visited);
977         AST_VECTOR_FREE(&visited);
978
979         if (AST_VECTOR_SIZE(&tree->root->children) > 0) {
980                 return 200;
981         } else {
982                 return 500;
983         }
984 }
985
986 static int datastore_hash(const void *obj, int flags)
987 {
988         const struct ast_datastore *datastore = obj;
989         const char *uid = flags & OBJ_KEY ? obj : datastore->uid;
990
991         ast_assert(uid != NULL);
992
993         return ast_str_hash(uid);
994 }
995
996 static int datastore_cmp(void *obj, void *arg, int flags)
997 {
998         const struct ast_datastore *datastore1 = obj;
999         const struct ast_datastore *datastore2 = arg;
1000         const char *uid2 = flags & OBJ_KEY ? arg : datastore2->uid;
1001
1002         ast_assert(datastore1->uid != NULL);
1003         ast_assert(uid2 != NULL);
1004
1005         return strcmp(datastore1->uid, uid2) ? 0 : CMP_MATCH | CMP_STOP;
1006 }
1007
1008 static int subscription_remove_serializer(void *obj)
1009 {
1010         struct sip_subscription_tree *sub_tree = obj;
1011
1012         /* This is why we keep the dialog on the subscription. When the subscription
1013          * is destroyed, there is no guarantee that the underlying dialog is ready
1014          * to be destroyed. Furthermore, there's no guarantee in the opposite direction
1015          * either. The dialog could be destroyed before our subscription is. We fix
1016          * this problem by keeping a reference to the dialog until it is time to
1017          * destroy the subscription. We need to have the dialog available when the
1018          * subscription is destroyed so that we can guarantee that our attempt to
1019          * remove the serializer will be successful.
1020          */
1021         ast_sip_dialog_set_serializer(sub_tree->dlg, NULL);
1022         ast_sip_dialog_set_endpoint(sub_tree->dlg, NULL);
1023         pjsip_dlg_dec_session(sub_tree->dlg, &pubsub_module);
1024
1025         return 0;
1026 }
1027
1028 static void add_subscription(struct sip_subscription_tree *obj)
1029 {
1030         SCOPED_LOCK(lock, &subscriptions, AST_RWLIST_WRLOCK, AST_RWLIST_UNLOCK);
1031         AST_RWLIST_INSERT_TAIL(&subscriptions, obj, next);
1032 }
1033
1034 static void remove_subscription(struct sip_subscription_tree *obj)
1035 {
1036         struct sip_subscription_tree *i;
1037         SCOPED_LOCK(lock, &subscriptions, AST_RWLIST_WRLOCK, AST_RWLIST_UNLOCK);
1038         AST_RWLIST_TRAVERSE_SAFE_BEGIN(&subscriptions, i, next) {
1039                 if (i == obj) {
1040                         AST_RWLIST_REMOVE_CURRENT(next);
1041                         if (i->root) {
1042                                 ast_debug(1, "Removing subscription to resource %s from list of subscriptions\n",
1043                                                 ast_sip_subscription_get_resource_name(i->root));
1044                         }
1045                         break;
1046                 }
1047         }
1048         AST_RWLIST_TRAVERSE_SAFE_END;
1049 }
1050
1051 static void subscription_destructor(void *obj)
1052 {
1053         struct ast_sip_subscription *sub = obj;
1054
1055         ast_debug(3, "Destroying SIP subscription to resource %s\n", sub->resource);
1056         ast_free(sub->body_text);
1057
1058         ao2_cleanup(sub->datastores);
1059 }
1060
1061 static struct ast_sip_subscription *allocate_subscription(const struct ast_sip_subscription_handler *handler,
1062                 const char *resource, struct sip_subscription_tree *tree)
1063 {
1064         struct ast_sip_subscription *sub;
1065         pjsip_sip_uri *contact_uri;
1066
1067         sub = ao2_alloc(sizeof(*sub) + strlen(resource) + 1, subscription_destructor);
1068         if (!sub) {
1069                 return NULL;
1070         }
1071         strcpy(sub->resource, resource); /* Safe */
1072
1073         sub->datastores = ao2_container_alloc(DATASTORE_BUCKETS, datastore_hash, datastore_cmp);
1074         if (!sub->datastores) {
1075                 ao2_ref(sub, -1);
1076                 return NULL;
1077         }
1078
1079         sub->body_text = ast_str_create(128);
1080         if (!sub->body_text) {
1081                 ao2_ref(sub, -1);
1082                 return NULL;
1083         }
1084
1085         sub->uri = pjsip_sip_uri_create(tree->dlg->pool, PJ_FALSE);
1086         contact_uri = pjsip_uri_get_uri(tree->dlg->local.contact->uri);
1087         pjsip_sip_uri_assign(tree->dlg->pool, sub->uri, contact_uri);
1088         pj_strdup2(tree->dlg->pool, &sub->uri->user, resource);
1089
1090         sub->handler = handler;
1091         sub->subscription_state = PJSIP_EVSUB_STATE_ACTIVE;
1092         sub->tree = tree;
1093
1094         return sub;
1095 }
1096
1097 /*!
1098  * \brief Create a tree of virtual subscriptions based on a resource tree node.
1099  *
1100  * \param handler The handler to supply to leaf subscriptions.
1101  * \param resource The requested resource for this subscription.
1102  * \param generator Body generator to use for leaf subscriptions.
1103  * \param tree The root of the subscription tree.
1104  * \param current The tree node that corresponds to the subscription being created.
1105  */
1106 static struct ast_sip_subscription *create_virtual_subscriptions(const struct ast_sip_subscription_handler *handler,
1107                 const char *resource, struct ast_sip_pubsub_body_generator *generator,
1108                 struct sip_subscription_tree *tree, struct tree_node *current)
1109 {
1110         int i;
1111         struct ast_sip_subscription *sub;
1112
1113         sub = allocate_subscription(handler, resource, tree);
1114         if (!sub) {
1115                 return NULL;
1116         }
1117
1118         sub->full_state = current->full_state;
1119         sub->body_generator = generator;
1120
1121         for (i = 0; i < AST_VECTOR_SIZE(&current->children); ++i) {
1122                 struct ast_sip_subscription *child;
1123                 struct tree_node *child_node = AST_VECTOR_GET(&current->children, i);
1124
1125                 child = create_virtual_subscriptions(handler, child_node->resource, generator,
1126                                 tree, child_node);
1127
1128                 if (!child) {
1129                         ast_debug(1, "Child subscription to resource %s could not be created\n",
1130                                         child_node->resource);
1131                         continue;
1132                 }
1133
1134                 if (AST_VECTOR_APPEND(&sub->children, child)) {
1135                         ast_debug(1, "Child subscription to resource %s could not be appended\n",
1136                                         child_node->resource);
1137                 }
1138         }
1139
1140         return sub;
1141 }
1142
1143 static void shutdown_subscriptions(struct ast_sip_subscription *sub)
1144 {
1145         int i;
1146
1147         if (!sub) {
1148                 return;
1149         }
1150
1151         if (AST_VECTOR_SIZE(&sub->children) > 0) {
1152                 for (i = 0; i < AST_VECTOR_SIZE(&sub->children); ++i) {
1153                         shutdown_subscriptions(AST_VECTOR_GET(&sub->children, i));
1154                         ao2_cleanup(AST_VECTOR_GET(&sub->children, i));
1155                 }
1156                 return;
1157         }
1158
1159         if (sub->handler->subscription_shutdown) {
1160                 sub->handler->subscription_shutdown(sub);
1161         }
1162 }
1163
1164 static void subscription_tree_destructor(void *obj)
1165 {
1166         struct sip_subscription_tree *sub_tree = obj;
1167
1168         remove_subscription(sub_tree);
1169
1170         subscription_persistence_remove(sub_tree);
1171         ao2_cleanup(sub_tree->endpoint);
1172
1173         if (sub_tree->dlg) {
1174                 ast_sip_push_task_synchronous(NULL, subscription_remove_serializer, sub_tree);
1175         }
1176
1177         shutdown_subscriptions(sub_tree->root);
1178         ao2_cleanup(sub_tree->root);
1179
1180         ast_taskprocessor_unreference(sub_tree->serializer);
1181         ast_module_unref(ast_module_info->self);
1182 }
1183
1184 static void subscription_setup_dialog(struct sip_subscription_tree *sub_tree, pjsip_dialog *dlg)
1185 {
1186         /* We keep a reference to the dialog until our subscription is destroyed. See
1187          * the subscription_destructor for more details
1188          */
1189         pjsip_dlg_inc_session(dlg, &pubsub_module);
1190         sub_tree->dlg = dlg;
1191         ast_sip_dialog_set_serializer(dlg, sub_tree->serializer);
1192         ast_sip_dialog_set_endpoint(dlg, sub_tree->endpoint);
1193         pjsip_evsub_set_mod_data(sub_tree->evsub, pubsub_module.id, sub_tree);
1194 }
1195
1196 static struct sip_subscription_tree *allocate_subscription_tree(struct ast_sip_endpoint *endpoint)
1197 {
1198         struct sip_subscription_tree *sub_tree;
1199
1200         sub_tree = ao2_alloc(sizeof *sub_tree, subscription_tree_destructor);
1201         if (!sub_tree) {
1202                 return NULL;
1203         }
1204
1205         ast_module_ref(ast_module_info->self);
1206
1207         sub_tree->serializer = ast_sip_create_serializer();
1208         if (!sub_tree->serializer) {
1209                 ao2_ref(sub_tree, -1);
1210                 return NULL;
1211         }
1212
1213         sub_tree->endpoint = ao2_bump(endpoint);
1214         sub_tree->notify_sched_id = -1;
1215
1216         add_subscription(sub_tree);
1217         return sub_tree;
1218 }
1219
1220 /*!
1221  * \brief Create a subscription tree based on a resource tree.
1222  *
1223  * Using the previously-determined valid resources in the provided resource tree,
1224  * a corresponding tree of ast_sip_subscriptions are created. The root of the
1225  * subscription tree is a real subscription, and the rest in the tree are
1226  * virtual subscriptions.
1227  *
1228  * \param handler The handler to use for leaf subscriptions
1229  * \param endpoint The endpoint that sent the SUBSCRIBE request
1230  * \param rdata The SUBSCRIBE content
1231  * \param resource The requested resource in the SUBSCRIBE request
1232  * \param generator The body generator to use in leaf subscriptions
1233  * \param tree The resource tree on which the subscription tree is based
1234  * \param dlg_status[out] The result of attempting to create a dialog.
1235  *
1236  * \retval NULL Could not create the subscription tree
1237  * \retval non-NULL The root of the created subscription tree
1238  */
1239
1240 static struct sip_subscription_tree *create_subscription_tree(const struct ast_sip_subscription_handler *handler,
1241                 struct ast_sip_endpoint *endpoint, pjsip_rx_data *rdata, const char *resource,
1242                 struct ast_sip_pubsub_body_generator *generator, struct resource_tree *tree,
1243                 pj_status_t *dlg_status)
1244 {
1245         struct sip_subscription_tree *sub_tree;
1246         pjsip_dialog *dlg;
1247         struct subscription_persistence *persistence;
1248
1249         sub_tree = allocate_subscription_tree(endpoint);
1250         if (!sub_tree) {
1251                 pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 500, NULL, NULL, NULL);
1252                 return NULL;
1253         }
1254         sub_tree->role = AST_SIP_NOTIFIER;
1255
1256         dlg = ast_sip_create_dialog_uas(endpoint, rdata, dlg_status);
1257         if (!dlg) {
1258                 if (*dlg_status != PJ_EEXISTS) {
1259                         ast_log(LOG_WARNING, "Unable to create dialog for SIP subscription\n");
1260                 }
1261                 ao2_ref(sub_tree, -1);
1262                 return NULL;
1263         }
1264
1265         persistence = ast_sip_mod_data_get(rdata->endpt_info.mod_data,
1266                         pubsub_module.id, MOD_DATA_PERSISTENCE);
1267         if (persistence) {
1268                 /* Update the created dialog with the persisted information */
1269                 pjsip_ua_unregister_dlg(pjsip_ua_instance(), dlg);
1270                 pj_strdup2(dlg->pool, &dlg->local.info->tag, persistence->tag);
1271                 dlg->local.tag_hval = pj_hash_calc_tolower(0, NULL, &dlg->local.info->tag);
1272                 pjsip_ua_register_dlg(pjsip_ua_instance(), dlg);
1273                 dlg->local.cseq = persistence->cseq;
1274                 dlg->remote.cseq = persistence->cseq;
1275         }
1276
1277         pjsip_evsub_create_uas(dlg, &pubsub_cb, rdata, 0, &sub_tree->evsub);
1278         subscription_setup_dialog(sub_tree, dlg);
1279
1280         ast_sip_mod_data_set(dlg->pool, dlg->mod_data, pubsub_module.id, MOD_DATA_MSG,
1281                         pjsip_msg_clone(dlg->pool, rdata->msg_info.msg));
1282
1283         sub_tree->notification_batch_interval = tree->notification_batch_interval;
1284
1285         sub_tree->root = create_virtual_subscriptions(handler, resource, generator, sub_tree, tree->root);
1286         if (AST_VECTOR_SIZE(&sub_tree->root->children) > 0) {
1287                 sub_tree->is_list = 1;
1288         }
1289
1290         return sub_tree;
1291 }
1292
1293 static int generate_initial_notify(struct ast_sip_subscription *sub);
1294 static int send_notify(struct sip_subscription_tree *sub_tree, unsigned int force_full_state);
1295
1296 /*! \brief Callback function to perform the actual recreation of a subscription */
1297 static int subscription_persistence_recreate(void *obj, void *arg, int flags)
1298 {
1299         struct subscription_persistence *persistence = obj;
1300         pj_pool_t *pool = arg;
1301         pjsip_rx_data rdata = { { 0, }, };
1302         RAII_VAR(struct ast_sip_endpoint *, endpoint, NULL, ao2_cleanup);
1303         struct sip_subscription_tree *sub_tree;
1304         struct ast_sip_pubsub_body_generator *generator;
1305         int resp;
1306         char *resource;
1307         size_t resource_size;
1308         pjsip_sip_uri *request_uri;
1309         struct resource_tree tree;
1310         pjsip_expires_hdr *expires_header;
1311         struct ast_sip_subscription_handler *handler;
1312
1313         /* If this subscription has already expired remove it */
1314         if (ast_tvdiff_ms(persistence->expires, ast_tvnow()) <= 0) {
1315                 ast_sorcery_delete(ast_sip_get_sorcery(), persistence);
1316                 return 0;
1317         }
1318
1319         endpoint = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "endpoint", persistence->endpoint);
1320         if (!endpoint) {
1321                 ast_log(LOG_WARNING, "A subscription for '%s' could not be recreated as the endpoint was not found\n",
1322                         persistence->endpoint);
1323                 ast_sorcery_delete(ast_sip_get_sorcery(), persistence);
1324                 return 0;
1325         }
1326
1327         pj_pool_reset(pool);
1328         rdata.tp_info.pool = pool;
1329
1330         if (ast_sip_create_rdata(&rdata, persistence->packet, persistence->src_name, persistence->src_port,
1331                 persistence->transport_key, persistence->local_name, persistence->local_port)) {
1332                 ast_log(LOG_WARNING, "A subscription for '%s' could not be recreated as the message could not be parsed\n",
1333                         persistence->endpoint);
1334                 ast_sorcery_delete(ast_sip_get_sorcery(), persistence);
1335                 return 0;
1336         }
1337
1338         request_uri = pjsip_uri_get_uri(rdata.msg_info.msg->line.req.uri);
1339         resource_size = pj_strlen(&request_uri->user) + 1;
1340         resource = alloca(resource_size);
1341         ast_copy_pj_str(resource, &request_uri->user, resource_size);
1342
1343         /* Update the expiration header with the new expiration */
1344         expires_header = pjsip_msg_find_hdr(rdata.msg_info.msg, PJSIP_H_EXPIRES, rdata.msg_info.msg->hdr.next);
1345         if (!expires_header) {
1346                 expires_header = pjsip_expires_hdr_create(pool, 0);
1347                 if (!expires_header) {
1348                         ast_sorcery_delete(ast_sip_get_sorcery(), persistence);
1349                         return 0;
1350                 }
1351                 pjsip_msg_add_hdr(rdata.msg_info.msg, (pjsip_hdr*)expires_header);
1352         }
1353         expires_header->ivalue = (ast_tvdiff_ms(persistence->expires, ast_tvnow()) / 1000);
1354
1355         handler = subscription_get_handler_from_rdata(&rdata);
1356         if (!handler || !handler->notifier) {
1357                 ast_sorcery_delete(ast_sip_get_sorcery(), persistence);
1358                 return 0;
1359         }
1360
1361         generator = subscription_get_generator_from_rdata(&rdata, handler);
1362         if (!generator) {
1363                 ast_sorcery_delete(ast_sip_get_sorcery(), persistence);
1364                 return 0;
1365         }
1366
1367         ast_sip_mod_data_set(rdata.tp_info.pool, rdata.endpt_info.mod_data,
1368                         pubsub_module.id, MOD_DATA_PERSISTENCE, persistence);
1369
1370         memset(&tree, 0, sizeof(tree));
1371         resp = build_resource_tree(endpoint, handler, resource, &tree,
1372                 ast_sip_pubsub_has_eventlist_support(&rdata));
1373         if (PJSIP_IS_STATUS_IN_CLASS(resp, 200)) {
1374                 pj_status_t dlg_status;
1375
1376                 sub_tree = create_subscription_tree(handler, endpoint, &rdata, resource, generator, &tree, &dlg_status);
1377                 if (!sub_tree) {
1378                         ast_sorcery_delete(ast_sip_get_sorcery(), persistence);
1379                         ast_log(LOG_WARNING, "Failed to re-create subscription for %s\n", persistence->endpoint);
1380                         return 0;
1381                 }
1382                 sub_tree->persistence = ao2_bump(persistence);
1383                 subscription_persistence_update(sub_tree, &rdata);
1384                 if (generate_initial_notify(sub_tree->root)) {
1385                         pjsip_evsub_terminate(sub_tree->evsub, PJ_TRUE);
1386                 }
1387                 send_notify(sub_tree, 1);
1388         } else {
1389                 ast_sorcery_delete(ast_sip_get_sorcery(), persistence);
1390         }
1391         resource_tree_destroy(&tree);
1392
1393         return 0;
1394 }
1395
1396 /*! \brief Function which loads and recreates persisted subscriptions upon startup when the system is fully booted */
1397 static int subscription_persistence_load(void *data)
1398 {
1399         struct ao2_container *persisted_subscriptions = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(),
1400                 "subscription_persistence", AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL);
1401         pj_pool_t *pool;
1402
1403         pool = pjsip_endpt_create_pool(ast_sip_get_pjsip_endpoint(), "rtd%p", PJSIP_POOL_RDATA_LEN,
1404                 PJSIP_POOL_RDATA_INC);
1405         if (!pool) {
1406                 ast_log(LOG_WARNING, "Could not create a memory pool for recreating SIP subscriptions\n");
1407                 return 0;
1408         }
1409
1410         ao2_callback(persisted_subscriptions, OBJ_NODATA, subscription_persistence_recreate, pool);
1411
1412         pjsip_endpt_release_pool(ast_sip_get_pjsip_endpoint(), pool);
1413
1414         ao2_ref(persisted_subscriptions, -1);
1415         return 0;
1416 }
1417
1418 /*! \brief Event callback which fires subscription persistence recreation when the system is fully booted */
1419 static void subscription_persistence_event_cb(void *data, struct stasis_subscription *sub, struct stasis_message *message)
1420 {
1421         struct ast_json_payload *payload;
1422         const char *type;
1423
1424         if (stasis_message_type(message) != ast_manager_get_generic_type()) {
1425                 return;
1426         }
1427
1428         payload = stasis_message_data(message);
1429         type = ast_json_string_get(ast_json_object_get(payload->json, "type"));
1430
1431         /* This subscription only responds to the FullyBooted event so that all modules have been loaded when we
1432          * recreate SIP subscriptions.
1433          */
1434         if (strcmp(type, "FullyBooted")) {
1435                 return;
1436         }
1437
1438         /* This has to be here so the subscription is recreated when the body generator is available */
1439         ast_sip_push_task(NULL, subscription_persistence_load, NULL);
1440
1441         /* Once the system is fully booted we don't care anymore */
1442         stasis_unsubscribe(sub);
1443 }
1444
1445 typedef int (*on_subscription_t)(struct sip_subscription_tree *sub, void *arg);
1446
1447 static int for_each_subscription(on_subscription_t on_subscription, void *arg)
1448 {
1449         int num = 0;
1450         struct sip_subscription_tree *i;
1451         SCOPED_LOCK(lock, &subscriptions, AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK);
1452
1453         if (!on_subscription) {
1454                 return num;
1455         }
1456
1457         AST_RWLIST_TRAVERSE(&subscriptions, i, next) {
1458                 if (on_subscription(i, arg)) {
1459                         break;
1460                 }
1461                 ++num;
1462         }
1463         return num;
1464 }
1465
1466 static void sip_subscription_to_ami(struct sip_subscription_tree *sub_tree,
1467                                     struct ast_str **buf)
1468 {
1469         char str[256];
1470         struct ast_sip_endpoint_id_configuration *id = &sub_tree->endpoint->id;
1471
1472         ast_str_append(buf, 0, "Role: %s\r\n",
1473                        sip_subscription_roles_map[sub_tree->role]);
1474         ast_str_append(buf, 0, "Endpoint: %s\r\n",
1475                        ast_sorcery_object_get_id(sub_tree->endpoint));
1476
1477         ast_copy_pj_str(str, &sub_tree->dlg->call_id->id, sizeof(str));
1478         ast_str_append(buf, 0, "Callid: %s\r\n", str);
1479
1480         ast_str_append(buf, 0, "State: %s\r\n", pjsip_evsub_get_state_name(sub_tree->evsub));
1481
1482         ast_callerid_merge(str, sizeof(str),
1483                            S_COR(id->self.name.valid, id->self.name.str, NULL),
1484                            S_COR(id->self.number.valid, id->self.number.str, NULL),
1485                            "Unknown");
1486
1487         ast_str_append(buf, 0, "Callerid: %s\r\n", str);
1488
1489         /* XXX This needs to be done recursively for lists */
1490         if (sub_tree->root->handler->to_ami) {
1491                 sub_tree->root->handler->to_ami(sub_tree->root, buf);
1492         }
1493 }
1494
1495
1496 void *ast_sip_subscription_get_header(const struct ast_sip_subscription *sub, const char *header)
1497 {
1498         pjsip_dialog *dlg = sub->tree->dlg;
1499         pjsip_msg *msg = ast_sip_mod_data_get(dlg->mod_data, pubsub_module.id, MOD_DATA_MSG);
1500         pj_str_t name;
1501
1502         pj_cstr(&name, header);
1503
1504         return pjsip_msg_find_hdr_by_name(msg, &name, NULL);
1505 }
1506
1507 struct ast_sip_subscription *ast_sip_create_subscription(const struct ast_sip_subscription_handler *handler,
1508                 struct ast_sip_endpoint *endpoint, const char *resource)
1509 {
1510         struct ast_sip_subscription *sub;
1511         pjsip_dialog *dlg;
1512         struct ast_sip_contact *contact;
1513         pj_str_t event;
1514         pjsip_tx_data *tdata;
1515         pjsip_evsub *evsub;
1516         struct sip_subscription_tree *sub_tree = NULL;
1517
1518         sub_tree = allocate_subscription_tree(endpoint);
1519         if (!sub_tree) {
1520                 return NULL;
1521         }
1522
1523         sub = allocate_subscription(handler, resource, sub_tree);
1524         if (!sub) {
1525                 ao2_cleanup(sub_tree);
1526                 return NULL;
1527         }
1528
1529         contact = ast_sip_location_retrieve_contact_from_aor_list(endpoint->aors);
1530         if (!contact || ast_strlen_zero(contact->uri)) {
1531                 ast_log(LOG_WARNING, "No contacts configured for endpoint %s. Unable to create SIP subsription\n",
1532                                 ast_sorcery_object_get_id(endpoint));
1533                 ao2_ref(sub_tree, -1);
1534                 ao2_cleanup(contact);
1535                 return NULL;
1536         }
1537
1538         dlg = ast_sip_create_dialog_uac(endpoint, contact->uri, NULL);
1539         ao2_cleanup(contact);
1540         if (!dlg) {
1541                 ast_log(LOG_WARNING, "Unable to create dialog for SIP subscription\n");
1542                 ao2_ref(sub_tree, -1);
1543                 return NULL;
1544         }
1545
1546         pj_cstr(&event, handler->event_name);
1547         pjsip_evsub_create_uac(dlg, &pubsub_cb, &event, 0, &sub_tree->evsub);
1548         subscription_setup_dialog(sub_tree, dlg);
1549
1550         evsub = sub_tree->evsub;
1551
1552         if (pjsip_evsub_initiate(evsub, NULL, -1, &tdata) == PJ_SUCCESS) {
1553                 pjsip_evsub_send_request(evsub, tdata);
1554         } else {
1555                 /* pjsip_evsub_terminate will result in pubsub_on_evsub_state,
1556                  * being called and terminating the subscription. Therefore, we don't
1557                  * need to decrease the reference count of sub here.
1558                  */
1559                 pjsip_evsub_terminate(evsub, PJ_TRUE);
1560                 ao2_ref(sub_tree, -1);
1561                 return NULL;
1562         }
1563
1564         return sub;
1565 }
1566
1567 struct ast_sip_endpoint *ast_sip_subscription_get_endpoint(struct ast_sip_subscription *sub)
1568 {
1569         ast_assert(sub->tree->endpoint != NULL);
1570         return ao2_bump(sub->tree->endpoint);
1571 }
1572
1573 struct ast_taskprocessor *ast_sip_subscription_get_serializer(struct ast_sip_subscription *sub)
1574 {
1575         ast_assert(sub->tree->serializer != NULL);
1576         return sub->tree->serializer;
1577 }
1578
1579 /*!
1580  * \brief Pre-allocate a buffer for the transmission
1581  *
1582  * Typically, we let PJSIP do this step for us when we send a request. PJSIP's buffer
1583  * allocation algorithm is to allocate a buffer of PJSIP_MAX_PKT_LEN bytes and attempt
1584  * to write the packet to the allocated buffer. If the buffer is too small to hold the
1585  * packet, then we get told the message is too long to be sent.
1586  *
1587  * When dealing with SIP NOTIFY, especially with RLS, it is possible to exceed
1588  * PJSIP_MAX_PKT_LEN. Rather than accepting the limitation imposed on us by default,
1589  * we instead take the strategy of pre-allocating the buffer, testing for ourselves
1590  * if the message will fit, and resizing the buffer as required.
1591  *
1592  * RFC 3261 says that a SIP UDP request can be up to 65535 bytes long. We're capping
1593  * it at 64000 for a couple of reasons:
1594  * 1) Allocating more than 64K at a time is hard to justify
1595  * 2) If the message goes through proxies, those proxies will want to add Via and
1596  *    Record-Route headers, making the message even larger. Giving some space for
1597  *    those headers is a nice thing to do.
1598  *
1599  * RFC 3261 does not place an upper limit on the size of TCP requests, but we are
1600  * going to impose the same 64K limit as a memory savings.
1601  *
1602  * \param tdata The tdata onto which to allocate a buffer
1603  * \retval 0 Success
1604  * \retval -1 The message is too large
1605  */
1606 static int allocate_tdata_buffer(pjsip_tx_data *tdata)
1607 {
1608         int buf_size;
1609         int size = -1;
1610         char *buf;
1611
1612         for (buf_size = PJSIP_MAX_PKT_LEN; size == -1 && buf_size < 64000; buf_size *= 2) {
1613                 buf = pj_pool_alloc(tdata->pool, buf_size);
1614                 size = pjsip_msg_print(tdata->msg, buf, buf_size);
1615         }
1616
1617         if (size == -1) {
1618                 return -1;
1619         }
1620
1621         tdata->buf.start = buf;
1622         tdata->buf.cur = tdata->buf.start;
1623         tdata->buf.end = tdata->buf.start + buf_size;
1624
1625         return 0;
1626 }
1627
1628 static int sip_subscription_send_request(struct sip_subscription_tree *sub_tree, pjsip_tx_data *tdata)
1629 {
1630 #ifdef TEST_FRAMEWORK
1631         struct ast_sip_endpoint *endpoint = sub_tree->endpoint;
1632 #endif
1633         int res;
1634
1635         if (allocate_tdata_buffer(tdata)) {
1636                 ast_log(LOG_ERROR, "SIP request %s is too large to send.\n", tdata->info);
1637                 return -1;
1638         }
1639
1640         res = pjsip_evsub_send_request(sub_tree->evsub, tdata) == PJ_SUCCESS ? 0 : -1;
1641         subscription_persistence_update(sub_tree, NULL);
1642
1643         ast_test_suite_event_notify("SUBSCRIPTION_STATE_SET",
1644                 "StateText: %s\r\n"
1645                 "Endpoint: %s\r\n",
1646                 pjsip_evsub_get_state_name(sub_tree->evsub),
1647                 ast_sorcery_object_get_id(endpoint));
1648
1649         return res;
1650 }
1651
1652 /*!
1653  * \brief Add a resource XML element to an RLMI body
1654  *
1655  * Each resource element represents a subscribed resource in the list. This function currently
1656  * will unconditionally add an instance element to each created resource element. Instance
1657  * elements refer to later parts in the multipart body.
1658  *
1659  * \param pool PJLIB allocation pool
1660  * \param cid Content-ID header of the resource
1661  * \param resource_name Name of the resource
1662  * \param resource_uri URI of the resource
1663  * \param state State of the subscribed resource
1664  */
1665 static void add_rlmi_resource(pj_pool_t *pool, pj_xml_node *rlmi, const pjsip_generic_string_hdr *cid,
1666                 const char *resource_name, const pjsip_sip_uri *resource_uri, pjsip_evsub_state state)
1667 {
1668         static pj_str_t cid_name = { "cid", 3 };
1669         pj_xml_node *resource;
1670         pj_xml_node *name;
1671         pj_xml_node *instance;
1672         pj_xml_attr *cid_attr;
1673         char id[6];
1674         char uri[PJSIP_MAX_URL_SIZE];
1675
1676         /* This creates a string representing the Content-ID without the enclosing < > */
1677         const pj_str_t cid_stripped = {
1678                 .ptr = cid->hvalue.ptr + 1,
1679                 .slen = cid->hvalue.slen - 2,
1680         };
1681
1682         resource = ast_sip_presence_xml_create_node(pool, rlmi, "resource");
1683         name = ast_sip_presence_xml_create_node(pool, resource, "name");
1684         instance = ast_sip_presence_xml_create_node(pool, resource, "instance");
1685
1686         pjsip_uri_print(PJSIP_URI_IN_CONTACT_HDR, resource_uri, uri, sizeof(uri));
1687         ast_sip_presence_xml_create_attr(pool, resource, "uri", uri);
1688
1689         pj_strdup2(pool, &name->content, resource_name);
1690
1691         ast_generate_random_string(id, sizeof(id));
1692
1693         ast_sip_presence_xml_create_attr(pool, instance, "id", id);
1694         ast_sip_presence_xml_create_attr(pool, instance, "state",
1695                         state == PJSIP_EVSUB_STATE_TERMINATED ? "terminated" : "active");
1696
1697         /* Use the PJLIB-util XML library directly here since we are using a
1698          * pj_str_t
1699          */
1700
1701         cid_attr = pj_xml_attr_new(pool, &cid_name, &cid_stripped);
1702         pj_xml_add_attr(instance, cid_attr);
1703 }
1704
1705 /*!
1706  * \brief A multipart body part and meta-information
1707  *
1708  * When creating a multipart body part, the end result (the
1709  * pjsip_multipart_part) is hard to inspect without undoing
1710  * a lot of what was done to create it. Therefore, we use this
1711  * structure to store meta-information about the body part.
1712  *
1713  * The main consumer of this is the creator of the RLMI body
1714  * part of a multipart resource list body.
1715  */
1716 struct body_part {
1717         /*! Content-ID header for the body part */
1718         pjsip_generic_string_hdr *cid;
1719         /*! Subscribed resource represented in the body part */
1720         const char *resource;
1721         /*! URI for the subscribed body part */
1722         pjsip_sip_uri *uri;
1723         /*! Subscription state of the resource represented in the body part */
1724         pjsip_evsub_state state;
1725         /*! The actual body part that will be present in the multipart body */
1726         pjsip_multipart_part *part;
1727 };
1728
1729 /*!
1730  * \brief Type declaration for container of body part structures
1731  */
1732 AST_VECTOR(body_part_list, struct body_part *);
1733
1734 /*!
1735  * \brief Create a Content-ID header
1736  *
1737  * Content-ID headers are required by RFC2387 for multipart/related
1738  * bodies. They serve as identifiers for each part of the multipart body.
1739  *
1740  * \param pool PJLIB allocation pool
1741  * \param sub Subscription to a resource
1742  */
1743 static pjsip_generic_string_hdr *generate_content_id_hdr(pj_pool_t *pool,
1744                 const struct ast_sip_subscription *sub)
1745 {
1746         static const pj_str_t cid_name = { "Content-ID", 10 };
1747         pjsip_generic_string_hdr *cid;
1748         char id[6];
1749         size_t alloc_size;
1750         pj_str_t cid_value;
1751
1752         /* '<' + '@' + '>' = 3. pj_str_t does not require a null-terminator */
1753         alloc_size = sizeof(id) + pj_strlen(&sub->uri->host) + 3;
1754         cid_value.ptr = pj_pool_alloc(pool, alloc_size);
1755         cid_value.slen = sprintf(cid_value.ptr, "<%s@%.*s>",
1756                         ast_generate_random_string(id, sizeof(id)),
1757                         (int) pj_strlen(&sub->uri->host), pj_strbuf(&sub->uri->host));
1758         cid = pjsip_generic_string_hdr_create(pool, &cid_name, &cid_value);
1759
1760         return cid;
1761 }
1762
1763 static int rlmi_print_body(struct pjsip_msg_body *msg_body, char *buf, pj_size_t size)
1764 {
1765         int num_printed;
1766         pj_xml_node *rlmi = msg_body->data;
1767
1768         num_printed = pj_xml_print(rlmi, buf, size, PJ_TRUE);
1769         if (num_printed == AST_PJSIP_XML_PROLOG_LEN) {
1770                 return -1;
1771         }
1772
1773         return num_printed;
1774 }
1775
1776 static void *rlmi_clone_data(pj_pool_t *pool, const void *data, unsigned len)
1777 {
1778         const pj_xml_node *rlmi = data;
1779
1780         return pj_xml_clone(pool, rlmi);
1781 }
1782
1783 /*!
1784  * \brief Create an RLMI body part for a multipart resource list body
1785  *
1786  * RLMI (Resource list meta information) is a special body type that lists
1787  * the subscribed resources and tells subscribers the number of subscribed
1788  * resources and what other body parts are in the multipart body. The
1789  * RLMI body also has a version number that a subscriber can use to ensure
1790  * that the locally-stored state corresponds to server state.
1791  *
1792  * \param pool The allocation pool
1793  * \param sub The subscription representing the subscribed resource list
1794  * \param body_parts A container of body parts that RLMI will refer to
1795  * \param full_state Indicates whether this is a full or partial state notification
1796  * \return The multipart part representing the RLMI body
1797  */
1798 static pjsip_multipart_part *build_rlmi_body(pj_pool_t *pool, struct ast_sip_subscription *sub,
1799                 struct body_part_list *body_parts, unsigned int full_state)
1800 {
1801         static const pj_str_t rlmi_type = { "application", 11 };
1802         static const pj_str_t rlmi_subtype = { "rlmi+xml", 8 };
1803         pj_xml_node *rlmi;
1804         pj_xml_node *name;
1805         pjsip_multipart_part *rlmi_part;
1806         char version_str[32];
1807         char uri[PJSIP_MAX_URL_SIZE];
1808         pjsip_generic_string_hdr *cid;
1809         int i;
1810
1811         rlmi = ast_sip_presence_xml_create_node(pool, NULL, "list");
1812         ast_sip_presence_xml_create_attr(pool, rlmi, "xmlns", "urn:ietf:params:xml:ns:rlmi");
1813
1814         ast_sip_subscription_get_local_uri(sub, uri, sizeof(uri));
1815         ast_sip_presence_xml_create_attr(pool, rlmi, "uri", uri);
1816
1817         snprintf(version_str, sizeof(version_str), "%u", sub->version++);
1818         ast_sip_presence_xml_create_attr(pool, rlmi, "version", version_str);
1819         ast_sip_presence_xml_create_attr(pool, rlmi, "fullState", full_state ? "true" : "false");
1820
1821         name = ast_sip_presence_xml_create_node(pool, rlmi, "name");
1822         pj_strdup2(pool, &name->content, ast_sip_subscription_get_resource_name(sub));
1823
1824         for (i = 0; i < AST_VECTOR_SIZE(body_parts); ++i) {
1825                 const struct body_part *part = AST_VECTOR_GET(body_parts, i);
1826
1827                 add_rlmi_resource(pool, rlmi, part->cid, part->resource, part->uri, part->state);
1828         }
1829
1830         rlmi_part = pjsip_multipart_create_part(pool);
1831
1832         rlmi_part->body = PJ_POOL_ZALLOC_T(pool, pjsip_msg_body);
1833         pj_strdup(pool, &rlmi_part->body->content_type.type, &rlmi_type);
1834         pj_strdup(pool, &rlmi_part->body->content_type.subtype, &rlmi_subtype);
1835         pj_list_init(&rlmi_part->body->content_type.param);
1836
1837         rlmi_part->body->data = pj_xml_clone(pool, rlmi);
1838         rlmi_part->body->clone_data = rlmi_clone_data;
1839         rlmi_part->body->print_body = rlmi_print_body;
1840
1841         cid = generate_content_id_hdr(pool, sub);
1842         pj_list_insert_before(&rlmi_part->hdr, cid);
1843
1844         return rlmi_part;
1845 }
1846
1847 static pjsip_msg_body *generate_notify_body(pj_pool_t *pool, struct ast_sip_subscription *root,
1848                 unsigned int force_full_state);
1849
1850 /*!
1851  * \brief Destroy a list of body parts
1852  *
1853  * \param parts The container of parts to destroy
1854  */
1855 static void free_body_parts(struct body_part_list *parts)
1856 {
1857         int i;
1858
1859         for (i = 0; i < AST_VECTOR_SIZE(parts); ++i) {
1860                 struct body_part *part = AST_VECTOR_GET(parts, i);
1861                 ast_free(part);
1862         }
1863
1864         AST_VECTOR_FREE(parts);
1865 }
1866
1867 /*!
1868  * \brief Allocate and initialize a body part structure
1869  *
1870  * \param pool PJLIB allocation pool
1871  * \param sub Subscription representing a subscribed resource
1872  */
1873 static struct body_part *allocate_body_part(pj_pool_t *pool, const struct ast_sip_subscription *sub)
1874 {
1875         struct body_part *bp;
1876
1877         bp = ast_calloc(1, sizeof(*bp));
1878         if (!bp) {
1879                 return NULL;
1880         }
1881
1882         bp->cid = generate_content_id_hdr(pool, sub);
1883         bp->resource = sub->resource;
1884         bp->state = sub->subscription_state;
1885         bp->uri = sub->uri;
1886
1887         return bp;
1888 }
1889
1890 /*!
1891  * \brief Create a multipart body part for a subscribed resource
1892  *
1893  * \param pool PJLIB allocation pool
1894  * \param sub The subscription representing a subscribed resource
1895  * \param parts A vector of parts to append the created part to.
1896  * \param use_full_state Unused locally, but may be passed to other functions
1897  */
1898 static void build_body_part(pj_pool_t *pool, struct ast_sip_subscription *sub,
1899                 struct body_part_list *parts, unsigned int use_full_state)
1900 {
1901         struct body_part *bp;
1902         pjsip_msg_body *body;
1903
1904         bp = allocate_body_part(pool, sub);
1905         if (!bp) {
1906                 return;
1907         }
1908
1909         body = generate_notify_body(pool, sub, use_full_state);
1910         if (!body) {
1911                 /* Partial state was requested and the resource has not changed state */
1912                 ast_free(bp);
1913                 return;
1914         }
1915
1916         bp->part = pjsip_multipart_create_part(pool);
1917         bp->part->body = body;
1918         pj_list_insert_before(&bp->part->hdr, bp->cid);
1919
1920         AST_VECTOR_APPEND(parts, bp);
1921 }
1922
1923 /*!
1924  * \brief Create and initialize the PJSIP multipart body structure for a resource list subscription
1925  *
1926  * \param pool
1927  * \return The multipart message body
1928  */
1929 static pjsip_msg_body *create_multipart_body(pj_pool_t *pool)
1930 {
1931         pjsip_media_type media_type;
1932         pjsip_param *media_type_param;
1933         char boundary[6];
1934         pj_str_t pj_boundary;
1935
1936         pjsip_media_type_init2(&media_type, "multipart", "related");
1937
1938         media_type_param = pj_pool_alloc(pool, sizeof(*media_type_param));
1939         pj_list_init(media_type_param);
1940
1941         pj_strdup2(pool, &media_type_param->name, "type");
1942         pj_strdup2(pool, &media_type_param->value, "\"application/rlmi+xml\"");
1943
1944         pj_list_insert_before(&media_type.param, media_type_param);
1945
1946         pj_cstr(&pj_boundary, ast_generate_random_string(boundary, sizeof(boundary)));
1947         return pjsip_multipart_create(pool, &media_type, &pj_boundary);
1948 }
1949
1950 /*!
1951  * \brief Create a resource list body for NOTIFY requests
1952  *
1953  * Resource list bodies are multipart/related bodies. The first part of the multipart body
1954  * is an RLMI body that describes the rest of the parts to come. The other parts of the body
1955  * convey state of individual subscribed resources.
1956  *
1957  * \param pool PJLIB allocation pool
1958  * \param sub Subscription details from which to generate body
1959  * \param force_full_state If true, ignore resource list settings and send a full state notification
1960  * \return The generated multipart/related body
1961  */
1962 static pjsip_msg_body *generate_list_body(pj_pool_t *pool, struct ast_sip_subscription *sub,
1963                 unsigned int force_full_state)
1964 {
1965         int i;
1966         pjsip_multipart_part *rlmi_part;
1967         pjsip_msg_body *multipart;
1968         struct body_part_list body_parts;
1969         unsigned int use_full_state = force_full_state ? 1 : sub->full_state;
1970
1971         if (AST_VECTOR_INIT(&body_parts, AST_VECTOR_SIZE(&sub->children))) {
1972                 return NULL;
1973         }
1974
1975         for (i = 0; i < AST_VECTOR_SIZE(&sub->children); ++i) {
1976                 build_body_part(pool, AST_VECTOR_GET(&sub->children, i), &body_parts, use_full_state);
1977         }
1978
1979         /* This can happen if issuing partial state and no children of the list have changed state */
1980         if (AST_VECTOR_SIZE(&body_parts) == 0) {
1981                 return NULL;
1982         }
1983
1984         multipart = create_multipart_body(pool);
1985
1986         rlmi_part = build_rlmi_body(pool, sub, &body_parts, use_full_state);
1987         if (!rlmi_part) {
1988                 return NULL;
1989         }
1990         pjsip_multipart_add_part(pool, multipart, rlmi_part);
1991
1992         for (i = 0; i < AST_VECTOR_SIZE(&body_parts); ++i) {
1993                 pjsip_multipart_add_part(pool, multipart, AST_VECTOR_GET(&body_parts, i)->part);
1994         }
1995
1996         free_body_parts(&body_parts);
1997         return multipart;
1998 }
1999
2000 /*!
2001  * \brief Create the body for a NOTIFY request.
2002  *
2003  * \param pool The pool used for allocations
2004  * \param root The root of the subscription tree
2005  * \param force_full_state If true, ignore resource list settings and send a full state notification
2006  */
2007 static pjsip_msg_body *generate_notify_body(pj_pool_t *pool, struct ast_sip_subscription *root,
2008                 unsigned int force_full_state)
2009 {
2010         pjsip_msg_body *body;
2011
2012         if (AST_VECTOR_SIZE(&root->children) == 0) {
2013                 if (force_full_state || root->body_changed) {
2014                         /* Not a list. We've already generated the body and saved it on the subscription.
2015                          * Use that directly.
2016                          */
2017                         pj_str_t type;
2018                         pj_str_t subtype;
2019                         pj_str_t text;
2020
2021                         pj_cstr(&type, ast_sip_subscription_get_body_type(root));
2022                         pj_cstr(&subtype, ast_sip_subscription_get_body_subtype(root));
2023                         pj_cstr(&text, ast_str_buffer(root->body_text));
2024
2025                         body = pjsip_msg_body_create(pool, &type, &subtype, &text);
2026                         root->body_changed = 0;
2027                 } else {
2028                         body = NULL;
2029                 }
2030         } else {
2031                 body = generate_list_body(pool, root, force_full_state);
2032         }
2033
2034         return body;
2035 }
2036
2037 /*!
2038  * \brief Shortcut method to create a Require: eventlist header
2039  */
2040 static pjsip_require_hdr *create_require_eventlist(pj_pool_t *pool)
2041 {
2042         pjsip_require_hdr *require;
2043
2044         require = pjsip_require_hdr_create(pool);
2045         pj_strdup2(pool, &require->values[0], "eventlist");
2046         require->count = 1;
2047
2048         return require;
2049 }
2050
2051 /*!
2052  * \brief Send a NOTIFY request to a subscriber
2053  *
2054  * \param sub_tree The subscription tree representing the subscription
2055  * \param force_full_state If true, ignore resource list settings and send full resource list state.
2056  * \retval 0 Success
2057  * \retval non-zero Failure
2058  */
2059 static int send_notify(struct sip_subscription_tree *sub_tree, unsigned int force_full_state)
2060 {
2061         pjsip_evsub *evsub = sub_tree->evsub;
2062         pjsip_tx_data *tdata;
2063
2064         if (ast_shutdown_final()
2065                 && sub_tree->root->subscription_state == PJSIP_EVSUB_STATE_TERMINATED
2066                 && sub_tree->persistence) {
2067                 return 0;
2068         }
2069
2070         if (pjsip_evsub_notify(evsub, sub_tree->root->subscription_state,
2071                                 NULL, NULL, &tdata) != PJ_SUCCESS) {
2072                 return -1;
2073         }
2074
2075         tdata->msg->body = generate_notify_body(tdata->pool, sub_tree->root, force_full_state);
2076         if (!tdata->msg->body) {
2077                 pjsip_tx_data_dec_ref(tdata);
2078                 return -1;
2079         }
2080
2081         if (sub_tree->is_list) {
2082                 pjsip_require_hdr *require = create_require_eventlist(tdata->pool);
2083                 pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr *) require);
2084         }
2085
2086         if (sip_subscription_send_request(sub_tree, tdata)) {
2087                 return -1;
2088         }
2089
2090         sub_tree->send_scheduled_notify = 0;
2091
2092         return 0;
2093 }
2094
2095 static int serialized_send_notify(void *userdata)
2096 {
2097         struct sip_subscription_tree *sub_tree = userdata;
2098
2099         /* It's possible that between when the notification was scheduled
2100          * and now, that a new SUBSCRIBE arrived, requiring full state to be
2101          * sent out in an immediate NOTIFY. If that has happened, we need to
2102          * bail out here instead of sending the batched NOTIFY.
2103          */
2104         if (!sub_tree->send_scheduled_notify) {
2105                 ao2_cleanup(sub_tree);
2106                 return 0;
2107         }
2108
2109         send_notify(sub_tree, 0);
2110         ast_test_suite_event_notify("SUBSCRIPTION_STATE_CHANGED",
2111                         "Resource: %s",
2112                         sub_tree->root->resource);
2113         sub_tree->notify_sched_id = -1;
2114         ao2_cleanup(sub_tree);
2115         return 0;
2116 }
2117
2118 static int sched_cb(const void *data)
2119 {
2120         struct sip_subscription_tree *sub_tree = (struct sip_subscription_tree *) data;
2121
2122         /* We don't need to bump the refcount of sub_tree since we bumped it when scheduling this task */
2123         ast_sip_push_task(sub_tree->serializer, serialized_send_notify, sub_tree);
2124         return 0;
2125 }
2126
2127 static int schedule_notification(struct sip_subscription_tree *sub_tree)
2128 {
2129         /* There's already a notification scheduled */
2130         if (sub_tree->notify_sched_id > -1) {
2131                 return 0;
2132         }
2133
2134         sub_tree->notify_sched_id = ast_sched_add(sched, sub_tree->notification_batch_interval, sched_cb, ao2_bump(sub_tree));
2135         if (sub_tree->notify_sched_id < 0) {
2136                 return -1;
2137         }
2138
2139         sub_tree->send_scheduled_notify = 1;
2140         return 0;
2141 }
2142
2143 int ast_sip_subscription_notify(struct ast_sip_subscription *sub, struct ast_sip_body_data *notify_data,
2144                 int terminate)
2145 {
2146         if (ast_sip_pubsub_generate_body_content(ast_sip_subscription_get_body_type(sub),
2147                                 ast_sip_subscription_get_body_subtype(sub), notify_data, &sub->body_text)) {
2148                 return -1;
2149         }
2150
2151         sub->body_changed = 1;
2152         if (terminate) {
2153                 sub->subscription_state = PJSIP_EVSUB_STATE_TERMINATED;
2154         }
2155
2156         if (sub->tree->notification_batch_interval) {
2157                 return schedule_notification(sub->tree);
2158         } else {
2159                 int res;
2160                 /* See the note in pubsub_on_rx_refresh() for why sub->tree is refbumped here */
2161                 ao2_ref(sub->tree, +1);
2162                 res = send_notify(sub->tree, 0);
2163                 ast_test_suite_event_notify(terminate ? "SUBSCRIPTION_TERMINATED" : "SUBSCRIPTION_STATE_CHANGED",
2164                                 "Resource: %s",
2165                                 sub->tree->root->resource);
2166                 ao2_ref(sub->tree, -1);
2167
2168                 return res;
2169         }
2170 }
2171
2172 void ast_sip_subscription_get_local_uri(struct ast_sip_subscription *sub, char *buf, size_t size)
2173 {
2174         pjsip_uri_print(PJSIP_URI_IN_CONTACT_HDR, sub->uri, buf, size);
2175 }
2176
2177 void ast_sip_subscription_get_remote_uri(struct ast_sip_subscription *sub, char *buf, size_t size)
2178 {
2179         pjsip_dialog *dlg = sub->tree->dlg;
2180         ast_copy_pj_str(buf, &dlg->remote.info_str, size);
2181 }
2182
2183 const char *ast_sip_subscription_get_resource_name(struct ast_sip_subscription *sub)
2184 {
2185         return sub->resource;
2186 }
2187
2188 int ast_sip_subscription_is_terminated(const struct ast_sip_subscription *sub)
2189 {
2190         return sub->subscription_state == PJSIP_EVSUB_STATE_TERMINATED ? 1 : 0;
2191 }
2192
2193 static int sip_subscription_accept(struct sip_subscription_tree *sub_tree, pjsip_rx_data *rdata, int response)
2194 {
2195         pjsip_hdr res_hdr;
2196
2197         /* If this is a persistence recreation the subscription has already been accepted */
2198         if (ast_sip_mod_data_get(rdata->endpt_info.mod_data, pubsub_module.id, MOD_DATA_PERSISTENCE)) {
2199                 return 0;
2200         }
2201
2202         pj_list_init(&res_hdr);
2203         if (sub_tree->is_list) {
2204                 /* If subscribing to a list, our response has to have a Require: eventlist header in it */
2205                 pj_list_insert_before(&res_hdr, create_require_eventlist(rdata->tp_info.pool));
2206         }
2207
2208         return pjsip_evsub_accept(sub_tree->evsub, rdata, response, &res_hdr) == PJ_SUCCESS ? 0 : -1;
2209 }
2210
2211 static void subscription_datastore_destroy(void *obj)
2212 {
2213         struct ast_datastore *datastore = obj;
2214
2215         /* Using the destroy function (if present) destroy the data */
2216         if (datastore->info->destroy != NULL && datastore->data != NULL) {
2217                 datastore->info->destroy(datastore->data);
2218                 datastore->data = NULL;
2219         }
2220
2221         ast_free((void *) datastore->uid);
2222         datastore->uid = NULL;
2223 }
2224
2225 struct ast_datastore *ast_sip_subscription_alloc_datastore(const struct ast_datastore_info *info, const char *uid)
2226 {
2227         RAII_VAR(struct ast_datastore *, datastore, NULL, ao2_cleanup);
2228         char uuid_buf[AST_UUID_STR_LEN];
2229         const char *uid_ptr = uid;
2230
2231         if (!info) {
2232                 return NULL;
2233         }
2234
2235         datastore = ao2_alloc(sizeof(*datastore), subscription_datastore_destroy);
2236         if (!datastore) {
2237                 return NULL;
2238         }
2239
2240         datastore->info = info;
2241         if (ast_strlen_zero(uid)) {
2242                 /* They didn't provide an ID so we'll provide one ourself */
2243                 uid_ptr = ast_uuid_generate_str(uuid_buf, sizeof(uuid_buf));
2244         }
2245
2246         datastore->uid = ast_strdup(uid_ptr);
2247         if (!datastore->uid) {
2248                 return NULL;
2249         }
2250
2251         ao2_ref(datastore, +1);
2252         return datastore;
2253 }
2254
2255 int ast_sip_subscription_add_datastore(struct ast_sip_subscription *subscription, struct ast_datastore *datastore)
2256 {
2257         ast_assert(datastore != NULL);
2258         ast_assert(datastore->info != NULL);
2259         ast_assert(!ast_strlen_zero(datastore->uid));
2260
2261         if (!ao2_link(subscription->datastores, datastore)) {
2262                 return -1;
2263         }
2264         return 0;
2265 }
2266
2267 struct ast_datastore *ast_sip_subscription_get_datastore(struct ast_sip_subscription *subscription, const char *name)
2268 {
2269         return ao2_find(subscription->datastores, name, OBJ_KEY);
2270 }
2271
2272 void ast_sip_subscription_remove_datastore(struct ast_sip_subscription *subscription, const char *name)
2273 {
2274         ao2_find(subscription->datastores, name, OBJ_SEARCH_KEY | OBJ_UNLINK | OBJ_NODATA);
2275 }
2276
2277 int ast_sip_publication_add_datastore(struct ast_sip_publication *publication, struct ast_datastore *datastore)
2278 {
2279         ast_assert(datastore != NULL);
2280         ast_assert(datastore->info != NULL);
2281         ast_assert(!ast_strlen_zero(datastore->uid));
2282
2283         if (!ao2_link(publication->datastores, datastore)) {
2284                 return -1;
2285         }
2286         return 0;
2287 }
2288
2289 struct ast_datastore *ast_sip_publication_get_datastore(struct ast_sip_publication *publication, const char *name)
2290 {
2291         return ao2_find(publication->datastores, name, OBJ_KEY);
2292 }
2293
2294 void ast_sip_publication_remove_datastore(struct ast_sip_publication *publication, const char *name)
2295 {
2296         ao2_callback(publication->datastores, OBJ_KEY | OBJ_UNLINK | OBJ_NODATA, NULL, (void *) name);
2297 }
2298
2299 AST_RWLIST_HEAD_STATIC(publish_handlers, ast_sip_publish_handler);
2300
2301 static int publication_hash_fn(const void *obj, const int flags)
2302 {
2303         const struct ast_sip_publication *publication = obj;
2304         const int *entity_tag = obj;
2305
2306         return flags & OBJ_KEY ? *entity_tag : publication->entity_tag;
2307 }
2308
2309 static int publication_cmp_fn(void *obj, void *arg, int flags)
2310 {
2311         const struct ast_sip_publication *publication1 = obj;
2312         const struct ast_sip_publication *publication2 = arg;
2313         const int *entity_tag = arg;
2314
2315         return (publication1->entity_tag == (flags & OBJ_KEY ? *entity_tag : publication2->entity_tag) ?
2316                 CMP_MATCH | CMP_STOP : 0);
2317 }
2318
2319 static void publish_add_handler(struct ast_sip_publish_handler *handler)
2320 {
2321         SCOPED_LOCK(lock, &publish_handlers, AST_RWLIST_WRLOCK, AST_RWLIST_UNLOCK);
2322         AST_RWLIST_INSERT_TAIL(&publish_handlers, handler, next);
2323 }
2324
2325 int ast_sip_register_publish_handler(struct ast_sip_publish_handler *handler)
2326 {
2327         if (ast_strlen_zero(handler->event_name)) {
2328                 ast_log(LOG_ERROR, "No event package specified for publish handler. Cannot register\n");
2329                 return -1;
2330         }
2331
2332         if (!(handler->publications = ao2_container_alloc(PUBLICATIONS_BUCKETS,
2333                 publication_hash_fn, publication_cmp_fn))) {
2334                 ast_log(LOG_ERROR, "Could not allocate publications container for event '%s'\n",
2335                         handler->event_name);
2336                 return -1;
2337         }
2338
2339         publish_add_handler(handler);
2340
2341         ast_module_ref(ast_module_info->self);
2342
2343         return 0;
2344 }
2345
2346 void ast_sip_unregister_publish_handler(struct ast_sip_publish_handler *handler)
2347 {
2348         struct ast_sip_publish_handler *iter;
2349         SCOPED_LOCK(lock, &publish_handlers, AST_RWLIST_WRLOCK, AST_RWLIST_UNLOCK);
2350         AST_RWLIST_TRAVERSE_SAFE_BEGIN(&publish_handlers, iter, next) {
2351                 if (handler == iter) {
2352                         AST_RWLIST_REMOVE_CURRENT(next);
2353                         ao2_cleanup(handler->publications);
2354                         ast_module_unref(ast_module_info->self);
2355                         break;
2356                 }
2357         }
2358         AST_RWLIST_TRAVERSE_SAFE_END;
2359 }
2360
2361 AST_RWLIST_HEAD_STATIC(subscription_handlers, ast_sip_subscription_handler);
2362
2363 static void sub_add_handler(struct ast_sip_subscription_handler *handler)
2364 {
2365         SCOPED_LOCK(lock, &subscription_handlers, AST_RWLIST_WRLOCK, AST_RWLIST_UNLOCK);
2366         AST_RWLIST_INSERT_TAIL(&subscription_handlers, handler, next);
2367         ast_module_ref(ast_module_info->self);
2368 }
2369
2370 static struct ast_sip_subscription_handler *find_sub_handler_for_event_name(const char *event_name)
2371 {
2372         struct ast_sip_subscription_handler *iter;
2373         SCOPED_LOCK(lock, &subscription_handlers, AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK);
2374
2375         AST_RWLIST_TRAVERSE(&subscription_handlers, iter, next) {
2376                 if (!strcmp(iter->event_name, event_name)) {
2377                         break;
2378                 }
2379         }
2380         return iter;
2381 }
2382
2383 int ast_sip_register_subscription_handler(struct ast_sip_subscription_handler *handler)
2384 {
2385         pj_str_t event;
2386         pj_str_t accept[AST_SIP_MAX_ACCEPT] = { {0, }, };
2387         struct ast_sip_subscription_handler *existing;
2388         int i = 0;
2389
2390         if (ast_strlen_zero(handler->event_name)) {
2391                 ast_log(LOG_ERROR, "No event package specified for subscription handler. Cannot register\n");
2392                 return -1;
2393         }
2394
2395         existing = find_sub_handler_for_event_name(handler->event_name);
2396         if (existing) {
2397                 ast_log(LOG_ERROR, "Unable to register subscription handler for event %s."
2398                                 "A handler is already registered\n", handler->event_name);
2399                 return -1;
2400         }
2401
2402         for (i = 0; i < AST_SIP_MAX_ACCEPT && !ast_strlen_zero(handler->accept[i]); ++i) {
2403                 pj_cstr(&accept[i], handler->accept[i]);
2404         }
2405
2406         pj_cstr(&event, handler->event_name);
2407
2408         pjsip_evsub_register_pkg(&pubsub_module, &event, DEFAULT_EXPIRES, i, accept);
2409
2410         sub_add_handler(handler);
2411
2412         return 0;
2413 }
2414
2415 void ast_sip_unregister_subscription_handler(struct ast_sip_subscription_handler *handler)
2416 {
2417         struct ast_sip_subscription_handler *iter;
2418         SCOPED_LOCK(lock, &subscription_handlers, AST_RWLIST_WRLOCK, AST_RWLIST_UNLOCK);
2419         AST_RWLIST_TRAVERSE_SAFE_BEGIN(&subscription_handlers, iter, next) {
2420                 if (handler == iter) {
2421                         AST_RWLIST_REMOVE_CURRENT(next);
2422                         ast_module_unref(ast_module_info->self);
2423                         break;
2424                 }
2425         }
2426         AST_RWLIST_TRAVERSE_SAFE_END;
2427 }
2428
2429 static struct ast_sip_pubsub_body_generator *find_body_generator_type_subtype(const char *content_type,
2430                 const char *content_subtype)
2431 {
2432         struct ast_sip_pubsub_body_generator *iter;
2433         SCOPED_LOCK(lock, &body_generators, AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK);
2434
2435         AST_LIST_TRAVERSE(&body_generators, iter, list) {
2436                 if (!strcmp(iter->type, content_type) &&
2437                                 !strcmp(iter->subtype, content_subtype)) {
2438                         break;
2439                 }
2440         };
2441
2442         return iter;
2443 }
2444
2445 static struct ast_sip_pubsub_body_generator *find_body_generator_accept(const char *accept)
2446 {
2447         char *accept_copy = ast_strdupa(accept);
2448         char *subtype = accept_copy;
2449         char *type = strsep(&subtype, "/");
2450
2451         if (ast_strlen_zero(type) || ast_strlen_zero(subtype)) {
2452                 return NULL;
2453         }
2454
2455         return find_body_generator_type_subtype(type, subtype);
2456 }
2457
2458 static struct ast_sip_pubsub_body_generator *find_body_generator(char accept[AST_SIP_MAX_ACCEPT][64],
2459                 size_t num_accept, const char *body_type)
2460 {
2461         int i;
2462         struct ast_sip_pubsub_body_generator *generator = NULL;
2463
2464         for (i = 0; i < num_accept; ++i) {
2465                 generator = find_body_generator_accept(accept[i]);
2466                 if (generator) {
2467                         ast_debug(3, "Body generator %p found for accept type %s\n", generator, accept[i]);
2468                         if (strcmp(generator->body_type, body_type)) {
2469                                 ast_log(LOG_WARNING, "Body generator '%s/%s'(%p) does not accept the type of data this event generates\n",
2470                                                 generator->type, generator->subtype, generator);
2471                                 generator = NULL;
2472                                 continue;
2473                         }
2474                         break;
2475                 } else {
2476                         ast_debug(3, "No body generator found for accept type %s\n", accept[i]);
2477                 }
2478         }
2479
2480         return generator;
2481 }
2482
2483 static int generate_initial_notify(struct ast_sip_subscription *sub)
2484 {
2485         void *notify_data;
2486         int res;
2487         struct ast_sip_body_data data = {
2488                 .body_type = sub->handler->body_type,
2489         };
2490
2491         if (AST_VECTOR_SIZE(&sub->children) > 0) {
2492                 int i;
2493
2494                 for (i = 0; i < AST_VECTOR_SIZE(&sub->children); ++i) {
2495                         if (generate_initial_notify(AST_VECTOR_GET(&sub->children, i))) {
2496                                 return -1;
2497                         }
2498                 }
2499
2500                 return 0;
2501         }
2502
2503         if (sub->handler->notifier->subscription_established(sub)) {
2504                 return -1;
2505         }
2506
2507         notify_data = sub->handler->notifier->get_notify_data(sub);
2508         if (!notify_data) {
2509                 return -1;
2510         }
2511
2512         data.body_data = notify_data;
2513
2514         res = ast_sip_pubsub_generate_body_content(ast_sip_subscription_get_body_type(sub),
2515                         ast_sip_subscription_get_body_subtype(sub), &data, &sub->body_text);
2516
2517         ao2_cleanup(notify_data);
2518
2519         return res;
2520 }
2521
2522 static pj_bool_t pubsub_on_rx_subscribe_request(pjsip_rx_data *rdata)
2523 {
2524         pjsip_expires_hdr *expires_header;
2525         struct ast_sip_subscription_handler *handler;
2526         RAII_VAR(struct ast_sip_endpoint *, endpoint, NULL, ao2_cleanup);
2527         struct sip_subscription_tree *sub_tree;
2528         struct ast_sip_pubsub_body_generator *generator;
2529         char *resource;
2530         pjsip_uri *request_uri;
2531         pjsip_sip_uri *request_uri_sip;
2532         size_t resource_size;
2533         int resp;
2534         struct resource_tree tree;
2535         pj_status_t dlg_status;
2536
2537         endpoint = ast_pjsip_rdata_get_endpoint(rdata);
2538         ast_assert(endpoint != NULL);
2539
2540         if (!endpoint->subscription.allow) {
2541                 ast_log(LOG_WARNING, "Subscriptions not permitted for endpoint %s.\n", ast_sorcery_object_get_id(endpoint));
2542                 pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 603, NULL, NULL, NULL);
2543                 return PJ_TRUE;
2544         }
2545
2546         request_uri = rdata->msg_info.msg->line.req.uri;
2547
2548         if (!PJSIP_URI_SCHEME_IS_SIP(request_uri) && !PJSIP_URI_SCHEME_IS_SIPS(request_uri)) {
2549                 char uri_str[PJSIP_MAX_URL_SIZE];
2550
2551                 pjsip_uri_print(PJSIP_URI_IN_REQ_URI, request_uri, uri_str, sizeof(uri_str));
2552                 ast_log(LOG_WARNING, "Request URI '%s' is not a sip: or sips: URI.\n", uri_str);
2553                 pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 416, NULL, NULL, NULL);
2554                 return PJ_TRUE;
2555         }
2556
2557         request_uri_sip = pjsip_uri_get_uri(request_uri);
2558         resource_size = pj_strlen(&request_uri_sip->user) + 1;
2559         resource = alloca(resource_size);
2560         ast_copy_pj_str(resource, &request_uri_sip->user, resource_size);
2561
2562         expires_header = pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_EXPIRES, rdata->msg_info.msg->hdr.next);
2563
2564         if (expires_header) {
2565                 if (expires_header->ivalue == 0) {
2566                         ast_log(LOG_WARNING, "Subscription request from endpoint %s rejected. Expiration of 0 is invalid\n",
2567                                 ast_sorcery_object_get_id(endpoint));
2568                         pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 400, NULL, NULL, NULL);
2569                                 return PJ_TRUE;
2570                 }
2571                 if (expires_header->ivalue < endpoint->subscription.minexpiry) {
2572                         ast_log(LOG_WARNING, "Subscription expiration %d is too brief for endpoint %s. Minimum is %u\n",
2573                                 expires_header->ivalue, ast_sorcery_object_get_id(endpoint), endpoint->subscription.minexpiry);
2574                         pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 423, NULL, NULL, NULL);
2575                         return PJ_TRUE;
2576                 }
2577         }
2578
2579         handler = subscription_get_handler_from_rdata(rdata);
2580         if (!handler) {
2581                 pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 489, NULL, NULL, NULL);
2582                 return PJ_TRUE;
2583         }
2584
2585         generator = subscription_get_generator_from_rdata(rdata, handler);
2586         if (!generator) {
2587                 pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 489, NULL, NULL, NULL);
2588                 return PJ_TRUE;
2589         }
2590
2591         memset(&tree, 0, sizeof(tree));
2592         resp = build_resource_tree(endpoint, handler, resource, &tree,
2593                 ast_sip_pubsub_has_eventlist_support(rdata));
2594         if (!PJSIP_IS_STATUS_IN_CLASS(resp, 200)) {
2595                 pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, resp, NULL, NULL, NULL);
2596                 resource_tree_destroy(&tree);
2597                 return PJ_TRUE;
2598         }
2599
2600         sub_tree = create_subscription_tree(handler, endpoint, rdata, resource, generator, &tree, &dlg_status);
2601         if (!sub_tree) {
2602                 if (dlg_status != PJ_EEXISTS) {
2603                         pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 500, NULL, NULL, NULL);
2604                 }
2605         } else {
2606                 sub_tree->persistence = subscription_persistence_create(sub_tree);
2607                 subscription_persistence_update(sub_tree, rdata);
2608                 sip_subscription_accept(sub_tree, rdata, resp);
2609                 if (generate_initial_notify(sub_tree->root)) {
2610                         pjsip_evsub_terminate(sub_tree->evsub, PJ_TRUE);
2611                 } else {
2612                         send_notify(sub_tree, 1);
2613                         ast_test_suite_event_notify("SUBSCRIPTION_ESTABLISHED",
2614                                         "Resource: %s",
2615                                         sub_tree->root->resource);
2616                 }
2617         }
2618
2619         resource_tree_destroy(&tree);
2620         return PJ_TRUE;
2621 }
2622
2623 static struct ast_sip_publish_handler *find_pub_handler(const char *event)
2624 {
2625         struct ast_sip_publish_handler *iter = NULL;
2626         SCOPED_LOCK(lock, &publish_handlers, AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK);
2627
2628         AST_RWLIST_TRAVERSE(&publish_handlers, iter, next) {
2629                 if (strcmp(event, iter->event_name)) {
2630                         ast_debug(3, "Event %s does not match %s\n", event, iter->event_name);
2631                         continue;
2632                 }
2633                 ast_debug(3, "Event name match: %s = %s\n", event, iter->event_name);
2634                 break;
2635         }
2636
2637         return iter;
2638 }
2639
2640 static enum sip_publish_type determine_sip_publish_type(pjsip_rx_data *rdata,
2641         pjsip_generic_string_hdr *etag_hdr, int *expires, int *entity_id)
2642 {
2643         pjsip_expires_hdr *expires_hdr = pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_EXPIRES, NULL);
2644
2645         if (etag_hdr) {
2646                 char etag[pj_strlen(&etag_hdr->hvalue) + 1];
2647
2648                 ast_copy_pj_str(etag, &etag_hdr->hvalue, sizeof(etag));
2649
2650                 if (sscanf(etag, "%30d", entity_id) != 1) {
2651                         return SIP_PUBLISH_UNKNOWN;
2652                 }
2653         }
2654
2655         *expires = expires_hdr ? expires_hdr->ivalue : DEFAULT_PUBLISH_EXPIRES;
2656
2657         if (!(*expires)) {
2658                 return SIP_PUBLISH_REMOVE;
2659         } else if (!etag_hdr && rdata->msg_info.msg->body) {
2660                 return SIP_PUBLISH_INITIAL;
2661         } else if (etag_hdr && !rdata->msg_info.msg->body) {
2662                 return SIP_PUBLISH_REFRESH;
2663         } else if (etag_hdr && rdata->msg_info.msg->body) {
2664                 return SIP_PUBLISH_MODIFY;
2665         }
2666
2667         return SIP_PUBLISH_UNKNOWN;
2668 }
2669
2670 /*! \brief Internal destructor for publications */
2671 static void publication_destroy_fn(void *obj)
2672 {
2673         struct ast_sip_publication *publication = obj;
2674
2675         ast_debug(3, "Destroying SIP publication\n");
2676
2677         ao2_cleanup(publication->datastores);
2678         ao2_cleanup(publication->endpoint);
2679 }
2680
2681 static struct ast_sip_publication *sip_create_publication(struct ast_sip_endpoint *endpoint, pjsip_rx_data *rdata,
2682         const char *resource, const char *event_configuration_name)
2683 {
2684         struct ast_sip_publication *publication;
2685         pjsip_expires_hdr *expires_hdr = pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_EXPIRES, NULL);
2686         size_t resource_len = strlen(resource) + 1, event_configuration_name_len = strlen(event_configuration_name) + 1;
2687         char *dst;
2688
2689         ast_assert(endpoint != NULL);
2690
2691         if (!(publication = ao2_alloc(sizeof(*publication) + resource_len + event_configuration_name_len, publication_destroy_fn))) {
2692                 return NULL;
2693         }
2694
2695         if (!(publication->datastores = ao2_container_alloc(DATASTORE_BUCKETS, datastore_hash, datastore_cmp))) {
2696                 ao2_ref(publication, -1);
2697                 return NULL;
2698         }
2699
2700         publication->entity_tag = ast_atomic_fetchadd_int(&esc_etag_counter, +1);
2701         ao2_ref(endpoint, +1);
2702         publication->endpoint = endpoint;
2703         publication->expires = expires_hdr ? expires_hdr->ivalue : DEFAULT_PUBLISH_EXPIRES;
2704         publication->sched_id = -1;
2705         dst = publication->data;
2706         publication->resource = strcpy(dst, resource);
2707         dst += resource_len;
2708         publication->event_configuration_name = strcpy(dst, event_configuration_name);
2709
2710         return publication;
2711 }
2712
2713 static int sip_publication_respond(struct ast_sip_publication *pub, int status_code,
2714                 pjsip_rx_data *rdata)
2715 {
2716         pj_status_t status;
2717         pjsip_tx_data *tdata;
2718         pjsip_transaction *tsx;
2719
2720         if (pjsip_endpt_create_response(ast_sip_get_pjsip_endpoint(), rdata, status_code, NULL, &tdata) != PJ_SUCCESS) {
2721                 return -1;
2722         }
2723
2724         if (PJSIP_IS_STATUS_IN_CLASS(status_code, 200)) {
2725                 RAII_VAR(char *, entity_tag, NULL, ast_free_ptr);
2726                 RAII_VAR(char *, expires, NULL, ast_free_ptr);
2727
2728                 if ((ast_asprintf(&entity_tag, "%d", pub->entity_tag) < 0) ||
2729                         (ast_asprintf(&expires, "%d", pub->expires) < 0)) {
2730                         pjsip_tx_data_dec_ref(tdata);
2731                         return -1;
2732                 }
2733
2734                 ast_sip_add_header(tdata, "SIP-ETag", entity_tag);
2735                 ast_sip_add_header(tdata, "Expires", expires);
2736         }
2737
2738         if ((status = pjsip_tsx_create_uas(&pubsub_module, rdata, &tsx)) != PJ_SUCCESS) {
2739                 return -1;
2740         }
2741
2742         pjsip_tsx_recv_msg(tsx, rdata);
2743
2744         if (pjsip_tsx_send_msg(tsx, tdata) != PJ_SUCCESS) {
2745                 return -1;
2746         }
2747
2748         return 0;
2749 }
2750
2751 static struct ast_sip_publication *publish_request_initial(struct ast_sip_endpoint *endpoint, pjsip_rx_data *rdata,
2752         struct ast_sip_publish_handler *handler)
2753 {
2754         struct ast_sip_publication *publication;
2755         char *resource_name;
2756         size_t resource_size;
2757         RAII_VAR(struct ast_sip_publication_resource *, resource, NULL, ao2_cleanup);
2758         struct ast_variable *event_configuration_name = NULL;
2759         pjsip_uri *request_uri;
2760         pjsip_sip_uri *request_uri_sip;
2761         int resp;
2762
2763         request_uri = rdata->msg_info.msg->line.req.uri;
2764
2765         if (!PJSIP_URI_SCHEME_IS_SIP(request_uri) && !PJSIP_URI_SCHEME_IS_SIPS(request_uri)) {
2766                 char uri_str[PJSIP_MAX_URL_SIZE];
2767
2768                 pjsip_uri_print(PJSIP_URI_IN_REQ_URI, request_uri, uri_str, sizeof(uri_str));
2769                 ast_log(LOG_WARNING, "Request URI '%s' is not a sip: or sips: URI.\n", uri_str);
2770                 pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 416, NULL, NULL, NULL);
2771                 return NULL;
2772         }
2773
2774         request_uri_sip = pjsip_uri_get_uri(request_uri);
2775         resource_size = pj_strlen(&request_uri_sip->user) + 1;
2776         resource_name = alloca(resource_size);
2777         ast_copy_pj_str(resource_name, &request_uri_sip->user, resource_size);
2778
2779         resource = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "inbound-publication", resource_name);
2780         if (!resource) {
2781                 pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 404, NULL, NULL, NULL);
2782                 return NULL;
2783         }
2784
2785         if (!ast_strlen_zero(resource->endpoint) && strcmp(resource->endpoint, ast_sorcery_object_get_id(endpoint))) {
2786                 pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 403, NULL, NULL, NULL);
2787                 return NULL;
2788         }
2789
2790         for (event_configuration_name = resource->events; event_configuration_name; event_configuration_name = event_configuration_name->next) {
2791                 if (!strcmp(event_configuration_name->name, handler->event_name)) {
2792                         break;
2793                 }
2794         }
2795
2796         if (!event_configuration_name) {
2797                 pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 404, NULL, NULL, NULL);
2798                 return NULL;
2799         }
2800
2801         resp = handler->new_publication(endpoint, resource_name, event_configuration_name->value);
2802
2803         if (!PJSIP_IS_STATUS_IN_CLASS(resp, 200)) {
2804                 pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, resp, NULL, NULL, NULL);
2805                 return NULL;
2806         }
2807
2808         publication = sip_create_publication(endpoint, rdata, S_OR(resource_name, ""), event_configuration_name->value);
2809
2810         if (!publication) {
2811                 pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 503, NULL, NULL, NULL);
2812                 return NULL;
2813         }
2814
2815         publication->handler = handler;
2816         if (publication->handler->publication_state_change(publication, rdata->msg_info.msg->body,
2817                         AST_SIP_PUBLISH_STATE_INITIALIZED)) {
2818                 pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 500, NULL, NULL, NULL);
2819                 ao2_cleanup(publication);
2820                 return NULL;
2821         }
2822
2823         sip_publication_respond(publication, resp, rdata);
2824
2825         return publication;
2826 }
2827
2828 static int publish_expire_callback(void *data)
2829 {
2830         RAII_VAR(struct ast_sip_publication *, publication, data, ao2_cleanup);
2831
2832         if (publication->handler->publish_expire) {
2833                 publication->handler->publish_expire(publication);
2834         }
2835
2836         return 0;
2837 }
2838
2839 static int publish_expire(const void *data)
2840 {
2841         struct ast_sip_publication *publication = (struct ast_sip_publication*)data;
2842
2843         ao2_unlink(publication->handler->publications, publication);
2844         publication->sched_id = -1;
2845
2846         if (ast_sip_push_task(NULL, publish_expire_callback, publication)) {
2847                 ao2_cleanup(publication);
2848         }
2849
2850         return 0;
2851 }
2852
2853 static pj_bool_t pubsub_on_rx_publish_request(pjsip_rx_data *rdata)
2854 {
2855         pjsip_event_hdr *event_header;
2856         struct ast_sip_publish_handler *handler;
2857         RAII_VAR(struct ast_sip_endpoint *, endpoint, NULL, ao2_cleanup);
2858         char event[32];
2859         static const pj_str_t str_sip_if_match = { "SIP-If-Match", 12 };
2860         pjsip_generic_string_hdr *etag_hdr = pjsip_msg_find_hdr_by_name(rdata->msg_info.msg, &str_sip_if_match, NULL);
2861         enum sip_publish_type publish_type;
2862         RAII_VAR(struct ast_sip_publication *, publication, NULL, ao2_cleanup);
2863         int expires = 0, entity_id, response = 0;
2864
2865         endpoint = ast_pjsip_rdata_get_endpoint(rdata);
2866         ast_assert(endpoint != NULL);
2867
2868         event_header = pjsip_msg_find_hdr_by_name(rdata->msg_info.msg, &str_event_name, rdata->msg_info.msg->hdr.next);
2869         if (!event_header) {
2870                 ast_log(LOG_WARNING, "Incoming PUBLISH request with no Event header\n");
2871                 pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 489, NULL, NULL, NULL);
2872                 return PJ_TRUE;
2873         }
2874         ast_copy_pj_str(event, &event_header->event_type, sizeof(event));
2875
2876         handler = find_pub_handler(event);
2877         if (!handler) {
2878                 ast_log(LOG_WARNING, "No registered publish handler for event %s\n", event);
2879                 pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 489, NULL, NULL, NULL);
2880                 return PJ_TRUE;
2881         }
2882
2883         publish_type = determine_sip_publish_type(rdata, etag_hdr, &expires, &entity_id);
2884
2885         /* If this is not an initial publish ensure that a publication is present */
2886         if ((publish_type != SIP_PUBLISH_INITIAL) && (publish_type != SIP_PUBLISH_UNKNOWN)) {
2887                 if (!(publication = ao2_find(handler->publications, &entity_id, OBJ_KEY | OBJ_UNLINK))) {
2888                         static const pj_str_t str_conditional_request_failed = { "Conditional Request Failed", 26 };
2889
2890                         pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 412, &str_conditional_request_failed,
2891                                 NULL, NULL);
2892                         return PJ_TRUE;
2893                 }
2894
2895                 /* Per the RFC every response has to have a new entity tag */
2896                 publication->entity_tag = ast_atomic_fetchadd_int(&esc_etag_counter, +1);
2897
2898                 /* Update the expires here so that the created responses will contain the correct value */
2899                 publication->expires = expires;
2900         }
2901
2902         switch (publish_type) {
2903                 case SIP_PUBLISH_INITIAL:
2904                         publication = publish_request_initial(endpoint, rdata, handler);
2905                         break;
2906                 case SIP_PUBLISH_REFRESH:
2907                 case SIP_PUBLISH_MODIFY:
2908                         if (handler->publication_state_change(publication, rdata->msg_info.msg->body,
2909                                                 AST_SIP_PUBLISH_STATE_ACTIVE)) {
2910                                 /* If an error occurs we want to terminate the publication */
2911                                 expires = 0;
2912                         }
2913                         response = 200;
2914                         break;
2915                 case SIP_PUBLISH_REMOVE:
2916                         handler->publication_state_change(publication, rdata->msg_info.msg->body,
2917                                         AST_SIP_PUBLISH_STATE_TERMINATED);
2918                         response = 200;
2919                         break;
2920                 case SIP_PUBLISH_UNKNOWN:
2921                 default:
2922                         pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 400, NULL, NULL, NULL);
2923                         break;
2924         }
2925
2926         if (publication) {
2927                 if (expires) {
2928                         ao2_link(handler->publications, publication);
2929
2930                         AST_SCHED_REPLACE_UNREF(publication->sched_id, sched, expires * 1000, publish_expire, publication,
2931                                                 ao2_ref(publication, -1), ao2_ref(publication, -1), ao2_ref(publication, +1));
2932                 } else {
2933                         AST_SCHED_DEL_UNREF(sched, publication->sched_id, ao2_ref(publication, -1));
2934                 }
2935         }
2936
2937         if (response) {
2938                 sip_publication_respond(publication, response, rdata);
2939         }
2940
2941         return PJ_TRUE;
2942 }
2943
2944 struct ast_sip_endpoint *ast_sip_publication_get_endpoint(struct ast_sip_publication *pub)
2945 {
2946         return pub->endpoint;
2947 }
2948
2949 const char *ast_sip_publication_get_resource(const struct ast_sip_publication *pub)
2950 {
2951         return pub->resource;
2952 }
2953
2954 const char *ast_sip_publication_get_event_configuration(const struct ast_sip_publication *pub)
2955 {
2956         return pub->event_configuration_name;
2957 }
2958
2959 int ast_sip_pubsub_register_body_generator(struct ast_sip_pubsub_body_generator *generator)
2960 {
2961         struct ast_sip_pubsub_body_generator *existing;
2962         pj_str_t accept;
2963         pj_size_t accept_len;
2964
2965         existing = find_body_generator_type_subtype(generator->type, generator->subtype);
2966         if (existing) {
2967                 ast_log(LOG_WARNING, "Cannot register body generator of %s/%s."
2968                                 "One is already registered.\n", generator->type, generator->subtype);
2969                 return -1;
2970         }
2971
2972         AST_RWLIST_WRLOCK(&body_generators);
2973         AST_LIST_INSERT_HEAD(&body_generators, generator, list);
2974         AST_RWLIST_UNLOCK(&body_generators);
2975
2976         /* Lengths of type and subtype plus space for a slash. pj_str_t is not
2977          * null-terminated, so there is no need to allocate for the extra null
2978          * byte
2979          */
2980         accept_len = strlen(generator->type) + strlen(generator->subtype) + 1;
2981
2982         accept.ptr = alloca(accept_len);
2983         accept.slen = accept_len;
2984         /* Safe use of sprintf */
2985         sprintf(accept.ptr, "%s/%s", generator->type, generator->subtype);
2986         pjsip_endpt_add_capability(ast_sip_get_pjsip_endpoint(), &pubsub_module,
2987                         PJSIP_H_ACCEPT, NULL, 1, &accept);
2988
2989         return 0;
2990 }
2991
2992 void ast_sip_pubsub_unregister_body_generator(struct ast_sip_pubsub_body_generator *generator)
2993 {
2994         struct ast_sip_pubsub_body_generator *iter;
2995         SCOPED_LOCK(lock, &body_generators, AST_RWLIST_WRLOCK, AST_RWLIST_UNLOCK);
2996
2997         AST_RWLIST_TRAVERSE_SAFE_BEGIN(&body_generators, iter, list) {
2998                 if (iter == generator) {
2999                         AST_LIST_REMOVE_CURRENT(list);
3000                         break;
3001                 }
3002         }
3003         AST_RWLIST_TRAVERSE_SAFE_END;
3004 }
3005
3006 int ast_sip_pubsub_register_body_supplement(struct ast_sip_pubsub_body_supplement *supplement)
3007 {
3008         AST_RWLIST_WRLOCK(&body_supplements);
3009         AST_RWLIST_INSERT_TAIL(&body_supplements, supplement, list);
3010         AST_RWLIST_UNLOCK(&body_supplements);
3011
3012         return 0;
3013 }
3014
3015 void ast_sip_pubsub_unregister_body_supplement(struct ast_sip_pubsub_body_supplement *supplement)
3016 {
3017         struct ast_sip_pubsub_body_supplement *iter;
3018         SCOPED_LOCK(lock, &body_supplements, AST_RWLIST_WRLOCK, AST_RWLIST_UNLOCK);
3019
3020         AST_RWLIST_TRAVERSE_SAFE_BEGIN(&body_supplements, iter, list) {
3021                 if (iter == supplement) {
3022                         AST_LIST_REMOVE_CURRENT(list);
3023                         break;
3024                 }
3025         }
3026         AST_RWLIST_TRAVERSE_SAFE_END;
3027 }
3028
3029 const char *ast_sip_subscription_get_body_type(struct ast_sip_subscription *sub)
3030 {
3031         return sub->body_generator->type;
3032 }
3033
3034 const char *ast_sip_subscription_get_body_subtype(struct ast_sip_subscription *sub)
3035 {
3036         return sub->body_generator->subtype;
3037 }
3038
3039 int ast_sip_pubsub_generate_body_content(const char *type, const char *subtype,
3040                 struct ast_sip_body_data *data, struct ast_str **str)
3041 {
3042         struct ast_sip_pubsub_body_supplement *supplement;
3043         struct ast_sip_pubsub_body_generator *generator;
3044         int res = 0;
3045         void *body;
3046
3047         generator = find_body_generator_type_subtype(type, subtype);
3048         if (!generator) {
3049                 ast_log(LOG_WARNING, "Unable to find a body generator for %s/%s\n",
3050                                 type, subtype);
3051                 return -1;
3052         }
3053
3054         if (strcmp(data->body_type, generator->body_type)) {
3055                 ast_log(LOG_WARNING, "Body generator does not accept the type of data provided\n");
3056                 return -1;
3057         }
3058
3059         body = generator->allocate_body(data->body_data);
3060         if (!body) {
3061                 ast_log(LOG_WARNING, "Unable to allocate a NOTIFY body of type %s/%s\n",
3062                                 type, subtype);
3063                 return -1;
3064         }
3065
3066         if (generator->generate_body_content(body, data->body_data)) {
3067                 res = -1;
3068                 goto end;
3069         }
3070
3071         AST_RWLIST_RDLOCK(&body_supplements);
3072         AST_RWLIST_TRAVERSE(&body_supplements, supplement, list) {
3073                 if (!strcmp(generator->type, supplement->type) &&
3074                                 !strcmp(generator->subtype, supplement->subtype)) {
3075                         res = supplement->supplement_body(body, data->body_data);
3076                         if (res) {
3077                                 break;
3078                         }
3079                 }
3080         }
3081         AST_RWLIST_UNLOCK(&body_supplements);
3082
3083         if (!res) {
3084                 generator->to_string(body, str);
3085         }
3086
3087 end:
3088         if (generator->destroy_body) {
3089                 generator->destroy_body(body);
3090         }
3091
3092         return res;
3093 }
3094
3095 static pj_bool_t pubsub_on_rx_request(pjsip_rx_data *rdata)
3096 {
3097         if (!pjsip_method_cmp(&rdata->msg_info.msg->line.req.method, pjsip_get_subscribe_method())) {
3098                 return pubsub_on_rx_subscribe_request(rdata);
3099         } else if (!pjsip_method_cmp(&rdata->msg_info.msg->line.req.method, &pjsip_publish_method)) {
3100                 return pubsub_on_rx_publish_request(rdata);
3101         }
3102
3103         return PJ_FALSE;
3104 }
3105
3106 static void pubsub_on_evsub_state(pjsip_evsub *evsub, pjsip_event *event)
3107 {
3108         struct sip_subscription_tree *sub_tree;
3109
3110         if (pjsip_evsub_get_state(evsub) != PJSIP_EVSUB_STATE_TERMINATED) {
3111                 return;
3112         }
3113
3114         sub_tree = pjsip_evsub_get_mod_data(evsub, pubsub_module.id);
3115         if (!sub_tree) {
3116                 return;
3117         }
3118
3119         ao2_cleanup(sub_tree);
3120
3121         pjsip_evsub_set_mod_data(evsub, pubsub_module.id, NULL);
3122 }
3123
3124 static void set_state_terminated(struct ast_sip_subscription *sub)
3125 {
3126         int i;
3127
3128         sub->subscription_state = PJSIP_EVSUB_STATE_TERMINATED;
3129         for (i = 0; i < AST_VECTOR_SIZE(&sub->children); ++i) {
3130                 set_state_terminated(AST_VECTOR_GET(&sub->children, i));
3131         }
3132 }
3133
3134 static void pubsub_on_rx_refresh(pjsip_evsub *evsub, pjsip_rx_data *rdata,
3135                 int *p_st_code, pj_str_t **p_st_text, pjsip_hdr *res_hdr, pjsip_msg_body **p_body)
3136 {
3137         struct sip_subscription_tree *sub_tree;
3138
3139         sub_tree = pjsip_evsub_get_mod_data(evsub, pubsub_module.id);
3140         if (!sub_tree) {
3141                 return;
3142         }
3143
3144         /* If sending a NOTIFY to terminate a subscription, then pubsub_on_evsub_state()
3145          * will be called when we send the NOTIFY, and that will result in dropping the
3146          * refcount of sub_tree by one, and possibly destroying the sub_tree. We need to
3147          * hold a reference to the sub_tree until this function returns so that we don't
3148          * try to read from or write to freed memory by accident
3149          */
3150         ao2_ref(sub_tree, +1);
3151
3152         if (pjsip_evsub_get_state(evsub) == PJSIP_EVSUB_STATE_TERMINATED) {
3153                 set_state_terminated(sub_tree->root);
3154         }
3155
3156         if (send_notify(sub_tree, 1)) {
3157                 *p_st_code = 500;
3158         }
3159
3160         ast_test_suite_event_notify(sub_tree->root->subscription_state == PJSIP_EVSUB_STATE_TERMINATED ?
3161                         "SUBSCRIPTION_TERMINATED" : "SUBSCRIPTION_REFRESHED",
3162                         "Resource: %s", sub_tree->root->resource);
3163
3164         if (sub_tree->is_list) {
3165                 pj_list_insert_before(res_hdr, create_require_eventlist(rdata->tp_info.pool));
3166         }
3167
3168         ao2_ref(sub_tree, -1);
3169 }
3170
3171 static void pubsub_on_rx_notify(pjsip_evsub *evsub, pjsip_rx_data *rdata, int *p_st_code,
3172                 pj_str_t **p_st_text, pjsip_hdr *res_hdr, pjsip_msg_body **p_body)
3173 {
3174         struct ast_sip_subscription *sub = pjsip_evsub_get_mod_data(evsub, pubsub_module.id);
3175
3176         if (!sub) {
3177                 return;
3178         }
3179
3180         sub->handler->subscriber->state_change(sub, rdata->msg_info.msg->body,
3181                         pjsip_evsub_get_state(evsub));
3182 }
3183
3184 static int serialized_pubsub_on_client_refresh(void *userdata)
3185 {
3186         struct sip_subscription_tree *sub_tree = userdata;
3187         pjsip_tx_data *tdata;
3188
3189         if (pjsip_evsub_initiate(sub_tree->evsub, NULL, -1, &tdata) == PJ_SUCCESS) {
3190                 pjsip_evsub_send_request(sub_tree->evsub, tdata);
3191         } else {
3192                 pjsip_evsub_terminate(sub_tree->evsub, PJ_TRUE);
3193         }
3194         ao2_cleanup(sub_tree);
3195         return 0;
3196 }
3197
3198 static void pubsub_on_client_refresh(pjsip_evsub *evsub)
3199 {
3200         struct sip_subscription_tree *sub_tree = pjsip_evsub_get_mod_data(evsub, pubsub_module.id);
3201
3202         ao2_ref(sub_tree, +1);
3203         ast_sip_push_task(sub_tree->serializer, serialized_pubsub_on_client_refresh, sub_tree);
3204 }
3205
3206 static int serialized_pubsub_on_server_timeout(void *userdata)
3207 {
3208         struct sip_subscription_tree *sub_tree = userdata;
3209
3210         set_state_terminated(sub_tree->root);
3211         send_notify(sub_tree, 1);
3212         ast_test_suite_event_notify("SUBSCRIPTION_TERMINATED",
3213                         "Resource: %s",
3214                         sub_tree->root->resource);
3215
3216         ao2_cleanup(sub_tree);
3217         return 0;
3218 }
3219
3220 static void pubsub_on_server_timeout(pjsip_evsub *evsub)
3221 {
3222         struct sip_subscription_tree *sub_tree = pjsip_evsub_get_mod_data(evsub, pubsub_module.id);
3223
3224         if (!sub_tree) {
3225                 /* if a subscription has been terminated and the subscription
3226                    timeout/expires is less than the time it takes for all pending
3227                    transactions to end then the subscription timer will not have
3228                    been canceled yet and sub will be null, so do nothing since
3229                    the subscription has already been terminated. */
3230                 return;
3231         }
3232
3233         ao2_ref(sub_tree, +1);
3234         ast_sip_push_task(sub_tree->serializer, serialized_pubsub_on_server_timeout, sub_tree);
3235 }
3236
3237 static int ami_subscription_detail(struct sip_subscription_tree *sub_tree,
3238                                    struct ast_sip_ami *ami,
3239                                    const char *event)
3240 {
3241         struct ast_str *buf;
3242
3243         buf = ast_sip_create_ami_event(event, ami);
3244         if (!buf) {
3245                 return -1;
3246         }
3247
3248         sip_subscription_to_ami(sub_tree, &buf);
3249         astman_append(ami->s, "%s\r\n", ast_str_buffer(buf));
3250         ast_free(buf);
3251         return 0;
3252 }
3253
3254 static int ami_subscription_detail_inbound(struct sip_subscription_tree *sub_tree, void *arg)
3255 {
3256         return sub_tree->role == AST_SIP_NOTIFIER ? ami_subscription_detail(
3257                 sub_tree, arg, "InboundSubscriptionDetail") : 0;
3258 }
3259
3260 static int ami_subscription_detail_outbound(struct sip_subscription_tree *sub_tree, void *arg)
3261 {
3262         return sub_tree->role == AST_SIP_SUBSCRIBER ? ami_subscription_detail(
3263  &nbs