Add Doxygen documentation for API changes from 1.6.0 to 1.6.1
[asterisk/asterisk.git] / include / asterisk / config.h
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2005, 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 File Parser
21  */
22
23 #ifndef _ASTERISK_CONFIG_H
24 #define _ASTERISK_CONFIG_H
25
26 #if defined(__cplusplus) || defined(c_plusplus)
27 extern "C" {
28 #endif
29
30 #include "asterisk/utils.h"
31 #include "asterisk/inline_api.h"
32
33 struct ast_config;
34
35 struct ast_category;
36
37 /*! Options for ast_config_load()
38  */
39 enum {
40         /*! Load the configuration, including comments */
41         CONFIG_FLAG_WITHCOMMENTS  = (1 << 0),
42         /*! On a reload, give us a -1 if the file hasn't changed. */
43         CONFIG_FLAG_FILEUNCHANGED = (1 << 1),
44         /*! Don't attempt to cache mtime on this config file. */
45         CONFIG_FLAG_NOCACHE       = (1 << 2),
46 };
47
48 #define CONFIG_STATUS_FILEMISSING       (void *)0
49 #define CONFIG_STATUS_FILEUNCHANGED     (void *)-1
50 #define CONFIG_STATUS_FILEINVALID       (void *)-2
51
52 /*!
53  * \brief Types used in ast_realtime_require_field
54  */
55 typedef enum {
56         RQ_INTEGER1,
57         RQ_UINTEGER1,
58         RQ_INTEGER2,
59         RQ_UINTEGER2,
60         RQ_INTEGER3,
61         RQ_UINTEGER3,
62         RQ_INTEGER4,
63         RQ_UINTEGER4,
64         RQ_INTEGER8,
65         RQ_UINTEGER8,
66         RQ_CHAR,
67         RQ_FLOAT,
68         RQ_DATE,
69         RQ_DATETIME,
70 } require_type;
71
72 /*! \brief Structure for variables, used for configurations and for channel variables
73 */
74 struct ast_variable {
75         const char *name;
76         const char *value;
77         struct ast_variable *next;
78
79         char *file;
80
81         int lineno;
82         int object;             /*!< 0 for variable, 1 for object */
83         int blanklines;         /*!< Number of blanklines following entry */
84         struct ast_comment *precomments;
85         struct ast_comment *sameline;
86         struct ast_comment *trailing; /*!< the last object in the list will get assigned any trailing comments when EOF is hit */
87         char stuff[0];
88 };
89
90 typedef struct ast_config *config_load_func(const char *database, const char *table, const char *configfile, struct ast_config *config, struct ast_flags flags, const char *suggested_include_file, const char *who_asked);
91 typedef struct ast_variable *realtime_var_get(const char *database, const char *table, va_list ap);
92 typedef struct ast_config *realtime_multi_get(const char *database, const char *table, va_list ap);
93 typedef int realtime_update(const char *database, const char *table, const char *keyfield, const char *entity, va_list ap);
94 typedef int realtime_update2(const char *database, const char *table, va_list ap);
95 typedef int realtime_store(const char *database, const char *table, va_list ap);
96 typedef int realtime_destroy(const char *database, const char *table, const char *keyfield, const char *entity, va_list ap);
97
98 /*!
99  * \brief Function pointer called to ensure database schema is properly configured for realtime use
100  * \since 1.6.1
101  */
102 typedef int realtime_require(const char *database, const char *table, va_list ap);
103
104 /*!
105  * \brief Function pointer called to clear the database cache and free resources used for such
106  * \since 1.6.1
107  */
108 typedef int realtime_unload(const char *database, const char *table);
109
110 /*! \brief Configuration engine structure, used to define realtime drivers */
111 struct ast_config_engine {
112         char *name;
113         config_load_func *load_func;
114         realtime_var_get *realtime_func;
115         realtime_multi_get *realtime_multi_func;
116         realtime_update *update_func;
117         realtime_update2 *update2_func;
118         realtime_store *store_func;
119         realtime_destroy *destroy_func;
120         realtime_require *require_func;
121         realtime_unload *unload_func;
122         struct ast_config_engine *next;
123 };
124
125 /*! \brief Load a config file
126  * \param filename path of file to open.  If no preceding '/' character, path is considered relative to AST_CONFIG_DIR
127  * Create a config structure from a given configuration file.
128  * \param who_asked The module which is making this request.
129  * \param flags Optional flags:
130  * CONFIG_FLAG_WITHCOMMENTS - load the file with comments intact;
131  * CONFIG_FLAG_FILEUNCHANGED - check the file mtime and return CONFIG_STATUS_FILEUNCHANGED if the mtime is the same; or
132  * CONFIG_FLAG_NOCACHE - don't cache file mtime (main purpose of this option is to save memory on temporary files).
133  *
134  * \return an ast_config data structure on success
135  * \retval NULL on error
136  */
137 struct ast_config *ast_config_load2(const char *filename, const char *who_asked, struct ast_flags flags);
138
139 #define ast_config_load(filename, flags)        ast_config_load2(filename, AST_MODULE, flags)
140
141 /*! \brief Destroys a config
142  * \param config pointer to config data structure
143  * Free memory associated with a given config
144  *
145  */
146 void ast_config_destroy(struct ast_config *config);
147
148 /*! \brief returns the root ast_variable of a config
149  * \param config pointer to an ast_config data structure
150  * \param cat name of the category for which you want the root
151  *
152  * Returns the category specified
153  */
154 struct ast_variable *ast_category_root(struct ast_config *config, char *cat);
155
156 /*! \brief Goes through categories
157  * \param config Which config structure you wish to "browse"
158  * \param prev A pointer to a previous category.
159  * This function is kind of non-intuitive in it's use.  To begin, one passes NULL as the second argument.  It will return a pointer to the string of the first category in the file.  From here on after, one must then pass the previous usage's return value as the second pointer, and it will return a pointer to the category name afterwards.
160  *
161  * \retval a category on success
162  * \retval NULL on failure/no-more-categories
163  */
164 char *ast_category_browse(struct ast_config *config, const char *prev);
165
166 /*!
167  * \brief Goes through variables
168  * Somewhat similar in intent as the ast_category_browse.
169  * List variables of config file category
170  *
171  * \retval ast_variable list on success
172  * \retval NULL on failure
173  */
174 struct ast_variable *ast_variable_browse(const struct ast_config *config, const char *category);
175
176 /*!
177  * \brief given a pointer to a category, return the root variable.
178  * This is equivalent to ast_variable_browse(), but more efficient if we
179  * already have the struct ast_category * (e.g. from ast_category_get())
180  */
181 struct ast_variable *ast_category_first(struct ast_category *cat);
182
183 /*!
184  * \brief Gets a variable
185  * \param config which (opened) config to use
186  * \param category category under which the variable lies
187  * \param variable which variable you wish to get the data for
188  * Goes through a given config file in the given category and searches for the given variable
189  *
190  * \retval The variable value on success
191  * \retval NULL if unable to find it.
192  */
193 const char *ast_variable_retrieve(const struct ast_config *config, const char *category, const char *variable);
194
195 /*!
196  * \brief Retrieve a category if it exists
197  * \param config which config to use
198  * \param category_name name of the category you're looking for
199  * This will search through the categories within a given config file for a match.
200  *
201  * \retval pointer to category if found
202  * \retval NULL if not.
203  */
204 struct ast_category *ast_category_get(const struct ast_config *config, const char *category_name);
205
206 /*!
207  * \brief Check for category duplicates
208  * \param config which config to use
209  * \param category_name name of the category you're looking for
210  * This will search through the categories within a given config file for a match.
211  *
212  * \return non-zero if found
213  */
214 int ast_category_exist(const struct ast_config *config, const char *category_name);
215
216 /*!
217  * \brief Retrieve realtime configuration
218  * \param family which family/config to lookup
219  * This will use builtin configuration backends to look up a particular
220  * entity in realtime and return a variable list of its parameters.  Note
221  * that unlike the variables in ast_config, the resulting list of variables
222  * MUST be freed with ast_variables_destroy() as there is no container.
223  *
224  * The difference between these two calls is that ast_load_realtime excludes
225  * fields whose values are NULL, while ast_load_realtime_all loads all columns.
226  *
227  * Note that you should use the constant SENTINEL to terminate arguments, in
228  * order to preserve cross-platform compatibility.
229  */
230 struct ast_variable *ast_load_realtime(const char *family, ...) attribute_sentinel;
231 struct ast_variable *ast_load_realtime_all(const char *family, ...) attribute_sentinel;
232
233 /*!
234  * \brief Release any resources cached for a realtime family
235  * \param family which family/config to destroy
236  * Various backends may cache attributes about a realtime data storage
237  * facility; on reload, a front end resource may request to purge that cache.
238  * \retval 0 If any cache was purged
239  * \retval -1 If no cache was found
240  * \since 1.6.1
241  */
242 int ast_unload_realtime(const char *family);
243
244 /*!
245  * \brief Inform realtime what fields that may be stored
246  * \param family which family/config is referenced
247  * This will inform builtin configuration backends that particular fields
248  * may be updated during the use of that configuration section.  This is
249  * mainly to be used during startup routines, to ensure that various fields
250  * exist in the backend.  The backends may take various actions, such as
251  * creating new fields in the data store or warning the administrator that
252  * new fields may need to be created, in order to ensure proper function.
253  *
254  * The arguments are specified in groups of 3:  column name, column type,
255  * and column size.  The column types are specified as integer constants,
256  * defined by the enum require_type.  Note that the size is specified as
257  * the number of equivalent character fields that a field may take up, even
258  * if a field is otherwise specified as an integer type.  This is due to
259  * the fact that some fields have historically been specified as character
260  * types, even if they contained integer values.
261  *
262  * A family should always specify its fields to the minimum necessary
263  * requirements to fulfill all possible values (within reason; for example,
264  * a timeout value may reasonably be specified as an INTEGER2, with size 5.
265  * Even though values above 32767 seconds are possible, they are unlikely
266  * to be useful, and we should not complain about that size).
267  *
268  * \retval 0 Required fields met specified standards
269  * \retval -1 One or more fields was missing or insufficient
270  *
271  * Note that you should use the constant SENTINEL to terminate arguments, in
272  * order to preserve cross-platform compatibility.
273  *
274  * \since 1.6.1
275  */
276 int ast_realtime_require_field(const char *family, ...) attribute_sentinel;
277
278 /*!
279  * \brief Retrieve realtime configuration
280  * \param family which family/config to lookup
281  *
282  * This will use builtin configuration backends to look up a particular
283  * entity in realtime and return a variable list of its parameters. Unlike
284  * the ast_load_realtime, this function can return more than one entry and
285  * is thus stored inside a traditional ast_config structure rather than
286  * just returning a linked list of variables.
287  *
288  * Note that you should use the constant SENTINEL to terminate arguments, in
289  * order to preserve cross-platform compatibility.
290  */
291 struct ast_config *ast_load_realtime_multientry(const char *family, ...) attribute_sentinel;
292
293 /*!
294  * \brief Update realtime configuration
295  * \param family which family/config to be updated
296  * \param keyfield which field to use as the key
297  * \param lookup which value to look for in the key field to match the entry.
298  * This function is used to update a parameter in realtime configuration space.
299  * \return Number of rows affected, or -1 on error.
300  *
301  * Note that you should use the constant SENTINEL to terminate arguments, in
302  * order to preserve cross-platform compatibility.
303  */
304 int ast_update_realtime(const char *family, const char *keyfield, const char *lookup, ...) attribute_sentinel;
305
306 /*!
307  * \brief Update realtime configuration
308  * \param family which family/config to be updated
309  * This function is used to update a parameter in realtime configuration space.
310  * It includes the ability to lookup a row based upon multiple key criteria.
311  * As a result, this function includes two sentinel values, one to terminate
312  * lookup values and the other to terminate the listing of fields to update.
313  * \return Number of rows affected, or -1 on error.
314  *
315  * Note that you should use the constant SENTINEL to terminate arguments, in
316  * order to preserve cross-platform compatibility.
317  */
318 int ast_update2_realtime(const char *family, ...) attribute_sentinel;
319
320 /*!
321  * \brief Create realtime configuration
322  * \param family which family/config to be created
323  * This function is used to create a parameter in realtime configuration space.
324  * \return Number of rows affected, or -1 on error.
325  * On the MySQL engine only, for reasons of backwards compatibility, the return
326  * value is the insert ID.  This value is nonportable and may be changed in a
327  * future version to match the other engines.
328  *
329  * Note that you should use the constant SENTINEL to terminate arguments, in
330  * order to preserve cross-platform compatibility.
331  */
332 int ast_store_realtime(const char *family, ...) attribute_sentinel;
333
334 /*!
335  * \brief Destroy realtime configuration
336  * \param family which family/config to be destroyed
337  * \param keyfield which field to use as the key
338  * \param lookup which value to look for in the key field to match the entry.
339  * This function is used to destroy an entry in realtime configuration space.
340  * Additional params are used as keys.
341  * \return Number of rows affected, or -1 on error.
342  *
343  * Note that you should use the constant SENTINEL to terminate arguments, in
344  * order to preserve cross-platform compatibility.
345  */
346 int ast_destroy_realtime(const char *family, const char *keyfield, const char *lookup, ...) attribute_sentinel;
347
348 /*!
349  * \brief Check if realtime engine is configured for family
350  * \param family which family/config to be checked
351  * \return 1 if family is configured in realtime and engine exists
352 */
353 int ast_check_realtime(const char *family);
354
355 /*! \brief Check if there's any realtime engines loaded */
356 int ast_realtime_enabled(void);
357
358 /*! \brief Free variable list
359  * \param var the linked list of variables to free
360  * This function frees a list of variables.
361  */
362 void ast_variables_destroy(struct ast_variable *var);
363
364 /*! \brief Register config engine
365  * \retval 1 Always
366  */
367 int ast_config_engine_register(struct ast_config_engine *newconfig);
368
369 /*! \brief Deregister config engine
370  * \retval 0 Always
371  */
372 int ast_config_engine_deregister(struct ast_config_engine *del);
373
374 /*!\brief Exposed initialization method for core process
375  * This method is intended for use only with the core initialization and is
376  * not designed to be called from any user applications.
377  */
378 int register_config_cli(void);
379
380 /*!\brief Exposed re-initialization method for core process
381  * This method is intended for use only with the core re-initialization and is
382  * not designed to be called from any user applications.
383  */
384 int read_config_maps(void);
385
386 /*!\brief Create a new base configuration structure */
387 struct ast_config *ast_config_new(void);
388
389 /*!\brief Retrieve the current category name being built.
390  * API for backend configuration engines while building a configuration set.
391  */
392 struct ast_category *ast_config_get_current_category(const struct ast_config *cfg);
393
394 /*!\brief Set the category within the configuration as being current.
395  * API for backend configuration engines while building a configuration set.
396  */
397 void ast_config_set_current_category(struct ast_config *cfg, const struct ast_category *cat);
398
399 /*!\brief Retrieve a configuration variable within the configuration set.
400  * Retrieves the named variable \p var within category \p cat of configuration
401  * set \p cfg.  If not found, attempts to retrieve the named variable \p var
402  * from within category \em general.
403  * \return Value of \p var, or NULL if not found.
404  */
405 const char *ast_config_option(struct ast_config *cfg, const char *cat, const char *var);
406
407 /*!\brief Create a category structure */
408 struct ast_category *ast_category_new(const char *name, const char *in_file, int lineno);
409 void ast_category_append(struct ast_config *config, struct ast_category *cat);
410
411 /*!
412  * \brief Inserts new category
413  * \param config which config to use
414  * \param cat newly created category to insert
415  * \param match which category to insert above
416  * This function is used to insert a new category above another category
417  * matching the match parameter.
418  */
419 void ast_category_insert(struct ast_config *config, struct ast_category *cat, const char *match);
420 int ast_category_delete(struct ast_config *cfg, const char *category);
421
422 /*!\brief Removes and destroys all variables within a category
423  * \retval 0 if the category was found and emptied
424  * \retval -1 if the category was not found
425  */
426 int ast_category_empty(struct ast_config *cfg, const char *category);
427 void ast_category_destroy(struct ast_category *cat);
428 struct ast_variable *ast_category_detach_variables(struct ast_category *cat);
429 void ast_category_rename(struct ast_category *cat, const char *name);
430
431 #ifdef MALLOC_DEBUG
432 struct ast_variable *_ast_variable_new(const char *name, const char *value, const char *filename, const char *file, const char *function, int lineno);
433 #define ast_variable_new(a, b, c) _ast_variable_new(a, b, c, __FILE__, __PRETTY_FUNCTION__, __LINE__)
434 #else
435 struct ast_variable *ast_variable_new(const char *name, const char *value, const char *filename);
436 #endif
437 struct ast_config_include *ast_include_new(struct ast_config *conf, const char *from_file, const char *included_file, int is_exec, const char *exec_file, int from_lineno, char *real_included_file_name, int real_included_file_name_size);
438 struct ast_config_include *ast_include_find(struct ast_config *conf, const char *included_file);
439 void ast_include_rename(struct ast_config *conf, const char *from_file, const char *to_file);
440 void ast_variable_append(struct ast_category *category, struct ast_variable *variable);
441 void ast_variable_insert(struct ast_category *category, struct ast_variable *variable, const char *line);
442 int ast_variable_delete(struct ast_category *category, const char *variable, const char *match, const char *line);
443
444 /*! \brief Update variable value within a config
445  * \param category Category element within the config
446  * \param variable Name of the variable to change
447  * \param value New value of the variable
448  * \param match If set, previous value of the variable (if NULL or zero-length, no matching will be done)
449  * \param object Boolean of whether to make the new variable an object
450  * \return 0 on success or -1 on failure.
451  */
452 int ast_variable_update(struct ast_category *category, const char *variable,
453                                                 const char *value, const char *match, unsigned int object);
454
455 int ast_config_text_file_save(const char *filename, const struct ast_config *cfg, const char *generator);
456 int config_text_file_save(const char *filename, const struct ast_config *cfg, const char *generator) __attribute__((deprecated));
457
458 struct ast_config *ast_config_internal_load(const char *configfile, struct ast_config *cfg, struct ast_flags flags, const char *suggested_incl_file, const char *who_asked);
459
460 /*! \brief Support code to parse config file arguments
461  *
462  * The function ast_parse_arg() provides a generic interface to parse
463  * strings (e.g. numbers, network addresses and so on) in a flexible
464  * way, e.g. by doing proper error and bound checks, provide default
465  * values, and so on.
466  * The function (described later) takes a string as an argument,
467  * a set of flags to specify the result format and checks to perform,
468  * a pointer to the result, and optionally some additional arguments.
469  * It returns 0 on success, != 0 otherwise.
470  *
471  */
472 enum ast_parse_flags {
473         /* low 4 bits of flags are used for the operand type */
474         PARSE_TYPE      =       0x000f,
475         /* numeric types, with optional default value and bound checks.
476          * Additional arguments are passed by value.
477          */
478         PARSE_INT32     =       0x0001,
479         PARSE_UINT32    =       0x0002,
480         PARSE_DOUBLE    =       0x0003,
481 #if 0   /* not supported yet */
482         PARSE_INT16     =       0x0004,
483         PARSE_UINT16    =       0x0005,
484 #endif
485         /* Returns a struct sockaddr_in, with optional default value
486          * (passed by reference) and port handling (accept, ignore,
487          * require, forbid). The format is 'host.name[:port]'
488          */
489         PARSE_INADDR    =       0x000f,
490
491         /* Other data types can be added as needed */
492
493         /* If PARSE_DEFAULT is set, next argument is a default value
494          * which is returned in case of error. The argument is passed
495          * by value in case of numeric types, by reference in other cases.
496          */
497         PARSE_DEFAULT   =       0x0010, /* assign default on error */
498
499         /* Request a range check, applicable to numbers. Two additional
500          * arguments are passed by value, specifying the low-high end of
501          * the range (inclusive). An error is returned if the value
502          * is outside or inside the range, respectively.
503          */
504         PARSE_IN_RANGE =        0x0020, /* accept values inside a range */
505         PARSE_OUT_RANGE =       0x0040, /* accept values outside a range */
506
507         /* Port handling, for sockaddr_in. accept/ignore/require/forbid
508          * port number after the hostname or address.
509          */
510         PARSE_PORT_MASK =       0x0300, /* 0x000: accept port if present */
511         PARSE_PORT_IGNORE =     0x0100, /* 0x100: ignore port if present */
512         PARSE_PORT_REQUIRE =    0x0200, /* 0x200: require port number */
513         PARSE_PORT_FORBID =     0x0300, /* 0x100: forbid port number */
514 };
515
516 /*! \brief The argument parsing routine.
517  * \param arg the string to parse. It is not modified.
518  * \param flags combination of ast_parse_flags to specify the
519  *      return type and additional checks.
520  * \param result pointer to the result. NULL is valid here, and can
521  *      be used to perform only the validity checks.
522  * \param ... extra arguments are required according to flags.
523  * \retval 0 in case of success, != 0 otherwise.
524  * \retval result returns the parsed value in case of success,
525  *      the default value in case of error, or it is left unchanged
526  *      in case of error and no default specified. Note that in certain
527  *      cases (e.g. sockaddr_in, with multi-field return values) some
528  *      of the fields in result may be changed even if an error occurs.
529  *
530  * Examples of use:
531  *      ast_parse_arg("223", PARSE_INT32|PARSE_IN_RANGE,
532  *              &a, -1000, 1000);
533  *              returns 0, a = 223
534  *      ast_parse_arg("22345", PARSE_INT32|PARSE_IN_RANGE|PARSE_DEFAULT,
535  *              &a, 9999, 10, 100);
536  *              returns 1, a = 9999
537  *      ast_parse_arg("22345ssf", PARSE_UINT32|PARSE_IN_RANGE, &b, 10, 100);
538  *              returns 1, b unchanged
539  *      ast_parse_arg("www.foo.biz:44", PARSE_INADDR, &sa);
540  *              returns 0, sa contains address and port
541  *      ast_parse_arg("www.foo.biz", PARSE_INADDR|PARSE_PORT_REQUIRE, &sa);
542  *              returns 1 because port is missing, sa contains address
543  */
544 int ast_parse_arg(const char *arg, enum ast_parse_flags flags,
545         void *result, ...);
546
547 /*
548  * Parsing config file options in C is slightly annoying because we cannot use
549  * string in a switch() statement, yet we need a similar behaviour, with many
550  * branches and a break on a matching one.
551  * The following somehow simplifies the job: we create a block using
552  * the  CV_START and CV_END macros, and then within the block we can run
553  * actions such as "if (condition) { body; break; }"
554  * Additional macros are present to run simple functions (e.g. ast_copy_string)
555  * or to pass arguments to ast_parse_arg()
556  *
557  * As an example:
558
559         CV_START(v->name, v->value);    // start the block
560         CV_STR("foo", x_foo);           // static string
561         CV_DSTR("bar", y_bar);          // malloc'ed string
562         CV_F("bar", ...);               // call a generic function
563         CV_END;                         // end the block
564  */
565
566 /*! \brief the macro to open a block for variable parsing */
567 #define CV_START(__in_var, __in_val)            \
568         do {                                    \
569                 const char *__var = __in_var;   \
570                 const char *__val = __in_val;
571
572 /*! \brief close a variable parsing block */
573 #define CV_END                  } while (0)
574
575 /*! \brief call a generic function if the name matches. */
576 #define CV_F(__pattern, __body) if (!strcasecmp((__var), __pattern)) { __body; break; }
577
578 /*! \brief helper macros to assign the value to a BOOL, UINT, static string and
579  * dynamic string
580  */
581 #define CV_BOOL(__x, __dst)     CV_F(__x, (__dst) = ast_true(__val) )
582 #define CV_UINT(__x, __dst)     CV_F(__x, (__dst) = strtoul(__val, NULL, 0) )
583 #define CV_STR(__x, __dst)      CV_F(__x, ast_copy_string(__dst, __val, sizeof(__dst)))
584 #define CV_DSTR(__x, __dst)     CV_F(__x, if (__dst) ast_free(__dst); __dst = ast_strdup(__val))
585 #define CV_STRFIELD(__x, __obj, __field) CV_F(__x, ast_string_field_set(__obj, __field, __val))
586
587 /*!\brief Check if require type is an integer type */
588 AST_INLINE_API(
589 int ast_rq_is_int(require_type type),
590 {
591         switch (type) {
592         case RQ_INTEGER1:
593         case RQ_UINTEGER1:
594         case RQ_INTEGER2:
595         case RQ_UINTEGER2:
596         case RQ_INTEGER3:
597         case RQ_UINTEGER3:
598         case RQ_INTEGER4:
599         case RQ_UINTEGER4:
600         case RQ_INTEGER8:
601         case RQ_UINTEGER8:
602                 return 1;
603         default:
604                 return 0;
605         }
606 }
607 )
608
609 #if defined(__cplusplus) || defined(c_plusplus)
610 }
611 #endif
612
613 #endif /* _ASTERISK_CONFIG_H */