Sat Nov 1 06:28:19 2008

Asterisk developer's documentation

---

app_meetme.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 1999 - 2007, Digium, Inc.
 *
 * Mark Spencer <markster@digium.com>
 *
 * SLA Implementation by:
 * Russell Bryant <russell@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 and Shared Line Appearances
 *
 * \author Mark Spencer <markster@digium.com>
 * \author (SLA) Russell Bryant <russell@digium.com>
 * 
 * \ingroup applications
 */

/*** MODULEINFO
   <depend>dahdi</depend>
 ***/

#include "asterisk.h"

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

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/types.h>

#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/translate.h"
#include "asterisk/ulaw.h"
#include "asterisk/astobj.h"
#include "asterisk/devicestate.h"
#include "asterisk/dial.h"
#include "asterisk/causes.h"

#include "asterisk/dahdi_compat.h"

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

#define CONFIG_FILE_NAME "meetme.conf"
#define SLA_CONFIG_FILE  "sla.conf"

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

enum {
   ADMINFLAG_MUTED =     (1 << 1), /*!< User is muted */
   ADMINFLAG_SELFMUTED = (1 << 2), /*!< User muted self */
   ADMINFLAG_KICKME =    (1 << 3)  /*!< User has been kicked */
};

#define MEETME_DELAYDETECTTALK     300
#define MEETME_DELAYDETECTENDTALK  1000

#define AST_FRAME_BITS  32

enum volume_action {
   VOL_UP,
   VOL_DOWN
};

enum entrance_sound {
   ENTER,
   LEAVE
};

enum recording_state {
   MEETME_RECORD_OFF,
   MEETME_RECORD_STARTED,
   MEETME_RECORD_ACTIVE,
   MEETME_RECORD_TERMINATE
};

#define CONF_SIZE  320

enum {
   /*! user has admin access on the conference */
   CONFFLAG_ADMIN = (1 << 0),
   /*! If set the user can only receive audio from the conference */
   CONFFLAG_MONITOR = (1 << 1),
   /*! If set asterisk will exit conference when '#' is pressed */
   CONFFLAG_POUNDEXIT = (1 << 2),
   /*! If set asterisk will provide a menu to the user when '*' is pressed */
   CONFFLAG_STARMENU = (1 << 3),
   /*! If set the use can only send audio to the conference */
   CONFFLAG_TALKER = (1 << 4),
   /*! If set there will be no enter or leave sounds */
   CONFFLAG_QUIET = (1 << 5),
   /*! If set, when user joins the conference, they will be told the number 
    *  of users that are already in */
   CONFFLAG_ANNOUNCEUSERCOUNT = (1 << 6),
   /*! Set to run AGI Script in Background */
   CONFFLAG_AGI = (1 << 7),
   /*! Set to have music on hold when user is alone in conference */
   CONFFLAG_MOH = (1 << 8),
   /*! If set the MeetMe will return if all marked with this flag left */
   CONFFLAG_MARKEDEXIT = (1 << 9),
   /*! If set, the MeetMe will wait until a marked user enters */
   CONFFLAG_WAITMARKED = (1 << 10),
   /*! If set, the MeetMe will exit to the specified context */
   CONFFLAG_EXIT_CONTEXT = (1 << 11),
   /*! If set, the user will be marked */
   CONFFLAG_MARKEDUSER = (1 << 12),
   /*! If set, user will be ask record name on entry of conference */
   CONFFLAG_INTROUSER = (1 << 13),
   /*! If set, the MeetMe will be recorded */
   CONFFLAG_RECORDCONF = (1<< 14),
   /*! If set, the user will be monitored if the user is talking or not */
   CONFFLAG_MONITORTALKER = (1 << 15),
   CONFFLAG_DYNAMIC = (1 << 16),
   CONFFLAG_DYNAMICPIN = (1 << 17),
   CONFFLAG_EMPTY = (1 << 18),
   CONFFLAG_EMPTYNOPIN = (1 << 19),
   CONFFLAG_ALWAYSPROMPT = (1 << 20),
   /*! If set, treats talking users as muted users */
   CONFFLAG_OPTIMIZETALKER = (1 << 21),
   /*! If set, won't speak the extra prompt when the first person 
    *  enters the conference */
   CONFFLAG_NOONLYPERSON = (1 << 22),
   /*! If set, user will be asked to record name on entry of conference 
    *  without review */
   CONFFLAG_INTROUSERNOREVIEW = (1 << 23),
   /*! If set, the user will be initially self-muted */
   CONFFLAG_STARTMUTED = (1 << 24),
   /*! Pass DTMF through the conference */
   CONFFLAG_PASS_DTMF = (1 << 25),
   /*! This is a SLA station. (Only for use by the SLA applications.) */
   CONFFLAG_SLA_STATION = (1 << 26),
   /*! This is a SLA trunk. (Only for use by the SLA applications.) */
   CONFFLAG_SLA_TRUNK = (1 << 27),
};

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

AST_APP_OPTIONS(meetme_opts, BEGIN_OPTIONS
   AST_APP_OPTION('A', CONFFLAG_MARKEDUSER ),
   AST_APP_OPTION('a', CONFFLAG_ADMIN ),
   AST_APP_OPTION('b', CONFFLAG_AGI ),
   AST_APP_OPTION('c', CONFFLAG_ANNOUNCEUSERCOUNT ),
   AST_APP_OPTION('D', CONFFLAG_DYNAMICPIN ),
   AST_APP_OPTION('d', CONFFLAG_DYNAMIC ),
   AST_APP_OPTION('E', CONFFLAG_EMPTYNOPIN ),
   AST_APP_OPTION('e', CONFFLAG_EMPTY ),
   AST_APP_OPTION('F', CONFFLAG_PASS_DTMF ),
   AST_APP_OPTION('i', CONFFLAG_INTROUSER ),
   AST_APP_OPTION('I', CONFFLAG_INTROUSERNOREVIEW ),
   AST_APP_OPTION('M', CONFFLAG_MOH ),
   AST_APP_OPTION('m', CONFFLAG_STARTMUTED ),
   AST_APP_OPTION('o', CONFFLAG_OPTIMIZETALKER ),
   AST_APP_OPTION('P', CONFFLAG_ALWAYSPROMPT ),
   AST_APP_OPTION('p', CONFFLAG_POUNDEXIT ),
   AST_APP_OPTION('q', CONFFLAG_QUIET ),
   AST_APP_OPTION('r', CONFFLAG_RECORDCONF ),
   AST_APP_OPTION('s', CONFFLAG_STARMENU ),
   AST_APP_OPTION('T', CONFFLAG_MONITORTALKER ),
   AST_APP_OPTION('l', CONFFLAG_MONITOR ),
   AST_APP_OPTION('t', CONFFLAG_TALKER ),
   AST_APP_OPTION_ARG('w', CONFFLAG_WAITMARKED, OPT_ARG_WAITMARKED ),
   AST_APP_OPTION('X', CONFFLAG_EXIT_CONTEXT ),
   AST_APP_OPTION('x', CONFFLAG_MARKEDEXIT ),
   AST_APP_OPTION('1', CONFFLAG_NOONLYPERSON ),
END_OPTIONS );

static const char *app = "MeetMe";
static const char *app2 = "MeetMeCount";
static const char *app3 = "MeetMeAdmin";
static const char *slastation_app = "SLAStation";
static const char *slatrunk_app = "SLATrunk";

static const char *synopsis = "MeetMe conference bridge";
static const char *synopsis2 = "MeetMe participant count";
static const char *synopsis3 = "MeetMe conference Administration";
static const char *slastation_synopsis = "Shared Line Appearance Station";
static const char *slatrunk_synopsis = "Shared Line Appearance Trunk";

static const char *descrip =
"  MeetMe([confno][,[options][,pin]]): Enters the user into a specified MeetMe\n"
"conference.  If the conference number is omitted, the user will be prompted\n"
"to enter one.  User can exit the conference by hangup, or if the 'p' option\n"
"is specified, by pressing '#'.\n"
"Please note: The DAHDI kernel modules and at least one hardware driver (or dahdi_dummy)\n"
"             must be present for conferencing to operate properly. In addition, the chan_dahdi\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  (Note: This does not work with\n"
"             non-DAHDI 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"
"      'F' -- Pass DTMF through the conference.\n"
"      'i' -- announce user join/leave with review\n"
"      'I' -- announce user join/leave without review\n"
"      'l' -- set listen only mode (Listen only, no talking)\n"
"      'm' -- set initially muted\n"
"      'M' -- enable music on hold when the conference has a single caller\n"
"      'o' -- set talker optimization - treats talkers who aren't speaking as\n"
"             being muted, meaning (a) No encode is done on transmission and\n"
"             (b) Received audio that is not registered as talking is omitted\n"
"             causing no buildup in background noise.  Note that this option\n"
"             will be removed in 1.6 and enabled by default.\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\n"
"             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"
"      '1' -- do not play message when first person enters\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\n"
"the channel, unless priority n+1 exists, in which case priority progress will\n"
"continue.\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 one user\n"
"      'M' -- Mute one user\n"
"      'n' -- Unmute all users in the conference\n"
"      'N' -- Mute all non-admin users in the conference\n"
"      'r' -- Reset one user's volume settings\n"
"      'R' -- Reset all users volume settings\n"
"      's' -- Lower entire conference speaking volume\n"
"      'S' -- Raise entire conference speaking volume\n"
"      't' -- Lower one user's talk volume\n"
"      'T' -- Raise one user's talk volume\n"
"      'u' -- Lower one user's listen volume\n"
"      'U' -- Raise one user's listen volume\n"
"      'v' -- Lower entire conference listening volume\n"
"      'V' -- Raise entire conference listening volume\n"
"";

static const char *slastation_desc =
"  SLAStation(station):\n"
"This application should be executed by an SLA station.  The argument depends\n"
"on how the call was initiated.  If the phone was just taken off hook, then\n"
"the argument \"station\" should be just the station name.  If the call was\n"
"initiated by pressing a line key, then the station name should be preceded\n"
"by an underscore and the trunk name associated with that line button.\n"
"For example: \"station1_line1\"."
"  On exit, this application will set the variable SLASTATION_STATUS to\n"
"one of the following values:\n"
"    FAILURE | CONGESTION | SUCCESS\n"
"";

static const char *slatrunk_desc =
"  SLATrunk(trunk):\n"
"This application should be executed by an SLA trunk on an inbound call.\n"
"The channel calling this application should correspond to the SLA trunk\n"
"with the name \"trunk\" that is being passed as an argument.\n"
"  On exit, this application will set the variable SLATRUNK_STATUS to\n"
"one of the following values:\n"
"   FAILURE | SUCCESS | UNANSWERED | RINGTIMEOUT\n" 
"";

#define MAX_CONFNUM 80
#define MAX_PIN     80

/*! \brief The MeetMe Conference object */
struct ast_conference {
   ast_mutex_t playlock;                   /*!< Conference specific lock (players) */
   ast_mutex_t listenlock;                 /*!< Conference specific lock (listeners) */
   char confno[MAX_CONFNUM];               /*!< Conference */
   struct ast_channel *chan;               /*!< Announcements channel */
   struct ast_channel *lchan;              /*!< Listen/Record channel */
   int fd;                                 /*!< Announcements fd */
   int zapconf;                            /*!< Zaptel Conf # */
   int users;                              /*!< Number of active users */
   int markedusers;                        /*!< Number of marked users */
   time_t start;                           /*!< Start time (s) */
   int refcount;                           /*!< reference count of usage */
   enum recording_state recording:2;       /*!< recording status */
   unsigned int isdynamic:1;               /*!< Created on the fly? */
   unsigned int locked:1;                  /*!< Is the conference locked? */
   pthread_t recordthread;                 /*!< thread for recording */
   ast_mutex_t recordthreadlock;    /*!< control threads trying to start recordthread */
   pthread_attr_t attr;                    /*!< thread attribute */
   const char *recordingfilename;          /*!< Filename to record the Conference into */
   const char *recordingformat;            /*!< Format to record the Conference in */
   char pin[MAX_PIN];                      /*!< If protected by a PIN */
   char pinadmin[MAX_PIN];                 /*!< If protected by a admin PIN */
   struct ast_frame *transframe[32];
   struct ast_frame *origframe;
   struct ast_trans_pvt *transpath[32];
   AST_LIST_HEAD_NOLOCK(, ast_conf_user) userlist;
   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 */
   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;
   AST_LIST_ENTRY(ast_conf_user) list;
};

enum sla_which_trunk_refs {
   ALL_TRUNK_REFS,
   INACTIVE_TRUNK_REFS,
};

enum sla_trunk_state {
   SLA_TRUNK_STATE_IDLE,
   SLA_TRUNK_STATE_RINGING,
   SLA_TRUNK_STATE_UP,
   SLA_TRUNK_STATE_ONHOLD,
   SLA_TRUNK_STATE_ONHOLD_BYME,
};

enum sla_hold_access {
   /*! This means that any station can put it on hold, and any station
    * can retrieve the call from hold. */
   SLA_HOLD_OPEN,
   /*! This means that only the station that put the call on hold may
    * retrieve it from hold. */
   SLA_HOLD_PRIVATE,
};

struct sla_trunk_ref;

struct sla_station {
   AST_RWLIST_ENTRY(sla_station) entry;
   AST_DECLARE_STRING_FIELDS(
      AST_STRING_FIELD(name); 
      AST_STRING_FIELD(device);  
      AST_STRING_FIELD(autocontext);   
   );
   AST_LIST_HEAD_NOLOCK(, sla_trunk_ref) trunks;
   struct ast_dial *dial;
   /*! Ring timeout for this station, for any trunk.  If a ring timeout
    *  is set for a specific trunk on this station, that will take
    *  priority over this value. */
   unsigned int ring_timeout;
   /*! Ring delay for this station, for any trunk.  If a ring delay
    *  is set for a specific trunk on this station, that will take
    *  priority over this value. */
   unsigned int ring_delay;
   /*! This option uses the values in the sla_hold_access enum and sets the
    * access control type for hold on this station. */
   unsigned int hold_access:1;
};

struct sla_station_ref {
   AST_LIST_ENTRY(sla_station_ref) entry;
   struct sla_station *station;
};

struct sla_trunk {
   AST_RWLIST_ENTRY(sla_trunk) entry;
   AST_DECLARE_STRING_FIELDS(
      AST_STRING_FIELD(name);
      AST_STRING_FIELD(device);
      AST_STRING_FIELD(autocontext);   
   );
   AST_LIST_HEAD_NOLOCK(, sla_station_ref) stations;
   /*! Number of stations that use this trunk */
   unsigned int num_stations;
   /*! Number of stations currently on a call with this trunk */
   unsigned int active_stations;
   /*! Number of stations that have this trunk on hold. */
   unsigned int hold_stations;
   struct ast_channel *chan;
   unsigned int ring_timeout;
   /*! If set to 1, no station will be able to join an active call with
    *  this trunk. */
   unsigned int barge_disabled:1;
   /*! This option uses the values in the sla_hold_access enum and sets the
    * access control type for hold on this trunk. */
   unsigned int hold_access:1;
   /*! Whether this trunk is currently on hold, meaning that once a station
    *  connects to it, the trunk channel needs to have UNHOLD indicated to it. */
   unsigned int on_hold:1;
};

struct sla_trunk_ref {
   AST_LIST_ENTRY(sla_trunk_ref) entry;
   struct sla_trunk *trunk;
   enum sla_trunk_state state;
   struct ast_channel *chan;
   /*! Ring timeout to use when this trunk is ringing on this specific
    *  station.  This takes higher priority than a ring timeout set at
    *  the station level. */
   unsigned int ring_timeout;
   /*! Ring delay to use when this trunk is ringing on this specific
    *  station.  This takes higher priority than a ring delay set at
    *  the station level. */
   unsigned int ring_delay;
};

static AST_RWLIST_HEAD_STATIC(sla_stations, sla_station);
static AST_RWLIST_HEAD_STATIC(sla_trunks, sla_trunk);

static const char sla_registrar[] = "SLA";

/*! \brief Event types that can be queued up for the SLA thread */
enum sla_event_type {
   /*! A station has put the call on hold */
   SLA_EVENT_HOLD,
   /*! The state of a dial has changed */
   SLA_EVENT_DIAL_STATE,
   /*! The state of a ringing trunk has changed */
   SLA_EVENT_RINGING_TRUNK,
};

struct sla_event {
   enum sla_event_type type;
   struct sla_station *station;
   struct sla_trunk_ref *trunk_ref;
   AST_LIST_ENTRY(sla_event) entry;
};

/*! \brief A station that failed to be dialed 
 * \note Only used by the SLA thread. */
struct sla_failed_station {
   struct sla_station *station;
   struct timeval last_try;
   AST_LIST_ENTRY(sla_failed_station) entry;
};

/*! \brief A trunk that is ringing */
struct sla_ringing_trunk {
   struct sla_trunk *trunk;
   /*! The time that this trunk started ringing */
   struct timeval ring_begin;
   AST_LIST_HEAD_NOLOCK(, sla_station_ref) timed_out_stations;
   AST_LIST_ENTRY(sla_ringing_trunk) entry;
};

enum sla_station_hangup {
   SLA_STATION_HANGUP_NORMAL,
   SLA_STATION_HANGUP_TIMEOUT,
};

/*! \brief A station that is ringing */
struct sla_ringing_station {
   struct sla_station *station;
   /*! The time that this station started ringing */
   struct timeval ring_begin;
   AST_LIST_ENTRY(sla_ringing_station) entry;
};

/*!
 * \brief A structure for data used by the sla thread
 */
static struct {
   /*! The SLA thread ID */
   pthread_t thread;
   ast_cond_t cond;
   ast_mutex_t lock;
   AST_LIST_HEAD_NOLOCK(, sla_ringing_trunk) ringing_trunks;
   AST_LIST_HEAD_NOLOCK(, sla_ringing_station) ringing_stations;
   AST_LIST_HEAD_NOLOCK(, sla_failed_station) failed_stations;
   AST_LIST_HEAD_NOLOCK(, sla_event) event_q;
   unsigned int stop:1;
   /*! Attempt to handle CallerID, even though it is known not to work
    *  properly in some situations. */
   unsigned int attempt_callerid:1;
} sla = {
   .thread = AST_PTHREADT_NULL,
};

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

/*! 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 char const gain_map[] = {
   -15,
   -13,
   -10,
   -6,
   0,
   0,
   0,
   6,
   10,
   13,
   15,
};


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

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 = DAHDI_IOMUX_WRITE | DAHDI_IOMUX_SIGEVENT;
         res = ioctl(fd, DAHDI_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;
}

static int set_talk_volume(struct ast_conf_user *user, int volume)
{
   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)
{
   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, enum entrance_sound 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);
}

/*!
 * \brief Find or create a conference
 *
 * \param confno The conference name/number
 * \param pin The regular user pin
 * \param pinadmin The admin pin
 * \param make Make the conf if it doesn't exist
 * \param dynamic Mark the newly created conference as dynamic
 * \param refcount How many references to mark on the conference
 *
 * \return A pointer to the conference struct, or NULL if it wasn't found and
 *         make or dynamic were not set.
 */
static struct ast_conference *build_conf(char *confno, char *pin, char *pinadmin, int make, int dynamic, int refcount)
{
   struct ast_conference *cnf;
   struct dahdi_confinfo ztc = { 0, };
   int confno_int = 0;

   AST_LIST_LOCK(&confs);

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

   if (cnf || (!make && !dynamic))
      goto cnfout;

   /* Make a new one */
   if (!(cnf = ast_calloc(1, sizeof(*cnf))))
      goto cnfout;

   ast_mutex_init(&cnf->playlock);
   ast_mutex_init(&cnf->listenlock);
   cnf->recordthread = AST_PTHREADT_NULL;
   ast_mutex_init(&cnf->recordthreadlock);
   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));

   /* Setup a new zap conference */
   ztc.confno = -1;
   ztc.confmode = DAHDI_CONF_CONFANN | DAHDI_CONF_CONFANNMON;
#ifdef HAVE_ZAPTEL
   cnf->fd = open("/dev/zap/pseudo", O_RDWR);
#else
   cnf->fd = open("/dev/dahdi/pseudo", O_RDWR);
#endif
   if (cnf->fd < 0 || ioctl(cnf->fd, DAHDI_SETCONF, &ztc)) {
      ast_log(LOG_WARNING, "Unable to open pseudo device\n");
      if (cnf->fd >= 0)
         close(cnf->fd);
      free(cnf);
      cnf = NULL;
      goto cnfout;
   }

   cnf->zapconf = ztc.confno;

   /* Setup a new channel for playback of audio files */
   cnf->chan = ast_request(dahdi_chan_name, AST_FORMAT_SLINEAR, "pseudo", NULL);
   if (cnf->chan) {
      ast_set_read_format(cnf->chan, AST_FORMAT_SLINEAR);
      ast_set_write_format(cnf->chan, AST_FORMAT_SLINEAR);
      ztc.chan = 0;
      ztc.confno = cnf->zapconf;
      ztc.confmode = DAHDI_CONF_CONFANN | DAHDI_CONF_CONFANNMON;
      if (ioctl(cnf->chan->fds[0], DAHDI_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->isdynamic = dynamic ? 1 : 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;
   
cnfout:
   if (cnf)
      ast_atomic_fetchadd_int(&cnf->refcount, refcount);

   AST_LIST_UNLOCK(&confs);

   return cnf;
}

static int meetme_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_EMPTY(&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_LIST_UNLOCK(&confs);
      ast_cli(fd, "* Total number of MeetMe users: %d\n", total);
      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) {
      int concise = ( 4 == argc && ( !strcasecmp(argv[3], "concise") ) );
      /* List all the users in a conference */
      if (AST_LIST_EMPTY(&confs)) {
         if ( !concise )
            ast_cli(fd, "No active conferences.\n");
         return RESULT_SUCCESS;  
      }
      /* Find the right conference */
      AST_LIST_LOCK(&confs);
      AST_LIST_TRAVERSE(&confs, cnf, list) {
         if (strcmp(cnf->confno, argv[2]) == 0)
            break;
      }
      if (!cnf) {
         if ( !concise )
            ast_cli(fd, "No such conference: %s.\n",argv[2]);
         AST_LIST_UNLOCK(&confs);
         return