Add default handler documentation and standardize acl handler
[asterisk/asterisk.git] / include / asterisk / config_options.h
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2012, Digium, Inc.
5  *
6  * Mark Spencer <markster@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 /*! \file
20  * \brief Configuration option-handling
21  * \author Terry Wilson <twilson@digium.com>
22  */
23
24 #ifndef _ASTERISK_CONFIG_OPTIONS_H
25 #define _ASTERISK_CONFIG_OPTIONS_H
26
27 #if defined(__cplusplus) || defined(c_plusplus)
28 extern "C" {
29 #endif
30
31 #include <regex.h>
32
33 #include "asterisk/config.h"
34 #include "asterisk/astobj2.h"
35
36 struct aco_option;
37 struct aco_info_internal;
38 struct aco_type_internal;
39
40 enum aco_type_t {
41         ACO_GLOBAL,
42         ACO_ITEM,
43 };
44
45 /*! \brief Whether a category regex is a blackist or a whitelist */
46 enum aco_category_op {
47         ACO_BLACKLIST = 0,
48         ACO_WHITELIST,
49 };
50
51 /*! \brief What kind of matching should be done on an option name */
52 enum aco_matchtype {
53         ACO_EXACT = 1,
54         ACO_REGEX,
55 };
56
57 /*! Callback functions for option parsing via aco_process_config() */
58
59 /*! \brief Allocate a configurable ao2 object
60  * \param category The config category the object is being generated for
61  * \retval NULL error
62  * \retval non-NULL a new configurable ao2 object
63  */
64 typedef void *(*aco_type_item_alloc)(const char *category);
65
66 /*! \brief Find a item given a category and container of items
67  * \param container The container to search for the item
68  * \param category The category associated with the item
69  * \retval non-NULL item from the container
70  * \retval NULL item does not exist in container
71  */
72 typedef void *(*aco_type_item_find)(struct ao2_container *newcontainer, const char *category);
73
74 /*! \brief Callback function that is called after a config object is initialized with defaults
75  *
76  * \note This callback is called during config processing after a new config is allocated and
77  * and defaults applied but before values from the config are read. This callback could be used
78  * to merge in settings inherited from the global settings if necessary, despite that being a
79  * bad thing to do!
80  *
81  * \param newitem The newly allocated config object with defaults populated
82  * \retval 0 succes, continue processing
83  * \retval non-zero failure, stop processing
84  */
85 typedef int (*aco_type_item_pre_process)(void *newitem);
86
87 /*! \brief Callback function that is called after config processing, but before linking
88  *
89  * \note This callback is called after config processing, but before linking the object
90  * in the config container. This callback can be used to verify that all settings make
91  * sense together, that required options have been set, etc.
92  *
93  * \param newitem The newly configured object
94  * \retval 0 success, continue processing
95  * \retval non-zero failure, stop processing
96  */
97 typedef int (*aco_type_prelink)(void *newitem);
98
99 /*! \brief A function for determining whether the value for the matchfield in an aco_type is sufficient for a match
100  * \param text The value of the option
101  * \retval -1 The value is sufficient for a match
102  * \retval 0 The value is not sufficient for a match
103  */
104 typedef int (*aco_matchvalue_func)(const char *text);
105
106 /*! \struct aco_type
107  * \brief Type information about a category-level configurable object
108  */
109 struct aco_type {
110         /* common stuff */
111         enum aco_type_t type;   /*!< Whether this is a global or item type */
112         const char *category;   /*!< A regular expression for matching categories to be allowed or denied */
113         const char *matchfield; /*!< An option name to match for this type (i.e. a 'type'-like column) */
114         const char *matchvalue; /*!< The value of the option to require for matching (i.e. 'peer' for type= in sip.conf) */
115         aco_matchvalue_func matchfunc;       /*!< A function for determing whether the option value matches (i.e. hassip= requires ast_true()) */
116         enum aco_category_op category_match; /*!< Whether the following category regex is a whitelist or blacklist */
117         size_t item_offset;                  /*!< The offset in the config snapshot for the global config or item config container */
118
119         /* non-global callbacks */
120         aco_type_item_alloc item_alloc;         /*!< An allocation function for item associated with this type */
121         aco_type_item_find item_find;           /*!< A callback function to find an existing item in a particular container */
122         aco_type_item_pre_process item_pre_process; /*!< An optional callback function that is called after defaults are applied, but before config processing */
123         aco_type_prelink item_prelink;          /*!< An optional callback function that is called after config processing, but before applying changes */
124         struct aco_type_internal *internal;
125 };
126
127 /*! \brief A callback function for applying the config changes
128  * \retval 0 Success
129  * \retval non-zero Failure. Changes not applied
130  */
131 typedef int (*aco_pre_apply_config)(void);
132
133 /*! \brief A callback functino for allocating an object to hold all config objects
134  * \retval NULL error
135  * \retval non-NULL a config object container
136  */
137 typedef void *(*aco_snapshot_alloc)(void);
138
139 struct aco_file {
140         const char *filename;
141         const char **preload;
142         struct aco_type *types[]; /*!< The list of types for this config. Required. Use a sentinel! */
143 };
144
145 struct aco_info {
146         const char *module;         /*!< The name of the module whose config is being processed */
147         aco_pre_apply_config pre_apply_config; /*!< A callback called after processing, but before changes are applied */
148         aco_snapshot_alloc snapshot_alloc;     /*!< Allocate an object to hold all global configs and item containers */
149         struct ao2_global_obj *global_obj;     /*!< The global object array that holds the user-defined config object */
150         struct aco_info_internal *internal;
151         struct aco_file *files[];    /*!< The config filename */
152 };
153
154 /*! \brief A helper macro to ensure that aco_info types always have a sentinel */
155 #define ACO_TYPES(...) { __VA_ARGS__, NULL, }
156 #define ACO_FILES(...) { __VA_ARGS__, NULL, }
157
158 /*! \brief Get pending config changes
159  * \note This will most likely be called from the pre_apply_config callback function
160  * \param info An initialized aco_info
161  * \retval NULL error
162  * \retval non-NULL A pointer to the user-defined config object with un-applied changes
163  */
164 void *aco_pending_config(struct aco_info *info);
165
166 /*! \def CONFIG_INFO_STANDARD
167  * \brief Declare an aco_info struct with default module and preload values
168  * \param name The name of the struct
169  * \param fn The filename of the config
170  * \param arr The global object array for holding the user-defined config object
171  * \param alloc The allocater for the user-defined config object
172  *
173  * Example:
174  * \code
175  * static AO2_GLOBAL_OBJ_STATIC(globals, 1);
176  * CONFIG_INFO_STANDARD(cfg_info, globals, skel_config_alloc,
177  *     .pre_apply_config = skel_pre_apply_config,
178  *     .files = { &app_skel_conf, NULL },
179  * );
180  * ...
181  * if (aco_info_init(&cfg_info)) {
182  *     return AST_MODULE_LOAD_DECLINE;
183  * }
184  * ...
185  * aco_info_destroy(&cfg_info);
186  * \endcode
187  */
188 #define CONFIG_INFO_STANDARD(name, arr, alloc, ...) \
189 static struct aco_info name = { \
190         .module = AST_MODULE, \
191         .global_obj = &arr, \
192         .snapshot_alloc = alloc, \
193         __VA_ARGS__ \
194 };
195
196 /*! \brief Initialize an aco_info structure
197  * \note aco_info_destroy must be called if this succeeds
198  * \param info The address of an aco_info struct to initialize
199  * \retval 0 Success
200  * \retval non-zero Failure
201  */
202 int aco_info_init(struct aco_info *info);
203
204 /*! \brief Destroy an initialized aco_info struct
205  * \param info The address of the aco_info struct to destroy
206  */
207 void aco_info_destroy(struct aco_info *info);
208
209 /*! \brief The option types
210  *
211  * \note aco_option_register takes an option type which is used
212  * to look up the handler for that type. Each non-custom type requires
213  * field names for specific types in the struct being configured. Each
214  * option below is commented with the field types, additional arguments
215  * and example usage with aco_option_register
216  */
217 enum aco_option_type {
218         /*! \brief Type for default option handler for ACLs
219          * \note aco_option_register flags:
220          *   non-zero : "permit"
221          *   0        : "deny"
222          * aco_option_register varargs:
223          *   FLDSET macro with the field of type struct ast_ha *.
224          *
225          * Example:
226          * {code}
227          * struct test_item {
228          *     struct ast_ha *ha;
229          * };
230          * aco_option_register(&cfg_info, "permit", ACO_EXACT, my_types, NULL, OPT_ACL_T, 1, FLDSET(struct test_item, ha));
231          * aco_option_register(&cfg_info, "deny", ACO_EXACT, my_types, NULL, OPT_ACL_T, 0, FLDSET(struct test_item, ha));
232          * {code}
233          */
234         OPT_ACL_T,
235
236         /*! \brief Type for default option handler for bools (ast_true/ast_false)
237          * \note aco_option_register flags:
238          *   non-zero : process via ast_true
239          *   0        : process via ast_false
240          * aco_option_register varargs:
241          *   FLDSET macro with the field of type int. It is important to note that the field
242          *   cannot be a bitfield. If bitfields are required, they must be set via a custom handler.
243          *
244          * Example:
245          * {code}
246          * struct test_item {
247          *     int enabled;
248          * };
249                 aco_option_register(&cfg_info, "enabled", ACO_EXACT, my_types, "no", OPT_BOOL_T, 1, FLDSET(struct test_item, enabled));
250          * {endcode}
251          */
252         OPT_BOOL_T,
253
254         /*! \brief Type for default option handler for codec preferences/capabilities
255          * \note aco_option_register flags:
256          *   non-zero : This is an "allow" style option
257          *   0        : This is a "disallow" style option
258          * aco_option_register varargs:
259          *   FLDSET macro with fields representing a struct ast_codec_pref and a struct ast_format_cap *
260          *
261          * Example:
262          * {code}
263          * struct test_item {
264          *     struct ast_codec_pref pref;
265          *     struct ast_format cap *cap;
266          * };
267          * aco_option_register(&cfg_info, "allow", ACO_EXACT, my_types, "ulaw,alaw", OPT_CODEC_T, 1, FLDSET(struct test_item, pref, cap));
268          * aco_option_register(&cfg_info, "disallow", ACO_EXACT, my_types, "all", OPT_CODEC_T, 0, FLDSET(struct test_item, pref, cap));
269          */
270         OPT_CODEC_T,
271
272         /*! \brief Type for a custom (user-defined) option handler */
273         OPT_CUSTOM_T,
274
275         /*! \brief Type for default option handler for doubles
276          *
277          * \note aco_option_register flags:
278          *   See flags available for use with the PARSE_DOUBLE type for the ast_parse_arg function
279          * aco_option_register varargs:
280          *   FLDSET macro with the field of type double
281          *
282          * Example:
283          * struct test_item {
284          *     double dub;
285          * };
286          * {code}
287          * aco_option_register(&cfg_info, "doubleopt", ACO_EXACT, my_types, "3", OPT_DOUBLE_T, FLDSET(struct test_item, dub));
288          * {endcode}
289          */
290         OPT_DOUBLE_T,
291
292         /*! \brief Type for default option handler for signed integers
293          *
294          * \note aco_option_register flags:
295          *   See flags available for use with the PARSE_INT32 type for the ast_parse_arg function
296          * aco_option_register varargs:
297          *   FLDSET macro with the field of type int32_t
298          *   The remaining varargs for should be arguments compatible with the varargs for the
299          *   ast_parse_arg function with the PARSE_INT32 type and the flags passed in the
300          *   aco_option_register flags parameter.
301          *
302          * \note In most situations, it is preferable to not pass the PARSE_DEFAULT flag. If a config
303          * contains an invalid value, it is better to let the config loading fail with warnings so that
304          * the problem is fixed by the administrator.
305          *
306          * Example:
307          * struct test_item {
308          *     int32_t intopt;
309          * };
310          * {code}
311          * aco_option_register(&cfg_info, "intopt", ACO_EXACT, my_types, "3", OPT_INT_T, PARSE_IN_RANGE, FLDSET(struct test_item, intopt), -10, 10);
312          * {endcode}
313          */
314         OPT_INT_T,
315
316         /*! \brief Type for default handler for ast_sockaddrs
317          *
318          * \note aco_option_register flags:
319          *   See flags available for use with the PARSE_ADDR type for the ast_parse_arg function
320          * aco_option_register varargs:
321          *   FLDSET macro with the field being of type struct ast_sockaddr.
322          *
323          * Example:
324          * {code}
325          * struct test_item {
326          *     struct ast_sockaddr addr;
327          * };
328          * aco_option_register(&cfg_info, "sockaddropt", ACO_EXACT, my_types, "0.0.0.0:1234", OPT_SOCKADDR_T, 0, FLDSET(struct test_item, addr));
329          * {endcode}
330          */
331         OPT_SOCKADDR_T,
332
333         /*! \brief Type for default option handler for stringfields
334          * \note aco_option_register flags:
335          *   none
336          * aco_option_register varargs:
337          *   STRFLDSET macro with the field being the field created by AST_STRING_FIELD
338          *
339          * Example:
340          * {code}
341          * struct test_item {
342          *     AST_DECLARE_STRING_FIELDS(
343          *         AST_STRING_FIELD(thing);
344          *     );
345          * };
346          * aco_option_register(&cfg_info, "thing", ACO_EXACT, my_types, NULL, OPT_STR_T, 0, STRFLDSET(struct test_item, thing));
347          * {endcode}
348          */
349         OPT_STRINGFIELD_T,
350
351         /*! \brief Type for default option handler for unsigned integers
352          *
353          * \note aco_option_register flags:
354          *   See flags available for use with the PARSE_UINT32 type for the ast_parse_arg function
355          * aco_option_register varargs:
356          *   FLDSET macro with the field of type uint32_t
357          *   The remaining varargs for should be arguments compatible with the varargs for the
358          *   ast_parse_arg function with the PARSE_UINT32 type and the flags passed in the
359          *   aco_option_register flags parameter.
360          *
361          * \note In most situations, it is preferable to not pass the PARSE_DEFAULT flag. If a config
362          * contains an invalid value, it is better to let the config loading fail with warnings so that
363          * the problem is fixed by the administrator.
364          *
365          * Example:
366          * struct test_item {
367          *     int32_t intopt;
368          * };
369          * {code}
370          * aco_option_register(&cfg_info, "uintopt", ACO_EXACT, my_types, "3", OPT_UINT_T, PARSE_IN_RANGE, FLDSET(struct test_item, uintopt), 1, 10);
371          * {endcode}
372          */
373         OPT_UINT_T,
374 };
375
376 /*! \brief A callback function for handling a particular option
377  * \param opt The option being configured
378  * \param var The config variable to use to configure \a obj
379  * \param obj The object to be configured
380  *
381  * \retval 0 Parsing and recording the config value succeeded
382  * \retval non-zero Failure. Parsing should stop and no reload applied
383  */
384 typedef int (*aco_option_handler)(const struct aco_option *opt, struct ast_variable *var, void *obj);
385
386 /*! \brief Allocate a container to hold config options */
387 struct ao2_container *aco_option_container_alloc(void);
388
389 /*! \brief Process a config info via the options registered with an aco_info
390  *
391  * \param info The config_options_info to be used for handling the config
392  * \param reload Whether or not this is a reload
393  *
394  * \retval 0 Success
395  * \retval -1 Failure
396  */
397 int aco_process_config(struct aco_info *info, int reload);
398
399 /*! \brief Process config info from an ast_config via options registered with an aco_info
400  *
401  * \param info The aco_info to be used for handling the config
402  * \param file The file attached to aco_info that the config represents
403  * \param cfg A pointer to a loaded ast_config to parse
404  * \param reload Whether or not this is a reload
405  *
406  * \retval 0 Success
407  * \retval -1 Failure
408  */
409 int aco_process_ast_config(struct aco_info *info, struct aco_file *file, struct ast_config *cfg);
410
411 /*! \brief Parse each option defined in a config category
412  * \param type The aco_type with the options for parsing
413  * \param cfg The ast_config being parsed
414  * \param cat The config category being parsed
415  * \param obj The user-defined config object that will store the parsed config items
416  *
417  * \retval 0 Success
418  * \retval -1 Failure
419  */
420 int aco_process_category_options(struct aco_type *type, struct ast_config *cfg, const char *cat, void *obj);
421
422 /*! \brief Set all default options of \a obj
423  * \param info The aco_type with the options
424  * \param category The configuration category from which \a obj is being configured
425  * \param obj The object being configured
426  *
427  * \retval 0 Success
428  * \retval -1 Failure
429  */
430 int aco_set_defaults(struct aco_type *type, const char *category, void *obj);
431
432 /*! \brief register a config option
433  *
434  * \note this should probably only be called by one of the aco_option_register* macros
435  *
436  * \param info The aco_info holding this module's config information
437  * \param name The name of the option
438  * \param types An array of valid option types for matching categories to the correct struct type
439  * \param default_val The default value of the option in the same format as defined in a config file
440  * \param type The option type (only for default handlers)
441  * \param handler The handler function for the option (only for non-default types)
442  * \param flags \a type specific flags, stored in the option and available to the handler
443  * \param argc The number for variadic arguments
444  * \param ... field offsets to store for default handlers
445  *
446  * \retval 0 success
447  * \retval -1 failure
448  */
449 int __aco_option_register(struct aco_info *info, const char *name, enum aco_matchtype match_type, struct aco_type **types,
450         const char *default_val, enum aco_option_type type, aco_option_handler handler, unsigned int flags, size_t argc, ...);
451
452 /*! \brief Register a config option
453  * \param info A pointer to the aco_info struct
454  * \param name The name of the option
455  * \param types An array of valid option types for matching categories to the correct struct type
456  * \param default_val The default value of the option in the same format as defined in a config file
457  * \param opt_type The option type for default option type handling
458  * \param flags \a type specific flags, stored in the option and available to the handler
459  *
460  * \returns An option on success, NULL on failure
461  */
462 #define aco_option_register(info, name, matchtype, types, default_val, opt_type, flags, ...) \
463         __aco_option_register(info, name, matchtype, types, default_val, opt_type, NULL, flags, VA_NARGS(__VA_ARGS__), __VA_ARGS__);
464
465 /*! \brief Register a config option
466  * \param info A pointer to the aco_info struct
467  * \param name The name of the option
468  * \param types An array of valid option types for matching categories to the correct struct type
469  * \param default_val The default value of the option in the same format as defined in a config file
470  * \param handler The handler callback for the option
471  * \param flags \a type specific flags, stored in the option and available to the handler
472  *
473  * \returns An option on success, NULL on failure
474  */
475 #define aco_option_register_custom(info, name, matchtype, type, default_val, handler, flags) \
476         __aco_option_register(info, name, matchtype, type, default_val, OPT_CUSTOM_T, handler, flags, 0);
477
478 /*! \note  Everything below this point is to handle converting varargs
479  * containing field names, to varargs containing a count of args, followed
480  * by the offset of each of the field names in the struct type that is
481  * passed in. It is currently limited to 8 arguments, but 8 variadic
482  * arguments, like 640K, should be good enough for anyone. If not, it is
483  * easy to add more.
484  * */
485
486 /*! \def ARGMAP(func, func_arg, x, ...)
487  * \brief Map \a func(\a func_arg, field) across all fields including \a x
488  * \param func The function (almost certainly offsetof) to map across the fields
489  * \param func_arg The first argument (almost certainly a type (e.g. "struct mystruct")
490  * \param x The first field
491  * \param varargs The rest of the fields
492  *
493  * Example usage:
494  * \code
495  * struct foo {
496  *     int a;
497  *     char *b;
498  *     foo *c;
499  * };
500  * ARGMAP(offsetof, struct foo, a, c)
501  * \endcode
502  * produces the string:
503  * \code
504  * 2, offsetof(struct foo, a), offsetof(struct foo, b)
505  * \encode
506  * which can be passed as the varargs to some other function
507  *
508  * The macro isn't limited to offsetof, but that is the only purpose for
509  * which it has been tested.
510  *
511  * As an example of how the processing works:
512  *
513  * ARGMAP(offsetof, struct foo, a, b, c) ->
514  * ARGMAP_(3, offsetof, struct foo, a, b, c) ->
515  * ARGMAP_3(offsetof, struct foo, 3, a, b, c) ->
516  * ARGMAP_2(offsetof, struct foo, ARGIFY(3, offsetof(struct foo, a)), b, c) ->
517  * ARGMAP_1(offsetof, struct foo, ARGIFY(3, offsetof(struct foo, a), offsetof(struct foo, b)), c) ->
518  * ARGIFY(3, offsetof(struct foo, a), offsetof(struct foo, b), offsetof(struct foo, c)) ->
519  * 3, offsetof(struct foo, a), offsetof(struct foo, b), offsetof(struct foo, c)
520  */
521 #define ARGMAP(func, func_arg, x, ...) ARGMAP_(VA_NARGS(x, ##__VA_ARGS__), func, func_arg, x, __VA_ARGS__)
522
523 /*! \note This is sneaky. On the very first argument, we set "in" to N, the number of arguments, so
524  * that the accumulation both works properly for the first argument (since "in" can't be empty) and
525  * we get the number of arguments in our varargs as a bonus */
526 #define ARGMAP_(N, func, func_arg, x, ...) PASTE(ARGMAP_, N)(func, func_arg, N, x, __VA_ARGS__)
527
528 /*! \def PASTE(arg1, arg2)
529  * \brief Paste two arguments together, even if they are macros themselves
530  * \note Uses two levels to handle the case where arg1 and arg2 are macros themselves
531  */
532 #define PASTE(arg1, arg2)  PASTE1(arg1, arg2)
533 #define PASTE1(arg1, arg2) arg1##arg2
534
535 /*! \brief Take a comma-separated list and allow it to be passed as a single argument to another macro */
536 #define ARGIFY(...) __VA_ARGS__
537
538 /*! \brief The individual field handlers for ARGMAP
539  * \param func The function (most likely offsetof)
540  * \param func_arg The first argument to func (most likely a type e.g. "struct my_struct")
541  * \param in The accumulated function-mapped field names so far
542  * \param x The next field name
543  * \param varargs The rest of the field names
544  */
545 #define ARGMAP_1(func, func_arg, in, x, ...) ARGIFY(in, func(func_arg, x))
546 #define ARGMAP_2(func, func_arg, in, x, ...)\
547         ARGMAP_1(func, func_arg, ARGIFY(in, func(func_arg, x)), __VA_ARGS__)
548 #define ARGMAP_3(func, func_arg, in, x, ...)\
549         ARGMAP_2(func, func_arg, ARGIFY(in, func(func_arg, x)), __VA_ARGS__)
550 #define ARGMAP_4(func, func_arg, in, x, ...)\
551         ARGMAP_3(func, func_arg, ARGIFY(in, func(func_arg, x)), __VA_ARGS__)
552 #define ARGMAP_5(func, func_arg, in, x, ...)\
553         ARGMAP_4(func, func_arg, ARGIFY(in, func(func_arg, x)), __VA_ARGS__)
554 #define ARGMAP_6(func, func_arg, in, x, ...)\
555         ARGMAP_5(func, func_arg, ARGIFY(in, func(func_arg, x)), __VA_ARGS__)
556 #define ARGMAP_7(func, func_arg, in, x, ...)\
557         ARGMAP_6(func, func_arg, ARGIFY(in, func(func_arg, x)), __VA_ARGS__)
558 #define ARGMAP_8(func, func_arg, in, x, ...)\
559         ARGMAP_7(func, func_arg, ARGIFY(in, func(func_arg, x)), __VA_ARGS__)
560
561 /*! \def VA_NARGS(...)
562  * \brief Results in the number of arguments passed to it
563  * \note Currently only up to 8, but expanding is easy. This macro basically counts
564  * commas + 1. To visualize:
565  *
566  * VA_NARGS(one, two, three) ->                    v
567  * VA_NARGS1(one, two, three,  8,  7,  6,  5,  4,  3,  2,  1,  0) ->
568  * VA_NARGS1( _1,  _2,    _3, _4, _5, _6, _7, _8,  N, ...       ) N -> 3
569  *
570  * Note that VA_NARGS *does not* work when there are no arguments passed. Pasting an empty
571  * __VA_ARGS__ with a comma like ", ##__VA_ARGS__" will delete the leading comma, but it
572  * does not work when __VA_ARGS__ is the first argument. Instead, 1 is returned instead of 0:
573  *
574  * VA_NARGS() ->                              v
575  * VA_NARGS1(  ,  8,  7,  6,  5,  4,  3,  2,  1,  0) ->
576  * VA_NARGS1(_1, _2, _3, _4, _5, _6, _7, _8,  N) -> 1
577  */
578 #define VA_NARGS(...) VA_NARGS1(__VA_ARGS__, 8, 7, 6, 5, 4, 3, 2, 1, 0)
579 #define VA_NARGS1(_1, _2, _3, _4, _5, _6, _7, _8, N, ...) N
580
581 /*! \def FLDSET(type, ...)
582  * \brief Convert a struct and list of fields to an argument list of field offsets
583  * \param type The type with the fields (e.g. "struct my_struct")
584  * \param varags The fields in the struct whose offsets are needed as arguments
585  *
586  * For example:
587  * \code
588  * struct foo {int a, char b[128], char *c};
589  * FLDSET(struct foo, a, c)
590  * \endcode
591  *
592  * produces
593  * \code
594  * offsetof(struct foo, a), offsetof(struct foo, c)
595  * \endcode
596  */
597 #define FLDSET(type, ...) FLDSET1(type, ##__VA_ARGS__)
598 #define FLDSET1(type, ...) POPPED(ARGMAP(offsetof, type, ##__VA_ARGS__))
599
600 /*! \def STRFLDSET(type, ...)
601  * \brief Convert a struct and a list of stringfield fields to an argument list of field offsets
602  * \note Stringfields require the passing of the field manager pool, and field manager to the
603  * default stringfield option handler, so registering options that point to stringfields requires
604  * this macro to be called instead of the FLDSET macro.
605  * \param type The type with the fields (e.g. "struct my_struct")
606  * \param varargs The fields in the struct whose offsets are needed as arguments
607  */
608 #define STRFLDSET(type, ...) FLDSET(type, __VA_ARGS__, __field_mgr_pool, __field_mgr)
609
610 /*! \def POPPED(...)
611  * \brief A list of arguments without the first argument
612  * \note Used internally to remove the leading "number of arguments" argument from ARGMAP for
613  * FLDSET. This is because a call to FLDSET may be followed by additional arguments in
614  * aco_register_option, so the true number of arguments will possibly be different than what
615  * ARGMAP returns.
616  * \params varags A list of arguments
617  *
618  * POPPED(a, b, c) -> b, c
619  */
620 #define POPPED(...) POPPED1(__VA_ARGS__)
621 #define POPPED1(x, ...) __VA_ARGS__
622
623 #if defined(__cplusplus) || defined(c_plusplus)
624 }
625 #endif
626
627 #endif /* _ASTERISK_CONFIG_OPTIONS_H */