Sat Nov 1 06:30:28 2008

Asterisk developer's documentation

---

app_meetme.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 1999 - 2006, Digium, Inc.
 *
 * Mark Spencer <markster@digium.com>
 *
 * 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.
 */

/*! \file
 *
 * \brief Meet me conference bridge
 * 
 * \ingroup applications
 */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/ioctl.h>
#ifdef __linux__
#include <linux/zaptel.h>
#else
#include <zaptel.h>
#endif /* __linux__ */

#include "asterisk.h"

ASTERISK_FILE_VERSION(__FILE__, "$Revision: 69894 $")

#include "asterisk/lock.h"
#include "asterisk/file.h"
#include "asterisk/logger.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/module.h"
#include "asterisk/config.h"
#include "asterisk/app.h"
#include "asterisk/dsp.h"
#include "asterisk/musiconhold.h"
#include "asterisk/manager.h"
#include "asterisk/options.h"
#include "asterisk/cli.h"
#include "asterisk/say.h"
#include "asterisk/utils.h"
#include "asterisk/linkedlists.h"

static const char *tdesc = "MeetMe conference bridge";

static const char *app = "MeetMe";
static const char *app2 = "MeetMeCount";
static const char *app3 = "MeetMeAdmin";

static const char *synopsis = "MeetMe conference bridge";
static const char *synopsis2 = "MeetMe participant count";
static const char *synopsis3 = "MeetMe conference Administration";

static const char *descrip =
"  MeetMe([confno][,[options][,pin]]): Enters the user into a specified MeetMe conference.\n"
"If the conference number is omitted, the user will be prompted to enter\n"
"one. \n"
"User can exit the conference by hangup, or if the 'p' option is specified, by pressing '#'.\n"
"Please note: The Zaptel kernel modules and at least one hardware driver (or ztdummy)\n"
"             must be present for conferencing to operate properly. In addition, the chan_zap\n"
"             channel driver must be loaded for the 'i' and 'r' options to operate at all.\n\n"
"The option string may contain zero or more of the following characters:\n"
"      'a' -- set admin mode\n"
"      'A' -- set marked mode\n"
"      'b' -- run AGI script specified in ${MEETME_AGI_BACKGROUND}\n"
"             Default: conf-background.agi\n"
"             (Note: This does not work with non-Zap channels in the same conference)\n"
"      'c' -- announce user(s) count on joining a conference\n"
"      'd' -- dynamically add conference\n"
"      'D' -- dynamically add conference, prompting for a PIN\n"
"      'e' -- select an empty conference\n"
"      'E' -- select an empty pinless conference\n"
"      'i' -- announce user join/leave\n"
"      'm' -- set monitor only mode (Listen only, no talking)\n"
"      'M' -- enable music on hold when the conference has a single caller\n"
"      'p' -- allow user to exit the conference by pressing '#'\n"
"      'P' -- always prompt for the pin even if it is specified\n"
"      'q' -- quiet mode (don't play enter/leave sounds)\n"
"      'r' -- Record conference (records as ${MEETME_RECORDINGFILE}\n"
"             using format ${MEETME_RECORDINGFORMAT}). Default filename is\n"
"             meetme-conf-rec-${CONFNO}-${UNIQUEID} and the default format is wav.\n"
"      's' -- Present menu (user or admin) when '*' is received ('send' to menu)\n"
"      't' -- set talk only mode. (Talk only, no listening)\n"
"      'T' -- set talker detection (sent to manager interface and meetme list)\n"
"      'w[(<secs>)]'\n"
"          -- wait until the marked user enters the conference\n"
"      'x' -- close the conference when last marked user exits\n"
"      'X' -- allow user to exit the conference by entering a valid single\n"
"             digit extension ${MEETME_EXIT_CONTEXT} or the current context\n"
"             if that variable is not defined.\n";

static const char *descrip2 =
"  MeetMeCount(confno[|var]): Plays back the number of users in the specified\n"
"MeetMe conference. If var is specified, playback will be skipped and the value\n"
"will be returned in the variable. Upon app completion, MeetMeCount will hangup the\n"
"channel, unless priority n+1 exists, in which case priority progress will continue.\n"
"A ZAPTEL INTERFACE MUST BE INSTALLED FOR CONFERENCING FUNCTIONALITY.\n";

static const char *descrip3 = 
"  MeetMeAdmin(confno,command[,user]): Run admin command for conference\n"
"      'e' -- Eject last user that joined\n"
"      'k' -- Kick one user out of conference\n"
"      'K' -- Kick all users out of conference\n"
"      'l' -- Unlock conference\n"
"      'L' -- Lock conference\n"
"      'm' -- Unmute conference\n"
"      'M' -- Mute conference\n"
"      'n' -- Unmute entire conference (except admin)\n"
"      'N' -- Mute entire conference (except admin)\n"
"";

#define CONFIG_FILE_NAME "meetme.conf"

STANDARD_LOCAL_USER;

LOCAL_USER_DECL;

struct ast_conference {
   char confno[AST_MAX_EXTENSION];     /* Conference */
   struct ast_channel *chan;     /* Announcements channel */
   int fd;              /* Announcements fd */
   int zapconf;            /* Zaptel Conf # */
   int users;           /* Number of active users */
   int markedusers;        /* Number of marked users */
   AST_LIST_HEAD_NOLOCK(, ast_conf_user) userlist;
   time_t start;           /* Start time (s) */
   int refcount;
   int recording;          /* recording status */
   int isdynamic;          /* Created on the fly? */
   int locked;          /* Is the conference locked? */
   pthread_t recordthread;       /* thread for recording */
   pthread_attr_t attr;       /* thread attribute */
   char *recordingfilename;      /* Filename to record the Conference into */
   char *recordingformat;        /* Format to record the Conference in */
   char pin[AST_MAX_EXTENSION];     /* If protected by a PIN */
   char pinadmin[AST_MAX_EXTENSION];   /* If protected by a admin PIN */
   AST_LIST_ENTRY(ast_conference) list;
};

static AST_LIST_HEAD_STATIC(confs, ast_conference);

static unsigned int conf_map[1024] = {0, };

struct volume {
   int desired;            /* Desired volume adjustment */
   int actual;          /* Actual volume adjustment (for channels that can't adjust) */
};

struct ast_conf_user {
   int user_no;            /* User Number */
   AST_LIST_ENTRY(ast_conf_user) list;
   int userflags;          /* Flags as set in the conference */
   int adminflags;            /* Flags set by the Admin */
   struct ast_channel *chan;     /* Connected channel */
   int talking;            /* Is user talking */
   int zapchannel;            /* Is a Zaptel channel */
   char usrvalue[50];         /* Custom User Value */
   char namerecloc[PATH_MAX]; /* Name Recorded file Location */
   time_t jointime;        /* Time the user joined the conference */
   struct volume talk;
   struct volume listen;
};

static int audio_buffers;        /* The number of audio buffers to be allocated on pseudo channels
                     when in a conference
                  */

#define DEFAULT_AUDIO_BUFFERS 32    /* each buffer is 20ms, so this is 640ms total */

#define ADMINFLAG_MUTED (1 << 1)    /* User is muted */
#define ADMINFLAG_KICKME (1 << 2)      /* User is kicked */
#define MEETME_DELAYDETECTTALK      300
#define MEETME_DELAYDETECTENDTALK   1000

enum volume_action {
   VOL_UP,
   VOL_DOWN,
};

static int admin_exec(struct ast_channel *chan, void *data);

static void *recordthread(void *args);

#include "enter.h"
#include "leave.h"

#define ENTER  0
#define LEAVE  1

#define MEETME_RECORD_OFF  0
#define MEETME_RECORD_ACTIVE  1
#define MEETME_RECORD_TERMINATE  2

#define CONF_SIZE 320

#define CONFFLAG_ADMIN  (1 << 1)    /* If set the user has admin access on the conference */
#define CONFFLAG_MONITOR (1 << 2)      /* If set the user can only receive audio from the conference */
#define CONFFLAG_POUNDEXIT (1 << 3)    /* If set asterisk will exit conference when '#' is pressed */
#define CONFFLAG_STARMENU (1 << 4)     /* If set asterisk will provide a menu to the user when '*' is pressed */
#define CONFFLAG_TALKER (1 << 5)    /* If set the use can only send audio to the conference */
#define CONFFLAG_QUIET (1 << 6)        /* If set there will be no enter or leave sounds */
#define CONFFLAG_ANNOUNCEUSERCOUNT (1 << 7)  /* If set, when user joins the conference, they will be told the number of users that are already in */
#define CONFFLAG_AGI (1 << 8)       /* Set to run AGI Script in Background */
#define CONFFLAG_MOH (1 << 9)       /* Set to have music on hold when user is alone in conference */
#define CONFFLAG_MARKEDEXIT (1 << 10)     /* If set the MeetMe will return if all marked with this flag left */
#define CONFFLAG_WAITMARKED (1 << 11)     /* If set, the MeetMe will wait until a marked user enters */
#define CONFFLAG_EXIT_CONTEXT (1 << 12)      /* If set, the MeetMe will exit to the specified context */
#define CONFFLAG_MARKEDUSER (1 << 13)     /* If set, the user will be marked */
#define CONFFLAG_INTROUSER (1 << 14)      /* If set, user will be ask record name on entry of conference */
#define CONFFLAG_RECORDCONF (1<< 15)      /* If set, the MeetMe will be recorded */
#define CONFFLAG_MONITORTALKER (1 << 16)  /* If set, the user will be monitored if the user is talking or not */
#define CONFFLAG_DYNAMIC (1 << 17)
#define CONFFLAG_DYNAMICPIN (1 << 18)
#define CONFFLAG_EMPTY (1 << 19)
#define CONFFLAG_EMPTYNOPIN (1 << 20)
#define CONFFLAG_ALWAYSPROMPT (1 << 21)

enum {
   OPT_ARG_WAITMARKED = 0,
   OPT_ARG_ARRAY_SIZE = 1,
} meetme_option_args;

AST_APP_OPTIONS(meetme_opts, {
   AST_APP_OPTION('a', CONFFLAG_ADMIN ),
   AST_APP_OPTION('c', CONFFLAG_ANNOUNCEUSERCOUNT ),
   AST_APP_OPTION('T', CONFFLAG_MONITORTALKER ),
   AST_APP_OPTION('i', CONFFLAG_INTROUSER ),
   AST_APP_OPTION('m', CONFFLAG_MONITOR ),
   AST_APP_OPTION('p', CONFFLAG_POUNDEXIT ),
   AST_APP_OPTION('s', CONFFLAG_STARMENU ),
   AST_APP_OPTION('t', CONFFLAG_TALKER ),
   AST_APP_OPTION('q', CONFFLAG_QUIET ),
   AST_APP_OPTION('M', CONFFLAG_MOH ),
   AST_APP_OPTION('x', CONFFLAG_MARKEDEXIT ),
   AST_APP_OPTION('X', CONFFLAG_EXIT_CONTEXT ),
   AST_APP_OPTION('A', CONFFLAG_MARKEDUSER ),
   AST_APP_OPTION('b', CONFFLAG_AGI ),
   AST_APP_OPTION_ARG('w', CONFFLAG_WAITMARKED, OPT_ARG_WAITMARKED ),
   AST_APP_OPTION('r', CONFFLAG_RECORDCONF ),
   AST_APP_OPTION('d', CONFFLAG_DYNAMIC ),
   AST_APP_OPTION('D', CONFFLAG_DYNAMICPIN ),
   AST_APP_OPTION('e', CONFFLAG_EMPTY ),
   AST_APP_OPTION('E', CONFFLAG_EMPTYNOPIN ),
   AST_APP_OPTION('P', CONFFLAG_ALWAYSPROMPT ),
});

static char *istalking(int x)
{
   if (x > 0)
      return "(talking)";
   else if (x < 0)
      return "(unmonitored)";
   else 
      return "(not talking)";
}

static int careful_write(int fd, unsigned char *data, int len, int block)
{
   int res;
   int x;

   while (len) {
      if (block) {
         x = ZT_IOMUX_WRITE | ZT_IOMUX_SIGEVENT;
         res = ioctl(fd, ZT_IOMUX, &x);
      } else
         res = 0;
      if (res >= 0)
         res = write(fd, data, len);
      if (res < 1) {
         if (errno != EAGAIN) {
            ast_log(LOG_WARNING, "Failed to write audio data to conference: %s\n", strerror(errno));
            return -1;
         } else
            return 0;
      }
      len -= res;
      data += res;
   }

   return 0;
}

/* Map 'volume' levels from -5 through +5 into
   decibel (dB) settings for channel drivers
   Note: these are not a straight linear-to-dB
   conversion... the numbers have been modified
   to give the user a better level of adjustability
*/
static signed char gain_map[] = {
   -15,
   -13,
   -10,
   -6,
   0,
   0,
   0,
   6,
   10,
   13,
   15,
};

static int set_talk_volume(struct ast_conf_user *user, int volume)
{
   signed char gain_adjust;

   /* attempt to make the adjustment in the channel driver;
      if successful, don't adjust in the frame reading routine
   */
   gain_adjust = gain_map[volume + 5];

   return ast_channel_setoption(user->chan, AST_OPTION_RXGAIN, &gain_adjust, sizeof(gain_adjust), 0);
}

static int set_listen_volume(struct ast_conf_user *user, int volume)
{
   signed char gain_adjust;

   /* attempt to make the adjustment in the channel driver;
      if successful, don't adjust in the frame reading routine
   */
   gain_adjust = gain_map[volume + 5];

   return ast_channel_setoption(user->chan, AST_OPTION_TXGAIN, &gain_adjust, sizeof(gain_adjust), 0);
}

static void tweak_volume(struct volume *vol, enum volume_action action)
{
   switch (action) {
   case VOL_UP:
      switch (vol->desired) {
      case 5:
         break;
      case 0:
         vol->desired = 2;
         break;
      case -2:
         vol->desired = 0;
         break;
      default:
         vol->desired++;
         break;
      }
      break;
   case VOL_DOWN:
      switch (vol->desired) {
      case -5:
         break;
      case 2:
         vol->desired = 0;
         break;
      case 0:
         vol->desired = -2;
         break;
      default:
         vol->desired--;
         break;
      }
   }
}

static void tweak_talk_volume(struct ast_conf_user *user, enum volume_action action)
{
   tweak_volume(&user->talk, action);
   /* attempt to make the adjustment in the channel driver;
      if successful, don't adjust in the frame reading routine
   */
   if (!set_talk_volume(user, user->talk.desired))
      user->talk.actual = 0;
   else
      user->talk.actual = user->talk.desired;
}

static void tweak_listen_volume(struct ast_conf_user *user, enum volume_action action)
{
   tweak_volume(&user->listen, action);
   /* attempt to make the adjustment in the channel driver;
      if successful, don't adjust in the frame reading routine
   */
   if (!set_listen_volume(user, user->listen.desired))
      user->listen.actual = 0;
   else
      user->listen.actual = user->listen.desired;
}

static void reset_volumes(struct ast_conf_user *user)
{
   signed char zero_volume = 0;

   ast_channel_setoption(user->chan, AST_OPTION_TXGAIN, &zero_volume, sizeof(zero_volume), 0);
   ast_channel_setoption(user->chan, AST_OPTION_RXGAIN, &zero_volume, sizeof(zero_volume), 0);
}

static void conf_play(struct ast_channel *chan, struct ast_conference *conf, int sound)
{
   unsigned char *data;
   int len;
   int res = -1;

   if (!chan->_softhangup)
      res = ast_autoservice_start(chan);

   AST_LIST_LOCK(&confs);

   switch(sound) {
   case ENTER:
      data = enter;
      len = sizeof(enter);
      break;
   case LEAVE:
      data = leave;
      len = sizeof(leave);
      break;
   default:
      data = NULL;
      len = 0;
   }
   if (data) 
      careful_write(conf->fd, data, len, 1);

   AST_LIST_UNLOCK(&confs);

   if (!res) 
      ast_autoservice_stop(chan);
}

static struct ast_conference *build_conf(char *confno, char *pin, char *pinadmin, int make, int dynamic, int refcount)
{
   struct ast_conference *cnf;
   struct zt_confinfo ztc;
   int confno_int = 0;

   AST_LIST_LOCK(&confs);
   AST_LIST_TRAVERSE(&confs, cnf, list) {
      if (!strcmp(confno, cnf->confno)) 
         break;
   }

   if (!cnf && (make || dynamic)) {
      /* Make a new one */
      cnf = calloc(1, sizeof(*cnf));
      if (cnf) {
         ast_copy_string(cnf->confno, confno, sizeof(cnf->confno));
         ast_copy_string(cnf->pin, pin, sizeof(cnf->pin));
         ast_copy_string(cnf->pinadmin, pinadmin, sizeof(cnf->pinadmin));
         cnf->markedusers = 0;
         cnf->chan = ast_request("zap", AST_FORMAT_ULAW, "pseudo", NULL);
         if (cnf->chan) {
            cnf->fd = cnf->chan->fds[0];  /* for use by conf_play() */
         } else {
            ast_log(LOG_WARNING, "Unable to open pseudo channel - trying device\n");
            cnf->fd = open("/dev/zap/pseudo", O_RDWR);
            if (cnf->fd < 0) {
               ast_log(LOG_WARNING, "Unable to open pseudo device\n");
               free(cnf);
               cnf = NULL;
               goto cnfout;
            }
         }
         memset(&ztc, 0, sizeof(ztc));
         /* Setup a new zap conference */
         ztc.chan = 0;
         ztc.confno = -1;
         ztc.confmode = ZT_CONF_CONFANN | ZT_CONF_CONFANNMON;
         if (ioctl(cnf->fd, ZT_SETCONF, &ztc)) {
            ast_log(LOG_WARNING, "Error setting conference\n");
            if (cnf->chan)
               ast_hangup(cnf->chan);
            else
               close(cnf->fd);
            free(cnf);
            cnf = NULL;
            goto cnfout;
         }
         /* Fill the conference struct */
         cnf->start = time(NULL);
         cnf->zapconf = ztc.confno;
         cnf->isdynamic = dynamic;
         cnf->locked = 0;
         if (option_verbose > 2)
            ast_verbose(VERBOSE_PREFIX_3 "Created MeetMe conference %d for conference '%s'\n", cnf->zapconf, cnf->confno);
         AST_LIST_INSERT_HEAD(&confs, cnf, list);
         /* Reserve conference number in map */
         if ((sscanf(cnf->confno, "%d", &confno_int) == 1) && (confno_int >= 0 && confno_int < 1024))
            conf_map[confno_int] = 1;
      } else   
         ast_log(LOG_WARNING, "Out of memory\n");
   }
 cnfout:
   if (cnf)
      ast_atomic_fetchadd_int(&cnf->refcount, refcount);
   AST_LIST_UNLOCK(&confs);
   return cnf;
}

static int confs_show(int fd, int argc, char **argv)
{
   ast_cli(fd, "Deprecated! Please use 'meetme' instead.\n");

   return RESULT_SUCCESS;
}

static char show_confs_usage[] =
"Deprecated! Please use 'meetme' instead.\n";

static struct ast_cli_entry cli_show_confs = {
   { "show", "conferences", NULL }, confs_show,
   "Show status of conferences", show_confs_usage, NULL };
   
static int conf_cmd(int fd, int argc, char **argv) {
   /* Process the command */
   struct ast_conference *cnf;
   struct ast_conf_user *user;
   int hr, min, sec;
   int i = 0, total = 0;
   time_t now;
   char *header_format = "%-14s %-14s %-10s %-8s  %-8s\n";
   char *data_format = "%-12.12s   %4.4d        %4.4s       %02d:%02d:%02d  %-8s\n";
   char cmdline[1024] = "";

   if (argc > 8)
      ast_cli(fd, "Invalid Arguments.\n");
   /* Check for length so no buffer will overflow... */
   for (i = 0; i < argc; i++) {
      if (strlen(argv[i]) > 100)
         ast_cli(fd, "Invalid Arguments.\n");
   }
   if (argc == 1) {
      /* 'MeetMe': List all the conferences */  
      now = time(NULL);
      AST_LIST_LOCK(&confs);
      if (!AST_LIST_FIRST(&confs)) {
         ast_cli(fd, "No active MeetMe conferences.\n");
         AST_LIST_UNLOCK(&confs);
         return RESULT_SUCCESS;
      }
      ast_cli(fd, header_format, "Conf Num", "Parties", "Marked", "Activity", "Creation");
      AST_LIST_TRAVERSE(&confs, cnf, list) {
         if (cnf->markedusers == 0)
            strcpy(cmdline, "N/A ");
         else 
            snprintf(cmdline, sizeof(cmdline), "%4.4d", cnf->markedusers);
         hr = (now - cnf->start) / 3600;
         min = ((now - cnf->start) % 3600) / 60;
         sec = (now - cnf->start) % 60;

         ast_cli(fd, data_format, cnf->confno, cnf->users, cmdline, hr, min, sec, cnf->isdynamic ? "Dynamic" : "Static");

         total += cnf->users;    
      }
      ast_cli(fd, "* Total number of MeetMe users: %d\n", total);
      AST_LIST_UNLOCK(&confs);
      return RESULT_SUCCESS;
   }
   if (argc < 3)
      return RESULT_SHOWUSAGE;
   ast_copy_string(cmdline, argv[2], sizeof(cmdline));   /* Argv 2: conference number */
   if (strstr(argv[1], "lock")) {   
      if (strcmp(argv[1], "lock") == 0) {
         /* Lock */
         strncat(cmdline, "|L", sizeof(cmdline) - strlen(cmdline) - 1);
      } else {
         /* Unlock */
         strncat(cmdline, "|l", sizeof(cmdline) - strlen(cmdline) - 1);
      }
   } else if (strstr(argv[1], "mute")) { 
      if (argc < 4)
         return RESULT_SHOWUSAGE;
      if (strcmp(argv[1], "mute") == 0) {
         /* Mute */
         if (strcmp(argv[3], "all") == 0) {
            strncat(cmdline, "|N", sizeof(cmdline) - strlen(cmdline) - 1);
         } else {
            strncat(cmdline, "|M|", sizeof(cmdline) - strlen(cmdline) - 1);   
            strncat(cmdline, argv[3], sizeof(cmdline) - strlen(cmdline) - 1);
         }
      } else {
         /* Unmute */
         if (strcmp(argv[3], "all") == 0) {
            strncat(cmdline, "|n", sizeof(cmdline) - strlen(cmdline) - 1);
         } else {
            strncat(cmdline, "|m|", sizeof(cmdline) - strlen(cmdline) - 1);
            strncat(cmdline, argv[3], sizeof(cmdline) - strlen(cmdline) - 1);
         }
      }
   } else if (strcmp(argv[1], "kick") == 0) {
      if (argc < 4)
         return RESULT_SHOWUSAGE;
      if (strcmp(argv[3], "all") == 0) {
         /* Kick all */
         strncat(cmdline, "|K", sizeof(cmdline) - strlen(cmdline) - 1);
      } else {
         /* Kick a single user */
         strncat(cmdline, "|k|", sizeof(cmdline) - strlen(cmdline) - 1);
         strncat(cmdline, argv[3], sizeof(cmdline) - strlen(cmdline) - 1);
      }  
   } else if(strcmp(argv[1], "list") == 0) {
      /* List all the users in a conference */
      if (!AST_LIST_FIRST(&confs)) {
         ast_cli(fd, "No active conferences.\n");
         return RESULT_SUCCESS;  
      }
      AST_LIST_LOCK(&confs);
      AST_LIST_TRAVERSE(&confs, cnf, list) {
         if (strcmp(cnf->confno, argv[2]) == 0)
            break;
      }
      if (!cnf) {
         ast_cli(fd, "No such conference: %s.\n", argv[2]);
         AST_LIST_UNLOCK(&confs);
         return RESULT_SUCCESS;
      }
      /* Show all the users */
      AST_LIST_TRAVERSE(&cnf->userlist, user, list) {
         ast_cli(fd, "User #: %-2.2d %12.12s %-20.20s Channel: %s %s %s %s %s\n",
            user->user_no,
            user->chan->cid.cid_num ? user->chan->cid.cid_num : "<unknown>",
            user->chan->cid.cid_name ? user->chan->cid.cid_name : "<no name>",
            user->chan->name,
            user->userflags & CONFFLAG_ADMIN ? "(Admin)" : "",
            user->userflags & CONFFLAG_MONITOR ? "(Listen only)" : "",
            user->adminflags & ADMINFLAG_MUTED ? "(Admin Muted)" : "",
            istalking(user->talking));
      }
      ast_cli(fd,"%d users in that conference.\n",cnf->users);
      AST_LIST_UNLOCK(&confs);

      return RESULT_SUCCESS;
   } else 
      return RESULT_SHOWUSAGE;
   ast_log(LOG_DEBUG, "Cmdline: %s\n", cmdline);
   admin_exec(NULL, cmdline);

   return 0;
}

static char *complete_confcmd(char *line, char *word, int pos, int state) {
#define CONF_COMMANDS 6
   int which = 0, x = 0;
   struct ast_conference *cnf = NULL;
   struct ast_conf_user *usr = NULL;
   char *confno = NULL;
   char usrno[50] = "";
   char cmds[CONF_COMMANDS][20] = {"lock", "unlock", "mute", "unmute", "kick", "list"};
   char *myline;
   char *res = NULL;
   
   if (pos == 1) {
      /* Command */
      for (x = 0;x < CONF_COMMANDS; x++) {
         if (!strncasecmp(cmds[x], word, strlen(word))) {
            if (++which > state) {
               return strdup(cmds[x]);
            }
         }
      }
   } else if (pos == 2) {
      /* Conference Number */
      AST_LIST_LOCK(&confs);
      AST_LIST_TRAVERSE(&confs, cnf, list) {
         if (!strncasecmp(word, cnf->confno, strlen(word))) {
            if (++which > state)
               break;
         }
      }
      res = cnf ? strdup(cnf->confno) : NULL;
      AST_LIST_UNLOCK(&confs);
      return res;
   } else if (pos == 3) {
      /* User Number || Conf Command option*/
      if (strstr(line, "mute") || strstr(line, "kick")) {
         if ((state == 0) && (strstr(line, "kick") || strstr(line,"mute")) && !(strncasecmp(word, "all", strlen(word)))) {
            return strdup("all");
         }
         which++;
         AST_LIST_LOCK(&confs);

         /* TODO: Find the conf number from the cmdline (ignore spaces) <- test this and make it fail-safe! */
         myline = ast_strdupa(line);
         if (strsep(&myline, " ") && strsep(&myline, " ") && !confno) {
            while((confno = strsep(&myline, " ")) && (strcmp(confno, " ") == 0))
               ;
         }

         AST_LIST_TRAVERSE(&confs, cnf, list) {
            if (!strcmp(confno, cnf->confno))
                break;
         }

         if (cnf) {
            /* Search for the user */
            AST_LIST_TRAVERSE(&cnf->userlist, usr, list) {
               snprintf(usrno, sizeof(usrno), "%d", usr->user_no);
               if (!strncasecmp(word, usrno, strlen(word))) {
                  if (++which > state)
                     break;
               }
            }
         }
         AST_LIST_UNLOCK(&confs);
         return usr ? strdup(usrno) : NULL;
      }
   }

   return NULL;
}
   
static char conf_usage[] =
"Usage: meetme  (un)lock|(un)mute|kick|list <confno> <usernumber>\n"
"       Executes a command for the conference or on a conferee\n";

static struct ast_cli_entry cli_conf = {
   {"meetme", NULL, NULL }, conf_cmd,
   "Execute a command on a conference or conferee", conf_usage, complete_confcmd};

static void conf_flush(int fd, struct ast_channel *chan)
{
   int x;

   /* read any frames that may be waiting on the channel
      and throw them away
   */
   if (chan) {
      struct ast_frame *f;

      /* when no frames are available, this will wait
         for 1 millisecond maximum
      */
      while (ast_waitfor(chan, 1)) {
         f = ast_read(chan);
         if (f)
            ast_frfree(f);
         else /* channel was hung up or something else happened */
            break;
      }
   }

   /* flush any data sitting in the pseudo channel */
   x = ZT_FLUSH_ALL;
   if (ioctl(fd, ZT_FLUSH, &x))
      ast_log(LOG_WARNING, "Error flushing channel\n");

}

/* Remove the conference from the list and free it.
   XXX We assume that this was called while holding the confs list lock. */
static int conf_free(struct ast_conference *conf)
{
   struct ast_conference *cur;

   AST_LIST_TRAVERSE_SAFE_BEGIN(&confs, cur, list) {
      if (cur == conf) {
         AST_LIST_REMOVE_CURRENT(&confs, list);
         break;
      }
   }
   AST_LIST_TRAVERSE_SAFE_END;

   if (!cur)
      ast_log(LOG_WARNING, "Conference not found\n");

   if (conf->recording == MEETME_RECORD_ACTIVE) {
      conf->recording = MEETME_RECORD_TERMINATE;
      AST_LIST_UNLOCK(&confs);
      while (1) {
         usleep(1);
         AST_LIST_LOCK(&confs);
         if (conf->recording == MEETME_RECORD_OFF)
            break;
         AST_LIST_UNLOCK(&confs);
      }
   }

   if (conf->chan)
      ast_hangup(conf->chan);
   else
      close(conf->fd);
   
   free(conf);

   return 0;
}

/* Decrement reference counts, as incremented by find_conf() */
static int dispose_conf(struct ast_conference *conf)
{
   int res = 0;
   int confno_int = 0;

   AST_LIST_LOCK(&confs);
   if (ast_atomic_dec_and_test(&conf->refcount)) {
      /* Take the conference room number out of an inuse state */
      if ((sscanf(conf->confno, "%d", &confno_int) == 1) && (confno_int >= 0 && confno_int < 1024))
         conf_map[confno_int] = 0;
      conf_free(conf);
      res = 1;
   }
   AST_LIST_UNLOCK(&confs);

   return res;
}

static int conf_run(struct ast_channel *chan, struct ast_conference *conf, int confflags, char *optargs[])
{
   struct ast_conf_user *user = calloc(1, sizeof(*user));
   struct ast_conf_user *usr = NULL;
   int fd;
   struct zt_confinfo ztc, ztc_empty;
   struct ast_frame *f;
   struct ast_channel *c;
   struct ast_frame fr;
   int outfd;
   int ms;
   int nfds;
   int res;
   int flags;
   int retryzap;
   int origfd;
   int musiconhold = 0;
   int firstpass = 0;
   int lastmarked = 0;
   int currentmarked = 0;
   int ret = -1;
   int x;
   int menu_active = 0;
   int using_pseudo = 0;
   int duration=20;
   struct ast_dsp *dsp=NULL;
   struct ast_app *app;
   char *agifile;
   char *agifiledefault = "conf-background.agi";
   char meetmesecs[30] = "";
   char exitcontext[AST_MAX_CONTEXT] = "";
   char recordingtmp[AST_MAX_EXTENSION] = "";
   int dtmf, opt_waitmarked_timeout = 0;
   time_t timeout = 0;
   ZT_BUFFERINFO bi;
   char __buf[CONF_SIZE + AST_FRIENDLY_OFFSET];
   char *buf = __buf + AST_FRIENDLY_OFFSET;
   
   if (!user) {
      ast_log(LOG_ERROR, "Out of memory\n");
      return ret;
   }

   /* Possible timeout waiting for marked user */
   if ((confflags & CONFFLAG_WAITMARKED) &&
      !ast_strlen_zero(optargs[OPT_ARG_WAITMARKED]) &&
      (sscanf(optargs[OPT_ARG_WAITMARKED], "%d", &opt_waitmarked_timeout) == 1) &&
      (opt_waitmarked_timeout > 0)) {
      timeout = time(NULL) + opt_waitmarked_timeout;
   }

   AST_LIST_LOCK(&confs);

   if (confflags & CONFFLAG_RECORDCONF && conf->recording !=MEETME_RECORD_ACTIVE) {
      conf->recordingfilename = pbx_builtin_getvar_helper(chan, "MEETME_RECORDINGFILE");
      if (!conf->recordingfilename) {
         snprintf(recordingtmp, sizeof(recordingtmp), "meetme-conf-rec-%s-%s", conf->confno, chan->uniqueid);
         conf->recordingfilename = ast_strdupa(recordingtmp);
      }
      conf->recordingformat = pbx_builtin_getvar_helper(chan, "MEETME_RECORDINGFORMAT");
      if (!conf->recordingformat) {
         snprintf(recordingtmp, sizeof(recordingtmp), "wav");
         conf->recordingformat = ast_strdupa(recordingtmp);
      }
      pthread_attr_init(&conf->attr);
      pthread_attr_setdetachstate(&conf->attr, PTHREAD_CREATE_DETACHED);
      ast_verbose(VERBOSE_PREFIX_4 "Starting recording of MeetMe Conference %s into file %s.%s.\n",
             conf->confno, conf->recordingfilename, conf->recordingformat);
      ast_pthread_create(&conf->recordthread, &conf->attr, recordthread, conf);
      pthread_attr_destroy(&conf->attr);
   }

   time(&user->jointime);

   if (conf->locked && (!(confflags & CONFFLAG_ADMIN))) {
      /* Sorry, but this confernce is locked! */   
      if (!ast_streamfile(chan, "conf-locked", chan->language))
         ast_waitstream(chan, "");
      AST_LIST_UNLOCK(&confs);
      goto outrun;
   }

   if (confflags & CONFFLAG_MARKEDUSER)
      conf->markedusers++;

   if (AST_LIST_LAST(&conf->userlist))
      user->user_no = AST_LIST_LAST(&conf->userlist)->user_no + 1;
   else
      user->user_no = 1;

   user->chan = chan;
   user->userflags = confflags;
   user->adminflags = 0;
   user->talking = -1;
   conf->users++;

   AST_LIST_INSERT_TAIL(&conf->userlist, user, list);

   /* Since we control a user in the userlist, our conference should never go away now. */
   AST_LIST_UNLOCK(&confs);

   if (confflags & CONFFLAG_EXIT_CONTEXT) {
      if ((agifile = pbx_builtin_getvar_helper(chan, "MEETME_EXIT_CONTEXT"))) 
         ast_copy_string(exitcontext, agifile, sizeof(exitcontext));
      else if (!ast_strlen_zero(chan->macrocontext)) 
         ast_copy_string(exitcontext, chan->macrocontext, sizeof(exitcontext));
      else
         ast_copy_string(exitcontext, chan->context, sizeof(exitcontext));
   }

   if (!(confflags & CONFFLAG_QUIET) && (confflags & CONFFLAG_INTROUSER)) {
      snprintf(user->namerecloc, sizeof(user->namerecloc),
          "%s/meetme/meetme-username-%s-%d", ast_config_AST_SPOOL_DIR,
          conf->confno, user->user_no);
      res = ast_record_review(chan, "vm-rec-name", user->namerecloc, 10, "sln", &duration, NULL);
      if (res == -1)
         goto outrun;
   }

   if (!(confflags & CONFFLAG_QUIET)) {
      if (conf->users == 1 && !(confflags & CONFFLAG_WAITMARKED))
         if (!ast_streamfile(chan, "conf-onlyperson", chan->language))
            ast_waitstream(chan, "");
      if ((confflags & CONFFLAG_WAITMARKED) && conf->markedusers == 0)
         if (!ast_streamfile(chan, "conf-waitforleader", chan->language))
            ast_waitstream(chan, "");
   }

   if (!(confflags & CONFFLAG_QUIET) && (confflags & CONFFLAG_ANNOUNCEUSERCOUNT) && conf->users > 1) {
      int keepplaying = 1;

      if (conf->users == 2) { 
         if (!ast_streamfile(chan,"conf-onlyone",chan->language)) {
            res = ast_waitstream(chan, AST_DIGIT_ANY);
            ast_stopstream(chan);
            if (res > 0)
               keepplaying=0;
            else if (res == -1)