From 918348f03c7e127beadc02d7de8da16f833c120e Mon Sep 17 00:00:00 2001 From: Tilghman Lesher Date: Wed, 15 Aug 2007 21:25:13 +0000 Subject: Missing from murf's last trunk commit, which was why trunk won't compile git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@79623 65c4cc65-6c06-0410-ace0-fbb531ad65f3 --- include/asterisk/extconf.h | 244 ++++++++++++++++++++++++++++++++++++++++ include/asterisk/pval.h | 272 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 516 insertions(+) create mode 100644 include/asterisk/extconf.h create mode 100644 include/asterisk/pval.h (limited to 'include') diff --git a/include/asterisk/extconf.h b/include/asterisk/extconf.h new file mode 100644 index 000000000..f0e919575 --- /dev/null +++ b/include/asterisk/extconf.h @@ -0,0 +1,244 @@ +/* + * Asterisk -- An open source telephony toolkit. + * + * Copyright (C) 2007, Digium, Inc. + * + * Steve Murphy + * + * See http://www.asterisk.org for more information about + * the Asterisk project. Please do not directly contact + * any of the maintainers of this project for assistance; + * the project provides a web site, mailing lists and IRC + * channels for your use. + * + * This program is free software, distributed under the terms of + * the GNU General Public License Version 2. See the LICENSE file + * at the top of the source tree. + */ + +#ifndef _ASTERISK_EXTCONF_H +#define _ASTERISK_EXTCONF_H + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +#ifdef NOTYET +/* I'm going to define all the structs mentioned below, to avoid + possible conflicts in declarations that might be introduced, + if we just include the files that define them-- this may be + unnecessary */ + +struct ast_comment { + struct ast_comment *next; + char cmt[0]; +}; + +struct ast_variable { + char *name; + char *value; + int lineno; + int object; /*!< 0 for variable, 1 for object */ + int blanklines; /*!< Number of blanklines following entry */ + struct ast_comment *precomments; + struct ast_comment *sameline; + struct ast_variable *next; + char stuff[0]; +}; + +struct ast_category { + char name[80]; + int ignored; /*!< do not let user of the config see this category */ + int include_level; + struct ast_comment *precomments; + struct ast_comment *sameline; + struct ast_variable *root; + struct ast_variable *last; + struct ast_category *next; +}; + +struct ast_config { + struct ast_category *root; + struct ast_category *last; + struct ast_category *current; + struct ast_category *last_browse; /*!< used to cache the last category supplied via category_browse */ + int include_level; + int max_include_level; +}; + +/* ================== above: the config world; below, the dialplan world */ + +/*! \brief ast_app: A registered application */ +struct ast_app { + int (*execute)(struct ast_channel *chan, void *data); + const char *synopsis; /*!< Synopsis text for 'show applications' */ + const char *description; /*!< Description (help text) for 'show application <name>' */ + AST_RWLIST_ENTRY(ast_app) list; /*!< Next app in list */ + void *module; /*!< Module this app belongs to */ + char name[0]; /*!< Name of the application */ +}; +/*! + \brief ast_exten: An extension + The dialplan is saved as a linked list with each context + having it's own linked list of extensions - one item per + priority. +*/ +struct ast_exten { + char *exten; /*!< Extension name */ + int matchcid; /*!< Match caller id ? */ + const char *cidmatch; /*!< Caller id to match for this extension */ + int priority; /*!< Priority */ + const char *label; /*!< Label */ + struct ast_context *parent; /*!< The context this extension belongs to */ + const char *app; /*!< Application to execute */ + struct ast_app *cached_app; /*!< Cached location of application */ + void *data; /*!< Data to use (arguments) */ + void (*datad)(void *); /*!< Data destructor */ + struct ast_exten *peer; /*!< Next higher priority with our extension */ + const char *registrar; /*!< Registrar */ + struct ast_exten *next; /*!< Extension with a greater ID */ + char stuff[0]; +}; +/* from pbx.h */ +typedef int (*ast_state_cb_type)(char *context, char* id, enum ast_extension_states state, void *data); +struct ast_timing { + int hastime; /*!< If time construct exists */ + unsigned int monthmask; /*!< Mask for month */ + unsigned int daymask; /*!< Mask for date */ + unsigned int dowmask; /*!< Mask for day of week (mon-sun) */ + unsigned int minmask[24]; /*!< Mask for minute */ +}; +/*! \brief ast_include: include= support in extensions.conf */ +struct ast_include { + const char *name; + const char *rname; /*!< Context to include */ + const char *registrar; /*!< Registrar */ + int hastime; /*!< If time construct exists */ + struct ast_timing timing; /*!< time construct */ + struct ast_include *next; /*!< Link them together */ + char stuff[0]; +}; + +/*! \brief ast_sw: Switch statement in extensions.conf */ +struct ast_sw { + char *name; + const char *registrar; /*!< Registrar */ + char *data; /*!< Data load */ + int eval; + AST_LIST_ENTRY(ast_sw) list; + char *tmpdata; + char stuff[0]; +}; + +*! \brief ast_ignorepat: Ignore patterns in dial plan */ +struct ast_ignorepat { + const char *registrar; + struct ast_ignorepat *next; + const char pattern[0]; +}; + +/*! \brief ast_context: An extension context */ +struct ast_context { + ast_rwlock_t lock; /*!< A lock to prevent multiple threads from clobbering the context */ + struct ast_exten *root; /*!< The root of the list of extensions */ + struct ast_context *next; /*!< Link them together */ + struct ast_include *includes; /*!< Include other contexts */ + struct ast_ignorepat *ignorepats; /*!< Patterns for which to continue playing dialtone */ + const char *registrar; /*!< Registrar */ + AST_LIST_HEAD_NOLOCK(, ast_sw) alts; /*!< Alternative switches */ + ast_mutex_t macrolock; /*!< A lock to implement "exclusive" macros - held whilst a call is executing in the macro */ + char name[0]; /*!< Name of the context */ +}; + +#endif + +struct ast_config *localized_config_load(const char *filename); +struct ast_config *localized_config_load_with_comments(const char *filename); +struct ast_category *localized_category_get(const struct ast_config *config, const char *category_name); +int localized_config_text_file_save(const char *configfile, const struct ast_config *cfg, const char *generator); +struct ast_context *localized_walk_contexts(struct ast_context *con); +struct ast_exten *localized_walk_context_extensions(struct ast_context *con, + struct ast_exten *exten); +struct ast_exten *localized_walk_extension_priorities(struct ast_exten *exten, + struct ast_exten *priority); +struct ast_include *localized_walk_context_includes(struct ast_context *con, + struct ast_include *inc); +struct ast_sw *localized_walk_context_switches(struct ast_context *con, + struct ast_sw *sw); + +void localized_context_destroy(struct ast_context *con, const char *registrar); +int localized_pbx_load_module(void); + +struct ast_context *localized_context_create(struct ast_context **extcontexts, const char *name, const char *registrar); +int localized_pbx_builtin_setvar(struct ast_channel *chan, void *data); +int localized_context_add_ignorepat2(struct ast_context *con, const char *value, const char *registrar); +int localized_context_add_switch2(struct ast_context *con, const char *value, + const char *data, int eval, const char *registrar); +int localized_context_add_include2(struct ast_context *con, const char *value, + const char *registrar); +int localized_add_extension2(struct ast_context *con, + int replace, const char *extension, int priority, const char *label, const char *callerid, + const char *application, void *data, void (*datad)(void *), + const char *registrar); +void localized_merge_contexts_and_delete(struct ast_context **extcontexts, const char *registrar); +int localized_context_verify_includes(struct ast_context *con); +void localized_use_conf_dir(void); +void localized_use_local_dir(void); + + +#ifndef _ASTERISK_PBX_H +/*! + * When looking up extensions, we can have different requests + * identified by the 'action' argument, as follows. + * Note that the coding is such that the low 4 bits are the + * third argument to extension_match_core. + */ +enum ext_match_t { + E_MATCHMORE = 0x00, /* extension can match but only with more 'digits' */ + E_CANMATCH = 0x01, /* extension can match with or without more 'digits' */ + E_MATCH = 0x02, /* extension is an exact match */ + E_MATCH_MASK = 0x03, /* mask for the argument to extension_match_core() */ + E_SPAWN = 0x12, /* want to spawn an extension. Requires exact match */ + E_FINDLABEL = 0x22 /* returns the priority for a given label. Requires exact match */ +}; +#define AST_PBX_MAX_STACK 128 + +/* request and result for pbx_find_extension */ +struct pbx_find_info { +#if 0 + const char *context; + const char *exten; + int priority; +#endif + + char *incstack[AST_PBX_MAX_STACK]; /* filled during the search */ + int stacklen; /* modified during the search */ + int status; /* set on return */ + struct ast_switch *swo; /* set on return */ + const char *data; /* set on return */ + const char *foundcontext; /* set on return */ +}; + +#define STATUS_NO_CONTEXT 1 +#define STATUS_NO_EXTENSION 2 +#define STATUS_NO_PRIORITY 3 +#define STATUS_NO_LABEL 4 +#define STATUS_SUCCESS 5 + +#endif + +struct ast_exten *localized_find_extension(struct ast_context *bypass, + struct pbx_find_info *q, + const char *context, + const char *exten, + int priority, + const char *label, + const char *callerid, + enum ext_match_t action); + + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif /* _ASTERISK_PBX_H */ diff --git a/include/asterisk/pval.h b/include/asterisk/pval.h new file mode 100644 index 000000000..11d672db2 --- /dev/null +++ b/include/asterisk/pval.h @@ -0,0 +1,272 @@ +#ifndef _ASTERISK_PVAL_H +#define _ASTERISK_PVAL_H + + +typedef enum +{ + PV_WORD, /* an ident, string, name, label, etc. A user-supplied string. */ /* 0 */ + PV_MACRO, /* 1 */ + PV_CONTEXT, /* 2 */ + PV_MACRO_CALL, /* 3 */ + PV_APPLICATION_CALL, /* 4 */ + PV_CASE, /* 5 */ + PV_PATTERN, /* 6 */ + PV_DEFAULT, /* 7 */ + PV_CATCH, /* 8 */ + PV_SWITCHES, /* 9 */ + PV_ESWITCHES, /* 10 */ + PV_INCLUDES, /* 11 */ + PV_STATEMENTBLOCK, /* 12 */ + PV_VARDEC, /* you know, var=val; */ /* 13 */ + PV_GOTO, /* 14 */ + PV_LABEL, /* 15 */ + PV_FOR, /* 16 */ + PV_WHILE, /* 17 */ + PV_BREAK, /* 18 */ + PV_RETURN, /* 19 */ + PV_CONTINUE, /* 20 */ + PV_IF, /* 21 */ + PV_IFTIME, /* 22 */ + PV_RANDOM, /* 23 */ + PV_SWITCH, /* 24 */ + PV_EXTENSION, /* 25 */ + PV_IGNOREPAT, /* 26 */ + PV_GLOBALS, /* 27 */ + PV_LOCALVARDEC, /* 28 */ +} pvaltype; + +/* why this horrible mess? It's always been a tradeoff-- tons of structs, + each storing it's specific lists of goodies, or a 'simple' single struct, + with lots of fields, that catches all uses at once. Either you have a long + list of struct names and subnames, or you have a long list of field names, + and where/how they are used. I'm going with a single struct, using unions + to reduce storage. Some simple generalizations, and a long list of types, + and a book about what is used with what types.... Sorry! +*/ + +struct pval +{ + pvaltype type; + int startline; + int endline; + int startcol; + int endcol; + char *filename; + + union + { + char *str; /* wow, used almost everywhere! */ + struct pval *list; /* used in SWITCHES, ESWITCHES, INCLUDES, STATEMENTBLOCK, GOTO */ + struct pval *statements;/* used in EXTENSION */ + char *for_init; /* used in FOR */ + } u1; + struct pval *u1_last; /* to build in-order lists -- looks like we only need one */ + + union + { + struct pval *arglist; /* used in macro_call, application_call, MACRO def, also attached to PWORD, the 4 timevals for includes */ + struct pval *statements; /* used in case, default, catch, while's statement, CONTEXT elements, GLOBALS */ + char *val; /* used in VARDEC */ + char *for_test; /* used in FOR */ + int label_in_case; /* a boolean for LABELs */ + struct pval *goto_target; /* used in GOTO */ + } u2; + + union + { + char *for_inc; /* used in FOR */ + struct pval *else_statements; /* used in IF */ + struct pval *macro_statements; /* used in MACRO */ + int abstract; /* used for context */ + char *hints; /* used in EXTENSION */ + int goto_target_in_case; /* used in GOTO */ + struct ael_extension *compiled_label; + } u3; + + union + { + struct pval *for_statements; /* used in PV_FOR */ + int regexten; /* used in EXTENSION */ + } u4; + + struct pval *next; /* the pval at the end of this ptr will ALWAYS be of the same type as this one! + EXCEPT for objects of the different types, that are in the same list, like contexts & macros, etc */ + + struct pval *dad; /* the 'container' of this struct instance */ + struct pval *prev; /* the opposite of the 'next' pointer */ +} ; + + +typedef struct pval pval; + +#ifndef AAL_ARGCHECK +/* for the time being, short circuit all the AAL related structures + without permanently removing the code; after/during the AAL + development, this code can be properly re-instated +*/ + +/* null definitions for structs passed down the infrastructure */ +struct argapp +{ + struct argapp *next; +}; + +#endif + +struct ast_context; + +#ifdef AAL_ARGCHECK +int option_matches_j( struct argdesc *should, pval *is, struct argapp *app); +int option_matches( struct argdesc *should, pval *is, struct argapp *app); +int ael_is_funcname(char *name); +#endif + +int do_pbx_load_module(void); +int count_labels_in_current_context(char *label); +int check_app_args(pval *appcall, pval *arglist, struct argapp *app); +void check_pval(pval *item, struct argapp *apps, int in_globals); +void check_pval_item(pval *item, struct argapp *apps, int in_globals); +void check_switch_expr(pval *item, struct argapp *apps); +void ast_expr_register_extra_error_info(char *errmsg); +void ast_expr_clear_extra_error_info(void); +int ast_expr(char *expr, char *buf, int length, struct ast_channel *chan); +struct pval *find_macro(char *name); +struct pval *find_context(char *name); +struct pval *find_context(char *name); +struct pval *find_macro(char *name); +struct ael_priority *new_prio(void); +struct ael_extension *new_exten(void); +void linkprio(struct ael_extension *exten, struct ael_priority *prio); +void destroy_extensions(struct ael_extension *exten); +/* static void linkexten(struct ael_extension *exten, struct ael_extension *add); + static void gen_prios(struct ael_extension *exten, char *label, pval *statement, struct ael_extension *mother_exten, struct ast_context *context ); */ +void set_priorities(struct ael_extension *exten); +void add_extensions(struct ael_extension *exten); +void ast_compile_ael2(struct ast_context **local_contexts, struct pval *root); +void destroy_pval(pval *item); +void destroy_pval_item(pval *item); +int is_float(char *arg ); +int is_int(char *arg ); +int is_empty(char *arg); + +/* PVAL PI */ + + +pval *pvalCreateNode( pvaltype type ); +pvaltype pvalObjectGetType( pval *p ); + +void pvalWordSetString( pval *p, char *str); +char *pvalWordGetString( pval *p ); + +void pvalMacroSetName( pval *p, char *name); +char *pvalMacroGetName( pval *p ); +void pvalMacroSetArglist( pval *p, pval *arglist ); +void pvalMacroAddArg( pval *p, pval *arg ); +pval *pvalMacroWalkArgs( pval *p, pval **arg ); +void pvalMacroAddStatement( pval *p, pval *statement ); +pval *pvalMacroWalkStatements( pval *p, pval **next_statement ); + +void pvalContextSetName( pval *p, char *name); +char *pvalContextGetName( pval *p ); +void pvalContextSetAbstract( pval *p ); +void pvalContextUnsetAbstract( pval *p ); +int pvalContextGetAbstract( pval *p ); +void pvalContextAddStatement( pval *p, pval *statement); +pval *pvalContextWalkStatements( pval *p, pval **statements ); + +void pvalMacroCallSetMacroName( pval *p, char *name ); +char* pvalMacroCallGetMacroName( pval *p ); +void pvalMacroCallSetArglist( pval *p, pval *arglist ); +void pvalMacroCallAddArg( pval *p, pval *arg ); +pval *pvalMacroCallWalkArgs( pval *p, pval **args ); + +void pvalAppCallSetAppName( pval *p, char *name ); +char* pvalAppCallGetAppName( pval *p ); +void pvalAppCallSetArglist( pval *p, pval *arglist ); +void pvalAppCallAddArg( pval *p, pval *arg ); +pval *pvalAppCallWalkArgs( pval *p, pval **args ); + +void pvalCasePatSetVal( pval *p, char *val ); +char* pvalCasePatGetVal( pval *p ); +void pvalCasePatDefAddStatement( pval *p, pval *statement ); +pval *pvalCasePatDefWalkStatements( pval *p, pval **statement ); + +void pvalCatchSetExtName( pval *p, char *name ); +char* pvalCatchGetExtName( pval *p ); +void pvalCatchSetStatement( pval *p, pval *statement ); +pval *pvalCatchGetStatement( pval *p ); + +void pvalSwitchesAddSwitch( pval *p, char *name ); +char* pvalSwitchesWalkNames( pval *p, pval **next_item ); +void pvalESwitchesAddSwitch( pval *p, char *name ); +char* pvalESwitchesWalkNames( pval *p, pval **next_item ); + +void pvalIncludesAddInclude( pval *p, const char *include ); + +void pvalIncludesAddIncludeWithTimeConstraints( pval *p, const char *include, char *hour_range, char *dom_range, char *dow_range, char *month_range ); +void pvalIncludeGetTimeConstraints( pval *p, char **hour_range, char **dom_range, char **dow_range, char **month_range ); +char* pvalIncludesWalk( pval *p, pval **next_item ); + +void pvalStatementBlockAddStatement( pval *p, pval *statement); +pval *pvalStatementBlockWalkStatements( pval *p, pval **next_statement); + +void pvalVarDecSetVarname( pval *p, char *name ); +void pvalVarDecSetValue( pval *p, char *value ); +char* pvalVarDecGetVarname( pval *p ); +char* pvalVarDecGetValue( pval *p ); + +void pvalGotoSetTarget( pval *p, char *context, char *exten, char *label ); +void pvalGotoGetTarget( pval *p, char **context, char **exten, char **label ); + +void pvalLabelSetName( pval *p, char *name ); +char* pvalLabelGetName( pval *p ); + +void pvalForSetInit( pval *p, char *init ); +void pvalForSetTest( pval *p, char *test ); +void pvalForSetInc( pval *p, char *inc ); +void pvalForSetStatement( pval *p, pval *statement ); +char* pvalForGetInit( pval *p ); +char* pvalForGetTest( pval *p ); +char* pvalForGetInc( pval *p ); +pval* pvalForGetStatement( pval *p ); + + +void pvalIfSetCondition( pval *p, char *expr ); +char* pvalIfGetCondition( pval *p ); +void pvalIfTimeSetCondition( pval *p, char *hour_range, char *dow_range, char *dom_range, char *mon_range ); /* time range format: 24-hour format begin-end|dow range|dom range|month range */ +void pvalIfTimeGetCondition( pval *p, char **hour_range, char **dow_range, char **dom_range, char **month_range ); +void pvalRandomSetCondition( pval *p, char *percent ); +char* pvalRandomGetCondition( pval *p ); +void pvalConditionalSetThenStatement( pval *p, pval *statement ); +void pvalConditionalSetElseStatement( pval *p, pval *statement ); +pval* pvalConditionalGetThenStatement( pval *p ); +pval* pvalConditionalGetElseStatement( pval *p ); + +void pvalSwitchSetTestexpr( pval *p, char *expr ); +char* pvalSwitchGetTestexpr( pval *p ); +void pvalSwitchAddCase( pval *p, pval *Case ); +pval* pvalSwitchWalkCases( pval *p, pval **next_case ); + +void pvalExtenSetName( pval *p, char *name ); +char *pvalExtenGetName( pval *p ); +void pvalExtenSetRegexten( pval *p ); +void pvalExtenUnSetRegexten( pval *p ); +int pvalExtenGetRegexten( pval *p ); +void pvalExtenSetHints( pval *p, char *hints ); +char* pvalExtenGetHints( pval *p ); +void pvalExtenSetStatement( pval *p, pval *statement ); +pval* pvalExtenGetStatement( pval *p ); + +void pvalIgnorePatSetPattern( pval *p, char *pat ); +char* pvalIgnorePatGetPattern( pval *p ); + +void pvalGlobalsAddStatement( pval *p, pval *statement ); +pval* pvalGlobalsWalkStatements( pval *p, pval **next_statement ); + +void pvalTopLevAddObject( pval *p, pval *contextOrObj ); +pval* pvalTopLevWalkObjects( pval *p, pval **next_obj ); + +int pvalCheckType( pval *p, char *funcname, pvaltype type ); + + +#endif -- cgit v1.2.3