Asterisk - The Open Source Telephony Project  GIT-master-a24979a
app_skel.c

Application Skeleton is an example of creating an application for Asterisk.

/*
* Asterisk -- An open source telephony toolkit.
*
* Copyright (C) <Year>, <Your Name Here>
*
* <Your Name Here> <<Your Email Here>>
*
* 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.
*
* Please follow coding guidelines
* https://wiki.asterisk.org/wiki/display/AST/Coding+Guidelines
*/
/*! \file
*
* \brief Skeleton application
*
* \author\verbatim <Your Name Here> <<Your Email Here>> \endverbatim
*
* This is a skeleton for development of an Asterisk application
* \ingroup applications
*/
/*! \li \ref app_skel.c uses configuration file \ref app_skel.conf
* \addtogroup configuration_file Configuration Files
*/
/*!
* \page app_skel.conf app_skel.conf
* \verbinclude app_skel.conf.sample
*/
/*** MODULEINFO
<defaultenabled>no</defaultenabled>
<support_level>core</support_level>
***/
#include "asterisk.h"
#include <math.h> /* log10 */
#include "asterisk/file.h"
#include "asterisk/pbx.h"
#include "asterisk/lock.h"
#include "asterisk/app.h"
#include "asterisk/say.h"
#include "asterisk/acl.h"
#include "asterisk/cli.h"
/*** DOCUMENTATION
<application name="SkelGuessNumber" language="en_US">
<synopsis>
An example number guessing game
</synopsis>
<syntax>
<parameter name="level" required="true"/>
<parameter name="options">
<optionlist>
<option name="c">
<para>The computer should cheat</para>
</option>
<option name="n">
<para>How many games to play before hanging up</para>
</option>
</optionlist>
</parameter>
</syntax>
<description>
<para>This simple number guessing application is a template to build other applications
from. It shows you the basic structure to create your own Asterisk applications.</para>
</description>
</application>
<configInfo name="app_skel" language="en_US">
<configFile name="app_skel.conf">
<configObject name="globals">
<synopsis>Options that apply globally to app_skel</synopsis>
<configOption name="games">
<synopsis>The number of games a single execution of SkelGuessNumber will play</synopsis>
</configOption>
<configOption name="cheat">
<synopsis>Should the computer cheat?</synopsis>
<description><para>If enabled, the computer will ignore winning guesses.</para></description>
</configOption>
</configObject>
<configObject name="sounds">
<synopsis>Prompts for SkelGuessNumber to play</synopsis>
<configOption name="prompt" default="please-enter-your&amp;number&amp;queue-less-than">
<synopsis>A prompt directing the user to enter a number less than the max number</synopsis>
</configOption>
<configOption name="wrong_guess" default="vm-pls-try-again">
<synopsis>The sound file to play when a wrong guess is made</synopsis>
</configOption>
<configOption name="right_guess" default="auth-thankyou">
<synopsis>The sound file to play when a correct guess is made</synopsis>
</configOption>
<configOption name="too_low">
<synopsis>The sound file to play when a guess is too low</synopsis>
</configOption>
<configOption name="too_high">
<synopsis>The sound file to play when a guess is too high</synopsis>
</configOption>
<configOption name="lose" default="vm-goodbye">
<synopsis>The sound file to play when a player loses</synopsis>
</configOption>
</configObject>
<configObject name="level">
<synopsis>Defined levels for the SkelGuessNumber game</synopsis>
<configOption name="max_number">
<synopsis>The maximum in the range of numbers to guess (1 is the implied minimum)</synopsis>
</configOption>
<configOption name="max_guesses">
<synopsis>The maximum number of guesses before a game is considered lost</synopsis>
</configOption>
</configObject>
</configFile>
</configInfo>
***/
static char *app = "SkelGuessNumber";
OPTION_CHEAT = (1 << 0),
OPTION_NUMGAMES = (1 << 1),
};
/* This *must* be the last value in this enum! */
};
});
/*! \brief A structure to hold global configuration-related options */
AST_STRING_FIELD(prompt); /*!< The comma-separated list of sounds to prompt to enter a number */
AST_STRING_FIELD(wrong); /*!< The comma-separated list of sounds to indicate a wrong guess */
AST_STRING_FIELD(right); /*!< The comma-separated list of sounds to indicate a right guess */
AST_STRING_FIELD(high); /*!< The comma-separated list of sounds to indicate a high guess */
AST_STRING_FIELD(low); /*!< The comma-separated list of sounds to indicate a low guess */
AST_STRING_FIELD(lose); /*!< The comma-separated list of sounds to indicate a lost game */
);
uint32_t num_games; /*!< The number of games to play before hanging up */
unsigned char cheat:1; /*!< Whether the computer can cheat or not */
};
/*! \brief A structure to maintain level state across reloads */
uint32_t wins; /*!< How many wins for this level */
uint32_t losses; /*!< How many losses for this level */
double avg_guesses; /*!< The average number of guesses to win for this level */
};
/*! \brief Object to hold level config information.
* \note This object should hold a reference to an object that holds state across reloads.
* The other fields are just examples of the kind of data that might be stored in an level.
*/
struct skel_level {
AST_STRING_FIELD(name); /*!< The name of the level */
);
uint32_t max_num; /*!< The upper value on th range of numbers to guess */
uint32_t max_guesses; /*!< The maximum number of guesses before losing */
struct skel_level_state *state; /*!< A pointer to level state that must exist across all reloads */
};
/*! \brief Information about a currently running set of games
* \note Because we want to be able to show true running information about the games
* regardless of whether or not a reload has modified what the level looks like, it
* is important to either copy the information we need from the level to the
* current_game struct, or as we do here, store a reference to the level as it is for
* the running game.
*/
uint32_t total_games; /*! The total number of games for this call to the app */
uint32_t games_left; /*! How many games are left to play in this set */
uint32_t cheat; /*! Whether or not cheating was enabled for the game */
struct skel_level *level_info; /*! The level information for the running game */
};
/* Treat the levels as an array--there won't be many and this will maintain the order */
#define LEVEL_BUCKETS 1
/*! \brief A container that holds all config-related information
* \note This object should contain a pointer to structs for global data and containers for
* any levels that are configured. Objects of this type will be swapped out on reload. If an
* level needs to maintain state across reloads, it needs to allocate a refcounted object to
* hold that state and ensure that a reference is passed to that state when creating a new
* level for reload. */
struct skel_config {
};
/* Config Options API callbacks */
/*! \brief Allocate a skel_config to hold a snapshot of the complete results of parsing a config
* \internal
* \returns A void pointer to a newly allocated skel_config
*/
static void *skel_config_alloc(void);
/*! \brief Allocate a skel_level based on a category in a configuration file
* \param cat The category to base the level on
* \returns A void pointer to a newly allocated skel_level
*/
static void *skel_level_alloc(const char *cat);
/*! \brief Find a skel level in the specified container
* \note This function *does not* look for a skel_level in the active container. It is used
* internally by the Config Options code to check if an level has already been added to the
* container that will be swapped for the live container on a successul reload.
*
* \param tmp_container A non-active container to search for a level
* \param category The category associated with the level to check for
* \retval non-NULL The level from the container
* \retval NULL The level does not exist in the container
*/
static void *skel_level_find(struct ao2_container *tmp_container, const char *category);
/*! \brief An aco_type structure to link the "general" category to the skel_global_config type */
static struct aco_type global_option = {
.name = "globals",
.item_offset = offsetof(struct skel_config, global),
.category_match = ACO_WHITELIST_EXACT,
.category = "general",
};
/*! \brief An aco_type structure to link the "sounds" category to the skel_global_config type */
static struct aco_type sound_option = {
.name = "sounds",
.item_offset = offsetof(struct skel_config, global),
.category_match = ACO_WHITELIST_EXACT,
.category = "sounds",
};
static const char *level_categories[] = {
"general",
"sounds",
};
/*! \brief An aco_type structure to link the everything but the "general" and "sounds" categories to the skel_level type */
static struct aco_type level_option = {
.name = "level",
.category_match = ACO_BLACKLIST_ARRAY,
.category = (const char *)level_categories,
.item_offset = offsetof(struct skel_config, levels),
};
.filename = "app_skel.conf",
};
/*! \brief A global object container that will contain the skel_config that gets swapped out on reloads */
/*! \brief The container of active games */
static struct ao2_container *games;
/*! \brief Register information about the configs being processed by this module */
);
static void skel_global_config_destructor(void *obj)
{
struct skel_global_config *global = obj;
}
static void skel_game_destructor(void *obj)
{
struct skel_current_game *game = obj;
}
static void skel_state_destructor(void *obj)
{
return;
}
static struct skel_current_game *skel_game_alloc(struct skel_level *level)
{
struct skel_current_game *game;
if (!(game = ao2_alloc(sizeof(struct skel_current_game), skel_game_destructor))) {
return NULL;
}
ao2_ref(level, +1);
game->level_info = level;
return game;
}
static void skel_level_destructor(void *obj)
{
struct skel_level *level = obj;
ao2_cleanup(level->state);
}
static int skel_level_hash(const void *obj, const int flags)
{
const struct skel_level *level = obj;
const char *name = (flags & OBJ_KEY) ? obj : level->name;
}
static int skel_level_cmp(void *obj, void *arg, int flags)
{
struct skel_level *one = obj, *two = arg;
const char *match = (flags & OBJ_KEY) ? arg : two->name;
return strcasecmp(one->name, match) ? 0 : (CMP_MATCH | CMP_STOP);
}
/*! \brief A custom bitfield handler
* \internal
* \note It is not possible to take the address of a bitfield, therefor all
* bitfields in the config struct will have to use a custom handler
* \param opt The opaque config option
* \param var The ast_variable containing the option name and value
* \param obj The object registerd for this option type
* \retval 0 Success
* \retval non-zero Failure
*/
static int custom_bitfield_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
{
struct skel_global_config *global = obj;
if (!strcasecmp(var->name, "cheat")) {
global->cheat = ast_true(var->value);
} else {
return -1;
}
return 0;
}
static void play_files_helper(struct ast_channel *chan, const char *prompts)
{
char *prompt, *rest = ast_strdupa(prompts);
while ((prompt = strsep(&rest, "&")) && !ast_stream_and_wait(chan, prompt, "")) {
}
}
static int app_exec(struct ast_channel *chan, const char *data)
{
int win = 0;
uint32_t guesses;
RAII_VAR(struct skel_level *, level, NULL, ao2_cleanup);
struct ast_flags flags;
AST_APP_ARG(level);
);
if (!cfg) {
ast_log(LOG_ERROR, "Couldn't access configuratino data!\n");
return -1;
}
if (ast_strlen_zero(data)) {
ast_log(LOG_WARNING, "%s requires an argument (level[,options])\n", app);
return -1;
}
/* We need to make a copy of the input string if we are going to modify it! */
parse = ast_strdupa(data);
if (args.argc == 2) {
}
if (ast_strlen_zero(args.level)) {
ast_log(LOG_ERROR, "%s requires a level argument\n", app);
return -1;
}
if (!(level = ao2_find(cfg->levels, args.level, OBJ_KEY))) {
ast_log(LOG_ERROR, "Unknown level: %s\n", args.level);
return -1;
}
if (!(game = skel_game_alloc(level))) {
return -1;
}
ao2_link(games, game);
/* Use app-specified values, or the options specified in [general] if they aren't passed to the app */
game->total_games = cfg->global->num_games;
}
game->games_left = game->total_games;
game->cheat = ast_test_flag(&flags, OPTION_CHEAT) || cfg->global->cheat;
for (game->games_left = game->total_games; game->games_left; game->games_left--) {
uint32_t num = ast_random() % level->max_num; /* random number between 0 and level->max_num */
ast_debug(1, "They should totally should guess %u\n", num);
/* Play the prompt */
play_files_helper(chan, cfg->global->prompt);
ast_say_number(chan, level->max_num, "", ast_channel_language(chan), "");
for (guesses = 0; guesses < level->max_guesses; guesses++) {
size_t buflen = log10(level->max_num) + 1;
char buf[buflen];
int guess;
buf[buflen] = '\0';
/* Read the number pressed */
ast_readstring(chan, buf, buflen - 1, 2000, 10000, "");
if (ast_parse_arg(buf, PARSE_INT32 | PARSE_IN_RANGE, &guess, 0, level->max_num)) {
if (guesses < level->max_guesses - 1) {
play_files_helper(chan, cfg->global->wrong);
}
continue;
}
/* Inform whether the guess was right, low, or high */
if (guess == num && !game->cheat) {
/* win */
win = 1;
play_files_helper(chan, cfg->global->right);
guesses++;
break;
} else if (guess < num) {
play_files_helper(chan, cfg->global->low);
} else {
play_files_helper(chan, cfg->global->high);
}
if (guesses < level->max_guesses - 1) {
play_files_helper(chan, cfg->global->wrong);
}
}
/* Process game stats */
ao2_lock(level->state);
if (win) {
++level->state->wins;
level->state->avg_guesses = ((level->state->wins - 1) * level->state->avg_guesses + guesses) / level->state->wins;
} else {
/* lose */
level->state->losses++;
play_files_helper(chan, cfg->global->lose);
}
ao2_unlock(level->state);
}
ao2_unlink(games, game);
return 0;
}
static struct skel_level *skel_state_alloc(const char *name)
{
struct skel_level *level;
if (!(level = ao2_alloc(sizeof(*level), skel_state_destructor))) {
return NULL;
}
return level;
}
static void *skel_level_find(struct ao2_container *tmp_container, const char *category)
{
return ao2_find(tmp_container, category, OBJ_KEY);
}
/*! \brief Look up an existing state object, or create a new one
* \internal
* \note Since the reload code will create a new level from scratch, it
* is important for any state that must persist between reloads to be
* in a separate refcounted object. This function allows the level alloc
* function to get a ref to an existing state object if it exists,
* otherwise it will return a reference to a newly allocated state object.
*/
static void *skel_find_or_create_state(const char *category)
{
RAII_VAR(struct skel_level *, level, NULL, ao2_cleanup);
if (!cfg || !cfg->levels || !(level = ao2_find(cfg->levels, category, OBJ_KEY))) {
return skel_state_alloc(category);
}
ao2_ref(level->state, +1);
return level->state;
}
static void *skel_level_alloc(const char *cat)
{
struct skel_level *level;
if (!(level = ao2_alloc(sizeof(*level), skel_level_destructor))) {
return NULL;
}
if (ast_string_field_init(level, 128)) {
ao2_ref(level, -1);
return NULL;
}
/* Since the level has state information that needs to persist between reloads,
* it is important to handle that here in the level's allocation function.
* If not separated out into its own object, the data would be destroyed on
* reload. */
if (!(level->state = skel_find_or_create_state(cat))) {
ao2_ref(level, -1);
return NULL;
}
ast_string_field_set(level, name, cat);
return level;
}
static void skel_config_destructor(void *obj)
{
struct skel_config *cfg = obj;
}
static void *skel_config_alloc(void)
{
struct skel_config *cfg;
if (!(cfg = ao2_alloc(sizeof(*cfg), skel_config_destructor))) {
return NULL;
}
/* Allocate/initialize memory */
if (!(cfg->global = ao2_alloc(sizeof(*cfg->global), skel_global_config_destructor))) {
goto error;
}
if (ast_string_field_init(cfg->global, 128)) {
goto error;
}
if (!cfg->levels) {
goto error;
}
return cfg;
ao2_ref(cfg, -1);
return NULL;
}
static char *handle_skel_show_config(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
{
switch(cmd) {
case CLI_INIT:
e->command = "skel show config";
e->usage =
"Usage: skel show config\n"
" List app_skel global config\n";
return NULL;
return NULL;
}
if (!(cfg = ao2_global_obj_ref(globals)) || !cfg->global) {
return NULL;
}
ast_cli(a->fd, "games per call: %u\n", cfg->global->num_games);
ast_cli(a->fd, "computer cheats: %s\n", AST_CLI_YESNO(cfg->global->cheat));
ast_cli(a->fd, "\n");
ast_cli(a->fd, "Sounds\n");
ast_cli(a->fd, " prompt: %s\n", cfg->global->prompt);
ast_cli(a->fd, " wrong guess: %s\n", cfg->global->wrong);
ast_cli(a->fd, " right guess: %s\n", cfg->global->right);
return CLI_SUCCESS;
}
static char *handle_skel_show_games(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
{
struct ao2_iterator iter;
struct skel_current_game *game;
switch(cmd) {
case CLI_INIT:
e->command = "skel show games";
e->usage =
"Usage: skel show games\n"
" List app_skel active games\n";
return NULL;
return NULL;
}
#define SKEL_FORMAT "%-15.15s %-15.15s %-15.15s\n"
#define SKEL_FORMAT1 "%-15.15s %-15u %-15u\n"
ast_cli(a->fd, SKEL_FORMAT, "Level", "Total Games", "Games Left");
while ((game = ao2_iterator_next(&iter))) {
ao2_ref(game, -1);
}
#undef SKEL_FORMAT
#undef SKEL_FORMAT1
return CLI_SUCCESS;
}
static char *handle_skel_show_levels(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
{
struct ao2_iterator iter;
struct skel_level *level;
switch(cmd) {
case CLI_INIT:
e->command = "skel show levels";
e->usage =
"Usage: skel show levels\n"
" List the app_skel levels\n";
return NULL;
return NULL;
}
if (!(cfg = ao2_global_obj_ref(globals)) || !cfg->levels) {
return NULL;
}
#define SKEL_FORMAT "%-15.15s %-11.11s %-12.12s %-8.8s %-8.8s %-12.12s\n"
#define SKEL_FORMAT1 "%-15.15s %-11u %-12u %-8u %-8u %-8f\n"
ast_cli(a->fd, SKEL_FORMAT, "Name", "Max number", "Max Guesses", "Wins", "Losses", "Avg Guesses");
iter = ao2_iterator_init(cfg->levels, 0);
while ((level = ao2_iterator_next(&iter))) {
ast_cli(a->fd, SKEL_FORMAT1, level->name, level->max_num, level->max_guesses, level->state->wins, level->state->losses, level->state->avg_guesses);
ao2_ref(level, -1);
}
#undef SKEL_FORMAT
#undef SKEL_FORMAT1
return CLI_SUCCESS;
}
static struct ast_cli_entry skel_cli[] = {
AST_CLI_DEFINE(handle_skel_show_config, "Show app_skel global config options"),
AST_CLI_DEFINE(handle_skel_show_levels, "Show app_skel levels"),
AST_CLI_DEFINE(handle_skel_show_games, "Show app_skel active games"),
};
static int reload_module(void)
{
if (aco_process_config(&cfg_info, 1) == ACO_PROCESS_ERROR) {
}
return 0;
}
static int unload_module(void)
{
aco_info_destroy(&cfg_info);
}
/*!
* \brief Load the module
*
* Module loading including tests for configuration or dependencies.
* This function can return AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_DECLINE,
* or AST_MODULE_LOAD_SUCCESS. If a dependency or environment variable fails
* tests return AST_MODULE_LOAD_FAILURE. If the module can not load the
* configuration file or other non-critical problem return
* AST_MODULE_LOAD_DECLINE. On success return AST_MODULE_LOAD_SUCCESS.
*/
static int load_module(void)
{
if (aco_info_init(&cfg_info)) {
goto error;
}
if (!games) {
goto error;
}
/* Global options */
aco_option_register(&cfg_info, "games", ACO_EXACT, global_options, "3", OPT_UINT_T, 0, FLDSET(struct skel_global_config, num_games));
/* Sound options */
aco_option_register(&cfg_info, "prompt", ACO_EXACT, sound_options, "please-enter-your&number&queue-less-than", OPT_STRINGFIELD_T, 0, STRFLDSET(struct skel_global_config, prompt));
aco_option_register(&cfg_info, "wrong_guess", ACO_EXACT, sound_options, "vm-pls-try-again", OPT_STRINGFIELD_T, 0, STRFLDSET(struct skel_global_config, wrong));
aco_option_register(&cfg_info, "right_guess", ACO_EXACT, sound_options, "auth-thankyou", OPT_STRINGFIELD_T, 0, STRFLDSET(struct skel_global_config, right));
aco_option_register(&cfg_info, "too_high", ACO_EXACT, sound_options, "high", OPT_STRINGFIELD_T, 0, STRFLDSET(struct skel_global_config, high));
aco_option_register(&cfg_info, "lose", ACO_EXACT, sound_options, "vm-goodbye", OPT_STRINGFIELD_T, 0, STRFLDSET(struct skel_global_config, lose));
/* Level options */
aco_option_register(&cfg_info, "max_number", ACO_EXACT, level_options, NULL, OPT_UINT_T, 0, FLDSET(struct skel_level, max_num));
aco_option_register(&cfg_info, "max_guesses", ACO_EXACT, level_options, NULL, OPT_UINT_T, 0, FLDSET(struct skel_level, max_guesses));
if (aco_process_config(&cfg_info, 0) == ACO_PROCESS_ERROR) {
goto error;
}
goto error;
}
aco_info_destroy(&cfg_info);
}
AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Skeleton (sample) Application",
.support_level = AST_MODULE_SUPPORT_CORE,
.load = load_module,
.unload = unload_module,
);
Access Control of various sorts.
struct aco_type * global_options[]
Definition: app_skel.c:249
CONFIG_INFO_STANDARD(cfg_info, globals, skel_config_alloc,.files=ACO_FILES(&app_skel_conf),)
Register information about the configs being processed by this module.
static int skel_level_hash(const void *obj, const int flags)
Definition: app_skel.c:332
static int custom_bitfield_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
A custom bitfield handler.
Definition: app_skel.c:356
static char * handle_skel_show_levels(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition: app_skel.c:655
#define LEVEL_BUCKETS
Definition: app_skel.c:201
struct aco_type * level_options[]
Definition: app_skel.c:279
static void skel_global_config_destructor(void *obj)
Definition: app_skel.c:297
option_args
Definition: app_skel.c:141
@ OPTION_ARG_NUMGAMES
Definition: app_skel.c:142
@ OPTION_ARG_ARRAY_SIZE
Definition: app_skel.c:144
option_flags
Definition: app_skel.c:136
@ OPTION_NUMGAMES
Definition: app_skel.c:138
@ OPTION_CHEAT
Definition: app_skel.c:137
static char * handle_skel_show_games(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition: app_skel.c:625
#define SKEL_FORMAT
static void * skel_level_find(struct ao2_container *tmp_container, const char *category)
Find a skel level in the specified container.
Definition: app_skel.c:508
static AO2_GLOBAL_OBJ_STATIC(globals)
A global object container that will contain the skel_config that gets swapped out on reloads.
static void skel_game_destructor(void *obj)
Definition: app_skel.c:303
#define SKEL_FORMAT1
static void skel_config_destructor(void *obj)
Definition: app_skel.c:559
static int reload_module(void)
Definition: app_skel.c:697
static void * skel_level_alloc(const char *cat)
Allocate a skel_level based on a category in a configuration file.
Definition: app_skel.c:532
static void play_files_helper(struct ast_channel *chan, const char *prompts)
Definition: app_skel.c:369
static struct aco_type sound_option
An aco_type structure to link the "sounds" category to the skel_global_config type.
Definition: app_skel.c:252
static struct ao2_container * games
The container of active games.
Definition: app_skel.c:290
static struct aco_type level_option
An aco_type structure to link the everything but the "general" and "sounds" categories to the skel_le...
Definition: app_skel.c:269
static void skel_level_destructor(void *obj)
Definition: app_skel.c:325
static struct ast_cli_entry skel_cli[]
Definition: app_skel.c:691
static const struct ast_app_option app_opts[128]
Definition: app_skel.c:150
static char * app
Definition: app_skel.c:134
static int app_exec(struct ast_channel *chan, const char *data)
Definition: app_skel.c:379
static void * skel_config_alloc(void)
Allocate a skel_config to hold a snapshot of the complete results of parsing a config.
Definition: app_skel.c:566
static void skel_state_destructor(void *obj)
Definition: app_skel.c:309
static int skel_level_cmp(void *obj, void *arg, int flags)
Definition: app_skel.c:339
struct aco_file app_skel_conf
Definition: app_skel.c:281
static char * handle_skel_show_config(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition: app_skel.c:595
static struct skel_current_game * skel_game_alloc(struct skel_level *level)
Definition: app_skel.c:314
static struct skel_level * skel_state_alloc(const char *name)
Definition: app_skel.c:497
static int load_module(void)
Load the module.
Definition: app_skel.c:725
static int unload_module(void)
Definition: app_skel.c:706
static void * skel_find_or_create_state(const char *category)
Look up an existing state object, or create a new one.
Definition: app_skel.c:521
static const char * level_categories[]
Definition: app_skel.c:262
static struct aco_type global_option
An aco_type structure to link the "general" category to the skel_global_config type.
Definition: app_skel.c:241
struct aco_type * sound_options[]
Definition: app_skel.c:260
#define var
Definition: ast_expr2f.c:614
static struct ast_str * prompt
Definition: asterisk.c:2761
Asterisk main include file. File version handling, generic pbx functions.
#define ast_strdupa(s)
duplicate a string in memory from the stack
Definition: astmm.h:298
#define ast_log
Definition: astobj2.c:42
#define ao2_iterator_next(iter)
Definition: astobj2.h:1911
#define ao2_link(container, obj)
Add an object to a container.
Definition: astobj2.h:1532
@ CMP_MATCH
Definition: astobj2.h:1027
@ CMP_STOP
Definition: astobj2.h:1028
#define OBJ_KEY
Definition: astobj2.h:1151
@ AO2_ALLOC_OPT_LOCK_MUTEX
Definition: astobj2.h:363
#define ao2_cleanup(obj)
Definition: astobj2.h:1934
#define ao2_unlink(container, obj)
Remove an object from a container.
Definition: astobj2.h:1578
#define ao2_global_obj_ref(holder)
Get a reference to the object stored in the global holder.
Definition: astobj2.h:918
#define ao2_find(container, arg, flags)
Definition: astobj2.h:1736
struct ao2_iterator ao2_iterator_init(struct ao2_container *c, int flags) attribute_warn_unused_result
Create an iterator for a container.
#define ao2_unlock(a)
Definition: astobj2.h:729
#define ao2_lock(a)
Definition: astobj2.h:717
#define ao2_ref(o, delta)
Reference/unreference an object and return the old refcount.
Definition: astobj2.h:459
#define ao2_global_obj_release(holder)
Release the ao2 object held in the global holder.
Definition: astobj2.h:859
void ao2_iterator_destroy(struct ao2_iterator *iter)
Destroy a container iterator.
#define ao2_container_alloc_list(ao2_options, container_options, sort_fn, cmp_fn)
Allocate and initialize a list container.
Definition: astobj2.h:1327
#define ao2_alloc(data_size, destructor_fn)
Definition: astobj2.h:409
#define ao2_container_alloc_hash(ao2_options, container_options, n_buckets, hash_fn, sort_fn, cmp_fn)
Allocate and initialize a hash container with the desired number of buckets.
Definition: astobj2.h:1303
static struct console_pvt globals
static int match(struct ast_sockaddr *addr, unsigned short callno, unsigned short dcallno, const struct chan_iax2_pvt *cur, int check_dcallno)
Definition: chan_iax2.c:2312
static void parse(struct mgcp_request *req)
Definition: chan_mgcp.c:1844
General Asterisk PBX channel definitions.
const char * ast_channel_language(const struct ast_channel *chan)
int ast_readstring(struct ast_channel *c, char *s, int len, int timeout, int rtimeout, char *enders)
Reads multiple digits.
Definition: channel.c:6636
Standard Command Line Interface.
#define AST_CLI_YESNO(x)
Return Yes or No depending on the argument.
Definition: cli.h:71
#define CLI_SUCCESS
Definition: cli.h:44
int ast_cli_unregister_multiple(struct ast_cli_entry *e, int len)
Unregister multiple commands.
Definition: clicompat.c:30
#define AST_CLI_DEFINE(fn, txt,...)
Definition: cli.h:197
void ast_cli(int fd, const char *fmt,...)
Definition: clicompat.c:6
@ CLI_INIT
Definition: cli.h:152
@ CLI_GENERATE
Definition: cli.h:153
#define ast_cli_register_multiple(e, len)
Register multiple commands.
Definition: cli.h:265
Configuration option-handling.
@ ACO_EXACT
void aco_info_destroy(struct aco_info *info)
Destroy an initialized aco_info struct.
@ ACO_PROCESS_ERROR
Their was an error and no changes were applied.
#define STRFLDSET(type,...)
Convert a struct and a list of stringfield fields to an argument list of field offsets.
int aco_info_init(struct aco_info *info)
Initialize an aco_info structure.
#define FLDSET(type,...)
Convert a struct and list of fields to an argument list of field offsets.
#define aco_option_register(info, name, matchtype, types, default_val, opt_type, flags,...)
Register a config option.
#define ACO_FILES(...)
@ OPT_UINT_T
Type for default option handler for unsigned integers.
@ OPT_STRINGFIELD_T
Type for default option handler for stringfields.
#define aco_option_register_custom(info, name, matchtype, types, default_val, handler, flags)
Register a config option.
@ ACO_ITEM
@ ACO_GLOBAL
@ ACO_WHITELIST_EXACT
@ ACO_BLACKLIST_ARRAY
enum aco_process_status aco_process_config(struct aco_info *info, int reload)
Process a config info via the options registered with an aco_info.
#define ACO_TYPES(...)
A helper macro to ensure that aco_info types always have a sentinel.
char buf[BUFSIZE]
Definition: eagi_proxy.c:66
Generic File Format Support. Should be included by clients of the file handling routines....
int ast_stopstream(struct ast_channel *c)
Stops a stream.
Definition: file.c:222
int ast_stream_and_wait(struct ast_channel *chan, const char *file, const char *digits)
stream file until digit If the file name is non-empty, try to play it.
Definition: file.c:1855
static const char name[]
Definition: format_mp3.c:68
Application convenience functions, designed to give consistent look and feel to Asterisk apps.
#define AST_APP_ARG(name)
Define an application argument.
#define AST_APP_OPTIONS(holder, options...)
Declares an array of options for an application.
#define AST_APP_OPTION_ARG(option, flagno, argno)
Declares an application option that accepts an argument.
#define AST_DECLARE_APP_ARGS(name, arglist)
Declare a structure to hold an application's arguments.
#define AST_STANDARD_APP_ARGS(args, parse)
Performs the 'standard' argument separation process for an application.
#define AST_APP_OPTION(option, flagno)
Declares an application option that does not accept an argument.
int ast_app_parse_options(const struct ast_app_option *options, struct ast_flags *flags, char **args, char *optstr)
Parses a string containing application options and sets flags/arguments.
Definition: main/app.c:3126
char * strsep(char **str, const char *delims)
Configuration File Parser.
int ast_parse_arg(const char *arg, enum ast_parse_flags flags, void *p_result,...)
The argument parsing routine.
Definition: main/config.c:3726
#define ast_debug(level,...)
Log a DEBUG message.
#define LOG_ERROR
#define LOG_WARNING
Asterisk locking-related definitions:
static char * levels[NUMLOGLEVELS]
Logging channels used in the Asterisk logging system.
Definition: logger.c:213
Asterisk module definitions.
@ AST_MODFLAG_DEFAULT
Definition: module.h:315
#define AST_MODULE_INFO(keystr, flags_to_set, desc, fields...)
Definition: module.h:543
@ AST_MODULE_SUPPORT_CORE
Definition: module.h:121
#define ASTERISK_GPL_KEY
The text the key() function should return.
Definition: module.h:46
int ast_unregister_application(const char *app)
Unregister an application.
Definition: pbx_app.c:392
@ AST_MODULE_LOAD_SUCCESS
Definition: module.h:70
@ AST_MODULE_LOAD_DECLINE
Module has failed to load, may be in an inconsistent state.
Definition: module.h:78
#define ast_register_application_xml(app, execute)
Register an application using XML documentation.
Definition: module.h:626
Network socket handling.
Core PBX routines and definitions.
static int reload(void)
#define NULL
Definition: resample.c:96
Say numbers and dates (maybe words one day too)
int ast_say_number(struct ast_channel *chan, int num, const char *ints, const char *lang, const char *options)
says a number
Definition: channel.c:8318
#define AST_DECLARE_STRING_FIELDS(field_list)
Declare the fields needed in a structure.
Definition: stringfields.h:341
#define AST_STRING_FIELD(name)
Declare a string field.
Definition: stringfields.h:303
#define ast_string_field_set(x, field, data)
Set a field to a simple string value.
Definition: stringfields.h:521
#define ast_string_field_init(x, size)
Initialize a field pool and fields.
Definition: stringfields.h:359
#define ast_string_field_free_memory(x)
free all memory - to be called before destroying the object
Definition: stringfields.h:374
String manipulation functions.
int attribute_pure ast_true(const char *val)
Make sure something is true. Determine if a string containing a boolean value is "true"....
Definition: main/utils.c:2097
static force_inline int attribute_pure ast_strlen_zero(const char *s)
Definition: strings.h:65
static force_inline int attribute_pure ast_str_case_hash(const char *str)
Compute a hash value on a case-insensitive string.
Definition: strings.h:1281
The representation of a single configuration file to be processed.
const char * filename
Type information about a category-level configurable object.
aco_type_item_find item_find
enum aco_type_t type
aco_type_item_alloc item_alloc
size_t item_offset
Generic container type.
When we need to walk through a container, we use an ao2_iterator to keep track of the current positio...
Definition: astobj2.h:1821
Main Channel structure associated with a channel.
descriptor for a cli entry.
Definition: cli.h:171
char * command
Definition: cli.h:186
const char * usage
Definition: cli.h:177
Structure used to handle boolean flags.
Definition: utils.h:199
unsigned int flags
Definition: utils.h:200
Structure for variables, used for configurations and for channel variables.
A container that holds all config-related information.
Definition: app_skel.c:209
struct skel_global_config * global
Definition: app_skel.c:210
struct ao2_container * levels
Definition: app_skel.c:211
Information about a currently running set of games.
Definition: app_skel.c:193
struct skel_level * level_info
Definition: app_skel.c:197
uint32_t games_left
Definition: app_skel.c:195
uint32_t cheat
Definition: app_skel.c:196
uint32_t total_games
Definition: app_skel.c:194
A structure to hold global configuration-related options.
Definition: app_skel.c:153
const ast_string_field right
Definition: app_skel.c:161
uint32_t num_games
Definition: app_skel.c:162
const ast_string_field lose
Definition: app_skel.c:161
const ast_string_field low
Definition: app_skel.c:161
const ast_string_field wrong
Definition: app_skel.c:161
unsigned char cheat
Definition: app_skel.c:163
const ast_string_field prompt
Definition: app_skel.c:161
const ast_string_field high
Definition: app_skel.c:161
A structure to maintain level state across reloads.
Definition: app_skel.c:167
uint32_t wins
Definition: app_skel.c:168
double avg_guesses
Definition: app_skel.c:170
uint32_t losses
Definition: app_skel.c:169
Object to hold level config information.
Definition: app_skel.c:177
uint32_t max_guesses
Definition: app_skel.c:182
struct skel_level_state * state
Definition: app_skel.c:183
const ast_string_field name
Definition: app_skel.c:180
uint32_t max_num
Definition: app_skel.c:181
static struct aco_type global
Definition: test_config.c:1445
const char * args
static struct test_options options
static struct test_val a
int error(const char *format,...)
Definition: utils/frame.c:999
#define ast_test_flag(p, flag)
Definition: utils.h:63
#define RAII_VAR(vartype, varname, initval, dtor)
Declare a variable that will call a destructor function when it goes out of scope.
Definition: utils.h:936
long int ast_random(void)
Definition: main/utils.c:2210
#define ARRAY_LEN(a)
Definition: utils.h:661