Wed Jan 8 2020 09:49:46

Asterisk developer's documentation


dnsmgr.c
Go to the documentation of this file.
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2005-2006, Kevin P. Fleming
5  *
6  * Kevin P. Fleming <kpfleming@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  *
21  * \brief Background DNS update manager
22  *
23  * \author Kevin P. Fleming <kpfleming@digium.com>
24  *
25  * \bug There is a minor race condition. In the event that an IP address
26  * of a dnsmgr managed host changes, there is the potential for the consumer
27  * of that address to access the in_addr data at the same time that the dnsmgr
28  * thread is in the middle of updating it to the new address.
29  */
30 
31 /*** MODULEINFO
32  <support_level>core</support_level>
33  ***/
34 
35 #include "asterisk.h"
36 
37 ASTERISK_FILE_VERSION(__FILE__, "$Revision: 377704 $")
38 
39 #include "asterisk/_private.h"
40 #include <regex.h>
41 #include <signal.h>
42 
43 #include "asterisk/dnsmgr.h"
44 #include "asterisk/linkedlists.h"
45 #include "asterisk/utils.h"
46 #include "asterisk/config.h"
47 #include "asterisk/sched.h"
48 #include "asterisk/cli.h"
49 #include "asterisk/manager.h"
50 #include "asterisk/acl.h"
51 
52 static struct sched_context *sched;
53 static int refresh_sched = -1;
54 static pthread_t refresh_thread = AST_PTHREADT_NULL;
55 
57  /*! where we will store the resulting IP address and port number */
59  /*! SRV record to lookup, if provided. Composed of service, protocol, and domain name: _Service._Proto.Name */
60  char *service;
61  /*! Address family to filter DNS responses. */
62  unsigned int family;
63  /*! Set to 1 if the entry changes */
64  unsigned int changed:1;
65  /*! Data to pass back to update_func */
66  void *data;
67  /*! The callback function to execute on address update */
71  /*! just 1 here, but we use calloc to allocate the correct size */
72  char name[1];
73 };
74 
76 
78 
79 #define REFRESH_DEFAULT 300
80 
81 static int enabled;
82 static int refresh_interval;
83 
84 struct refresh_info {
85  struct entry_list *entries;
86  int verbose;
87  unsigned int regex_present:1;
88  regex_t filter;
89 };
90 
92  .entries = &entry_list,
93  .verbose = 0,
94 };
95 
96 struct ast_dnsmgr_entry *ast_dnsmgr_get_family(const char *name, struct ast_sockaddr *result, const char *service, unsigned int family)
97 {
98  struct ast_dnsmgr_entry *entry;
99  int total_size = sizeof(*entry) + strlen(name) + (service ? strlen(service) + 1 : 0);
100 
101  if (!result || ast_strlen_zero(name) || !(entry = ast_calloc(1, total_size))) {
102  return NULL;
103  }
104 
105  entry->result = result;
106  ast_mutex_init(&entry->lock);
107  strcpy(entry->name, name);
108  if (service) {
109  entry->service = ((char *) entry) + sizeof(*entry) + strlen(name);
110  strcpy(entry->service, service);
111  }
112  entry->family = family;
113 
114  AST_RWLIST_WRLOCK(&entry_list);
115  AST_RWLIST_INSERT_HEAD(&entry_list, entry, list);
116  AST_RWLIST_UNLOCK(&entry_list);
117 
118  return entry;
119 }
120 
121 struct ast_dnsmgr_entry *ast_dnsmgr_get(const char *name, struct ast_sockaddr *result, const char *service)
122 {
123  return ast_dnsmgr_get_family(name, result, service, 0);
124 }
125 
126 void ast_dnsmgr_release(struct ast_dnsmgr_entry *entry)
127 {
128  if (!entry)
129  return;
130 
131  AST_RWLIST_WRLOCK(&entry_list);
132  AST_RWLIST_REMOVE(&entry_list, entry, list);
133  AST_RWLIST_UNLOCK(&entry_list);
134  ast_verb(6, "removing dns manager for '%s'\n", entry->name);
135 
136  ast_mutex_destroy(&entry->lock);
137  ast_free(entry);
138 }
139 
140 static int internal_dnsmgr_lookup(const char *name, struct ast_sockaddr *result, struct ast_dnsmgr_entry **dnsmgr, const char *service, dns_update_func func, void *data)
141 {
142  unsigned int family;
143 
144  if (ast_strlen_zero(name) || !result || !dnsmgr) {
145  return -1;
146  }
147 
148  if (*dnsmgr && !strcasecmp((*dnsmgr)->name, name)) {
149  return 0;
150  }
151 
152  /* Lookup address family filter. */
153  family = result->ss.ss_family;
154 
155  /*
156  * If it's actually an IP address and not a name, there's no
157  * need for a managed lookup.
158  */
159  if (ast_sockaddr_parse(result, name, PARSE_PORT_FORBID)) {
160  return 0;
161  }
162 
163  ast_verb(6, "doing dnsmgr_lookup for '%s'\n", name);
164 
165  /* do a lookup now but add a manager so it will automagically get updated in the background */
166  ast_get_ip_or_srv(result, name, service);
167 
168  /* if dnsmgr is not enable don't bother adding an entry */
169  if (!enabled) {
170  return 0;
171  }
172 
173  ast_verb(6, "adding dns manager for '%s'\n", name);
174  *dnsmgr = ast_dnsmgr_get_family(name, result, service, family);
175  (*dnsmgr)->update_func = func;
176  (*dnsmgr)->data = data;
177  return !*dnsmgr;
178 }
179 
180 int ast_dnsmgr_lookup(const char *name, struct ast_sockaddr *result, struct ast_dnsmgr_entry **dnsmgr, const char *service)
181 {
182  return internal_dnsmgr_lookup(name, result, dnsmgr, service, NULL, NULL);
183 }
184 
185 int ast_dnsmgr_lookup_cb(const char *name, struct ast_sockaddr *result, struct ast_dnsmgr_entry **dnsmgr, const char *service, dns_update_func func, void *data)
186 {
187  return internal_dnsmgr_lookup(name, result, dnsmgr, service, func, data);
188 }
189 
190 /*
191  * Refresh a dnsmgr entry
192  */
193 static int dnsmgr_refresh(struct ast_dnsmgr_entry *entry, int verbose)
194 {
195  struct ast_sockaddr tmp = { .len = 0, };
196  int changed = 0;
197 
198  ast_mutex_lock(&entry->lock);
199 
200  if (verbose) {
201  ast_verb(6, "refreshing '%s'\n", entry->name);
202  }
203 
204  tmp.ss.ss_family = entry->family;
205  if (!ast_get_ip_or_srv(&tmp, entry->name, entry->service)) {
206  if (!ast_sockaddr_port(&tmp)) {
208  }
209  if (ast_sockaddr_cmp(&tmp, entry->result)) {
210  const char *old_addr = ast_strdupa(ast_sockaddr_stringify(entry->result));
211  const char *new_addr = ast_strdupa(ast_sockaddr_stringify(&tmp));
212 
213  if (entry->update_func) {
214  entry->update_func(entry->result, &tmp, entry->data);
215  } else {
216  ast_log(LOG_NOTICE, "dnssrv: host '%s' changed from %s to %s\n",
217  entry->name, old_addr, new_addr);
218 
219  ast_sockaddr_copy(entry->result, &tmp);
220  changed = entry->changed = 1;
221  }
222  }
223  }
224 
225  ast_mutex_unlock(&entry->lock);
226 
227  return changed;
228 }
229 
230 int ast_dnsmgr_refresh(struct ast_dnsmgr_entry *entry)
231 {
232  return dnsmgr_refresh(entry, 0);
233 }
234 
235 /*
236  * Check if dnsmgr entry has changed from since last call to this function
237  */
238 int ast_dnsmgr_changed(struct ast_dnsmgr_entry *entry)
239 {
240  int changed;
241 
242  ast_mutex_lock(&entry->lock);
243 
244  changed = entry->changed;
245  entry->changed = 0;
246 
247  ast_mutex_unlock(&entry->lock);
248 
249  return changed;
250 }
251 
252 static void *do_refresh(void *data)
253 {
254  for (;;) {
255  pthread_testcancel();
256  usleep((ast_sched_wait(sched)*1000));
257  pthread_testcancel();
258  ast_sched_runq(sched);
259  }
260  return NULL;
261 }
262 
263 static int refresh_list(const void *data)
264 {
265  struct refresh_info *info = (struct refresh_info *)data;
266  struct ast_dnsmgr_entry *entry;
267 
268  /* if a refresh or reload is already in progress, exit now */
269  if (ast_mutex_trylock(&refresh_lock)) {
270  if (info->verbose)
271  ast_log(LOG_WARNING, "DNS Manager refresh already in progress.\n");
272  return -1;
273  }
274 
275  ast_verb(6, "Refreshing DNS lookups.\n");
276  AST_RWLIST_RDLOCK(info->entries);
277  AST_RWLIST_TRAVERSE(info->entries, entry, list) {
278  if (info->regex_present && regexec(&info->filter, entry->name, 0, NULL, 0))
279  continue;
280 
281  dnsmgr_refresh(entry, info->verbose);
282  }
283  AST_RWLIST_UNLOCK(info->entries);
284 
285  ast_mutex_unlock(&refresh_lock);
286 
287  /* automatically reschedule based on the interval */
288  return refresh_interval * 1000;
289 }
290 
292 {
293  if (refresh_sched > -1) {
294  AST_SCHED_DEL(sched, refresh_sched);
295  refresh_sched = ast_sched_add_variable(sched, 100, refresh_list, &master_refresh_info, 1);
296  }
297 }
298 
299 static int do_reload(int loading);
300 
301 static char *handle_cli_reload(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
302 {
303  switch (cmd) {
304  case CLI_INIT:
305  e->command = "dnsmgr reload";
306  e->usage =
307  "Usage: dnsmgr reload\n"
308  " Reloads the DNS manager configuration.\n";
309  return NULL;
310  case CLI_GENERATE:
311  return NULL;
312  }
313  if (a->argc > 2)
314  return CLI_SHOWUSAGE;
315 
316  do_reload(0);
317  return CLI_SUCCESS;
318 }
319 
320 static char *handle_cli_refresh(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
321 {
322  struct refresh_info info = {
323  .entries = &entry_list,
324  .verbose = 1,
325  };
326  switch (cmd) {
327  case CLI_INIT:
328  e->command = "dnsmgr refresh";
329  e->usage =
330  "Usage: dnsmgr refresh [pattern]\n"
331  " Peforms an immediate refresh of the managed DNS entries.\n"
332  " Optional regular expression pattern is used to filter the entries to refresh.\n";
333  return NULL;
334  case CLI_GENERATE:
335  return NULL;
336  }
337 
338  if (!enabled) {
339  ast_cli(a->fd, "DNS Manager is disabled.\n");
340  return 0;
341  }
342 
343  if (a->argc > 3) {
344  return CLI_SHOWUSAGE;
345  }
346 
347  if (a->argc == 3) {
348  if (regcomp(&info.filter, a->argv[2], REG_EXTENDED | REG_NOSUB)) {
349  return CLI_SHOWUSAGE;
350  } else {
351  info.regex_present = 1;
352  }
353  }
354 
355  refresh_list(&info);
356 
357  if (info.regex_present) {
358  regfree(&info.filter);
359  }
360 
361  return CLI_SUCCESS;
362 }
363 
364 static char *handle_cli_status(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
365 {
366  int count = 0;
367  struct ast_dnsmgr_entry *entry;
368  switch (cmd) {
369  case CLI_INIT:
370  e->command = "dnsmgr status";
371  e->usage =
372  "Usage: dnsmgr status\n"
373  " Displays the DNS manager status.\n";
374  return NULL;
375  case CLI_GENERATE:
376  return NULL;
377  }
378 
379  if (a->argc > 2)
380  return CLI_SHOWUSAGE;
381 
382  ast_cli(a->fd, "DNS Manager: %s\n", enabled ? "enabled" : "disabled");
383  ast_cli(a->fd, "Refresh Interval: %d seconds\n", refresh_interval);
384  AST_RWLIST_RDLOCK(&entry_list);
385  AST_RWLIST_TRAVERSE(&entry_list, entry, list)
386  count++;
387  AST_RWLIST_UNLOCK(&entry_list);
388  ast_cli(a->fd, "Number of entries: %d\n", count);
389 
390  return CLI_SUCCESS;
391 }
392 
393 static struct ast_cli_entry cli_reload = AST_CLI_DEFINE(handle_cli_reload, "Reloads the DNS manager configuration");
394 static struct ast_cli_entry cli_refresh = AST_CLI_DEFINE(handle_cli_refresh, "Performs an immediate refresh");
395 static struct ast_cli_entry cli_status = AST_CLI_DEFINE(handle_cli_status, "Display the DNS manager status");
396 
397 static void dnsmgr_shutdown(void)
398 {
402 
403  /* Destroy refresh thread. */
404  ast_mutex_lock(&refresh_lock);
405  if (refresh_thread != AST_PTHREADT_NULL) {
406  /* wake up the thread so it will exit */
407  pthread_cancel(refresh_thread);
408  pthread_kill(refresh_thread, SIGURG);
409  pthread_join(refresh_thread, NULL);
410  refresh_thread = AST_PTHREADT_NULL;
411  }
412  ast_mutex_unlock(&refresh_lock);
413 
414  sched_context_destroy(sched);
415 }
416 
417 int dnsmgr_init(void)
418 {
419  if (!(sched = sched_context_create())) {
420  ast_log(LOG_ERROR, "Unable to create schedule context.\n");
421  return -1;
422  }
426 
428 
429  return do_reload(1);
430 }
431 
432 int dnsmgr_reload(void)
433 {
434  return do_reload(0);
435 }
436 
437 static int do_reload(int loading)
438 {
439  struct ast_config *config;
440  struct ast_flags config_flags = { loading ? 0 : CONFIG_FLAG_FILEUNCHANGED };
441  const char *interval_value;
442  const char *enabled_value;
443  int interval;
444  int was_enabled;
445  int res = -1;
446 
447  config = ast_config_load2("dnsmgr.conf", "dnsmgr", config_flags);
448  if (config == CONFIG_STATUS_FILEMISSING || config == CONFIG_STATUS_FILEUNCHANGED || config == CONFIG_STATUS_FILEINVALID) {
449  return 0;
450  }
451 
452  /* ensure that no refresh cycles run while the reload is in progress */
453  ast_mutex_lock(&refresh_lock);
454 
455  /* reset defaults in preparation for reading config file */
457  was_enabled = enabled;
458  enabled = 0;
459 
460  AST_SCHED_DEL(sched, refresh_sched);
461 
462  if (config) {
463  if ((enabled_value = ast_variable_retrieve(config, "general", "enable"))) {
464  enabled = ast_true(enabled_value);
465  }
466  if ((interval_value = ast_variable_retrieve(config, "general", "refreshinterval"))) {
467  if (sscanf(interval_value, "%30d", &interval) < 1)
468  ast_log(LOG_WARNING, "Unable to convert '%s' to a numeric value.\n", interval_value);
469  else if (interval < 0)
470  ast_log(LOG_WARNING, "Invalid refresh interval '%d' specified, using default\n", interval);
471  else
472  refresh_interval = interval;
473  }
474  ast_config_destroy(config);
475  }
476 
477  if (enabled && refresh_interval)
478  ast_log(LOG_NOTICE, "Managed DNS entries will be refreshed every %d seconds.\n", refresh_interval);
479 
480  /* if this reload enabled the manager, create the background thread
481  if it does not exist */
482  if (enabled) {
483  if (!was_enabled && (refresh_thread == AST_PTHREADT_NULL)) {
484  if (ast_pthread_create_background(&refresh_thread, NULL, do_refresh, NULL) < 0) {
485  ast_log(LOG_ERROR, "Unable to start refresh thread.\n");
486  }
487  }
488  /* make a background refresh happen right away */
489  refresh_sched = ast_sched_add_variable(sched, 100, refresh_list, &master_refresh_info, 1);
490  res = 0;
491  }
492  /* if this reload disabled the manager and there is a background thread,
493  kill it */
494  else if (!enabled && was_enabled && (refresh_thread != AST_PTHREADT_NULL)) {
495  /* wake up the thread so it will exit */
496  pthread_cancel(refresh_thread);
497  pthread_kill(refresh_thread, SIGURG);
498  pthread_join(refresh_thread, NULL);
499  refresh_thread = AST_PTHREADT_NULL;
500  res = 0;
501  }
502  else
503  res = 0;
504 
505  ast_mutex_unlock(&refresh_lock);
506  manager_event(EVENT_FLAG_SYSTEM, "Reload", "Module: DNSmgr\r\nStatus: %s\r/nMessage: DNSmgr reload Requested\r\n", enabled ? "Enabled" : "Disabled");
507 
508  return res;
509 }
struct sockaddr_storage ss
Definition: netsock2.h:64
regex_t filter
Definition: dnsmgr.c:88
ast_mutex_t lock
Definition: dnsmgr.c:69
#define AST_CLI_DEFINE(fn, txt,...)
Definition: cli.h:191
static struct refresh_info master_refresh_info
Definition: dnsmgr.c:91
Asterisk main include file. File version handling, generic pbx functions.
const char * ast_variable_retrieve(const struct ast_config *config, const char *category, const char *variable)
Gets a variable.
Definition: config.c:625
static const char config[]
Definition: cdr_csv.c:57
#define AST_RWLIST_HEAD_STATIC(name, type)
Defines a structure to be used to hold a read/write list of specified type, statically initialized...
Definition: linkedlists.h:332
int ast_sched_add_variable(struct sched_context *con, int when, ast_sched_cb callback, const void *data, int variable) attribute_warn_unused_result
Schedule callback(data) to happen when ms into the future.
Definition: sched.c:406
int ast_cli_register(struct ast_cli_entry *e)
Registers a command or an array of commands.
Definition: cli.c:2159
int ast_sockaddr_parse(struct ast_sockaddr *addr, const char *str, int flags)
Parse an IPv4 or IPv6 address string.
Definition: netsock2.c:198
static int refresh_interval
Definition: dnsmgr.c:82
static void ast_sockaddr_copy(struct ast_sockaddr *dst, const struct ast_sockaddr *src)
Copies the data from one ast_sockaddr to another.
Definition: netsock2.h:121
struct entry_list * entries
Definition: dnsmgr.c:85
#define AST_RWLIST_WRLOCK(head)
Write locks a list.
Definition: linkedlists.h:51
int ast_cli_unregister(struct ast_cli_entry *e)
Unregisters a command or an array of commands.
Definition: cli.c:2153
descriptor for a cli entry.
Definition: cli.h:165
const int argc
Definition: cli.h:154
#define LOG_WARNING
Definition: logger.h:144
#define AST_RWLIST_UNLOCK(head)
Attempts to unlock a read/write based list.
Definition: linkedlists.h:150
socklen_t len
Definition: netsock2.h:65
static struct ast_cli_entry cli_reload
Definition: dnsmgr.c:393
static char * handle_cli_refresh(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition: dnsmgr.c:320
Definition: cli.h:146
Configuration File Parser.
#define REFRESH_DEFAULT
Definition: dnsmgr.c:79
static pthread_t refresh_thread
Definition: dnsmgr.c:54
struct ast_dnsmgr_entry * ast_dnsmgr_get(const char *name, struct ast_sockaddr *result, const char *service)
Allocate a new DNS manager entry.
Definition: dnsmgr.c:121
Background DNS update manager.
static int refresh_sched
Definition: dnsmgr.c:53
#define ast_mutex_lock(a)
Definition: lock.h:155
static struct ast_cli_entry cli_refresh
Definition: dnsmgr.c:394
Definition: dnsmgr.c:56
int ast_sockaddr_cmp(const struct ast_sockaddr *a, const struct ast_sockaddr *b)
Compares two ast_sockaddr structures.
Definition: netsock2.c:300
unsigned int family
Definition: dnsmgr.c:62
int ast_dnsmgr_refresh(struct ast_dnsmgr_entry *entry)
Force a refresh of a dnsmgr entry.
Definition: dnsmgr.c:230
void ast_cli(int fd, const char *fmt,...)
Definition: cli.c:105
Socket address structure.
Definition: netsock2.h:63
struct ast_config * ast_config_load2(const char *filename, const char *who_asked, struct ast_flags flags)
Load a config file.
Definition: config.c:2499
#define ast_verb(level,...)
Definition: logger.h:243
void ast_config_destroy(struct ast_config *config)
Destroys a config.
Definition: config.c:1037
Utility functions.
#define ast_pthread_create_background(a, b, c, d)
Definition: utils.h:426
#define CONFIG_STATUS_FILEMISSING
Definition: config.h:50
#define ast_sockaddr_port(addr)
Get the port number of a socket address.
Definition: netsock2.h:406
#define AST_RWLIST_RDLOCK(head)
Read locks a list.
Definition: linkedlists.h:77
#define AST_RWLIST_INSERT_HEAD
Definition: linkedlists.h:703
#define EVENT_FLAG_SYSTEM
Definition: manager.h:71
dns_update_func update_func
Definition: dnsmgr.c:68
#define AST_SCHED_DEL(sched, id)
a loop construct to ensure that the scheduled task get deleted. The idea is that if we loop attemptin...
Definition: sched.h:51
#define ast_mutex_trylock(a)
Definition: lock.h:157
const int fd
Definition: cli.h:153
void ast_dnsmgr_release(struct ast_dnsmgr_entry *entry)
Free a DNS manager entry.
Definition: dnsmgr.c:126
#define AST_PTHREADT_NULL
Definition: lock.h:65
static force_inline int attribute_pure ast_strlen_zero(const char *s)
Definition: strings.h:63
Access Control of various sorts.
static int do_reload(int loading)
Definition: dnsmgr.c:437
#define AST_RWLIST_TRAVERSE
Definition: linkedlists.h:493
Scheduler Routines (derived from cheops)
int ast_register_atexit(void(*func)(void))
Register a function to be executed before Asterisk exits.
Definition: asterisk.c:998
struct ast_sockaddr * result
Definition: dnsmgr.c:58
A set of macros to manage forward-linked lists.
static struct sched_context * sched
Definition: chan_gtalk.c:227
const char *const * argv
Definition: cli.h:155
The AMI - Asterisk Manager Interface - is a TCP protocol created to manage Asterisk with third-party ...
static struct ast_cli_entry cli_status
Definition: dnsmgr.c:395
#define ast_strdupa(s)
duplicate a string in memory from the stack
Definition: utils.h:663
static ast_mutex_t refresh_lock
Definition: dnsmgr.c:77
void(* dns_update_func)(struct ast_sockaddr *old_addr, struct ast_sockaddr *new_addr, void *data)
Definition: dnsmgr.h:40
void * data
Definition: dnsmgr.c:66
#define LOG_ERROR
Definition: logger.h:155
static void dnsmgr_shutdown(void)
Definition: dnsmgr.c:397
int attribute_pure ast_true(const char *val)
Make sure something is true. Determine if a string containing a boolean value is &quot;true&quot;. This function checks to see whether a string passed to it is an indication of an &quot;true&quot; value. It checks to see if the string is &quot;yes&quot;, &quot;true&quot;, &quot;y&quot;, &quot;t&quot;, &quot;on&quot; or &quot;1&quot;.
Definition: utils.c:1533
void sched_context_destroy(struct sched_context *c)
destroys a schedule context Destroys (free&#39;s) the given sched_context structure
Definition: sched.c:267
unsigned int regex_present
Definition: dnsmgr.c:87
#define CLI_SHOWUSAGE
Definition: cli.h:44
#define ast_sockaddr_set_port(addr, port)
Sets the port number of a socket address.
Definition: netsock2.h:422
static int refresh_list(const void *data)
Definition: dnsmgr.c:263
static char * ast_sockaddr_stringify(const struct ast_sockaddr *addr)
Wrapper around ast_sockaddr_stringify_fmt() with default format.
Definition: netsock2.h:210
void ast_log(int level, const char *file, int line, const char *function, const char *fmt,...)
Used for sending a log message This is the standard logger function. Probably the only way you will i...
Definition: logger.c:1207
static int dnsmgr_refresh(struct ast_dnsmgr_entry *entry, int verbose)
Definition: dnsmgr.c:193
#define LOG_NOTICE
Definition: logger.h:133
static const char name[]
#define ast_free(a)
Definition: astmm.h:97
char * command
Definition: cli.h:180
static char * handle_cli_status(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition: dnsmgr.c:364
Structure used to handle boolean flags.
Definition: utils.h:200
#define AST_RWLIST_ENTRY
Definition: linkedlists.h:414
int ast_sched_runq(struct sched_context *con)
Runs the queue.
Definition: sched.c:600
const char * usage
Definition: cli.h:171
int dnsmgr_reload(void)
Definition: dnsmgr.c:432
int ast_get_ip_or_srv(struct ast_sockaddr *addr, const char *hostname, const char *service)
Get the IP address given a hostname and optional service.
Definition: acl.c:597
static int internal_dnsmgr_lookup(const char *name, struct ast_sockaddr *result, struct ast_dnsmgr_entry **dnsmgr, const char *service, dns_update_func func, void *data)
Definition: dnsmgr.c:140
#define CLI_SUCCESS
Definition: cli.h:43
struct sched_context * sched_context_create(void)
New schedule context.
Definition: sched.c:246
Standard Command Line Interface.
#define ast_calloc(a, b)
Definition: astmm.h:82
int ast_dnsmgr_lookup(const char *name, struct ast_sockaddr *result, struct ast_dnsmgr_entry **dnsmgr, const char *service)
Allocate and initialize a DNS manager entry.
Definition: dnsmgr.c:180
int dnsmgr_init(void)
Definition: dnsmgr.c:417
int ast_sched_wait(struct sched_context *con) attribute_warn_unused_result
Determines number of seconds until the next outstanding event to take place Determine the number of s...
Definition: sched.c:334
void dnsmgr_start_refresh(void)
Definition: dnsmgr.c:291
static char * handle_cli_reload(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition: dnsmgr.c:301
int ast_dnsmgr_changed(struct ast_dnsmgr_entry *entry)
Check is see if a dnsmgr entry has changed.
Definition: dnsmgr.c:238
#define AST_RWLIST_REMOVE
Definition: linkedlists.h:870
int verbose
Definition: dnsmgr.c:86
unsigned int changed
Definition: dnsmgr.c:64
#define ast_mutex_init(pmutex)
Definition: lock.h:152
#define CONFIG_STATUS_FILEINVALID
Definition: config.h:52
static int enabled
Definition: cdr.c:91
#define ast_mutex_destroy(a)
Definition: lock.h:154
#define manager_event(category, event, contents,...)
External routines may send asterisk manager events this way.
Definition: manager.h:219
static struct entry_list entry_list
static void * do_refresh(void *data)
Definition: dnsmgr.c:252
#define AST_MUTEX_DEFINE_STATIC(mutex)
Definition: lock.h:526
Structure for mutex and tracking information.
Definition: lock.h:121
int ast_dnsmgr_lookup_cb(const char *name, struct ast_sockaddr *result, struct ast_dnsmgr_entry **dnsmgr, const char *service, dns_update_func func, void *data)
Allocate and initialize a DNS manager entry, with update callback.
Definition: dnsmgr.c:185
struct ast_dnsmgr_entry * ast_dnsmgr_get_family(const char *name, struct ast_sockaddr *result, const char *service, unsigned int family)
Allocate a new DNS manager entry.
Definition: dnsmgr.c:96
#define ASTERISK_FILE_VERSION(file, version)
Register/unregister a source code file with the core.
Definition: asterisk.h:180
#define CONFIG_STATUS_FILEUNCHANGED
Definition: config.h:51
#define ast_mutex_unlock(a)
Definition: lock.h:156
char * service
Definition: dnsmgr.c:60