bebfe8abe6925b7e276b99d91c9747926bcc0ab0
[asterisk/asterisk.git] / res / res_pjsip_notify.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2013, Digium, Inc.
5  *
6  * Kevin Harwell <kharwell@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*** MODULEINFO
20         <depend>pjproject</depend>
21         <depend>res_pjsip</depend>
22         <support_level>core</support_level>
23  ***/
24
25 #include "asterisk.h"
26
27 #include <pjsip.h>
28
29 #include "asterisk/cli.h"
30 #include "asterisk/config.h"
31 #include "asterisk/manager.h"
32 #include "asterisk/module.h"
33 #include "asterisk/pbx.h"
34 #include "asterisk/res_pjsip.h"
35 #include "asterisk/sorcery.h"
36
37 /*** DOCUMENTATION
38         <manager name="PJSIPNotify" language="en_US">
39                 <synopsis>
40                         Send a NOTIFY to an endpoint.
41                 </synopsis>
42                 <syntax>
43                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
44                         <parameter name="Endpoint" required="true">
45                                 <para>The endpoint to which to send the NOTIFY.</para>
46                         </parameter>
47                         <parameter name="Variable" required="true">
48                                 <para>Appends variables as headers/content to the NOTIFY. If the variable is
49                                 named <literal>Content</literal>, then the value will compose the body
50                                 of the message if another variable sets <literal>Content-Type</literal>.
51                                 <replaceable>name</replaceable>=<replaceable>value</replaceable></para>
52                         </parameter>
53                 </syntax>
54                 <description>
55                         <para>Sends a NOTIFY to an endpoint.</para>
56                         <para>All parameters for this event must be specified in the body of this request
57                         via multiple <literal>Variable: name=value</literal> sequences.</para>
58                 </description>
59         </manager>
60         <configInfo name="res_pjsip_notify" language="en_US">
61                 <synopsis>Module that supports sending NOTIFY requests to endpoints from external sources</synopsis>
62                 <configFile name="pjsip_notify.conf">
63                         <configObject name="general">
64                                 <synopsis>Unused, but reserved.</synopsis>
65                         </configObject>
66                         <configObject name="notify">
67                                 <synopsis>Configuration of a NOTIFY request.</synopsis>
68                                 <description>
69                                         <para>Each key-value pair in a <literal>notify</literal>
70                                         configuration section defines either a SIP header to send
71                                         in the request or a line of content in the request message
72                                         body. A key of <literal>Content</literal> is treated
73                                         as part of the message body and is appended in sequential
74                                         order; any other header is treated as part of the SIP
75                                         request.</para>
76                                 </description>
77                                 <configOption name="^.*$">
78                                         <synopsis>A key/value pair to add to a NOTIFY request.</synopsis>
79                                         <description>
80                                                 <para>If the key is <literal>Content</literal>,
81                                                 it will be treated as part of the message body. Otherwise,
82                                                 it will be added as a header in the NOTIFY request.</para>
83                                                 <para>The following headers are reserved and cannot be
84                                                 specified:</para>
85                                                 <enumlist>
86                                                         <enum name="Call-ID" />
87                                                         <enum name="Contact" />
88                                                         <enum name="CSeq" />
89                                                         <enum name="To" />
90                                                         <enum name="From" />
91                                                         <enum name="Record-Route" />
92                                                         <enum name="Route" />
93                                                         <enum name="Via" />
94                                                 </enumlist>
95                                         </description>
96                                 </configOption>
97                         </configObject>
98                 </configFile>
99         </configInfo>
100  ***/
101
102 #define CONTENT_TYPE_SIZE 64
103 #define CONTENT_SIZE 512
104
105 /*!
106  * \internal
107  * \brief The configuration file containing NOTIFY payload types to send.
108  */
109 static const char notify_config[] = "pjsip_notify.conf";
110
111 struct notify_option_item {
112         const char *name;
113         const char *value;
114         char buf[0];
115 };
116
117 struct notify_option {
118         /*! Contains header and/or content information */
119         struct ao2_container *items;
120         /*! The name of the notify option */
121         char name[0];
122 };
123
124 static int notify_option_hash(const void *obj, int flags)
125 {
126         const struct notify_option *option = obj;
127         return ast_str_case_hash(flags & OBJ_KEY ? obj : option->name);
128 }
129
130 static int notify_option_cmp(void *obj, void *arg, int flags)
131 {
132         struct notify_option *option1 = obj;
133         struct notify_option *option2 = arg;
134         const char *key = flags & OBJ_KEY ? arg : option2->name;
135
136         return strcasecmp(option1->name, key) ? 0 : CMP_MATCH;
137 }
138
139 static void notify_option_destroy(void *obj)
140 {
141         struct notify_option *option = obj;
142         ao2_cleanup(option->items);
143 }
144
145 static void *notify_option_alloc(const char *category)
146 {
147         int category_size = strlen(category) + 1;
148
149         struct notify_option *option = ao2_alloc(
150                 sizeof(*option) + category_size, notify_option_destroy);
151
152         if (!option) {
153                 return NULL;
154         }
155
156         ast_copy_string(option->name, category, category_size);
157
158         if (!(option->items = ao2_container_alloc_list(
159                       AO2_ALLOC_OPT_LOCK_NOLOCK,
160                       AO2_CONTAINER_ALLOC_OPT_DUPS_ALLOW, NULL, NULL))) {
161                 ao2_cleanup(option);
162                 return NULL;
163         }
164
165         return option;
166 }
167
168 static void *notify_option_find(struct ao2_container *container, const char *category)
169 {
170         return ao2_find(container, category, OBJ_KEY);
171 }
172
173 static int notify_option_handler(const struct aco_option *opt,
174                                  struct ast_variable *var, void *obj)
175 {
176         struct notify_option *option = obj;
177
178         int name_size = strlen(var->name) + 1;
179         int value_size = strlen(var->value) + 1;
180
181         RAII_VAR(struct notify_option_item *, item,
182                  ao2_alloc(sizeof(*item) + name_size + value_size,
183                            NULL), ao2_cleanup);
184
185         item->name = item->buf;
186         item->value = item->buf + name_size;
187
188         ast_copy_string(item->buf, var->name, name_size);
189         ast_copy_string(item->buf + name_size, var->value, value_size);
190
191         if (!ao2_link(option->items, item)) {
192                 return -1;
193         }
194
195         return 0;
196 }
197
198 struct notify_cfg {
199         struct ao2_container *notify_options;
200 };
201
202 static void notify_cfg_destroy(void *obj)
203 {
204         struct notify_cfg *cfg = obj;
205         ao2_cleanup(cfg->notify_options);
206 }
207
208 static void *notify_cfg_alloc(void)
209 {
210         struct notify_cfg *cfg;
211
212         if (!(cfg = ao2_alloc(sizeof(*cfg), notify_cfg_destroy))) {
213                 return NULL;
214         }
215
216         if (!(cfg->notify_options = ao2_container_alloc_options(
217                       AO2_ALLOC_OPT_LOCK_NOLOCK, 20, notify_option_hash,
218                       notify_option_cmp))) {
219                 ao2_cleanup(cfg);
220                 return NULL;
221         }
222
223         return cfg;
224 }
225
226 static struct aco_type notify_option = {
227         .type = ACO_ITEM,
228         .name = "notify",
229         .category_match = ACO_BLACKLIST,
230         .category = "^general$",
231         .item_offset = offsetof(struct notify_cfg, notify_options),
232         .item_alloc = notify_option_alloc,
233         .item_find = notify_option_find
234 };
235
236 static struct aco_type *notify_options[] = ACO_TYPES(&notify_option);
237
238 static struct aco_file module_conf = {
239         .filename = notify_config,
240         .types = ACO_TYPES(&notify_option),
241 };
242
243 AO2_GLOBAL_OBJ_STATIC(globals);
244
245 CONFIG_INFO_STANDARD(notify_cfg, globals, notify_cfg_alloc,
246         .files = ACO_FILES(&module_conf)
247 );
248
249 /*!
250  * \internal
251  * \brief Structure to hold task data for notifications.
252  */
253 struct notify_data {
254         /*! The endpoint being notified */
255         struct ast_sip_endpoint *endpoint;
256         /*! The info of headers, types and content */
257         void *info;
258         /*! Function to help build notify request */
259         void (*build_notify)(pjsip_tx_data *, void *);
260 };
261
262 /*!
263  * \internal
264  * \brief Destroy the notify CLI data releasing any resources.
265  */
266 static void notify_cli_data_destroy(void *obj)
267 {
268         struct notify_data *data = obj;
269
270         ao2_cleanup(data->endpoint);
271         ao2_cleanup(data->info);
272 }
273
274 static void build_cli_notify(pjsip_tx_data *tdata, void *info);
275
276 /*!
277  * \internal
278  * \brief Construct a notify data object for CLI.
279  */
280 static struct notify_data* notify_cli_data_create(
281         struct ast_sip_endpoint *endpoint, void *info)
282 {
283         struct notify_data *data = ao2_alloc(sizeof(*data),
284                                              notify_cli_data_destroy);
285         if (!data) {
286                 return NULL;
287         }
288
289         data->endpoint = endpoint;
290         ao2_ref(data->endpoint, +1);
291
292         data->info = info;
293         ao2_ref(data->info, +1);
294
295         data->build_notify = build_cli_notify;
296
297         return data;
298 }
299
300 /*!
301  * \internal
302  * \brief Destroy the notify AMI data releasing any resources.
303  */
304 static void notify_ami_data_destroy(void *obj)
305 {
306         struct notify_data *data = obj;
307         struct ast_variable *info = data->info;
308
309         ao2_cleanup(data->endpoint);
310         ast_variables_destroy(info);
311 }
312
313 static void build_ami_notify(pjsip_tx_data *tdata, void *info);
314
315 /*!
316  * \internal
317  * \brief Construct a notify data object for AMI.
318  */
319 static struct notify_data* notify_ami_data_create(
320         struct ast_sip_endpoint *endpoint, void *info)
321 {
322         struct notify_data *data = ao2_alloc(sizeof(*data),
323                                              notify_ami_data_destroy);
324         if (!data) {
325                 return NULL;
326         }
327
328         data->endpoint = endpoint;
329         ao2_ref(data->endpoint, +1);
330
331         data->info = info;
332         data->build_notify = build_ami_notify;
333
334         return data;
335 }
336
337 /*!
338  * \internal
339  * \brief Checks if the given header name is not allowed.
340  *
341  * \details Some headers are not allowed to be set by the user within the
342  *          scope of a NOTIFY request.  If the given var header name is
343  *          found in the "not allowed" list then return true.
344  */
345 static int not_allowed(const char *name)
346 {
347         int i;
348         static const char *names[] = {
349                 "Call-ID",
350                 "Contact",
351                 "CSeq",
352                 "To",
353                 "From",
354                 "Record-Route",
355                 "Route",
356                 "Request-URI",
357                 "Via",
358         };
359
360         for (i = 0; i < ARRAY_LEN(names); ++i) {
361                 if (!strcasecmp(name, names[i])) {
362                         return 1;
363                 }
364         }
365         return 0;
366 }
367
368 /*!
369  * \internal
370  * \brief If a content type was specified add it and the content body to the
371  *        NOTIFY request.
372  */
373 static void build_notify_body(pjsip_tx_data *tdata, struct ast_str *content_type,
374                               struct ast_str *content)
375 {
376         if (content_type) {
377                 char *p;
378                 struct ast_sip_body body;
379
380                 if (content) {
381                         body.body_text = ast_str_buffer(content);
382                 }
383
384                 body.type = ast_str_buffer(content_type);
385                 if ((p = strchr(body.type, '/'))) {
386                         *p++ = '\0';
387                         body.subtype = p;
388                 }
389                 ast_sip_add_body(tdata, &body);
390         }
391 }
392
393 /*!
394  * \internal
395  * \brief Build the NOTIFY request adding content or header info.
396  */
397 static void build_notify(pjsip_tx_data *tdata, const char *name, const char *value,
398                          struct ast_str **content_type, struct ast_str **content)
399 {
400         if (not_allowed(name)) {
401                 ast_log(LOG_WARNING, "Cannot specify %s header, "
402                         "ignoring\n", name);
403                 return;
404         }
405
406         if (!strcasecmp(name, "Content-type")) {
407                 if (!(*content_type)) {
408                         *content_type = ast_str_create(CONTENT_TYPE_SIZE);
409                 }
410                 ast_str_set(content_type, 0,"%s", value);
411         } else if (!strcasecmp(name, "Content")) {
412                 if (!(*content)) {
413                         *content = ast_str_create(CONTENT_SIZE);
414                 }
415
416                 if (ast_str_strlen(*content)) {
417                         ast_str_append(content, 0, "\r\n");
418                 }
419                 ast_str_append(content, 0, "%s", value);
420         } else {
421                 ast_sip_add_header(tdata, name, value);
422         }
423 }
424
425 /*!
426  * \internal
427  * \brief Build the NOTIFY request from CLI info adding header and content
428  *        when specified.
429  */
430 static void build_cli_notify(pjsip_tx_data *tdata, void *info)
431 {
432         struct notify_option *option = info;
433         RAII_VAR(struct ast_str *, content_type, NULL, ast_free);
434         RAII_VAR(struct ast_str *, content, NULL, ast_free);
435
436         struct notify_option_item *item;
437         struct ao2_iterator i = ao2_iterator_init(option->items, 0);
438
439         while ((item = ao2_iterator_next(&i))) {
440                 build_notify(tdata, item->name, item->value,
441                              &content_type, &content);
442                 ao2_cleanup(item);
443         }
444         ao2_iterator_destroy(&i);
445
446         build_notify_body(tdata, content_type, content);
447 }
448
449 /*!
450  * \internal
451  * \brief Build the NOTIFY request from AMI info adding header and content
452  *        when specified.
453  */
454 static void build_ami_notify(pjsip_tx_data *tdata, void *info)
455 {
456         struct ast_variable *vars = info;
457         RAII_VAR(struct ast_str *, content_type, NULL, ast_free);
458         RAII_VAR(struct ast_str *, content, NULL, ast_free);
459         struct ast_variable *i;
460
461         for (i = vars; i; i = i->next) {
462                 if (!strcasecmp(i->name, "Content-Length")) {
463                         ast_log(LOG_NOTICE, "It is not necessary to specify Content-Length, ignoring.\n");
464                         continue;
465                 }
466                 build_notify(tdata, i->name, i->value,
467                              &content_type, &content);
468         }
469
470         build_notify_body(tdata, content_type, content);
471 }
472
473 /*!
474  * \internal
475  * \brief Build and send a NOTIFY request to a contact.
476  */
477 static int notify_contact(void *obj, void *arg, int flags)
478 {
479         struct ast_sip_contact *contact = obj;
480         struct notify_data *data = arg;
481         pjsip_tx_data *tdata;
482
483         if (ast_sip_create_request("NOTIFY", NULL, data->endpoint,
484                                    NULL, contact, &tdata)) {
485                 ast_log(LOG_WARNING, "SIP NOTIFY - Unable to create request for "
486                         "contact %s\n", contact->uri);
487                 return -1;
488         }
489
490         ast_sip_add_header(tdata, "Subscription-State", "terminated");
491         data->build_notify(tdata, data->info);
492
493         if (ast_sip_send_request(tdata, NULL, data->endpoint, NULL, NULL)) {
494                 ast_log(LOG_ERROR, "SIP NOTIFY - Unable to send request for "
495                         "contact %s\n", contact->uri);
496                 return -1;
497         }
498
499         return 0;
500 }
501
502 /*!
503  * \internal
504  * \brief Send a NOTIFY request to the endpoint.
505  *
506  * \detail Iterates over an endpoint's AORs sending a NOTIFY request
507  *         with the appropriate payload information to each contact.
508  */
509 static int notify_endpoint(void *obj)
510 {
511         RAII_VAR(struct notify_data *, data, obj, ao2_cleanup);
512         char *aor_name, *aors;
513
514         if (ast_strlen_zero(data->endpoint->aors)) {
515                 ast_log(LOG_WARNING, "Unable to NOTIFY - "
516                         "endpoint has no configured AORs\n");
517                 return -1;
518         }
519
520         aors = ast_strdupa(data->endpoint->aors);
521
522         while ((aor_name = strsep(&aors, ","))) {
523                 RAII_VAR(struct ast_sip_aor *, aor,
524                          ast_sip_location_retrieve_aor(aor_name), ao2_cleanup);
525                 RAII_VAR(struct ao2_container *, contacts, NULL, ao2_cleanup);
526
527                 if (!aor || !(contacts = ast_sip_location_retrieve_aor_contacts(aor))) {
528                         continue;
529                 }
530
531                 ao2_callback(contacts, OBJ_NODATA, notify_contact, data);
532         }
533
534         return 0;
535 }
536
537 enum notify_result {
538         SUCCESS,
539         INVALID_ENDPOINT,
540         ALLOC_ERROR,
541         TASK_PUSH_ERROR
542 };
543
544 typedef struct notify_data *(*task_data_create)(
545         struct ast_sip_endpoint *, void *info);
546 /*!
547  * \internal
548  * \brief Send a NOTIFY request to the endpoint within a threaded task.
549  */
550 static enum notify_result push_notify(const char *endpoint_name, void *info,
551                                       task_data_create data_create)
552 {
553         RAII_VAR(struct ast_sip_endpoint *, endpoint, NULL, ao2_cleanup);
554         struct notify_data *data;
555
556         if (!(endpoint = ast_sorcery_retrieve_by_id(
557                       ast_sip_get_sorcery(), "endpoint", endpoint_name))) {
558                 return INVALID_ENDPOINT;
559         }
560
561         if (!(data = data_create(endpoint, info))) {
562                 return ALLOC_ERROR;
563         }
564
565         if (ast_sip_push_task(NULL, notify_endpoint, data)) {
566                 ao2_cleanup(data);
567                 return TASK_PUSH_ERROR;
568         }
569
570         return SUCCESS;
571 }
572
573 /*!
574  * \internal
575  * \brief Do completion on the endpoint.
576  */
577 static char *cli_complete_endpoint(const char *word, int state)
578 {
579         char *result = NULL;
580         int wordlen = strlen(word);
581         int which = 0;
582
583         struct ast_sip_endpoint *endpoint;
584         RAII_VAR(struct ao2_container *, endpoints,
585                  ast_sip_get_endpoints(), ao2_cleanup);
586
587         struct ao2_iterator i = ao2_iterator_init(endpoints, 0);
588         while ((endpoint = ao2_iterator_next(&i))) {
589                 const char *name = ast_sorcery_object_get_id(endpoint);
590                 if (!strncasecmp(word, name, wordlen) && ++which > state) {
591                         result = ast_strdup(name);
592                 }
593
594                 ao2_cleanup(endpoint);
595                 if (result) {
596                         break;
597                 }
598         }
599         ao2_iterator_destroy(&i);
600         return result;
601 }
602
603 /*!
604  * \internal
605  * \brief Do completion on the notify CLI command.
606  */
607 static char *cli_complete_notify(const char *line, const char *word,
608                                  int pos, int state)
609 {
610         char *c = NULL;
611
612         if (pos == 3) {
613                 int which = 0;
614                 int wordlen = strlen(word);
615
616                 RAII_VAR(struct notify_cfg *, cfg,
617                          ao2_global_obj_ref(globals), ao2_cleanup);
618                 struct notify_option *option;
619
620                 /* do completion for notify type */
621                 struct ao2_iterator i = ao2_iterator_init(cfg->notify_options, 0);
622                 while ((option = ao2_iterator_next(&i))) {
623                         if (!strncasecmp(word, option->name, wordlen) && ++which > state) {
624                                 c = ast_strdup(option->name);
625                         }
626
627                         ao2_cleanup(option);
628                         if (c) {
629                                 break;
630                         }
631                 }
632                 ao2_iterator_destroy(&i);
633                 return c;
634         }
635         return pos > 3 ? cli_complete_endpoint(word, state) : NULL;
636 }
637
638 /*!
639  * \internal
640  * \brief CLI command to send a SIP notify to an endpoint.
641  *
642  * \details Attempts to match the "type" given in the CLI command to a
643  *          configured one.  If found, sends a NOTIFY to the endpoint
644  *          with the associated payload.
645  */
646 static char *cli_notify(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
647 {
648         RAII_VAR(struct notify_cfg *, cfg, NULL, ao2_cleanup);
649         RAII_VAR(struct notify_option *, option, NULL, ao2_cleanup);
650
651         int i;
652
653         switch (cmd) {
654         case CLI_INIT:
655                 e->command = "pjsip send notify";
656                 e->usage =
657                         "Usage: pjsip send notify <type> <peer> [<peer>...]\n"
658                         "       Send a NOTIFY request to an endpoint\n"
659                         "       Message types are defined in sip_notify.conf\n";
660                 return NULL;
661         case CLI_GENERATE:
662                 return cli_complete_notify(a->line, a->word, a->pos, a->n);
663         }
664
665         if (a->argc < 5) {
666                 return CLI_SHOWUSAGE;
667         }
668
669         cfg = ao2_global_obj_ref(globals);
670
671         if (!(option = notify_option_find(cfg->notify_options, a->argv[3])))
672         {
673                 ast_cli(a->fd, "Unable to find notify type '%s'\n",
674                         a->argv[3]);
675                 return CLI_FAILURE;
676         }
677
678         for (i = 4; i < a->argc; ++i) {
679                 ast_cli(a->fd, "Sending NOTIFY of type '%s' to '%s'\n",
680                         a->argv[3], a->argv[i]);
681
682                 switch (push_notify(a->argv[i], option,
683                                     notify_cli_data_create)) {
684                 case INVALID_ENDPOINT:
685                         ast_cli(a->fd, "Unable to retrieve endpoint %s\n",
686                                 a->argv[i]);
687                         break;
688                 case ALLOC_ERROR:
689                         ast_cli(a->fd, "Unable to allocate NOTIFY task data\n");
690                         return CLI_FAILURE;
691                 case TASK_PUSH_ERROR:
692                         ast_cli(a->fd, "Unable to push NOTIFY task\n");
693                         return CLI_FAILURE;
694                 default:
695                         break;
696                 }
697         }
698
699         return CLI_SUCCESS;
700 }
701
702 static struct ast_cli_entry cli_options[] = {
703         AST_CLI_DEFINE(cli_notify, "Send a NOTIFY request to a SIP endpoint")
704 };
705
706 /*!
707  * \internal
708  * \brief AMI entry point to send a SIP notify to an endpoint.
709  */
710 static int manager_notify(struct mansession *s, const struct message *m)
711 {
712         const char *endpoint_name = astman_get_header(m, "Endpoint");
713         struct ast_variable *vars = astman_get_variables_order(m, ORDER_NATURAL);
714
715         if (ast_strlen_zero(endpoint_name)) {
716                 astman_send_error(s, m, "PJSIPNotify requires an endpoint name");
717                 ast_variables_destroy(vars);
718                 return 0;
719         }
720
721         if (!strncasecmp(endpoint_name, "sip/", 4)) {
722                 endpoint_name += 4;
723         }
724
725         if (!strncasecmp(endpoint_name, "pjsip/", 6)) {
726                 endpoint_name += 6;
727         }
728
729         switch (push_notify(endpoint_name, vars, notify_ami_data_create)) {
730         case INVALID_ENDPOINT:
731                 ast_variables_destroy(vars);
732                 astman_send_error_va(s, m, "Unable to retrieve endpoint %s\n",
733                         endpoint_name);
734                 break;
735         case ALLOC_ERROR:
736                 ast_variables_destroy(vars);
737                 astman_send_error(s, m, "Unable to allocate NOTIFY task data\n");
738                 break;
739         case TASK_PUSH_ERROR:
740                 /* Don't need to destroy vars since it is handled by cleanup in push_notify */
741                 astman_send_error(s, m, "Unable to push NOTIFY task\n");
742                 break;
743         case SUCCESS:
744                 astman_send_ack(s, m, "NOTIFY sent");
745                 break;
746         }
747
748         return 0;
749 }
750
751 static int load_module(void)
752 {
753         if (aco_info_init(&notify_cfg)) {
754                 return AST_MODULE_LOAD_DECLINE;
755         }
756
757         aco_option_register_custom(&notify_cfg, "^.*$", ACO_REGEX, notify_options,
758                                    "", notify_option_handler, 0);
759
760         if (aco_process_config(&notify_cfg, 0)) {
761                 aco_info_destroy(&notify_cfg);
762                 return AST_MODULE_LOAD_DECLINE;
763         }
764
765         ast_cli_register_multiple(cli_options, ARRAY_LEN(cli_options));
766         ast_manager_register_xml("PJSIPNotify", EVENT_FLAG_SYSTEM, manager_notify);
767
768         return AST_MODULE_LOAD_SUCCESS;
769 }
770
771 static int reload_module(void)
772 {
773         return aco_process_config(&notify_cfg, 1) ?
774                 AST_MODULE_LOAD_DECLINE : 0;
775 }
776
777 static int unload_module(void)
778 {
779         ast_manager_unregister("PJSIPNotify");
780         aco_info_destroy(&notify_cfg);
781
782         return 0;
783 }
784
785 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "CLI/AMI PJSIP NOTIFY Support",
786                 .support_level = AST_MODULE_SUPPORT_CORE,
787                 .load = load_module,
788                 .reload = reload_module,
789                 .unload = unload_module,
790                 .load_pri = AST_MODPRI_APP_DEPEND,
791                );