8c9a1d3beb0a1a4870e47cddcc415f2f1d03774f
[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_store(const char *database, const char *table, va_list ap);
95 typedef int realtime_destroy(const char *database, const char *table, const char *keyfield, const char *entity, va_list ap);
96 typedef int realtime_require(const char *database, const char *table, va_list ap);
97 typedef int realtime_unload(const char *database, const char *table);
98
99 /*! \brief Configuration engine structure, used to define realtime drivers */
100 struct ast_config_engine {
101         char *name;
102         config_load_func *load_func;
103         realtime_var_get *realtime_func;
104         realtime_multi_get *realtime_multi_func;
105         realtime_update *update_func;
106         realtime_store *store_func;
107         realtime_destroy *destroy_func;
108         realtime_require *require_func;
109         realtime_unload *unload_func;
110         struct ast_config_engine *next;
111 };
112
113 /*! \brief Load a config file 
114  * \param filename path of file to open.  If no preceding '/' character, path is considered relative to AST_CONFIG_DIR
115  * Create a config structure from a given configuration file.
116  * \param who_asked The module which is making this request.
117  * \param flags Optional flags:
118  * CONFIG_FLAG_WITHCOMMENTS - load the file with comments intact;
119  * CONFIG_FLAG_FILEUNCHANGED - check the file mtime and return CONFIG_STATUS_FILEUNCHANGED if the mtime is the same; or
120  * CONFIG_FLAG_NOCACHE - don't cache file mtime (main purpose of this option is to save memory on temporary files).
121  *
122  * \retval an ast_config data structure on success
123  * \retval NULL on error
124  */
125 struct ast_config *ast_config_load2(const char *filename, const char *who_asked, struct ast_flags flags);
126
127 #define ast_config_load(filename, flags)        ast_config_load2(filename, AST_MODULE, flags)
128
129 /*! \brief Destroys a config 
130  * \param config pointer to config data structure
131  * Free memory associated with a given config
132  *
133  */
134 void ast_config_destroy(struct ast_config *config);
135
136 /*! \brief returns the root ast_variable of a config
137  * \param config pointer to an ast_config data structure
138  * \param cat name of the category for which you want the root
139  *
140  * Returns the category specified
141  */
142 struct ast_variable *ast_category_root(struct ast_config *config, char *cat);
143
144 /*! \brief Goes through categories 
145  * \param config Which config structure you wish to "browse"
146  * \param prev A pointer to a previous category.
147  * 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.
148  *
149  * \retval a category on success
150  * \retval NULL on failure/no-more-categories
151  */
152 char *ast_category_browse(struct ast_config *config, const char *prev);
153
154 /*! 
155  * \brief Goes through variables
156  * Somewhat similar in intent as the ast_category_browse.
157  * List variables of config file category
158  *
159  * \retval ast_variable list on success
160  * \retval NULL on failure
161  */
162 struct ast_variable *ast_variable_browse(const struct ast_config *config, const char *category);
163
164 /*!
165  * \brief given a pointer to a category, return the root variable.
166  * This is equivalent to ast_variable_browse(), but more efficient if we
167  * already have the struct ast_category * (e.g. from ast_category_get())
168  */
169 struct ast_variable *ast_category_first(struct ast_category *cat);
170
171 /*! 
172  * \brief Gets a variable 
173  * \param config which (opened) config to use
174  * \param category category under which the variable lies
175  * \param variable which variable you wish to get the data for
176  * Goes through a given config file in the given category and searches for the given variable
177  *
178  * \retval The variable value on success 
179  * \retval NULL if unable to find it.
180  */
181 const char *ast_variable_retrieve(const struct ast_config *config, const char *category, const char *variable);
182
183 /*! 
184  * \brief Retrieve a category if it exists
185  * \param config which config to use
186  * \param category_name name of the category you're looking for
187  * This will search through the categories within a given config file for a match.
188  *
189  * \retval pointer to category if found
190  * \retval NULL if not.
191  */
192 struct ast_category *ast_category_get(const struct ast_config *config, const char *category_name);
193
194 /*! 
195  * \brief Check for category duplicates 
196  * \param config which config to use
197  * \param category_name name of the category you're looking for
198  * This will search through the categories within a given config file for a match.
199  *
200  * \return non-zero if found
201  */
202 int ast_category_exist(const struct ast_config *config, const char *category_name);
203
204 /*! 
205  * \brief Retrieve realtime configuration 
206  * \param family which family/config to lookup
207  * This will use builtin configuration backends to look up a particular 
208  * entity in realtime and return a variable list of its parameters.  Note
209  * that unlike the variables in ast_config, the resulting list of variables
210  * MUST be freed with ast_variables_destroy() as there is no container.
211  */
212 struct ast_variable *ast_load_realtime(const char *family, ...) attribute_sentinel;
213 struct ast_variable *ast_load_realtime_all(const char *family, ...) attribute_sentinel;
214
215 /*!
216  * \brief Release any resources cached for a realtime family
217  * \param family which family/config to destroy
218  * Various backends may cache attributes about a realtime data storage
219  * facility; on reload, a front end resource may request to purge that cache.
220  */
221 int ast_unload_realtime(const char *family);
222
223 /*!
224  * \brief Inform realtime what fields that may be stored
225  * \param family which family/config is referenced
226  * This will inform builtin configuration backends that particular fields
227  * may be updated during the use of that configuration section.  This is
228  * mainly to be used during startup routines, to ensure that various fields
229  * exist in the backend.  The backends may take various actions, such as
230  * creating new fields in the data store or warning the administrator that
231  * new fields may need to be created, in order to ensure proper function.
232  *
233  * The arguments are specified in groups of 3:  column name, column type,
234  * and column size.  The column types are specified as integer constants,
235  * defined by the enum require_type.  Note that the size is specified as
236  * the number of equivalent character fields that a field may take up, even
237  * if a field is otherwise specified as an integer type.  This is due to
238  * the fact that some fields have historically been specified as character
239  * types, even if they contained integer values.
240  *
241  * A family should always specify its fields to the minimum necessary
242  * requirements to fulfill all possible values (within reason; for example,
243  * a timeout value may reasonably be specified as an INTEGER2, with size 5.
244  * Even though values above 32767 seconds are possible, they are unlikely
245  * to be useful, and we should not complain about that size).
246  */
247 int ast_realtime_require_field(const char *family, ...) attribute_sentinel;
248
249 /*! 
250  * \brief Retrieve realtime configuration 
251  * \param family which family/config to lookup
252  * This will use builtin configuration backends to look up a particular 
253  * entity in realtime and return a variable list of its parameters. Unlike
254  * the ast_load_realtime, this function can return more than one entry and
255  * is thus stored inside a taditional ast_config structure rather than 
256  * just returning a linked list of variables.
257  */
258 struct ast_config *ast_load_realtime_multientry(const char *family, ...) attribute_sentinel;
259
260 /*! 
261  * \brief Update realtime configuration 
262  * \param family which family/config to be updated
263  * \param keyfield which field to use as the key
264  * \param lookup which value to look for in the key field to match the entry.
265  * This function is used to update a parameter in realtime configuration space.
266  *
267  */
268 int ast_update_realtime(const char *family, const char *keyfield, const char *lookup, ...) attribute_sentinel;
269
270 /*! 
271  * \brief Create realtime configuration 
272  * \param family which family/config to be created
273  * This function is used to create a parameter in realtime configuration space.
274  *
275  */
276 int ast_store_realtime(const char *family, ...) attribute_sentinel;
277
278 /*! 
279  * \brief Destroy realtime configuration 
280  * \param family which family/config to be destroyed
281  * \param keyfield which field to use as the key
282  * \param lookup which value to look for in the key field to match the entry.
283  * This function is used to destroy an entry in realtime configuration space.
284  * Additional params are used as keys.
285  *
286  */
287 int ast_destroy_realtime(const char *family, const char *keyfield, const char *lookup, ...) attribute_sentinel;
288
289 /*! 
290  * \brief Check if realtime engine is configured for family 
291  * \param family which family/config to be checked
292  * \return 1 if family is configured in realtime and engine exists
293 */
294 int ast_check_realtime(const char *family);
295
296 /*! \brief Check if there's any realtime engines loaded */
297 int ast_realtime_enabled(void);
298
299 /*! \brief Free variable list 
300  * \param var the linked list of variables to free
301  * This function frees a list of variables.
302  */
303 void ast_variables_destroy(struct ast_variable *var);
304
305 /*! \brief Register config engine */
306 int ast_config_engine_register(struct ast_config_engine *newconfig);
307
308 /*! \brief Deegister config engine */
309 int ast_config_engine_deregister(struct ast_config_engine *del);
310
311 int register_config_cli(void);
312 int read_config_maps(void);
313
314 struct ast_config *ast_config_new(void);
315 struct ast_category *ast_config_get_current_category(const struct ast_config *cfg);
316 void ast_config_set_current_category(struct ast_config *cfg, const struct ast_category *cat);
317 const char *ast_config_option(struct ast_config *cfg, const char *cat, const char *var);
318
319 struct ast_category *ast_category_new(const char *name, const char *in_file, int lineno);
320 void ast_category_append(struct ast_config *config, struct ast_category *cat);
321
322 /*! 
323  * \brief Inserts new category
324  * \param config which config to use
325  * \param cat newly created category to insert
326  * \param match which category to insert above
327  * This function is used to insert a new category above another category
328  * matching the match parameter.
329  */
330 void ast_category_insert(struct ast_config *config, struct ast_category *cat, const char *match);
331 int ast_category_delete(struct ast_config *cfg, const char *category);
332 int ast_category_empty(struct ast_config *cfg, const char *category);
333 void ast_category_destroy(struct ast_category *cat);
334 struct ast_variable *ast_category_detach_variables(struct ast_category *cat);
335 void ast_category_rename(struct ast_category *cat, const char *name);
336
337 struct ast_variable *ast_variable_new(const char *name, const char *value, const char *filename);
338 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);
339 struct ast_config_include *ast_include_find(struct ast_config *conf, const char *included_file);
340 void ast_include_rename(struct ast_config *conf, const char *from_file, const char *to_file);
341 void ast_variable_append(struct ast_category *category, struct ast_variable *variable);
342 void ast_variable_insert(struct ast_category *category, struct ast_variable *variable, const char *line);
343 int ast_variable_delete(struct ast_category *category, const char *variable, const char *match, const char *line);
344
345 /*! \brief Update variable value within a config
346  * \param category Category element within the config
347  * \param variable Name of the variable to change
348  * \param value New value of the variable
349  * \param match If set, previous value of the variable (if NULL or zero-length, no matching will be done)
350  * \param object Boolean of whether to make the new variable an object
351  * \return 0 on success or -1 on failure.
352  */
353 int ast_variable_update(struct ast_category *category, const char *variable, 
354                                                 const char *value, const char *match, unsigned int object);
355
356 int config_text_file_save(const char *filename, const struct ast_config *cfg, const char *generator);
357
358 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);
359
360 /*! \brief Support code to parse config file arguments
361  *
362  * The function ast_parse_arg() provides a generic interface to parse
363  * strings (e.g. numbers, network addresses and so on) in a flexible
364  * way, e.g. by doing proper error and bound checks, provide default
365  * values, and so on.
366  * The function (described later) takes a string as an argument,
367  * a set of flags to specify the result format and checks to perform,
368  * a pointer to the result, and optionally some additional arguments.
369  * It returns 0 on success, != 0 otherwise.
370  *
371  */
372 enum ast_parse_flags {
373         /* low 4 bits of flags are used for the operand type */
374         PARSE_TYPE      =       0x000f,
375         /* numeric types, with optional default value and bound checks.
376          * Additional arguments are passed by value.
377          */
378         PARSE_INT32     =       0x0001,
379         PARSE_UINT32    =       0x0002,
380         PARSE_DOUBLE    =       0x0003,
381 #if 0   /* not supported yet */
382         PARSE_INT16     =       0x0004,
383         PARSE_UINT16    =       0x0005,
384 #endif
385         /* Returns a struct sockaddr_in, with optional default value
386          * (passed by reference) and port handling (accept, ignore,
387          * require, forbid). The format is 'host.name[:port]'
388          */
389         PARSE_INADDR    =       0x000f,
390
391         /* Other data types can be added as needed */
392
393         /* If PARSE_DEFAULT is set, next argument is a default value
394          * which is returned in case of error. The argument is passed
395          * by value in case of numeric types, by reference in other cases.
396          */
397         PARSE_DEFAULT   =       0x0010, /* assign default on error */
398
399         /* Request a range check, applicable to numbers. Two additional
400          * arguments are passed by value, specifying the low-high end of
401          * the range (inclusive). An error is returned if the value
402          * is outside or inside the range, respectively.
403          */
404         PARSE_IN_RANGE =        0x0020, /* accept values inside a range */
405         PARSE_OUT_RANGE =       0x0040, /* accept values outside a range */
406
407         /* Port handling, for sockaddr_in. accept/ignore/require/forbid
408          * port number after the hostname or address.
409          */
410         PARSE_PORT_MASK =       0x0300, /* 0x000: accept port if present */
411         PARSE_PORT_IGNORE =     0x0100, /* 0x100: ignore port if present */
412         PARSE_PORT_REQUIRE =    0x0200, /* 0x200: require port number */
413         PARSE_PORT_FORBID =     0x0300, /* 0x100: forbid port number */
414 };
415
416 /*! \brief The argument parsing routine.
417  * \param arg the string to parse. It is not modified.
418  * \param flags combination of ast_parse_flags to specify the
419  *      return type and additional checks.
420  * \param result pointer to the result. NULL is valid here, and can
421  *      be used to perform only the validity checks.
422  * \param ... extra arguments are required according to flags.
423  * \retval 0 in case of success, != 0 otherwise.
424  * \retval result returns the parsed value in case of success,
425  *      the default value in case of error, or it is left unchanged
426  *      in case of error and no default specified. Note that in certain
427  *      cases (e.g. sockaddr_in, with multi-field return values) some
428  *      of the fields in result may be changed even if an error occurs.
429  *
430  * Examples of use:
431  *      ast_parse_arg("223", PARSE_INT32|PARSE_IN_RANGE,
432  *              &a, -1000, 1000); 
433  *              returns 0, a = 223
434  *      ast_parse_arg("22345", PARSE_INT32|PARSE_IN_RANGE|PARSE_DEFAULT,
435  *              &a, 9999, 10, 100);
436  *              returns 1, a = 9999
437  *      ast_parse_arg("22345ssf", PARSE_UINT32|PARSE_IN_RANGE, &b, 10, 100);
438  *              returns 1, b unchanged
439  *      ast_parse_arg("www.foo.biz:44", PARSE_INADDR, &sa);
440  *              returns 0, sa contains address and port
441  *      ast_parse_arg("www.foo.biz", PARSE_INADDR|PARSE_PORT_REQUIRE, &sa);
442  *              returns 1 because port is missing, sa contains address
443  */
444 int ast_parse_arg(const char *arg, enum ast_parse_flags flags,
445         void *result, ...);
446
447 /*
448  * Parsing config file options in C is slightly annoying because we cannot use
449  * string in a switch() statement, yet we need a similar behaviour, with many
450  * branches and a break on a matching one.
451  * The following somehow simplifies the job: we create a block using
452  * the  CV_START and CV_END macros, and then within the block we can run
453  * actions such as "if (condition) { body; break; }"
454  * Additional macros are present to run simple functions (e.g. ast_copy_string)
455  * or to pass arguments to ast_parse_arg()
456  *
457  * As an example:
458
459         CV_START(v->name, v->value);    // start the block
460         CV_STR("foo", x_foo);           // static string
461         CV_DSTR("bar", y_bar);          // malloc'ed string
462         CV_F("bar", ...);               // call a generic function
463         CV_END;                         // end the block
464  */
465
466 /*! \brief the macro to open a block for variable parsing */
467 #define CV_START(__in_var, __in_val)            \
468         do {                                    \
469                 const char *__var = __in_var;   \
470                 const char *__val = __in_val;
471
472 /*! \brief close a variable parsing block */
473 #define CV_END                  } while (0)
474
475 /*! \brief call a generic function if the name matches. */
476 #define CV_F(__pattern, __body) if (!strcasecmp((__var), __pattern)) { __body; break; }
477
478 /*! \brief helper macros to assign the value to a BOOL, UINT, static string and
479  * dynamic string
480  */
481 #define CV_BOOL(__x, __dst)     CV_F(__x, (__dst) = ast_true(__val) )
482 #define CV_UINT(__x, __dst)     CV_F(__x, (__dst) = strtoul(__val, NULL, 0) )
483 #define CV_STR(__x, __dst)      CV_F(__x, ast_copy_string(__dst, __val, sizeof(__dst)))
484 #define CV_DSTR(__x, __dst)     CV_F(__x, if (__dst) ast_free(__dst); __dst = ast_strdup(__val))
485 #define CV_STRFIELD(__x, __obj, __field) CV_F(__x, ast_string_field_set(__obj, __field, __val))
486
487 AST_INLINE_API(
488 int ast_rq_is_int(require_type type),
489 {
490         switch (type) {
491         case RQ_INTEGER1:
492         case RQ_UINTEGER1:
493         case RQ_INTEGER2:
494         case RQ_UINTEGER2:
495         case RQ_INTEGER3:
496         case RQ_UINTEGER3:
497         case RQ_INTEGER4:
498         case RQ_UINTEGER4:
499         case RQ_INTEGER8:
500         case RQ_UINTEGER8:
501                 return 1;
502         default:
503                 return 0;
504         }
505 }
506 )
507
508 #if defined(__cplusplus) || defined(c_plusplus)
509 }
510 #endif
511
512 #endif /* _ASTERISK_CONFIG_H */