Sat Nov 1 06:31:10 2008

Asterisk developer's documentation

---

pbx_config.c File Reference

Populate and remember extensions from static config file. More...

#include <sys/types.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include "asterisk.h"
#include "asterisk/pbx.h"
#include "asterisk/config.h"
#include "asterisk/options.h"
#include "asterisk/module.h"
#include "asterisk/logger.h"
#include "asterisk/cli.h"
#include "asterisk/callerid.h"

Include dependency graph for pbx_config.c:

Go to the source code of this file.

Defines
#define	BROKEN_READLINE   1
#define	FREE   free
Functions
	AST_MUTEX_DEFINE_STATIC (save_dialplan_lock)
static char *	complete_context_add_extension (char *line, char *word, int pos, int state)
static char *	complete_context_add_ignorepat (char *line, char *word, int pos, int state)
static char *	complete_context_add_include (char *line, char *word, int pos, int state)
static char *	complete_context_dont_include (char *line, char *word, int pos, int state)
static char *	complete_context_remove_extension (char *line, char *word, int pos, int state)
static char *	complete_context_remove_ignorepat (char *line, char *word, int pos, int state)
char *	description (void)
	Provides a description of the module.
static int	fix_complete_args (char *line, char **word, int *pos)
static int	handle_context_add_extension (int fd, int argc, char *argv[])
	ADD EXTENSION command stuff.
static int	handle_context_add_ignorepat (int fd, int argc, char *argv[])
static int	handle_context_add_include (int fd, int argc, char *argv[])
static int	handle_context_dont_include (int fd, int argc, char *argv[])
static int	handle_context_remove_extension (int fd, int argc, char *argv[])
static int	handle_context_remove_ignorepat (int fd, int argc, char *argv[])
static int	handle_reload_extensions (int fd, int argc, char *argv[])
static int	handle_save_dialplan (int fd, int argc, char *argv[])
	'save dialplan' CLI command implementation functions ...
char *	key (void)
	Returns the ASTERISK_GPL_KEY.
int	load_module (void)
	Initialize the module.
static int	pbx_load_module (void)
int	reload (void)
	Reload stuff.
int	unload_module (void)
	Cleanup all module structures, sockets, etc.
int	usecount (void)
	Provides a usecount.
Variables
static int	autofallthrough_config = 0
static int	clearglobalvars_config = 0
static char *	config = "extensions.conf"
static struct ast_cli_entry	context_add_extension_cli
static char	context_add_extension_help []
static struct ast_cli_entry	context_add_ignorepat_cli
static char	context_add_ignorepat_help []
static struct ast_cli_entry	context_add_include_cli
static char	context_add_include_help []
static struct ast_cli_entry	context_dont_include_cli
static char	context_dont_include_help []
static struct ast_cli_entry	context_remove_extension_cli
static char	context_remove_extension_help []
static struct ast_cli_entry	context_remove_ignorepat_cli
static char	context_remove_ignorepat_help []
static char *	dtext = "Text Extension Configuration"
static struct ast_context *	local_contexts = NULL
static char *	registrar = "pbx_config"
static struct ast_cli_entry	reload_extensions_cli
static char	reload_extensions_help []
static struct ast_cli_entry	save_dialplan_cli
static char	save_dialplan_help []
static int	static_config = 0
static int	write_protect_config = 1

---

Detailed Description

Populate and remember extensions from static config file.

Definition in file pbx_config.c.

---

Define Documentation

#define BROKEN_READLINE   1

Definition at line 437 of file pbx_config.c.

#define FREE   free

Definition at line 51 of file pbx_config.c.

---

Function Documentation

AST_MUTEX_DEFINE_STATIC

(

save_dialplan_lock

)

static char* complete_context_add_extension	(	char *	line,
		char *	word,
		int	pos,
		int	state
	)			[static]

add extension 6123,1,Dial,IAX/212.71.138.13/6123 into local

Definition at line 1255 of file pbx_config.c.

References ast_get_context_name(), ast_lock_contexts(), ast_log(), ast_unlock_contexts(), ast_walk_contexts(), LOG_WARNING, and strdup.

{
   int which = 0;

   /* complete 'into' word ... */
   if (pos == 3) {
      if (state == 0) return strdup("into");
      return NULL;
   }

   /* complete context */
   if (pos == 4) {
      struct ast_context *c;

      /* try to lock contexts list ... */
      if (ast_lock_contexts()) {
         ast_log(LOG_WARNING, "Failed to lock contexts list\n");
         return NULL;
      }

      /* walk through all contexts */
      c = ast_walk_contexts(NULL);
      while (c) {
         /* matching context? */
         if (!strncmp(ast_get_context_name(c), word, strlen(word))) {
            if (++which > state) {
               char *res = strdup(ast_get_context_name(c));
               ast_unlock_contexts();
               return res;
            }
         }
         c = ast_walk_contexts(c);
      }

      ast_unlock_contexts();
      return NULL;
   }

   if (pos == 5) return state == 0 ? strdup("replace") : NULL;

   return NULL;
}

static char* complete_context_add_ignorepat	(	char *	line,
		char *	word,
		int	pos,
		int	state
	)			[static]

Definition at line 1338 of file pbx_config.c.

References ast_get_context_name(), ast_get_ignorepat_name(), ast_lock_context(), ast_lock_contexts(), ast_log(), ast_unlock_context(), ast_unlock_contexts(), ast_walk_context_ignorepats(), ast_walk_contexts(), context, free, LOG_ERROR, strdup, and strsep().

{
   if (pos == 3) return state == 0 ? strdup("into") : NULL;

   if (pos == 4) {
      struct ast_context *c;
      int which = 0;
      char *dupline, *duplinet, *ignorepat = NULL;

      dupline = strdup(line);
      duplinet = dupline;

      if (duplinet) {
         strsep(&duplinet, " "); /* skip 'add' */
         strsep(&duplinet, " "); /* skip 'ignorepat' */
         ignorepat = strsep(&duplinet, " ");
      }

      if (ast_lock_contexts()) {
         ast_log(LOG_ERROR, "Failed to lock contexts list\n");
         return NULL;
      }

      c = ast_walk_contexts(NULL);
      while (c) {
         if (!strncmp(ast_get_context_name(c), word, strlen(word))) {
            int serve_context = 1;
            if (ignorepat) {
               if (!ast_lock_context(c)) {
                  struct ast_ignorepat *ip;
                  ip = ast_walk_context_ignorepats(c, NULL);
                  while (ip && serve_context) {
                     if (!strcmp(ast_get_ignorepat_name(ip), ignorepat))
                        serve_context = 0;
                     ip = ast_walk_context_ignorepats(c, ip);
                  }
                  ast_unlock_context(c);
               }
            }
            if (serve_context) {
               if (++which > state) {
                  char *context = strdup(ast_get_context_name(c));
                  if (dupline) free(dupline);
                  ast_unlock_contexts();
                  return context;
               }
            }
         }
         c = ast_walk_contexts(c);
      }

      if (dupline) free(dupline);
      ast_unlock_contexts();
      return NULL;
   }

   return NULL;
}

static char* complete_context_add_include	(	char *	line,
		char *	word,
		int	pos,
		int	state
	)			[static]

Definition at line 748 of file pbx_config.c.

References ast_get_context_name(), ast_get_include_name(), ast_lock_context(), ast_lock_contexts(), ast_log(), ast_unlock_context(), ast_unlock_contexts(), ast_walk_context_includes(), ast_walk_contexts(), context, free, LOG_ERROR, strdup, and strsep().

{
   struct ast_context *c;
   int which = 0;

   /* server context for inclusion ... */
   if (pos == 1)
   {
      if (ast_lock_contexts()) {
         ast_log(LOG_ERROR, "Failed to lock context list\n");
         return NULL;
      }

      /* server all contexts */ 
      c = ast_walk_contexts(NULL); 
      while (c) {
         if ((!strlen(word) || 
             !strncmp(ast_get_context_name(c), word, strlen(word))) &&
            ++which > state)
         {
            char *context = strdup(ast_get_context_name(c));
            ast_unlock_contexts();
            return context;
         }
         c = ast_walk_contexts(c);
      }

      ast_unlock_contexts();
   }

   /* complete 'in' only if context exist ... */
   if (pos == 2)
   {
      char *context, *dupline, *duplinet;

      if (state != 0) return NULL;

      /* parse context from line ... */
      if (!(dupline = strdup(line))) {
         ast_log(LOG_ERROR, "Out of free memory\n");
         if (state == 0) return strdup("in");
         return NULL;
      }

      duplinet = dupline;

      strsep(&duplinet, " ");
      context = strsep(&duplinet, " ");
      if (context) {
         struct ast_context *c;
         int context_existence = 0;

         /* check for context existence ... */
         if (ast_lock_contexts()) {
            ast_log(LOG_ERROR, "Failed to lock context list\n");
            free(dupline);
            /* our fault, we can't check, so complete 'in' ... */
            return strdup("in");
         }

         c = ast_walk_contexts(NULL);
         while (c && !context_existence) {
            if (!strcmp(context, ast_get_context_name(c))) {
               context_existence = 1;
               continue;
            }
            c = ast_walk_contexts(c);
         }

         /* if context exists, return 'into' ... */
         if (context_existence) {
            free(dupline);
            ast_unlock_contexts();
            return strdup("into");
         }

         ast_unlock_contexts();
      }  

      free(dupline);
      return NULL;
   }

   /* serve context into which we include another context */
   if (pos == 3)
   {
      char *context, *dupline, *duplinet, *in;
      int context_existence = 0;

      if (!(dupline = strdup(line))) {
         ast_log(LOG_ERROR, "Out of free memory\n");
         return NULL;
      }

      duplinet = dupline;

      strsep(&duplinet, " "); /* skip 'include' */
      context = strsep(&duplinet, " ");
      in = strsep(&duplinet, " ");

      /* given some context and third word is in? */
      if (!strlen(context) || strcmp(in, "in")) {
         free(dupline);
         return NULL;
      }

      if (ast_lock_contexts()) {
         ast_log(LOG_ERROR, "Failed to lock context list\n");
         free(dupline);
         return NULL;
      }

      /* check for context existence ... */
      c = ast_walk_contexts(NULL);
      while (c && !context_existence) {
         if (!strcmp(context, ast_get_context_name(c))) {
            context_existence = 1;
            continue;
         }
         c = ast_walk_contexts(c);
      }

      if (!context_existence) {
         free(dupline);
         ast_unlock_contexts();
         return NULL;
      }

      /* go through all contexts ... */
      c = ast_walk_contexts(NULL);
      while (c) {
         /* must be different contexts ... */
         if (strcmp(context, ast_get_context_name(c))) {
            if (!ast_lock_context(c)) {
               struct ast_include *i;
               int included = 0;

               /* check for duplicity inclusion ... */
               i = ast_walk_context_includes(c, NULL);
               while (i && !included) {
                  if (!strcmp(ast_get_include_name(i), context))
                     included = 1;
                  i = ast_walk_context_includes(c, i);
               }
               ast_unlock_context(c);

               /* not included yet, so show possibility ... */
               if (!included &&
                  !strncmp(ast_get_context_name(c), word, strlen(word))){
                  
                  if (++which > state) {
                     char *res = strdup(ast_get_context_name(c));
                     free(dupline);
                     ast_unlock_contexts();
                     return res;
                  }
               }  
            }
         }
         c = ast_walk_contexts(c);
      }

      ast_unlock_contexts();
      free(dupline);
      return NULL;
   }

   return NULL;
}

static char* complete_context_dont_include	(	char *	line,
		char *	word,
		int	pos,
		int	state
	)			[static]

Definition at line 146 of file pbx_config.c.

References ast_get_context_name(), ast_get_include_name(), ast_lock_context(), ast_lock_contexts(), ast_log(), ast_unlock_context(), ast_unlock_contexts(), ast_walk_context_includes(), ast_walk_contexts(), context, free, LOG_ERROR, LOG_WARNING, strdup, and strsep().

{
   int which = 0;

   /*
    * Context completion ...
    */
   if (pos == 2) {
      struct ast_context *c;

      if (ast_lock_contexts()) {
         ast_log(LOG_ERROR, "Failed to lock context list\n");
         return NULL;
      }

      /* walk pbx_get_contexts ... */
      c = ast_walk_contexts(NULL); 
      while (c) {
         struct ast_include *i;

         if (ast_lock_context(c)) {
            c = ast_walk_contexts(c);
            continue;
         }

         i = ast_walk_context_includes(c, NULL);
         while (i) {
            if (!strlen(word) ||
               !strncmp(ast_get_include_name(i), word, strlen(word))) {
               struct ast_context *nc;
               int already_served = 0;

               /* check if this include is already served or not */

               /* go through all contexts again till we reach actuall
                * context or already_served = 1
                */
               nc = ast_walk_contexts(NULL);
               while (nc && nc != c && !already_served) {
                  if (!ast_lock_context(nc)) {
                     struct ast_include *ni;

                     ni = ast_walk_context_includes(nc, NULL);
                     while (ni && !already_served) {
                        if (!strcmp(ast_get_include_name(i),
                           ast_get_include_name(ni)))
                           already_served = 1;
                        ni = ast_walk_context_includes(nc, ni);
                     }  
                     
                     ast_unlock_context(nc);
                  }
                  nc = ast_walk_contexts(nc);
               }

               if (!already_served) {
                  if (++which > state) {
                     char *res =
                        strdup(ast_get_include_name(i));
                     ast_unlock_context(c);
                     ast_unlock_contexts();
                     return res;
                  }
               }
            }
            i = ast_walk_context_includes(c, i);
         }

         ast_unlock_context(c);
         c = ast_walk_contexts(c);
      }

      ast_unlock_contexts();
      return NULL;
   }

   /*
    * 'in' completion ... (complete only if previous context is really
    * included somewhere)
    */
   if (pos == 3) {
      struct ast_context *c;
      char *context, *dupline, *duplinet;

      if (state > 0) return NULL;

      /* take 'context' from line ... */
      if (!(dupline = strdup(line))) {
         ast_log(LOG_ERROR, "Out of free memory\n");
         return NULL;
      }

      duplinet = dupline;
      strsep(&duplinet, " "); /* skip 'dont' */
      strsep(&duplinet, " "); /* skip 'include' */
      context = strsep(&duplinet, " ");

      if (!context) {
         free(dupline);
         return NULL;
      }

      if (ast_lock_contexts()) {
         ast_log(LOG_WARNING, "Failed to lock contexts list\n");
         free(dupline);
         return NULL;
      }

      /* go through all contexts and check if is included ... */
      c = ast_walk_contexts(NULL);
      while (c) {
         struct ast_include *i;
         if (ast_lock_context(c)) {
            free(dupline);
            ast_unlock_contexts();
            return NULL;
         }

         i = ast_walk_context_includes(c, NULL);
         while (i) {
            /* is it our context? */
            if (!strcmp(ast_get_include_name(i), context)) {
               /* yes, it is, context is really included, so
                * complete "in" command
                */
               free(dupline);
               ast_unlock_context(c);
               ast_unlock_contexts();
               return strdup("in");
            }
            i = ast_walk_context_includes(c, i);
         }
         ast_unlock_context(c);
         c = ast_walk_contexts(c);
      }
      free(dupline);
      ast_unlock_contexts();
      return NULL;
   }

   /*
    * Context from which we removing include ... 
    */
   if (pos == 4) {
      struct ast_context *c;
      char *context, *dupline, *duplinet, *in;

      if (!(dupline = strdup(line))) {
         ast_log(LOG_ERROR, "Out of free memory\n");
         return NULL;
      }

      duplinet = dupline;

      strsep(&duplinet, " "); /* skip 'dont' */
      strsep(&duplinet, " "); /* skip 'include' */

      if (!(context = strsep(&duplinet, " "))) {
         free(dupline);
         return NULL;
      }

      /* third word must be in */
      in = strsep(&duplinet, " ");
      if (!in ||
         strcmp(in, "in")) {
         free(dupline);
         return NULL;
      }

      if (ast_lock_contexts()) {
         ast_log(LOG_ERROR, "Failed to lock context list\n");
         free(dupline);
         return NULL;
      }

      /* walk through all contexts ... */
      c = ast_walk_contexts(NULL);
      while (c) {
         struct ast_include *i;
         if (ast_lock_context(c)) {
            free(dupline);
            return NULL;
         }
   
         /* walk through all includes and check if it is our context */ 
         i = ast_walk_context_includes(c, NULL);
         while (i) {
            /* is in this context included another on which we want to
             * remove?
             */
            if (!strcmp(context, ast_get_include_name(i))) {
               /* yes, it's included, is matching our word too? */
               if (!strncmp(ast_get_context_name(c),
                     word, strlen(word))) {
                  /* check state for completion */
                  if (++which > state) {
                     char *res = strdup(ast_get_context_name(c));
                     free(dupline);
                     ast_unlock_context(c);
                     ast_unlock_contexts();
                     return res;
                  }
               }
               break;
            }
            i = ast_walk_context_includes(c, i);
         }  
         ast_unlock_context(c);
         c = ast_walk_contexts(c);
      }

      free(dupline);
      ast_unlock_contexts();
      return NULL;
   }

   return NULL;
}

static char* complete_context_remove_extension	(	char *	line,
		char *	word,
		int	pos,
		int	state
	)			[static]

Definition at line 484 of file pbx_config.c.

References ast_get_context_name(), ast_get_extension_name(), ast_get_extension_priority(), ast_lock_contexts(), ast_log(), ast_unlock_contexts(), ast_walk_context_extensions(), ast_walk_contexts(), ast_walk_extension_priorities(), context, exten, fix_complete_args(), free, LOG_ERROR, malloc, ast_exten::priority, strdup, and strsep().

{
   char *ret = NULL;
   int which = 0;

#ifdef BROKEN_READLINE
   /*
    * Fix arguments, *word is a new allocated structure, REMEMBER to
    * free *word when you want to return from this function ...
    */
   if (fix_complete_args(line, &word, &pos)) {
      ast_log(LOG_ERROR, "Out of free memory\n");
      return NULL;
   }
#endif

   /*
    * exten@context completion ... 
    */
   if (pos == 2) {
      struct ast_context *c;
      struct ast_exten *e;
      char *context = NULL, *exten = NULL, *delim = NULL;

      /* now, parse values from word = exten@context */
      if ((delim = strchr(word, (int)'@'))) {
         /* check for duplicity ... */
         if (delim != strrchr(word, (int)'@')) {
#ifdef BROKEN_READLINE
            free(word);
#endif
            return NULL;
         }

         *delim = '\0';
         exten = strdup(word);
         context = strdup(delim + 1);
         *delim = '@';
      } else {
         exten = strdup(word);
      }
#ifdef BROKEN_READLINE
      free(word);
#endif

      if (ast_lock_contexts()) {
         ast_log(LOG_ERROR, "Failed to lock context list\n");
         free(context); free(exten);
         return NULL;
      }

      /* find our context ... */
      c = ast_walk_contexts(NULL); 
      while (c) {
         /* our context? */
         if ( (!context || !strlen(context)) ||                            /* if no input, all contexts ... */
             (context && !strncmp(ast_get_context_name(c),
                          context, strlen(context))) ) {                  /* if input, compare ... */
            /* try to complete extensions ... */
            e = ast_walk_context_extensions(c, NULL);
            while (e) {
               /* our extension? */
               if ( (!exten || !strlen(exten)) ||                           /* if not input, all extensions ... */
                   (exten && !strncmp(ast_get_extension_name(e), exten,
                                      strlen(exten))) ) { /* if input, compare ... */
                  if (++which > state) {
                     /* If there is an extension then return
                      * exten@context.
                      */
                     if (exten) {
                        ret = malloc(strlen(ast_get_extension_name(e)) +
                           strlen(ast_get_context_name(c)) + 2);
                        if (ret)
                           sprintf(ret, "%s@%s", ast_get_extension_name(e),
                              ast_get_context_name(c));
                     }
                     free(exten); free(context);

                     ast_unlock_contexts();
   
                     return ret;
                  }
               }
               e = ast_walk_context_extensions(c, e);
            }
         }
         c = ast_walk_contexts(c);
      }

      ast_unlock_contexts();

      free(exten); free(context);

      return NULL;
   }

   /*
    * Complete priority ...
    */
   if (pos == 3) {
      char *delim, *exten, *context, *dupline, *duplinet, *ec;
      struct ast_context *c;

      dupline = strdup(line);
      if (!dupline) {
#ifdef BROKEN_READLINE
         free(word);
#endif
         return NULL;
      }
      duplinet = dupline;

      strsep(&duplinet, " "); /* skip 'remove' */
      strsep(&duplinet, " "); /* skip 'extension */

      if (!(ec = strsep(&duplinet, " "))) {
         free(dupline);
#ifdef BROKEN_READLINE
         free(word);
#endif
         return NULL;
      }

      /* wrong exten@context format? */
      if (!(delim = strchr(ec, (int)'@')) ||
         (strchr(ec, (int)'@') != strrchr(ec, (int)'@'))) {
#ifdef BROKEN_READLINE
         free(word);
#endif
         free(dupline);
         return NULL;
      }

      /* check if there is exten and context too ... */
      *delim = '\0';
      if ((!strlen(ec)) || (!strlen(delim + 1))) {
#ifdef BROKEN_READLINE
         free(word);
#endif
         free(dupline);
         return NULL;
      }

      exten = strdup(ec);
      context = strdup(delim + 1);
      free(dupline);

      if (ast_lock_contexts()) {
         ast_log(LOG_ERROR, "Failed to lock context list\n");
#ifdef BROKEN_READLINE
         free(word);
#endif
         free(exten); free(context);
         return NULL;
      }

      /* walk contexts */
      c = ast_walk_contexts(NULL); 
      while (c) {
         if (!strcmp(ast_get_context_name(c), context)) {
            struct ast_exten *e;

            /* walk extensions */
            free(context);
            e = ast_walk_context_extensions(c, NULL); 
            while (e) {
               if (!strcmp(ast_get_extension_name(e), exten)) {
                  struct ast_exten *priority;
                  char buffer[10];
               
                  free(exten);
                  priority = ast_walk_extension_priorities(e, NULL);
                  /* serve priorities */
                  do {
                     snprintf(buffer, 10, "%u",
                        ast_get_extension_priority(priority));
                     if (!strncmp(word, buffer, strlen(word))) {
                        if (++which > state) {
#ifdef BROKEN_READLINE
                           free(word);
#endif
                           ast_unlock_contexts();
                           return strdup(buffer);
                        }
                     }
                     priority = ast_walk_extension_priorities(e,
                        priority);
                  } while (priority);

#ifdef BROKEN_READLINE
                  free(word);
#endif
                  ast_unlock_contexts();
                  return NULL;         
               }
               e = ast_walk_context_extensions(c, e);
            }
#ifdef BROKEN_READLINE
            free(word);
#endif
            free(exten);
            ast_unlock_contexts();
            return NULL;
         }
         c = ast_walk_contexts(c);
      }

#ifdef BROKEN_READLINE
      free(word);
#endif
      free(exten); free(context);

      ast_unlock_contexts();
      return NULL;
   }

#ifdef BROKEN_READLINE
   free(word);
#endif
   return NULL; 
}

static char* complete_context_remove_ignorepat	(	char *	line,
		char *	word,
		int	pos,
		int	state
	)			[static]

Definition at line 1441 of file pbx_config.c.

References ast_get_context_name(), ast_get_ignorepat_name(), ast_lock_context(), ast_lock_contexts(), ast_log(), ast_unlock_context(), ast_unlock_contexts(), ast_walk_context_ignorepats(), ast_walk_contexts(), free, LOG_WARNING, strdup, and strsep().

{
   struct ast_context *c;
   int which = 0;

   if (pos == 2) {
      if (ast_lock_contexts()) {
         ast_log(LOG_WARNING, "Failed to lock contexts list\n");
         return NULL;
      }

      c = ast_walk_contexts(NULL);
      while (c) {
         if (!ast_lock_context(c)) {
            struct ast_ignorepat *ip;
         
            ip = ast_walk_context_ignorepats(c, NULL);
            while (ip) {
               if (!strncmp(ast_get_ignorepat_name(ip), word, strlen(word))) {
                  if (which + 1 > state) {
                     struct ast_context *cw;
                     int already_served = 0;
                     cw = ast_walk_contexts(NULL);
                     while (cw && cw != c && !already_served) {
                        if (!ast_lock_context(cw)) {
                           struct ast_ignorepat *ipw;
                           ipw = ast_walk_context_ignorepats(cw, NULL);
                           while (ipw) {
                              if (!strcmp(ast_get_ignorepat_name(ipw),
                                 ast_get_ignorepat_name(ip))) already_served = 1;
                              ipw = ast_walk_context_ignorepats(cw, ipw);
                           }
                           ast_unlock_context(cw);
                        }
                        cw = ast_walk_contexts(cw);
                     }
                     if (!already_served) {
                        char *ret = strdup(ast_get_ignorepat_name(ip));
                        ast_unlock_context(c);
                        ast_unlock_contexts();
                        return ret;
                     }
                  } else
                     which++;
               }
               ip = ast_walk_context_ignorepats(c, ip);
            }

            ast_unlock_context(c);
         }
         c = ast_walk_contexts(c);
      }

      ast_unlock_contexts();
      return NULL;
   }
 
   if (pos == 3) return state == 0 ? strdup("from") : NULL;

   if (pos == 4) {
      char *dupline, *duplinet, *ignorepat;

      dupline = strdup(line);
      if (!dupline) {
         ast_log(LOG_WARNING, "Out of free memory\n");
         return NULL;
      }

      duplinet = dupline;
      strsep(&duplinet, " ");
      strsep(&duplinet, " ");
      ignorepat = strsep(&duplinet, " ");

      if (!ignorepat) {
         free(dupline);
         return NULL;
      }

      if (ast_lock_contexts()) {
         ast_log(LOG_WARNING, "Failed to lock contexts list\n");
         free(dupline);
         return NULL;
      }

      c = ast_walk_contexts(NULL);
      while (c) {
         if (!ast_lock_context(c)) {
            struct ast_ignorepat *ip;
            ip = ast_walk_context_ignorepats(c, NULL);
            while (ip) {
               if (!strcmp(ast_get_ignorepat_name(ip), ignorepat)) {
                  if (!strncmp(ast_get_context_name(c), word, strlen(word))) {
                     if (++which > state) {
                        char *ret = strdup(ast_get_context_name(c));
                        free(dupline);
                        ast_unlock_context(c);
                        ast_unlock_contexts();
                        return ret;
                     }
                  }
               }
               ip = ast_walk_context_ignorepats(c, ip);
            }

            ast_unlock_context(c);
         }
         c = ast_walk_contexts(c);
      }

      free(dupline);
      ast_unlock_contexts();
      return NULL;
   }

   return NULL;
}

char* description

(

void

)

Provides a description of the module.

Returns:

a short description of your module

Definition at line 1837 of file pbx_config.c.

{
   return dtext;
}

static int fix_complete_args	(	char *	line,
		char **	word,
		int *	pos
	)			[static]

Definition at line 452 of file pbx_config.c.

References free, strdup, and strsep().

Referenced by complete_context_remove_extension().

{
   char *_line, *_strsep_line, *_previous_word = NULL, *_word = NULL;
   int words = 0;

   _line = strdup(line);

   _strsep_line = _line;
   while (_strsep_line) {
      _previous_word = _word;
      _word = strsep(&_strsep_line, " ");

      if (_word && strlen(_word)) words++;
   }


   if (_word || _previous_word) {
      if (_word) {
         if (!strlen(_word)) words++;
         *word = strdup(_word);
      } else
         *word = strdup(_previous_word);
      *pos = words - 1;
      free(_line);
      return 0;
   }

   free(_line);
   return -1;
}

static int handle_context_add_extension	(	int	fd,
		int	argc,
		char *	argv[]
	)			[static]

ADD EXTENSION command stuff.

Definition at line 1169 of file pbx_config.c.

References app, ast_add_extension(), ast_cli(), ast_process_quotes_and_slashes(), ast_exten::cidmatch, exten, free, PRIORITY_HINT, RESULT_FAILURE, RESULT_SHOWUSAGE, RESULT_SUCCESS, strdup, and strsep().

{
   char *whole_exten;
   char *exten, *prior;
   int iprior = -2;
   char *cidmatch, *app, *app_data;
   char *start, *end;

   /* check for arguments at first */
   if (argc != 5 && argc != 6) return RESULT_SHOWUSAGE;
   if (strcmp(argv[3], "into")) return RESULT_SHOWUSAGE;
   if (argc == 6) if (strcmp(argv[5], "replace")) return RESULT_SHOWUSAGE;

   whole_exten = argv[2];
   exten       = strsep(&whole_exten,",");
   if (strchr(exten, '/')) {
      cidmatch = exten;
      strsep(&cidmatch,"/");
   } else {
      cidmatch = NULL;
   }
   prior       = strsep(&whole_exten,",");
   if (prior) {
      if (!strcmp(prior, "hint")) {
         iprior = PRIORITY_HINT;
      } else {
         if (sscanf(prior, "%d", &iprior) != 1) {
            ast_cli(fd, "'%s' is not a valid priority\n", prior);
            prior = NULL;
         }
      }
   }
   app = whole_exte