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