loader: Add dependency fields to module structures.
[asterisk/asterisk.git] / include / asterisk / module.h
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2008, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  * Kevin P. Fleming <kpfleming@digium.com>
8  * Luigi Rizzo <rizzo@icir.org>
9  *
10  * See http://www.asterisk.org for more information about
11  * the Asterisk project. Please do not directly contact
12  * any of the maintainers of this project for assistance;
13  * the project provides a web site, mailing lists and IRC
14  * channels for your use.
15  *
16  * This program is free software, distributed under the terms of
17  * the GNU General Public License Version 2. See the LICENSE file
18  * at the top of the source tree.
19  */
20
21 /*! \file
22  * \brief Asterisk module definitions.
23  *
24  * This file contains the definitons for functions Asterisk modules should
25  * provide and some other module related functions.
26  */
27
28 /*! \li \ref module.h uses the configuration file \ref modules.conf
29  * \addtogroup configuration_file
30  */
31
32 /*! \page modules.conf modules.conf
33  * \verbinclude modules.conf.sample
34  */
35
36 #ifndef _ASTERISK_MODULE_H
37 #define _ASTERISK_MODULE_H
38
39 #include "asterisk/utils.h"
40
41 #if defined(__cplusplus) || defined(c_plusplus)
42 extern "C" {
43 #endif
44
45 /*! \brief The text the key() function should return. */
46 #define ASTERISK_GPL_KEY \
47 "This paragraph is copyright (c) 2006 by Digium, Inc. \
48 In order for your module to load, it must return this \
49 key via a function called \"key\".  Any code which \
50 includes this paragraph must be licensed under the GNU \
51 General Public License version 2 or later (at your \
52 option).  In addition to Digium's general reservations \
53 of rights, Digium expressly reserves the right to \
54 allow other parties to license this paragraph under \
55 different terms. Any use of Digium, Inc. trademarks or \
56 logos (including \"Asterisk\" or \"Digium\") without \
57 express written permission of Digium, Inc. is prohibited.\n"
58
59 #define AST_MODULE_CONFIG "modules.conf" /*!< \brief Module configuration file */
60
61 enum ast_module_unload_mode {
62         AST_FORCE_SOFT = 0, /*!< Softly unload a module, only if not in use */
63         AST_FORCE_FIRM = 1, /*!< Firmly unload a module, even if in use */
64         AST_FORCE_HARD = 2, /*!< as FIRM, plus dlclose() on the module. Not recommended
65                                 as it may cause crashes */
66 };
67
68 enum ast_module_load_result {
69         AST_MODULE_LOAD_SUCCESS = 0,    /*!< Module loaded and configured */
70         AST_MODULE_LOAD_DECLINE = 1,    /*!< Module is not configured */
71         AST_MODULE_LOAD_SKIP = 2,       /*!< Module was skipped for some reason (For loader.c use only. Should never be returned by modules)*/
72         AST_MODULE_LOAD_PRIORITY = 3,   /*!< Module is not loaded yet, but is added to priority list */
73         AST_MODULE_LOAD_FAILURE = -1,   /*!< Module could not be loaded properly */
74 };
75
76 /*!
77  * \since 12
78  * \brief Possible return types for \ref ast_module_reload
79  */
80 enum ast_module_reload_result {
81         AST_MODULE_RELOAD_SUCCESS = 0,      /*!< The module was reloaded succesfully */
82         AST_MODULE_RELOAD_QUEUED,           /*!< The module reload request was queued */
83         AST_MODULE_RELOAD_NOT_FOUND,        /*!< The requested module was not found */
84         AST_MODULE_RELOAD_ERROR,            /*!< An error occurred while reloading the module */
85         AST_MODULE_RELOAD_IN_PROGRESS,      /*!< A module reload request is already in progress */
86         AST_MODULE_RELOAD_UNINITIALIZED,    /*!< The module has not been initialized */
87         AST_MODULE_RELOAD_NOT_IMPLEMENTED,  /*!< This module doesn't support reloading */
88 };
89
90 enum ast_module_support_level {
91         AST_MODULE_SUPPORT_UNKNOWN,
92         AST_MODULE_SUPPORT_CORE,
93         AST_MODULE_SUPPORT_EXTENDED,
94         AST_MODULE_SUPPORT_DEPRECATED,
95 };
96
97 /*! Used to specify which modules should be returned by ast_module_helper. */
98 enum ast_module_helper_type {
99         /*! Modules that are loaded by dlopen. */
100         AST_MODULE_HELPER_LOADED = 0,
101         /*! Running modules that include a reload callback. */
102         AST_MODULE_HELPER_RELOAD = 1,
103         /*! Modules that can be loaded or started. */
104         AST_MODULE_HELPER_LOAD,
105         /*! Modules that can be unloaded. */
106         AST_MODULE_HELPER_UNLOAD,
107         /*! Running modules */
108         AST_MODULE_HELPER_RUNNING,
109 };
110
111 /*!
112  * \brief Load a module.
113  * \param resource_name The name of the module to load.
114  *
115  * This function is run by the PBX to load the modules.  It performs
116  * all loading and initialization tasks.   Basically, to load a module, just
117  * give it the name of the module and it will do the rest.
118  *
119  * \return See possible enum values for ast_module_load_result.
120  */
121 enum ast_module_load_result ast_load_resource(const char *resource_name);
122
123 /*!
124  * \brief Unload a module.
125  * \param resource_name The name of the module to unload.
126  * \param ast_module_unload_mode The force flag. This should be set using one of the AST_FORCE flags.
127  *
128  * This function unloads a module.  It will only unload modules that are not in
129  * use (usecount not zero), unless #AST_FORCE_FIRM or #AST_FORCE_HARD is
130  * specified.  Setting #AST_FORCE_FIRM or #AST_FORCE_HARD will unload the
131  * module regardless of consequences (NOT RECOMMENDED).
132  *
133  * \retval 0 on success.
134  * \retval -1 on error.
135  */
136 int ast_unload_resource(const char *resource_name, enum ast_module_unload_mode);
137
138 /*!
139  * \brief Reload asterisk modules.
140  * \param name the name of the module to reload
141  *
142  * This function reloads the specified module, or if no modules are specified,
143  * it will reload all loaded modules.
144  *
145  * \note Modules are reloaded using their reload() functions, not unloading
146  * them and loading them again.
147  *
148  * \retval The \ref ast_module_reload_result status of the module load request
149  */
150 enum ast_module_reload_result ast_module_reload(const char *name);
151
152 /*!
153  * \brief Notify when usecount has been changed.
154  *
155  * This function calulates use counts and notifies anyone trying to keep track
156  * of them.  It should be called whenever your module's usecount changes.
157  *
158  * \note The ast_module_user_* functions take care of calling this function for you.
159  */
160 void ast_update_use_count(void);
161
162 /*!
163  * \brief Ask for a list of modules, descriptions, use counts and status.
164  * \param modentry A callback to an updater function.
165  * \param like
166  *
167  * For each of the modules loaded, modentry will be executed with the resource,
168  * description, and usecount values of each particular module.
169  *
170  * \return the number of modules loaded
171  */
172 int ast_update_module_list(int (*modentry)(const char *module, const char *description,
173                                            int usecnt, const char *status, const char *like,
174                                            enum ast_module_support_level support_level),
175                            const char *like);
176
177 /*!
178  * \brief Ask for a list of modules, descriptions, use counts and status.
179  * \param modentry A callback to an updater function
180  * \param like
181  * \param data Data passed into the callback for manipulation
182  *
183  * For each of the modules loaded, modentry will be executed with the resource,
184  * description, and usecount values of each particular module.
185  *
186  * \return the number of modules loaded
187  * \since 13.5.0
188  */
189 int ast_update_module_list_data(int (*modentry)(const char *module, const char *description,
190                                                 int usecnt, const char *status, const char *like,
191                                                 enum ast_module_support_level support_level,
192                                                 void *data),
193                                 const char *like, void *data);
194
195 /*!
196  * \brief Ask for a list of modules, descriptions, use counts and status.
197  * \param modentry A callback to an updater function
198  * \param like
199  * \param data Data passed into the callback for manipulation
200  * \param condition The condition to meet
201  *
202  * For each of the modules loaded, modentry will be executed with the resource,
203  * description, and usecount values of each particular module.
204  *
205  * \return the number of conditions met
206  * \since 13.5.0
207  */
208 int ast_update_module_list_condition(int (*modentry)(const char *module, const char *description,
209                                                      int usecnt, const char *status, const char *like,
210                                                      enum ast_module_support_level support_level,
211                                                      void *data, const char *condition),
212                                      const char *like, void *data, const char *condition);
213
214 /*!
215  * \brief Check if module with the name given is loaded
216  * \param name Module name, like "chan_sip.so"
217  * \retval 1 if true
218  * \retval 0 if false
219  */
220 int ast_module_check(const char *name);
221
222 /*!
223  * \brief Add a procedure to be run when modules have been updated.
224  * \param updater The function to run when modules have been updated.
225  *
226  * This function adds the given function to a linked list of functions to be
227  * run when the modules are updated.
228  *
229  * \retval 0 on success
230  * \retval -1 on failure.
231  */
232 int ast_loader_register(int (*updater)(void));
233
234 /*!
235  * \brief Remove a procedure to be run when modules are updated.
236  * \param updater The updater function to unregister.
237  *
238  * This removes the given function from the updater list.
239  *
240  * \retval 0 on success
241  * \retval -1 on failure.
242  */
243 int ast_loader_unregister(int (*updater)(void));
244
245 /*!
246  * \brief Match modules names for the Asterisk cli.
247  * \param line Unused by this function, but this should be the line we are
248  *        matching.
249  * \param word The partial name to match.
250  * \param pos The position the word we are completing is in.
251  * \param state The possible match to return.
252  * \param rpos The position we should be matching.  This should be the same as
253  *        pos.
254  * \param type The type of action that will be performed by CLI.
255  *
256  * \retval A possible completion of the partial match.
257  * \retval NULL if no matches were found.
258  */
259 char *ast_module_helper(const char *line, const char *word, int pos, int state, int rpos, enum ast_module_helper_type type);
260
261 /* Opaque type for module handles generated by the loader */
262
263 struct ast_module;
264
265 /*!
266  * \brief Get the name of a module.
267  * \param mod A pointer to the module.
268  * \return the name of the module
269  * \retval NULL if mod or mod->info is NULL
270  */
271 const char *ast_module_name(const struct ast_module *mod);
272
273 /* User count routines keep track of which channels are using a given module
274    resource.  They can help make removing modules safer, particularly if
275    they're in use at the time they have been requested to be removed */
276
277 struct ast_module_user;
278 struct ast_module_user_list;
279
280 /*! \page ModMngmnt The Asterisk Module management interface
281  *
282  * All modules must implement the module API (load, unload...)
283  */
284
285 enum ast_module_flags {
286         AST_MODFLAG_DEFAULT = 0,
287         AST_MODFLAG_GLOBAL_SYMBOLS = (1 << 0),
288         AST_MODFLAG_LOAD_ORDER = (1 << 1),
289 };
290
291 enum ast_module_load_priority {
292         AST_MODPRI_REALTIME_DEPEND =    10,  /*!< Dependency for a realtime driver */
293         AST_MODPRI_REALTIME_DEPEND2 =   20,  /*!< Second level dependency for a realtime driver (func_curl needs res_curl, but is needed by res_config_curl) */
294         AST_MODPRI_REALTIME_DRIVER =    30,  /*!< A realtime driver, which provides configuration services for other modules */
295         AST_MODPRI_TIMING =             40,  /*!< Dependency for a channel (MOH needs timing interfaces to be fully loaded) */
296         AST_MODPRI_CHANNEL_DEPEND =     50,  /*!< Channel driver dependency (may depend upon realtime, e.g. MOH) */
297         AST_MODPRI_CHANNEL_DRIVER =     60,  /*!< Channel drivers (provide devicestate) */
298         AST_MODPRI_APP_DEPEND =         70,  /*!< Dependency for an application */
299         AST_MODPRI_DEVSTATE_PROVIDER =  80,  /*!< Applications and other modules that _provide_ devicestate (e.g. meetme) */
300         AST_MODPRI_DEVSTATE_PLUGIN =    90,  /*!< Plugin for a module that provides devstate (e.g. res_calendar_*) */
301         AST_MODPRI_CDR_DRIVER =        100,  /*!< CDR or CEL backend */
302         AST_MODPRI_DEFAULT =           128,  /*!< Modules not otherwise defined (such as most apps) will load here */
303         AST_MODPRI_DEVSTATE_CONSUMER = 150,  /*!< Certain modules, which consume devstate, need to load after all others (e.g. app_queue) */
304 };
305
306 struct ast_module_info {
307         /*!
308          * The 'self' pointer for a module; it will be set by the loader before
309          * it calls the module's load_module() entrypoint, and used by various
310          * other macros that need to identify the module.
311          */
312         struct ast_module *self;
313         /*! Register stuff etc. Optional. */
314         enum ast_module_load_result (*load)(void);
315         /*! Config etc. Optional. */
316         int (*reload)(void);
317         /*! Unload. called with the module locked */
318         int (*unload)(void);
319         /*! Name of the module for loader reference and CLI commands */
320         const char *name;
321         /*! User friendly description of the module. */
322         const char *description;
323
324         /*!
325          * This holds the ASTERISK_GPL_KEY, signifiying that you agree to the terms of
326          * the Asterisk license as stated in the ASTERISK_GPL_KEY.  Your module will not
327          * load if it does not return the EXACT key string.
328          */
329         const char *key;
330         unsigned int flags;
331
332         /*! The value of AST_BUILDOPT_SUM when this module was compiled */
333         const char buildopt_sum[33];
334
335         /*! This value represents the order in which a module's load() function is initialized.
336          *  The lower this value, the higher the priority.  The value is only checked if the
337          *  AST_MODFLAG_LOAD_ORDER flag is set.  If the AST_MODFLAG_LOAD_ORDER flag is not set,
338          *  this value will never be read and the module will be given the lowest possible priority
339          *  on load. */
340         unsigned char load_pri;
341
342         /*! Modules which must always be started first, in comma-separated string format. */
343         const char *requires;
344
345         /*!
346          * \brief Comma-separated list of optionally required modules.
347          *
348          * The listed modules are optional, but load order is enforced.  For example
349          * app_voicemail optionally requires res_adsi.  This means that app_voicemail
350          * will happily load without res_adsi, but if both are being loaded the module
351          * loader will force res_adsi to start first.
352          */
353         const char *optional_modules;
354
355         /*!
356          * \brief Modules that we provide enhanced functionality for.
357          *
358          * This is similar to a "requires" but specifies that we add functionality to
359          * the other modules.  Any module that requires something we "enhances" will
360          * also require us, but only if we are dlopen'ed.
361          *
362          * Example:
363          * - res_fax_spandsp has .enhances = "res_fax".
364          * - res_my_module has .requires = "res_fax" but has no direct knowledge
365          *   of res_fax_spandsp.
366          *
367          * This forces the following startup order among the 3 modules:
368          * 1) res_fax starts.
369          * 2) res_fax_spandsp starts, holds a reference to res_fax.
370          * 3) res_mymod starts, holds a reference to res_fax and res_fax_spandsp.
371          *
372          * If res_fax_spandsp were not being loaded res_mymod would load with
373          * res_fax only.  If res_fax_spandsp were later loaded res_mymod would
374          * get a reference to it.
375          */
376         const char *enhances;
377
378         /*! The support level for the given module */
379         enum ast_module_support_level support_level;
380 };
381
382 void ast_module_register(const struct ast_module_info *);
383 void ast_module_unregister(const struct ast_module_info *);
384
385 struct ast_module_user *__ast_module_user_add(struct ast_module *, struct ast_channel *);
386 void __ast_module_user_remove(struct ast_module *, struct ast_module_user *);
387 void __ast_module_user_hangup_all(struct ast_module *);
388
389 #define ast_module_user_add(chan) __ast_module_user_add(AST_MODULE_SELF, chan)
390 #define ast_module_user_remove(user) __ast_module_user_remove(AST_MODULE_SELF, user)
391 #define ast_module_user_hangup_all() __ast_module_user_hangup_all(AST_MODULE_SELF)
392
393 struct ast_module *__ast_module_ref(struct ast_module *mod, const char *file, int line, const char *func);
394 struct ast_module *__ast_module_running_ref(struct ast_module *mod, const char *file, int line, const char *func);
395 void __ast_module_shutdown_ref(struct ast_module *mod, const char *file, int line, const char *func);
396 void __ast_module_unref(struct ast_module *mod, const char *file, int line, const char *func);
397
398 /*!
399  * \brief Hold a reference to the module
400  * \param mod Module to reference
401  * \return mod
402  *
403  * \note A module reference will prevent the module
404  * from being unloaded.
405  */
406 #define ast_module_ref(mod)           __ast_module_ref(mod, __FILE__, __LINE__, __PRETTY_FUNCTION__)
407
408 /*!
409  * \brief Hold a reference to the module if it is running.
410  * \param mod Module to reference
411  * \retval mod if running
412  * \retval NULL if not running
413  *
414  * The returned pointer should be released with ast_module_unref.
415  *
416  * \note A module reference will prevent the module from being unloaded.
417  */
418 #define ast_module_running_ref(mod) \
419         __ast_module_running_ref(mod, __FILE__, __LINE__, __PRETTY_FUNCTION__)
420
421 /*!
422  * \brief Prevent unload of the module before shutdown
423  * \param mod Module to hold
424  *
425  * \note This should not be balanced by a call to ast_module_unref.
426  */
427 #define ast_module_shutdown_ref(mod)  __ast_module_shutdown_ref(mod, __FILE__, __LINE__, __PRETTY_FUNCTION__)
428 /*!
429  * \brief Release a reference to the module
430  * \param mod Module to release
431  */
432 #define ast_module_unref(mod)         __ast_module_unref(mod, __FILE__, __LINE__, __PRETTY_FUNCTION__)
433
434 #if defined(__cplusplus) || defined(c_plusplus)
435 #define AST_MODULE_INFO(keystr, flags_to_set, desc, load_func, unload_func, reload_func, load_pri, support_level)       \
436         static struct ast_module_info __mod_info = {    \
437                 NULL,                                                          \
438                 load_func,                                                     \
439                 reload_func,                                                   \
440                 unload_func,                                                   \
441                 AST_MODULE,                                                    \
442                 desc,                                                          \
443                 keystr,                                                        \
444                 flags_to_set,                                                  \
445                 AST_BUILDOPT_SUM,                                              \
446                 load_pri,                                                      \
447                 NULL,                                                          \
448                 NULL,                                                          \
449                 NULL,                                                          \
450                 support_level,                                                 \
451         };                                                                 \
452         static void  __attribute__((constructor)) __reg_module(void)       \
453         {                                                                  \
454                 ast_module_register(&__mod_info);                              \
455         }                                                                  \
456         static void  __attribute__((destructor)) __unreg_module(void)      \
457         {                                                                  \
458                 ast_module_unregister(&__mod_info);                            \
459         }                                                                  \
460         struct ast_module *AST_MODULE_SELF_SYM(void)                       \
461         {                                                                  \
462                 return __mod_info.self;                                        \
463         }                                                                  \
464         static const __attribute__((unused)) struct ast_module_info *ast_module_info = &__mod_info
465
466
467 #define AST_MODULE_INFO_STANDARD(keystr, desc)              \
468         AST_MODULE_INFO(keystr, AST_MODFLAG_LOAD_ORDER, desc,   \
469                         load_module,                                    \
470                         unload_module,                                  \
471                         NULL,                                           \
472                         AST_MODPRI_DEFAULT,                             \
473                         AST_MODULE_SUPPORT_CORE                         \
474                        )
475
476 #define AST_MODULE_INFO_STANDARD_EXTENDED(keystr, desc)     \
477         AST_MODULE_INFO(keystr, AST_MODFLAG_LOAD_ORDER, desc,   \
478                         load_module,                                    \
479                         unload_module,                                  \
480                         NULL,                                           \
481                         AST_MODPRI_DEFAULT,                             \
482                         AST_MODULE_SUPPORT_EXTENDED                     \
483                        )
484 #define AST_MODULE_INFO_STANDARD_DEPRECATED(keystr, desc)   \
485         AST_MODULE_INFO(keystr, AST_MODFLAG_LOAD_ORDER, desc,   \
486                         load_module,                                    \
487                         unload_module,                                  \
488                         NULL,                                           \
489                         AST_MODPRI_DEFAULT,                             \
490                         AST_MODULE_SUPPORT_DEPRECATED                   \
491                        )
492
493 #else /* plain C */
494
495 /* forward declare this pointer in modules, so that macro/function
496    calls that need it can get it, since it will actually be declared
497    and populated at the end of the module's source file... */
498 #if !defined(AST_IN_CORE)
499 static const __attribute__((unused)) struct ast_module_info *ast_module_info;
500 #endif
501
502 #define AST_MODULE_INFO(keystr, flags_to_set, desc, fields...)  \
503         static struct ast_module_info                           \
504                 __mod_info = {                                  \
505                 .name = AST_MODULE,                             \
506                 .flags = flags_to_set,                          \
507                 .description = desc,                            \
508                 .key = keystr,                                  \
509                 .buildopt_sum = AST_BUILDOPT_SUM,               \
510                 fields                                          \
511         };                                                      \
512         static void  __attribute__((constructor)) __reg_module(void) \
513         { \
514                 ast_module_register(&__mod_info); \
515         } \
516         static void  __attribute__((destructor)) __unreg_module(void) \
517         { \
518                 ast_module_unregister(&__mod_info); \
519         } \
520         struct ast_module *AST_MODULE_SELF_SYM(void)                       \
521         {                                                                  \
522                 return __mod_info.self;                                        \
523         }                                                                  \
524         static const struct ast_module_info *ast_module_info = &__mod_info
525
526 #define AST_MODULE_INFO_STANDARD(keystr, desc)              \
527         AST_MODULE_INFO(keystr, AST_MODFLAG_LOAD_ORDER, desc,   \
528                         .load = load_module,                            \
529                         .unload = unload_module,                        \
530                         .load_pri = AST_MODPRI_DEFAULT,                 \
531                         .support_level = AST_MODULE_SUPPORT_CORE,       \
532                        )
533
534 #define AST_MODULE_INFO_STANDARD_EXTENDED(keystr, desc)     \
535         AST_MODULE_INFO(keystr, AST_MODFLAG_LOAD_ORDER, desc,   \
536                         .load = load_module,                            \
537                         .unload = unload_module,                        \
538                         .load_pri = AST_MODPRI_DEFAULT,                 \
539                         .support_level = AST_MODULE_SUPPORT_EXTENDED,   \
540                        )
541
542 #define AST_MODULE_INFO_STANDARD_DEPRECATED(keystr, desc)   \
543         AST_MODULE_INFO(keystr, AST_MODFLAG_LOAD_ORDER, desc,   \
544                         .load = load_module,                            \
545                         .unload = unload_module,                        \
546                         .load_pri = AST_MODPRI_DEFAULT,                 \
547                         .support_level = AST_MODULE_SUPPORT_DEPRECATED, \
548                        )
549
550 #endif  /* plain C */
551
552 /*!
553  * \brief Register an application.
554  *
555  * \param app Short name of the application
556  * \param execute a function callback to execute the application. It should return
557  *                non-zero if the channel needs to be hung up.
558  * \param synopsis a short description (one line synopsis) of the application
559  * \param description long description with all of the details about the use of
560  *                    the application
561  *
562  * This registers an application with Asterisk's internal application list.
563  * \note The individual applications themselves are responsible for registering and unregistering
564  *       and unregistering their own CLI commands.
565  *
566  * \retval 0 success
567  * \retval -1 failure.
568  */
569 #define ast_register_application(app, execute, synopsis, description) ast_register_application2(app, execute, synopsis, description, AST_MODULE_SELF)
570
571 /*!
572  * \brief Register an application using XML documentation.
573  *
574  * \param app Short name of the application
575  * \param execute a function callback to execute the application. It should return
576  *                non-zero if the channel needs to be hung up.
577  *
578  * This registers an application with Asterisk's internal application list.
579  * \note The individual applications themselves are responsible for registering and unregistering
580  *       and unregistering their own CLI commands.
581  *
582  * \retval 0 success
583  * \retval -1 failure.
584  */
585 #define ast_register_application_xml(app, execute) ast_register_application(app, execute, NULL, NULL)
586
587
588 /*!
589  * \brief Register an application.
590  *
591  * \param app Short name of the application
592  * \param execute a function callback to execute the application. It should return
593  *                non-zero if the channel needs to be hung up.
594  * \param synopsis a short description (one line synopsis) of the application
595  * \param description long description with all of the details about the use of
596  *                    the application
597  * \param mod module this application belongs to
598  *
599  * This registers an application with Asterisk's internal application list.
600  * \note The individual applications themselves are responsible for registering and unregistering
601  *       and unregistering their own CLI commands.
602  *
603  * \retval 0 success
604  * \retval -1 failure.
605  */
606 int ast_register_application2(const char *app, int (*execute)(struct ast_channel *, const char *),
607                                      const char *synopsis, const char *description, void *mod);
608
609 /*!
610  * \brief Unregister an application
611  *
612  * \param app name of the application (does not have to be the same string as the one that was registered)
613  *
614  * This unregisters an application from Asterisk's internal application list.
615  *
616  * \retval 0 success
617  * \retval -1 failure
618  */
619 int ast_unregister_application(const char *app);
620
621 const char *ast_module_support_level_to_string(enum ast_module_support_level support_level);
622
623 /*! Macro to safely ref and unref the self module for the current scope */
624 #define SCOPED_MODULE_USE(module) \
625         RAII_VAR(struct ast_module *, __self__ ## __LINE__, ast_module_ref(module), ast_module_unref)
626
627 #if defined(__cplusplus) || defined(c_plusplus)
628 }
629 #endif
630
631 #endif /* _ASTERISK_MODULE_H */