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