Asterisk - The Open Source Telephony Project GIT-master-754dea3
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Macros Modules Pages
named_acl.c
Go to the documentation of this file.
1/*
2 * Asterisk -- An open source telephony toolkit.
3 *
4 * Copyright (C) 2012, Digium, Inc.
5 *
6 * Mark Spencer <markster@digium.com>
7 * Jonathan Rose <jrose@digium.com>
8 *
9 * See http://www.asterisk.org for more information about
10 * the Asterisk project. Please do not directly contact
11 * any of the maintainers of this project for assistance;
12 * the project provides a web site, mailing lists and IRC
13 * channels for your use.
14 *
15 * This program is free software, distributed under the terms of
16 * the GNU General Public License Version 2. See the LICENSE file
17 * at the top of the source tree.
18 */
19
20/*! \file
21 *
22 * \brief Named Access Control Lists
23 *
24 * \author Jonathan Rose <jrose@digium.com>
25 *
26 * \note Based on a feature proposed by
27 * Olle E. Johansson <oej@edvina.net>
28 */
29
30/* This maintains the original "module reload acl" CLI command instead
31 * of replacing it with "module reload named_acl". */
32#undef AST_MODULE
33#define AST_MODULE "acl"
34
35#include "asterisk.h"
36
37#include "asterisk/config.h"
39#include "asterisk/utils.h"
40#include "asterisk/module.h"
41#include "asterisk/cli.h"
42#include "asterisk/acl.h"
43#include "asterisk/astobj2.h"
44#include "asterisk/paths.h"
45#include "asterisk/stasis.h"
46#include "asterisk/json.h"
48
49#define NACL_CONFIG "acl.conf"
50#define ACL_FAMILY "acls"
51
52/*** DOCUMENTATION
53 <configInfo name="named_acl" language="en_US">
54 <configFile name="acl.conf">
55 <configObject name="named_acl">
56 <since>
57 <version>12.0.0</version>
58 </since>
59 <synopsis>Options for configuring a named ACL</synopsis>
60 <configOption name="permit">
61 <since>
62 <version>11.0.0</version>
63 </since>
64 <synopsis>An address/subnet from which to allow access</synopsis>
65 </configOption>
66 <configOption name="deny">
67 <since>
68 <version>11.0.0</version>
69 </since>
70 <synopsis>An address/subnet from which to disallow access</synopsis>
71 </configOption>
72 </configObject>
73 </configFile>
74 </configInfo>
75***/
76
77/*
78 * Configuration structure - holds pointers to ao2 containers used for configuration
79 * Since there isn't a general level or any other special levels for acl.conf at this
80 * time, it's really a config options friendly wrapper for the named ACL container
81 */
84};
85
87
88/*! \note These functions are used for placing/retrieving named ACLs in their ao2_container. */
89static void *named_acl_config_alloc(void);
90static void *named_acl_alloc(const char *cat);
91static void *named_acl_find(struct ao2_container *container, const char *cat);
92
93/* Config type for named ACL profiles (must not be named general) */
94static struct aco_type named_acl_type = {
95 .type = ACO_ITEM, /*!< named_acls are items stored in containers, not individual global objects */
96 .name = "named_acl",
97 .category_match = ACO_BLACKLIST_EXACT,
98 .category = "general", /*!< Match everything but "general" */
99 .item_alloc = named_acl_alloc, /*!< A callback to allocate a new named_acl based on category */
100 .item_find = named_acl_find, /*!< A callback to find a named_acl in some container of named_acls */
101 .item_offset = offsetof(struct named_acl_config, named_acl_list), /*!< Could leave this out since 0 */
102};
103
104/* This array of aco_type structs is necessary to use aco_option_register */
106
108 .filename = "acl.conf",
109 .types = ACO_TYPES(&named_acl_type),
110};
111
112/* Create a config info struct that describes the config processing for named ACLs. */
114 .files = ACO_FILES(&named_acl_conf),
115);
116
117struct named_acl {
118 struct ast_ha *ha;
119 char name[ACL_NAME_LENGTH]; /* Same max length as a configuration category */
120};
121
124
125/*! \brief destructor for named_acl_config */
126static void named_acl_config_destructor(void *obj)
127{
128 struct named_acl_config *cfg = obj;
130}
131
132/*! \brief allocator callback for named_acl_config. Notice it returns void * since it is used by
133 * the backend config code
134 */
135static void *named_acl_config_alloc(void)
136{
137 struct named_acl_config *cfg;
138
139 if (!(cfg = ao2_alloc(sizeof(*cfg), named_acl_config_destructor))) {
140 return NULL;
141 }
142
144 named_acl_hash_fn, NULL, named_acl_cmp_fn);
145 if (!cfg->named_acl_list) {
146 goto error;
147 }
148
149 return cfg;
150
151error:
152 ao2_ref(cfg, -1);
153 return NULL;
154}
155
156/*! \brief Destroy a named ACL object */
157static void destroy_named_acl(void *obj)
158{
159 struct named_acl *named_acl = obj;
161}
162
163/*!
164 * \brief Create a named ACL structure
165 *
166 * \param cat name given to the ACL
167 * \retval NULL failure
168 *\retval non-NULL successfully allocated named ACL
169 */
170static void *named_acl_alloc(const char *cat)
171{
172 struct named_acl *named_acl;
173
175 if (!named_acl) {
176 return NULL;
177 }
178
180
181 return named_acl;
182}
183
184/*!
185 * \brief Find a named ACL in a container by its name
186 *
187 * \param container ao2container holding the named ACLs
188 * \param cat name of the ACL wanted to be found
189 * \retval pointer to the named ACL if available. Null if not found.
190 */
191static void *named_acl_find(struct ao2_container *container, const char *cat)
192{
193 struct named_acl tmp;
194 ast_copy_string(tmp.name, cat, sizeof(tmp.name));
195 return ao2_find(container, &tmp, OBJ_POINTER);
196}
197
198/*!
199 * \internal
200 * \brief Callback function to compare the ACL order of two given categories.
201 * This function is used to sort lists of ACLs received from realtime.
202 *
203 * \param p first category being compared
204 * \param q second category being compared
205 *
206 * \retval -1 (p < q)
207 * \retval 0 (p == q)
208 * \retval 1 (p > q)
209 */
210static int acl_order_comparator(struct ast_category *p, struct ast_category *q)
211{
212 int p_value = 0, q_value = 0;
213 struct ast_variable *p_var = ast_category_first(p);
214 struct ast_variable *q_var = ast_category_first(q);
215
216 while (p_var) {
217 if (!strcasecmp(p_var->name, "rule_order")) {
218 p_value = atoi(p_var->value);
219 break;
220 }
221 p_var = p_var->next;
222 }
223
224 while (q_var) {
225 if (!strcasecmp(q_var->name, "rule_order")) {
226 q_value = atoi(q_var->value);
227 break;
228 }
229 q_var = q_var->next;
230 }
231
232 if (p_value < q_value) {
233 return -1;
234 } else if (q_value < p_value) {
235 return 1;
236 }
237
238 return 0;
239}
240
241/*!
242 * \internal
243 * \brief Search for a named ACL via realtime Database and build the named_acl
244 * if it is valid.
245 *
246 * \param name of the ACL wanted to be found
247 * \retval pointer to the named ACL if available. Null if the ACL subsystem is unconfigured.
248 */
249static struct named_acl *named_acl_find_realtime(const char *name)
250{
251 struct ast_config *cfg;
252 char *item = NULL;
253 const char *systemname = NULL;
254 struct ast_ha *built_ha = NULL;
255 struct named_acl *acl;
256
257 /* If we have a systemname set in the global options, we only want to retrieve entries with a matching systemname field. */
258 systemname = ast_config_AST_SYSTEM_NAME;
259
260 if (ast_strlen_zero(systemname)) {
262 } else {
263 cfg = ast_load_realtime_multientry(ACL_FAMILY, "name", name, "systemname", systemname, SENTINEL);
264 }
265
266 if (!cfg) {
267 return NULL;
268 }
269
270 /* At this point, the configuration must be sorted by the order field. */
272
273 while ((item = ast_category_browse(cfg, item))) {
274 int append_ha_error = 0;
275 const char *order = ast_variable_retrieve(cfg, item, "rule_order");
276 const char *sense = ast_variable_retrieve(cfg, item, "sense");
277 const char *rule = ast_variable_retrieve(cfg, item, "rule");
278
279 built_ha = ast_append_ha(sense, rule, built_ha, &append_ha_error);
280 if (append_ha_error) {
281 /* We need to completely reject an ACL that contains any bad rules. */
282 ast_log(LOG_ERROR, "Rejecting realtime ACL due to bad ACL definition '%s': %s - %s - %s\n", name, order, sense, rule);
283 ast_free_ha(built_ha);
284 return NULL;
285 }
286 }
287
289
291 if (!acl) {
292 ast_log(LOG_ERROR, "allocation error\n");
293 ast_free_ha(built_ha);
294 return NULL;
295 }
296
297 acl->ha = built_ha;
298
299 return acl;
300}
301
302struct ast_ha *ast_named_acl_find(const char *name, int *is_realtime, int *is_undefined)
303{
304 struct ast_ha *ha = NULL;
305
308
309 if (is_realtime) {
310 *is_realtime = 0;
311 }
312
313 if (is_undefined) {
314 *is_undefined = 0;
315 }
316
317 /* If the config or its named_acl_list hasn't been initialized, abort immediately. */
318 if ((!cfg) || (!(cfg->named_acl_list))) {
319 ast_log(LOG_ERROR, "Attempted to find named ACL '%s', but the ACL configuration isn't available.\n", name);
320 return NULL;
321 }
322
323 named_acl = named_acl_find(cfg->named_acl_list, name);
324
325 /* If a named ACL couldn't be retrieved locally, we need to try realtime storage. */
326 if (!named_acl) {
327 RAII_VAR(struct named_acl *, realtime_acl, NULL, ao2_cleanup);
328
329 /* Attempt to create from realtime */
330 if ((realtime_acl = named_acl_find_realtime(name))) {
331 if (is_realtime) {
332 *is_realtime = 1;
333 }
334 ha = ast_duplicate_ha_list(realtime_acl->ha);
335 return ha;
336 }
337
338 /* Couldn't create from realtime. Raise relevant flags and print relevant warnings. */
340 ast_log(LOG_WARNING, "ACL '%s' does not exist. The ACL will be marked as undefined and will automatically fail if applied.\n"
341 "This ACL may exist in the configured realtime backend, but that backend hasn't been registered yet. "
342 "Fix this establishing preload for the backend in 'modules.conf'.\n", name);
343 } else {
344 ast_log(LOG_WARNING, "ACL '%s' does not exist. The ACL will be marked as undefined and will automatically fail if applied.\n", name);
345 }
346
347 if (is_undefined) {
348 *is_undefined = 1;
349 }
350
351 return NULL;
352 }
353
355
356 if (!ha) {
357 ast_log(LOG_NOTICE, "ACL '%s' contains no rules. It is valid, but it will accept addresses unconditionally.\n", name);
358 }
359
360 return ha;
361}
362
363/*! \brief Message type for named ACL changes */
365
366/*!
367 * \internal
368 * \brief Sends a stasis message corresponding to a given named ACL that has changed or
369 * that all ACLs have been updated and old copies must be refreshed. Consumers of
370 * named ACLs should subscribe to the ast_security_topic and respond to messages
371 * of the ast_named_acl_change_type stasis message type in order to be able to
372 * accommodate changes to named ACLs.
373 *
374 * \param name Name of the ACL that has changed. May be an empty string (but not NULL)
375 * If name is an empty string, then all ACLs must be refreshed.
376 *
377 * \retval 0 success
378 * \retval 1 failure
379 */
380static int publish_acl_change(const char *name)
381{
382 RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
383 RAII_VAR(struct ast_json_payload *, json_payload, NULL, ao2_cleanup);
384 RAII_VAR(struct ast_json *, json_object, ast_json_object_create(), ast_json_unref);
385
386 if (!json_object || !ast_named_acl_change_type()) {
387 goto publish_failure;
388 }
389
390 if (ast_json_object_set(json_object, "name", ast_json_string_create(name))) {
391 goto publish_failure;
392 }
393
394 if (!(json_payload = ast_json_payload_create(json_object))) {
395 goto publish_failure;
396 }
397
399
400 if (!msg) {
401 goto publish_failure;
402 }
403
405
406 return 0;
407
408publish_failure:
409 ast_log(LOG_ERROR, "Failed to issue ACL change message for %s.\n",
410 ast_strlen_zero(name) ? "all named ACLs" : name);
411 return -1;
412}
413
414/*!
415 * \internal
416 * \brief secondary handler for the 'acl show <name>' command (with arg)
417 *
418 * \param fd file descriptor of the cli
419 * \name name of the ACL requested for display
420 */
421static void cli_display_named_acl(int fd, const char *name)
422{
423 int is_realtime = 0;
424
427
428 /* If the configuration or the configuration's named_acl_list is unavailable, abort. */
429 if ((!cfg) || (!cfg->named_acl_list)) {
430 ast_log(LOG_ERROR, "Attempted to show named ACL '%s', but the acl configuration isn't available.\n", name);
431 return;
432 }
433
434 named_acl = named_acl_find(cfg->named_acl_list, name);
435
436 /* If the named_acl couldn't be found with the search, also abort. */
437 if (!named_acl) {
439 ast_cli(fd, "\nCould not find ACL named '%s'\n", name);
440 return;
441 }
442
443 is_realtime = 1;
444 }
445
446 ast_cli(fd, "\nACL: %s%s\n---------------------------------------------\n", name, is_realtime ? " (realtime)" : "");
448}
449
450/*!
451 * \internal
452 * \brief secondary handler for the 'acl show' command (no args)
453 *
454 * \param fd file descriptor of the cli
455 */
456static void cli_display_named_acl_list(int fd)
457{
458 struct ao2_iterator i;
459 void *o;
461
462 ast_cli(fd, "\nacl\n---\n");
463
464 if (!cfg || !cfg->named_acl_list) {
465 ast_cli(fd, "ACL configuration isn't available.\n");
466 return;
467 }
468 i = ao2_iterator_init(cfg->named_acl_list, 0);
469
470 while ((o = ao2_iterator_next(&i))) {
471 struct named_acl *named_acl = o;
472 ast_cli(fd, "%s\n", named_acl->name);
473 ao2_ref(o, -1);
474 }
475
477}
478
479/*! \brief ACL command show <name> */
480static char *handle_show_named_acl_cmd(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
481{
482 struct named_acl_config *cfg;
483 int length;
484 struct ao2_iterator i;
485 struct named_acl *named_acl;
486
487 switch (cmd) {
488 case CLI_INIT:
489 e->command = "acl show";
490 e->usage =
491 "Usage: acl show [name]\n"
492 " Shows a list of named ACLs or lists all entries in a given named ACL.\n";
493 return NULL;
494 case CLI_GENERATE:
495 if (a->pos != 2) {
496 return NULL;
497 }
498
500 if (!cfg) {
501 return NULL;
502 }
503 length = strlen(a->word);
505 while ((named_acl = ao2_iterator_next(&i))) {
506 if (!strncasecmp(a->word, named_acl->name, length)) {
508 ao2_ref(named_acl, -1);
509 break;
510 }
511 }
512 ao2_ref(named_acl, -1);
513 }
515 ao2_ref(cfg, -1);
516
517 return NULL;
518 }
519
520 if (a->argc == 2) {
522 return CLI_SUCCESS;
523 }
524
525 if (a->argc == 3) {
526 cli_display_named_acl(a->fd, a->argv[2]);
527 return CLI_SUCCESS;
528 }
529
530
531 return CLI_SHOWUSAGE;
532}
533
534static struct ast_cli_entry cli_named_acl[] = {
535 AST_CLI_DEFINE(handle_show_named_acl_cmd, "Show a named ACL or list all named ACLs"),
536};
537
538static int reload_module(void)
539{
541
542 status = aco_process_config(&cfg_info, 1);
543
544 if (status == ACO_PROCESS_ERROR) {
545 ast_log(LOG_WARNING, "Could not reload ACL config\n");
546 return 0;
547 }
548
550 /* We don't actually log anything if the config was unchanged,
551 * but we don't need to send a config change event either.
552 */
553 return 0;
554 }
555
556 /* We need to push an ACL change event with no ACL name so that all subscribers update with all ACLs */
558
559 return 0;
560}
561
562static int unload_module(void)
563{
565
567 aco_info_destroy(&cfg_info);
569
570 return 0;
571}
572
573static int load_module(void)
574{
575 if (aco_info_init(&cfg_info)) {
577 }
578
580
581 /* Register the per level options. */
582 aco_option_register(&cfg_info, "permit", ACO_EXACT, named_acl_types, NULL, OPT_ACL_T, 1, FLDSET(struct named_acl, ha));
583 aco_option_register(&cfg_info, "deny", ACO_EXACT, named_acl_types, NULL, OPT_ACL_T, 0, FLDSET(struct named_acl, ha));
584
585 aco_process_config(&cfg_info, 0);
586
588
590}
591
593 .support_level = AST_MODULE_SUPPORT_CORE,
594 .load = load_module,
595 .unload = unload_module,
597 .load_pri = AST_MODPRI_CORE,
598 .requires = "extconfig",
Access Control of various sorts.
void ast_free_ha(struct ast_ha *ha)
Free a list of HAs.
Definition: acl.c:222
struct stasis_message_type * ast_named_acl_change_type(void)
a stasis_message_type for changes against a named ACL or the set of all named ACLs
void ast_ha_output(int fd, const struct ast_ha *ha, const char *prefix)
output an HA to the provided fd
Definition: acl.c:1103
struct ast_ha * ast_duplicate_ha_list(struct ast_ha *original)
Duplicate the contents of a list of host access rules.
Definition: acl.c:276
#define ACL_NAME_LENGTH
Definition: acl.h:59
struct ast_ha * ast_append_ha(const char *sense, const char *stuff, struct ast_ha *path, int *error)
Add a new rule to a list of HAs.
Definition: acl.c:712
integer order
Definition: analys.c:66
jack_status_t status
Definition: app_jack.c:149
Asterisk main include file. File version handling, generic pbx functions.
#define ast_strdup(str)
A wrapper for strdup()
Definition: astmm.h:241
#define ast_log
Definition: astobj2.c:42
#define ao2_iterator_next(iter)
Definition: astobj2.h:1911
#define OBJ_POINTER
Definition: astobj2.h:1150
@ AO2_ALLOC_OPT_LOCK_MUTEX
Definition: astobj2.h:363
#define AO2_STRING_FIELD_CMP_FN(stype, field)
Creates a compare function for a structure string field.
Definition: astobj2.h:2048
#define ao2_cleanup(obj)
Definition: astobj2.h:1934
#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_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
#define AO2_STRING_FIELD_HASH_FN(stype, field)
Creates a hash function for a structure string field.
Definition: astobj2.h:2032
void ao2_iterator_destroy(struct ao2_iterator *iter)
Destroy a container iterator.
#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
Standard Command Line Interface.
#define CLI_SHOWUSAGE
Definition: cli.h:45
#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
int ast_cli_completion_add(char *value)
Add a result to a request for completion options.
Definition: main/cli.c:2768
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
#define SENTINEL
Definition: compiler.h:87
Configuration option-handling.
@ ACO_EXACT
void aco_info_destroy(struct aco_info *info)
Destroy an initialized aco_info struct.
aco_process_status
Return values for the aco_process functions.
@ ACO_PROCESS_UNCHANGED
The config had not been edited and no changes applied.
@ ACO_PROCESS_ERROR
Their was an error and no changes were applied.
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_ACL_T
Type for default option handler for ACLs.
@ ACO_ITEM
@ ACO_BLACKLIST_EXACT
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.
static const char name[]
Definition: format_mp3.c:68
Configuration File Parser.
char * ast_category_browse(struct ast_config *config, const char *prev_name)
Browse categories.
Definition: extconf.c:3326
void ast_config_sort_categories(struct ast_config *config, int descending, int(*comparator)(struct ast_category *p, struct ast_category *q))
Sorts categories in a config in the order of a numerical value contained within them.
Definition: main/config.c:1372
struct ast_config * ast_load_realtime_multientry(const char *family,...) attribute_sentinel
Retrieve realtime configuration.
Definition: main/config.c:3842
int ast_realtime_is_mapping_defined(const char *family)
Determine if a mapping exists for a given family.
Definition: main/config.c:3413
int ast_check_realtime(const char *family)
Check if realtime engine is configured for family.
Definition: main/config.c:3750
void ast_config_destroy(struct ast_config *cfg)
Destroys a config.
Definition: extconf.c:1289
const char * ast_variable_retrieve(struct ast_config *config, const char *category, const char *variable)
Definition: main/config.c:869
struct ast_variable * ast_category_first(struct ast_category *cat)
given a pointer to a category, return the root variable.
Definition: main/config.c:1358
#define LOG_ERROR
#define LOG_NOTICE
#define LOG_WARNING
Asterisk JSON abstraction layer.
struct ast_json * ast_json_string_create(const char *value)
Construct a JSON string from value.
Definition: json.c:278
void ast_json_unref(struct ast_json *value)
Decrease refcount on value. If refcount reaches zero, value is freed.
Definition: json.c:73
struct ast_json * ast_json_object_create(void)
Create a new JSON object.
Definition: json.c:399
struct ast_json_payload * ast_json_payload_create(struct ast_json *json)
Create an ao2 object to pass json blobs as data payloads for stasis.
Definition: json.c:756
int ast_json_object_set(struct ast_json *object, const char *key, struct ast_json *value)
Set a field in a JSON object.
Definition: json.c:414
Asterisk module definitions.
@ AST_MODFLAG_LOAD_ORDER
Definition: module.h:331
@ AST_MODFLAG_GLOBAL_SYMBOLS
Definition: module.h:330
#define AST_MODULE_INFO(keystr, flags_to_set, desc, fields...)
Definition: module.h:557
@ AST_MODPRI_CORE
Definition: module.h:338
@ AST_MODULE_SUPPORT_CORE
Definition: module.h:121
#define ASTERISK_GPL_KEY
The text the key() function should return.
Definition: module.h:46
@ AST_MODULE_LOAD_FAILURE
Module could not be loaded properly.
Definition: module.h:102
@ AST_MODULE_LOAD_SUCCESS
Definition: module.h:70
struct aco_file named_acl_conf
Definition: named_acl.c:107
struct aco_type * named_acl_types[]
Definition: named_acl.c:105
static void named_acl_config_destructor(void *obj)
destructor for named_acl_config
Definition: named_acl.c:126
static void * named_acl_alloc(const char *cat)
Create a named ACL structure.
Definition: named_acl.c:170
static void * named_acl_find(struct ao2_container *container, const char *cat)
Find a named ACL in a container by its name.
Definition: named_acl.c:191
static struct named_acl * named_acl_find_realtime(const char *name)
Definition: named_acl.c:249
static void destroy_named_acl(void *obj)
Destroy a named ACL object.
Definition: named_acl.c:157
static AO2_GLOBAL_OBJ_STATIC(globals)
#define ACL_FAMILY
Definition: named_acl.c:50
static int reload_module(void)
Definition: named_acl.c:538
struct ast_ha * ast_named_acl_find(const char *name, int *is_realtime, int *is_undefined)
Retrieve a named ACL.
Definition: named_acl.c:302
static int acl_order_comparator(struct ast_category *p, struct ast_category *q)
Definition: named_acl.c:210
static void cli_display_named_acl_list(int fd)
Definition: named_acl.c:456
CONFIG_INFO_CORE("named_acl", cfg_info, globals, named_acl_config_alloc,.files=ACO_FILES(&named_acl_conf),)
static void * named_acl_config_alloc(void)
allocator callback for named_acl_config. Notice it returns void * since it is used by the backend con...
Definition: named_acl.c:135
static int load_module(void)
Definition: named_acl.c:573
static struct ast_cli_entry cli_named_acl[]
Definition: named_acl.c:534
static int unload_module(void)
Definition: named_acl.c:562
static int publish_acl_change(const char *name)
Definition: named_acl.c:380
static void cli_display_named_acl(int fd, const char *name)
Definition: named_acl.c:421
static struct aco_type named_acl_type
Definition: named_acl.c:94
STASIS_MESSAGE_TYPE_DEFN(ast_named_acl_change_type)
Message type for named ACL changes.
static char * handle_show_named_acl_cmd(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
ACL command show <name>
Definition: named_acl.c:480
Asterisk file paths, configured in asterisk.conf.
const char * ast_config_AST_SYSTEM_NAME
Definition: options.c:170
static int reload(void)
struct ao2_container * container
Definition: res_fax.c:531
#define NULL
Definition: resample.c:96
Security Event Reporting API.
struct stasis_topic * ast_security_topic(void)
A stasis_topic which publishes messages for security related issues.
Stasis Message Bus API. See Stasis Message Bus API for detailed documentation.
#define STASIS_MESSAGE_TYPE_CLEANUP(name)
Boiler-plate messaging macro for cleaning up message types.
Definition: stasis.h:1515
#define STASIS_MESSAGE_TYPE_INIT(name)
Boiler-plate messaging macro for initializing message types.
Definition: stasis.h:1493
struct stasis_message * stasis_message_create(struct stasis_message_type *type, void *data)
Create a new message.
void stasis_publish(struct stasis_topic *topic, struct stasis_message *message)
Publish a message to a topic's subscribers.
Definition: stasis.c:1538
static force_inline int attribute_pure ast_strlen_zero(const char *s)
Definition: strings.h:65
void ast_copy_string(char *dst, const char *src, size_t size)
Size-limited null-terminating string copy.
Definition: strings.h:425
Definition: test_acl.c:111
The representation of a single configuration file to be processed.
const char * filename
Type information about a category-level configurable object.
enum aco_type_t type
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
descriptor for a cli entry.
Definition: cli.h:171
char * command
Definition: cli.h:186
const char * usage
Definition: cli.h:177
internal representation of ACL entries In principle user applications would have no need for this,...
Definition: acl.h:51
Abstract JSON element (object, array, string, int, ...).
Structure for variables, used for configurations and for channel variables.
struct ast_variable * next
struct ao2_container * named_acl_list
Definition: named_acl.c:83
struct ast_ha * ha
Definition: named_acl.c:118
char name[ACL_NAME_LENGTH]
Definition: named_acl.c:119
static struct aco_type item
Definition: test_config.c:1463
static struct test_val a
int error(const char *format,...)
Definition: utils/frame.c:999
Utility functions.
#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:941
#define ARRAY_LEN(a)
Definition: utils.h:666