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